3 %% Copyright (C) 2000-2011 Simone Piccardi. Permission is granted to
4 %% copy, distribute and/or modify this document under the terms of the GNU Free
5 %% Documentation License, Version 1.1 or any later version published by the
6 %% Free Software Foundation; with the Invariant Sections being "Un preambolo",
7 %% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the
8 %% license is included in the section entitled "GNU Free Documentation
12 \chapter{L'interfaccia base con i processi}
13 \label{cha:process_interface}
15 Come accennato nell'introduzione il \textsl{processo} è l'unità di base con
16 cui un sistema unix-like alloca ed utilizza le risorse. Questo capitolo
17 tratterà l'interfaccia base fra il sistema e i processi, come vengono passati
18 gli argomenti, come viene gestita e allocata la memoria, come un processo può
19 richiedere servizi al sistema e cosa deve fare quando ha finito la sua
20 esecuzione. Nella sezione finale accenneremo ad alcune problematiche generiche
23 In genere un programma viene eseguito quando un processo lo fa partire
24 eseguendo una funzione della famiglia \func{exec}; torneremo su questo e sulla
25 creazione e gestione dei processi nel prossimo capitolo. In questo
26 affronteremo l'avvio e il funzionamento di un singolo processo partendo dal
27 punto di vista del programma che viene messo in esecuzione.
30 \section{Esecuzione e conclusione di un programma}
32 Uno dei concetti base di Unix è che un processo esegue sempre uno ed un solo
33 programma: si possono avere più processi che eseguono lo stesso programma ma
34 ciascun processo vedrà la sua copia del codice (in realtà il kernel fa sì che
35 tutte le parti uguali siano condivise), avrà un suo spazio di indirizzi,
36 variabili proprie e sarà eseguito in maniera completamente indipendente da
37 tutti gli altri. Questo non è del tutto vero nel caso di un programma
38 \textit{multi-thread}, ma la gestione dei \itindex{thread} \textit{thread} in
39 Linux sarà trattata a parte in cap.~\ref{cha:threads}.
42 \subsection{L'avvio e l'esecuzione di un programma}
45 \itindbeg{link-loader}
47 Quando un programma viene messo in esecuzione cosa che può essere fatta solo
48 con una funzione della famiglia \func{exec} (vedi sez.~\ref{sec:proc_exec}) il
49 kernel esegue un opportuno codice di avvio, il cosiddetto
50 \textit{link-loader}, costituito dal programma \cmd{ld-linux.so}. Questo
51 programma è una parte fondamentale del sistema il cui compito è quello della
52 gestione delle cosiddette \textsl{librerie condivise}, quelle che nel mondo
53 Windows sono chiamate DLL (\textit{Dinamic Link Library}), e che invece in un
54 sistema unix-like vengono chiamate \textit{shared objects}.
56 Infatti, a meno di non aver specificato il flag \texttt{-static} durante la
57 compilazione, tutti i programmi in Linux sono compilati facendo riferimento a
58 librerie condivise, in modo da evitare di duplicare lo stesso codice nei
59 relativi eseguibili e consentire un uso più efficiente della memoria, dato che
60 il codice di uno \itindex{shared~objects} \textit{shared objects} viene
61 caricato in memoria dal kernel una sola volta per tutti i programmi che lo
64 Questo significa però che normalmente il codice di un programma è incompleto,
65 contenendo solo i riferimenti alle funzioni di libreria che vuole utilizzare e
66 non il relativo codice. Per questo motivo all'avvio del programma è necessario
67 l'intervento del \textit{link-loader} il cui compito è
68 caricare in memoria le librerie condivise eventualmente assenti, ed effettuare
69 poi il collegamento dinamico del codice del programma alle funzioni di
70 libreria da esso utilizzate prima di metterlo in esecuzione.
72 Il funzionamento di \cmd{ld-linux.so} è controllato da alcune variabili di
73 ambiente e dal contenuto del file \conffile{/etc/ld.so.conf}, che consentono
74 di elencare le directory un cui cercare le librerie e determinare quali
75 verranno utilizzate. In particolare con la variabile di ambiente
76 \texttt{LD\_LIBRARY\_PATH} si possono indicare ulteriori directory rispetto a
77 quelle di sistema in cui inserire versioni personali delle librerie che hanno
78 la precedenza su quelle di sistema, mentre con la variabile di ambiente
79 \texttt{LD\_PRELOAD} si può passare direttamente una lista di file di librerie
80 condivise da usare al posto di quelli di sistema. In questo modo è possibile
81 effettuare lo sviluppo o il test di nuove librerie senza dover sostituire
82 quelle di sistema. Ulteriori dettagli sono riportati nella pagina di manuale
83 di \cmd{ld.so} e per un approfondimento dell'argomento si può consultare
84 sez.~3.1.2 di \cite{AGL}.
86 Una volta completate le operazioni di inizializzazione di \cmd{ld-linux.so}, il
87 sistema fa partire qualunque programma chiamando la funzione \func{main}. Sta
88 al programmatore chiamare così la funzione principale del programma da cui si
89 suppone che inizi l'esecuzione. In ogni caso senza questa funzione lo stesso
90 \textit{link-loader} darebbe luogo ad errori. Lo standard ISO C specifica che
91 la funzione \func{main} può non avere argomenti o prendere due argomenti che
92 rappresentano gli argomenti passati da linea di comando (su cui torneremo in
93 sez.~\ref{sec:proc_par_format}), in sostanza un prototipo che va sempre bene è
95 \includecodesnip{listati/main_def.c}
97 \itindend{link-loader}
99 In realtà nei sistemi Unix esiste un altro modo per definire la funzione
100 \func{main}, che prevede la presenza di un terzo argomento, \code{char
101 *envp[]}, che fornisce l'\textsl{ambiente} del programma; questa forma però
102 non è prevista dallo standard POSIX.1 per cui se si vogliono scrivere
103 programmi portabili è meglio evitarla. Per accedere all'ambiente, come vedremo
104 in sez.~\ref{sec:proc_environ} si usa in genere una variabile globale che
105 viene sempre definita automaticamente.
107 Ogni programma viene fatto partire mettendo in esecuzione il codice contenuto
108 nella funzione \func{main}, ogni altra funzione usata dal programma, che sia
109 ottenuta da una libreria condivisa, o che sia direttamente definita nel
110 codice, dovrà essere invocata a partire dal codice di \func{main}. Nel caso di
111 funzioni definite nel programma occorre tenere conto che, nel momento stesso
112 in cui si usano le librerie di sistema (vale a dire la \acr{glibc}) alcuni
113 nomi sono riservati e non possono essere utilizzati.
115 In particolare sono riservati a priori e non possono essere mai ridefiniti in
116 nessun caso i nomi di tutte le funzioni, le variabili, le macro di
117 preprocessore, ed i tipi di dati previsti dallo standard ISO C. Lo stesso
118 varrà per tutti i nomi definiti negli \textit{header file} che si sono
119 esplicitamente inclusi nel programma (vedi sez.~\ref{sec:proc_syscall}), ma
120 anche se è possibile riutilizzare nomi definiti in altri \textit{header file}
121 la pratica è da evitare nella maniera più assoluta per non generare ambiguità.
123 Oltre ai nomi delle funzioni di libreria sono poi riservati in maniera
124 generica tutti i nomi di variabili o funzioni globali che iniziano con il
125 carattere di sottolineato (``\texttt{\_}''), e qualunque nome che inizi con il
126 doppio sottolineato (``\texttt{\_\_}'') o con il sottolineato seguito da
127 lettera maiuscola. Questi identificativi infatti sono utilizzati per i nomi
128 usati internamente in forma privata dalle librerie, ed evitandone l'uso si
129 elimina il rischio di conflitti.
131 Infine esiste una serie di classi di nomi che sono riservati per un loro
132 eventuale uso futuro da parte degli standard ISO C e POSIX.1, questi in teoria
133 possono essere usati senza problemi oggi, ma potrebbero dare un conflitto con
134 una revisione futura di questi standard, per cui è comunque opportuno
135 evitarli, in particolare questi sono:
137 \item i nomi che iniziano per ``\texttt{E}'' costituiti da lettere maiuscole e
138 numeri, che potrebbero essere utilizzati per nuovi codici di errore (vedi
139 sez.~\ref{sec:sys_errors}),
140 \item i nomi che iniziano con ``\texttt{is}'' o ``\texttt{to}'' e costituiti
141 da lettere minuscole che potrebbero essere utilizzati da nuove funzioni per
142 il controllo e la conversione del tipo di caratteri,
143 \item i nomi che iniziano con ``\texttt{LC\_}'' e costituiti
144 da lettere maiuscole che possono essere usato per macro attinenti la
145 localizzazione (vedi sez.~\ref{sec:proc_localization}),
146 \item nomi che iniziano con ``\texttt{SIG}'' o ``\texttt{SIG\_}'' e costituiti
147 da lettere maiuscole che potrebbero essere usati per nuovi nomi di segnale
148 (vedi sez.~\ref{sec:sig_classification}),
149 \item nomi che iniziano con ``\texttt{str}'', ``\texttt{mem}'', o
150 ``\texttt{wcs}'' e costituiti da lettere minuscole che possono essere
151 utilizzati per funzioni attinenti la manipolazione delle stringhe e delle
153 \item nomi che terminano in ``\texttt{\_t}'' che potrebbero essere utilizzati
154 per la definizione di nuovi tipi di dati di sistema oltre quelli di
155 tab.~\ref{tab:intro_primitive_types}).
159 \subsection{Chiamate a funzioni e \textit{system call}}
160 \label{sec:proc_syscall}
162 Come accennato in sez.~\ref{sec:intro_syscall} un programma può utilizzare le
163 risorse che il sistema gli mette a disposizione attraverso l'uso delle
164 opportune \textit{system call}. Abbiamo inoltre appena visto come all'avvio un
165 programma venga messo in grado di chiamare le funzioni fornite da eventuali
166 librerie condivise da esso utilizzate.
168 Vedremo nel resto della guida quali sono le risorse del sistema accessibili
169 attraverso le \textit{system call} e tratteremo buona parte delle funzioni
170 messe a disposizione dalla libreria standard del C, in questa sezione però si
171 forniranno alcune indicazioni generali sul come fare perché un programma possa
172 utilizzare queste funzioni.
174 \itindbeg{header~file}
176 In sez.~\ref{sec:intro_standard} abbiamo accennato come le funzioni definite
177 nei vari standard siano definite in una serie di \textit{header file} (in
178 italiano \textsl{file di intestazione}). Vengono chiamati in questo modo quei
179 file, forniti insieme al codice delle librerie, che contengono le
180 dichiarazioni delle variabili, dei tipi di dati, delle macro di preprocessore
181 e soprattutto delle funzioni che fanno parte di una libreria.
183 Questi file sono necessari al compilatore del linguaggio C per ottenere i
184 riferimenti ai nomi delle funzioni (e alle altre risorse) definite in una
185 libreria, per questo quando si vogliono usare le funzioni di una libreria
186 occorre includere nel proprio codice gli \textit{header file} che le
187 definiscono con la direttiva \code{\#include}. Dato che le funzioni devono
188 essere definite prima di poterle usare in genere gli \textit{header file}
189 vengono inclusi all'inizio del programma. Se inoltre si vogliono utilizzare le
190 macro di controllo delle funzionalità fornite dai vari standard illustrate in
191 sez.~\ref{sec:intro_gcc_glibc_std} queste, come accennato, dovranno a loro
192 volta essere definite prima delle varie inclusioni.
194 Ogni libreria fornisce i propri file di intestazione per i quali si deve
195 consultare la documentazione, ma in tab.~\ref{tab:intro_posix_header} si sono
196 riportati i principali \textit{header file} definiti nella libreria standard
197 del C (nel caso la \acr{glibc}) che contengono le varie funzioni previste
198 negli standard POSIX ed ANSI C, e che prevedono la definizione sia delle
199 funzioni di utilità generica che delle interfacce alle \textit{system call}. In
200 seguito per ciascuna funzione o \textit{system call} che tratteremo
201 indicheremo anche quali sono gli \textit{header file} contenenti le necessarie
207 \begin{tabular}[c]{|l|c|c|l|}
209 \multirow{2}{*}{\textbf{Header}}&
210 \multicolumn{2}{|c|}{\textbf{Standard}}&
211 \multirow{2}{*}{\textbf{Contenuto}} \\
216 \file{assert.h}&$\bullet$& -- & Verifica le asserzioni fatte in un
218 \file{ctype.h} &$\bullet$& -- & Tipi standard.\\
219 \file{dirent.h}& -- &$\bullet$& Manipolazione delle directory.\\
220 \file{errno.h} & -- &$\bullet$& Errori di sistema.\\
221 \file{fcntl.h} & -- &$\bullet$& Controllo sulle opzioni dei file.\\
222 \file{limits.h}& -- &$\bullet$& Limiti e parametri del sistema.\\
223 \file{malloc.h}&$\bullet$& -- & Allocazione della memoria.\\
224 \file{setjmp.h}&$\bullet$& -- & Salti non locali.\\
225 \file{signal.h}& -- &$\bullet$& Gestione dei segnali.\\
226 \file{stdarg.h}&$\bullet$& -- & Gestione di funzioni a argomenti
228 \file{stdio.h} &$\bullet$& -- & I/O bufferizzato in standard ANSI C.\\
229 \file{stdlib.h}&$\bullet$& -- & Definizioni della libreria standard.\\
230 \file{string.h}&$\bullet$& -- & Manipolazione delle stringhe.\\
231 \file{time.h} & -- &$\bullet$& Gestione dei tempi.\\
232 \file{times.h} &$\bullet$& -- & Gestione dei tempi.\\
233 \file{unistd.h}& -- &$\bullet$& Unix standard library.\\
234 \file{utmp.h} & -- &$\bullet$& Registro connessioni utenti.\\
237 \caption{Elenco dei principali \textit{header file} definiti dagli standard
239 \label{tab:intro_posix_header}
242 Un esempio di inclusione di questi file, preso da uno dei programmi di
243 esempio, è il seguente, e si noti come gli \textit{header file} possano essere
244 referenziati con il nome fra parentesi angolari, nel qual caso si indica l'uso
245 di quelli installati con il sistema,\footnote{in un sistema GNU/Linux che
246 segue le specifiche del \itindex{Filesystem~Hierarchy~Standard~(FHS)}
247 \textit{Filesystem Hierarchy Standard} (per maggiori informazioni si
248 consulti sez.~1.2.3 di \cite{AGL}) si trovano sotto \texttt{/usr/include}.}
249 o fra virgolette, nel qual caso si fa riferimento ad una versione locale, da
250 indicare con un pathname relativo:
251 \includecodesnip{listati/main_include.c}
253 Si tenga presente che oltre ai nomi riservati a livello generale di cui si è
254 parlato in sez.~\ref{sec:proc_main}, alcuni di questi \textit{header file}
255 riservano degli ulteriori identificativi, il cui uso sarà da evitare, ad
258 \item in \file{dirent.h} vengono riservati i nomi che iniziano con
259 ``\texttt{d\_}'' e costituiti da lettere minuscole,
260 \item in \file{fcntl.h} vengono riservati i nomi che iniziano con
261 ``\texttt{l\_}'', ``\texttt{F\_}'',``\texttt{O\_}'' e ``\texttt{S\_}'',
262 \item in \file{limits.h} vengono riservati i nomi che finiscono in
264 \item in \file{signal.h} vengono riservati i nomi che iniziano con
265 ``\texttt{sa\_}'' e ``\texttt{SA\_}'',
266 \item in \file{sys/stat.h} vengono riservati i nomi che iniziano con
267 ``\texttt{st\_}'' e ``\texttt{S\_}'',
268 \item in \file{sys/times.h} vengono riservati i nomi che iniziano con
270 \item in \file{termios.h} vengono riservati i nomi che iniziano con
271 ``\texttt{c\_}'', ``\texttt{V}'', ``\texttt{I}'', ``\texttt{O}'' e
272 ``\texttt{TC}'' e con ``\texttt{B}'' seguito da un numero,
273 \item in \file{grp.h} vengono riservati i nomi che iniziano con
275 \item in \file{pwd.h}vengono riservati i nomi che iniziano con
279 \itindend{header~file}
281 Una volta inclusi gli \textit{header file} necessari un programma potrà
282 richiamare le funzioni di libreria direttamente nel proprio codice ed accedere
283 ai servizi del kernel; come accennato infatti normalmente ogni \textit{system
284 call} è associata ad una omonima funzione di libreria, che è quella che si
285 usa normalmente per invocarla.
287 Occorre però tenere presente che anche se dal punto di vista della scrittura
288 del codice la chiamata di una \textit{system call} non è diversa da quella di
289 una qualunque funzione ordinaria, la situazione è totalmente diversa
290 nell'esecuzione del programma. Una funzione ordinaria infatti viene eseguita,
291 esattamente come il codice che si è scritto nel corpo del programma, in
292 \textit{user space}. Quando invece si esegue una \textit{system call}
293 l'esecuzione ordinaria del programma viene interrotta, i dati forniti (come
294 argomenti della chiamata) vengono trasferiti al kernel che esegue il codice
295 della \textit{system call} (che è codice del kernel) in \textit{kernel space}.
297 Dato che il passaggio dei dati ed il salvataggio del contesto di esecuzione
298 del programma che consentirà di riprenderne l'esecuzione ordinaria al
299 completamento della \textit{system call} sono operazioni critiche per le
300 prestazioni del sistema, per rendere il più veloce possibile questa
301 operazione, usualmente chiamata \textit{context switch} sono state sviluppate
302 una serie di ottimizzazioni che richiedono alcune preparazioni abbastanza
303 complesse dei dati, che in genere dipendono dall'architettura del processore
304 sono scritte direttamente in \textit{assembler}.
307 % TODO:trattare qui, quando sarà il momento vsyscall e vDSO, vedi:
308 % http://davisdoesdownunder.blogspot.com/2011/02/linux-syscall-vsyscall-and-vdso-oh-my.html
309 % http://www.win.tue.nl/~aeb/linux/lk/lk-4.html
312 Inoltre alcune \textit{system call} sono state modificate nel corso degli anni
313 con lo sviluppo del kernel per aggiungere ad esempio funzionalità in forma di
314 nuovi argomenti, o per consolidare diverse varianti in una interfaccia
315 generica. Per questo motivo dovendo utilizzare una \textit{system call} è
316 sempre preferibile usare l'interfaccia fornita dalla \textsl{glibc}, che si
317 cura di mantenere una uniformità chiamando le versioni più aggiornate.
319 Ci sono alcuni casi però in cui può essere necessario evitare questa
320 associazione, e lavorare a basso livello con una specifica versione, oppure si
321 può voler utilizzare una \textit{system call} che non è stata ancora associata
322 ad una funzione di libreria. In tal caso, per evitare di dover effettuare
323 esplicitamente le operazioni di preparazione citate, all'interno della
324 \textsl{glibc} è fornita una specifica funzione, \funcd{syscall}, che consente
325 eseguire direttamente una \textit{system call}; il suo prototipo, accessibile
326 se si è definita la macro \macro{\_GNU\_SOURCE}, è:
330 \fhead{sys/syscall.h}
331 \fdecl{int syscall(int number, ...)}
332 \fdesc{Esegue la \textit{system call} indicata da \param{number}.}
334 {La funzione ritorna un intero dipendente dalla \textit{system call} invocata,
335 in generale $0$ indica il successo ed un valore negativo un errore.}
338 La funzione richiede come primo argomento il numero della \textit{system call}
339 da invocare, seguita dagli argomenti da passare alla stessa, che ovviamente
340 dipendono da quest'ultima, e restituisce il codice di ritorno della
341 \textit{system call} invocata. In generale un valore nullo indica il successo
342 ed un valore negativo è un codice di errore che poi viene memorizzato nella
343 variabile \var{errno} (sulla gestione degli errori torneremo in dettaglio in
344 sez.~\ref{sec:sys_errors}).
346 Il valore di \param{number} dipende sia dalla versione di kernel che
347 dall'architettura,\footnote{in genere le vecchie \textit{system call} non
348 vengono eliminate e se ne aggiungono di nuove con nuovi numeri.} ma
349 ciascuna \textit{system call} viene in genere identificata da una costante
350 nella forma \texttt{SYS\_*} dove al prefisso viene aggiunto il nome che spesso
351 corrisponde anche alla omonima funzione di libreria. Queste costanti sono
352 definite nel file \texttt{sys/syscall.h}, ma si possono anche usare
353 direttamente valori numerici.
356 \subsection{La terminazione di un programma}
357 \label{sec:proc_conclusion}
359 Normalmente un programma conclude la sua esecuzione quando si fa ritornare la
360 funzione \func{main}, si usa cioè l'istruzione \instruction{return} del
361 linguaggio C all'interno della stessa, o se si richiede esplicitamente la
362 chiusura invocando direttamente la funzione \func{exit}. Queste due modalità
363 sono assolutamente equivalenti, dato che \func{exit} viene chiamata in maniera
364 trasparente anche quando \func{main} ritorna, passandogli come argomento il
365 valore di ritorno (che essendo .
367 La funzione \funcd{exit}, che è completamente generale, essendo definita dallo
368 standard ANSI C, è quella che deve essere invocata per una terminazione
369 ``\textit{normale}'', il suo prototipo è:
373 \fdecl{void exit(int status)}
374 \fdesc{Causa la conclusione ordinaria del programma.}
376 {La funzione non ritorna, il processo viene terminato.}
379 La funzione è pensata per eseguire una conclusione pulita di un programma che
380 usi la libreria standard del C; essa esegue tutte le funzioni che sono state
381 registrate con \func{atexit} e \func{on\_exit} (vedi
382 sez.~\ref{sec:proc_atexit}), chiude tutti gli \textit{stream} (vedi
383 sez.~\ref{sec:file_stream}) effettuando il salvataggio dei dati sospesi
384 (chiamando \func{fclose}, vedi sez.~\ref{sec:file_fopen}), infine passa il
385 controllo al kernel chiamando la \textit{system call} \func{\_exit} (che
386 vedremo a breve) che completa la terminazione del processo.
388 \itindbeg{exit~status}
390 Il valore dell'argomento \param{status} o il valore di ritorno di \func{main},
391 costituisce quello che viene chiamato lo \textsl{stato di uscita}
392 (l'\textit{exit status}) del processo. In generale si usa questo valore per
393 fornire al processo padre (come vedremo in sez.~\ref{sec:proc_wait}) delle
394 informazioni generiche sulla riuscita o il fallimento del programma appena
397 Anche se l'argomento \param{status} (ed il valore di ritorno di \func{main})
398 sono numeri interi di tipo \ctyp{int}, si deve tener presente che il valore
399 dello stato di uscita viene comunque troncato ad 8 bit,
400 per cui deve essere sempre compreso fra 0 e 255. Si tenga presente che se si
401 raggiunge la fine della funzione \func{main} senza ritornare esplicitamente si
402 ha un valore di uscita indefinito, è pertanto consigliabile di concludere
403 sempre in maniera esplicita detta funzione.
405 Non esiste un valore significato intrinseco della stato di uscita, ma una
406 convenzione in uso pressoché universale è quella di restituire 0 in caso di
407 successo e 1 in caso di fallimento. Una eccezione a questa convenzione è per i
408 programmi che effettuano dei confronti (come \cmd{diff}), che usano 0 per
409 indicare la corrispondenza, 1 per indicare la non corrispondenza e 2 per
410 indicare l'incapacità di effettuare il confronto. Un'altra convenzione riserva
411 i valori da 128 a 256 per usi speciali: ad esempio 128 viene usato per
412 indicare l'incapacità di eseguire un altro programma in un
413 sottoprocesso. Benché le convenzioni citate non siano seguite universalmente è
414 una buona idea tenerle presenti ed adottarle a seconda dei casi.
416 Si tenga presente inoltre che non è una buona idea usare eventuali codici di
417 errore restituiti nella variabile \var{errno} (vedi sez.~\ref{sec:sys_errors})
418 come \textit{exit status}. In generale infatti non ci si cura del valore dello
419 stato di uscita di un processo se non per vedere se è diverso da zero, come
420 indicazione di un qualche errore. Dato che viene troncato ad 8 bit utilizzare
421 un intero di valore generico può comportare il rischio, qualora si vada ad
422 usare un multiplo di 256, di avere uno stato di uscita uguale a zero, che
423 verrebbe interpretato come un successo.
425 Per questo motivo in \file{stdlib.h} sono definite, seguendo lo standard
426 POSIX, le due costanti \const{EXIT\_SUCCESS} e \const{EXIT\_FAILURE}, da usare
427 sempre per specificare lo stato di uscita di un processo. Su Linux, ed in
428 generale in qualunque sistema POSIX, ad esse sono assegnati rispettivamente i
431 \itindend{exit~status}
433 Una forma alternativa per effettuare una terminazione esplicita di un
434 programma è quella di chiamare direttamente la \textit{system call}
435 \func{\_exit}, che restituisce il controllo direttamente al kernel,
436 concludendo immediatamente il processo, il suo prototipo è:
438 \begin{funcproto}{ \fhead{unistd.h} \fdecl{void \_exit(int status)}
439 \fdesc{Causa la conclusione immediata del programma.} } {La funzione non
440 ritorna, il processo viene terminato.}
443 La funzione termina immediatamente il processo e le eventuali funzioni
444 registrate con \func{atexit} e \func{on\_exit} non vengono eseguite. La
445 funzione chiude tutti i file descriptor appartenenti al processo, cosa che
446 però non comporta il salvataggio dei dati eventualmente presenti nei buffer
447 degli \textit{stream}, (torneremo sulle due interfacce dei file in
448 cap.~\ref{cha:files_std_interface} e
449 cap.~\ref{cha:file_unix_interface})). Infine fa sì che ogni figlio del
450 processo sia adottato da \cmd{init} (vedi sez.~\ref{sec:proc_termination}),
451 manda un segnale \signal{SIGCHLD} al processo padre (vedi
452 sez.~\ref{sec:sig_job_control}) e ritorna lo stato di uscita specificato
453 in \param{status} che può essere raccolto usando la funzione \func{wait} (vedi
454 sez.~\ref{sec:proc_wait}).
456 Si tenga presente infine che oltre alla conclusione ``\textsl{normale}''
457 appena illustrata esiste anche la possibilità di una conclusione
458 ``\textsl{anomala}'' del programma a causa della ricezione di un segnale
459 (tratteremo i segnali in cap.~\ref{cha:signals}) o della chiamata alla
460 funzione \func{abort}; torneremo su questo in sez.~\ref{sec:proc_termination}.
463 \subsection{Esecuzione di funzioni preliminari all'uscita}
464 \label{sec:proc_atexit}
466 Un'esigenza comune che si incontra è quella di dover effettuare una serie di
467 operazioni di pulizia (ad esempio salvare dei dati, ripristinare delle
468 impostazioni, eliminare dei file temporanei, ecc.) prima della conclusione di
469 un programma. In genere queste operazioni vengono fatte in un'apposita sezione
470 del programma, ma quando si realizza una libreria diventa antipatico dover
471 richiedere una chiamata esplicita ad una funzione di pulizia al programmatore
474 È invece molto meno soggetto ad errori, e completamente trasparente
475 all'utente, avere la possibilità di fare effettuare automaticamente la
476 chiamata ad una funzione che effettui tali operazioni all'uscita dal
477 programma. A questo scopo lo standard ANSI C prevede la possibilità di
478 registrare un certo numero di funzioni che verranno eseguite all'uscita dal
479 programma,\footnote{nel caso di \func{atexit} lo standard POSIX.1-2001
480 richiede che siano registrabili almeno \const{ATEXIT\_MAX} funzioni (il
481 valore può essere ottenuto con \func{sysconf}, vedi
482 sez.~\ref{sec:sys_sysconf}).} sia per la chiamata ad \func{exit} che per il
483 ritorno di \func{main}. La prima funzione che si può utilizzare a tal fine è
484 \funcd{atexit}, il cui prototipo è:
486 \begin{funcproto}{ \fhead{stdlib.h} \fdecl{void (*function)(void)}
487 \fdesc{Registra la funzione \param{function} per la chiamata all'uscita
488 dal programma.} } {La funzione ritorna $0$ in caso di successo e
489 $-1$ per un errore, \var{errno} non viene modificata.}
492 La funzione richiede come argomento \param{function} l'indirizzo di una
493 opportuna funzione di pulizia da chiamare all'uscita del programma, che non
494 deve prendere argomenti e non deve ritornare niente. In sostanza deve la
495 funzione di pulizia dovrà essere definita come \code{void function(void)}.
497 Un'estensione di \func{atexit} è la funzione \funcd{on\_exit}, che le
498 \acr{glibc} includono per compatibilità con SunOS ma che non è detto sia
499 definita su altri sistemi,\footnote{non essendo prevista dallo standard POSIX
500 è in genere preferibile evitarne l'uso.} il suo prototipo è:
504 \fdecl{void (*function)(int , void *), void *arg)}
505 \fdesc{Registra la funzione \param{function} per la chiamata all'uscita dal
508 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, \var{errno}
509 non viene modificata.}
512 In questo caso la funzione da chiamare all'uscita prende i due argomenti
513 specificati nel prototipo, un intero ed un puntatore; dovrà cioè essere
514 definita come \code{void function(int status, void *argp)}. Il primo argomento
515 sarà inizializzato allo stato di uscita con cui è stata chiamata \func{exit}
516 ed il secondo al puntatore \param{arg} passato come secondo argomento di
517 \func{on\_exit}. Così diventa possibile passare dei dati alla funzione di
520 Nella sequenza di chiusura tutte le funzioni registrate verranno chiamate in
521 ordine inverso rispetto a quello di registrazione, ed una stessa funzione
522 registrata più volte sarà chiamata più volte. Siccome entrambe le funzioni
523 \func{atexit} e \func{on\_exit} fanno riferimento alla stessa lista, l'ordine
524 di esecuzione sarà riferito alla registrazione in quanto tale,
525 indipendentemente dalla funzione usata per farla.
527 Una volta completata l'esecuzione di tutte le funzioni registrate verranno
528 chiusi tutti gli \textit{stream} aperti ed infine verrà chiamata \func{\_exit}
529 per la terminazione del programma. Questa è la sequenza ordinaria, eseguita a
530 meno che una delle funzioni registrate non esegua al suo interno
531 \func{\_exit}, nel qual caso la terminazione del programma sarà immediata ed
532 anche le successive funzioni registrate non saranno invocate.
534 Se invece all'interno di una delle funzioni registrate si chiama un'altra
535 volta \func{exit} lo standard POSIX.1-2001 prescrive un comportamento
536 indefinito, con la possibilità (che su Linux comunque non c'è) di una
537 ripetizione infinita. Pertanto questa eventualità è da evitare nel modo più
538 assoluto. Una altro comportamento indefinito si può avere se si termina
539 l'esecuzione di una delle funzioni registrate con \func{longjmp} (vedi
540 sez.~\ref{sec:proc_longjmp}).
542 Si tenga presente infine che in caso di terminazione anomala di un processo
543 (ad esempio a causa di un segnale) nessuna delle funzioni registrate verrà
544 eseguita e che se invece si crea un nuovo processo con \func{fork} (vedi
545 sez.~\ref{sec:proc_fork}) questo manterrà tutte le funzioni già registrate.
548 \subsection{Un riepilogo}
549 \label{sec:proc_term_conclusion}
551 Data l'importanza dell'argomento è opportuno un piccolo riepilogo dei fatti
552 essenziali relativi alla esecuzione di un programma. Il primo punto da
553 sottolineare è che in un sistema unix-like l'unico modo in cui un programma
554 può essere eseguito dal kernel è attraverso la chiamata alla \textit{system
555 call} \func{execve}, sia direttamente che attraverso una delle funzioni
556 della famiglia \func{exec} che ne semplificano l'uso (vedi
557 sez.~\ref{sec:proc_exec}).
559 Allo stesso modo l'unico modo in cui un programma può concludere
560 volontariamente la propria esecuzione è attraverso una chiamata alla
561 \textit{system call} \func{\_exit}, sia che questa venga fatta esplicitamente,
562 o in maniera indiretta attraverso l'uso di \func{exit} o il ritorno di
565 Uno schema riassuntivo che illustra le modalità con cui si avvia e conclude
566 normalmente un programma è riportato in fig.~\ref{fig:proc_prog_start_stop}.
570 % \includegraphics[width=9cm]{img/proc_beginend}
571 \begin{tikzpicture}[>=stealth]
572 \filldraw[fill=black!35] (-0.3,0) rectangle (12,1);
573 \draw(5.5,0.5) node {\large{kernel}};
575 \filldraw[fill=black!15] (1.5,2) rectangle (4,3);
576 \draw (2.75,2.5) node {\texttt{ld-linux.so}};
577 \draw [->] (2.75,1) -- (2.75,2);
578 \draw (2.75,1.5) node [anchor=west]{\texttt{execve}};
580 \filldraw[fill=black!15,rounded corners] (1.5,4) rectangle (4,5);
581 \draw (2.75,4.5) node {\texttt{main}};
583 \draw [<->, dashed] (2.75,3) -- (2.75,4);
584 \draw [->] (1.5,4.5) -- (0.3,4.5) -- (0.3,1);
585 \draw (0.9,4.5) node [anchor=south] {\texttt{\_exit}};
587 \filldraw[fill=black!15,rounded corners] (1.5,6) rectangle (4,7);
588 \draw (2.75,6.5) node {\texttt{funzione}};
590 \draw [<->, dashed] (2.75,5) -- (2.75,6);
591 \draw [->] (1.5,6.5) -- (0.05,6.5) -- (0.05,1);
592 \draw (0.9,6.5) node [anchor=south] {\texttt{\_exit}};
594 \draw (6.75,4.5) node (exit) [rectangle,fill=black!15,minimum width=2.5cm,minimum height=1cm,rounded corners, draw]{\texttt{exit}};
596 \draw[->] (4,6.5) -- node[anchor=south west]{\texttt{exit}} (exit);
597 \draw[->] (4,4.5) -- node[anchor=south]{\texttt{exit}} (exit);
598 \draw[->] (exit) -- node[anchor=east]{\texttt{\_exit}}(6.75,1);
600 \draw (10,4.5) node (exithandler1) [rectangle,fill=black!15,rounded corners, draw]{exit handler};
601 \draw (10,5.5) node (exithandler2) [rectangle,fill=black!15,rounded corners, draw]{exit handler};
602 \draw (10,3.5) node (stream) [rectangle,fill=black!15,rounded corners, draw]{chiusura stream};
604 \draw[<->, dashed] (exithandler1) -- (exit);
605 \draw[<->, dashed] (exithandler2) -- (exit);
606 \draw[<->, dashed] (stream) -- (exit);
608 \caption{Schema dell'avvio e della conclusione di un programma.}
609 \label{fig:proc_prog_start_stop}
612 Si ricordi infine che un programma può anche essere interrotto dall'esterno
613 attraverso l'uso di un segnale (modalità di conclusione non mostrata in
614 fig.~\ref{fig:proc_prog_start_stop}); tratteremo nei dettagli i segnali e la
615 loro gestione nel capitolo \ref{cha:signals}.
619 \section{I processi e l'uso della memoria}
620 \label{sec:proc_memory}
622 Una delle risorse più importanti che ciascun processo ha a disposizione è la
623 memoria, e la gestione della memoria è appunto uno degli aspetti più complessi
624 di un sistema unix-like. In questa sezione, dopo una breve introduzione ai
625 concetti di base, esamineremo come la memoria viene vista da parte di un
626 programma in esecuzione, e le varie funzioni utilizzabili per la sua gestione.
629 \subsection{I concetti generali}
630 \label{sec:proc_mem_gen}
632 Ci sono vari modi in cui i sistemi operativi organizzano la memoria, ed i
633 dettagli di basso livello dipendono spesso in maniera diretta
634 dall'architettura dell'hardware, ma quello più tipico, usato dai sistemi
635 unix-like come Linux è la cosiddetta \index{memoria~virtuale} \textsl{memoria
636 virtuale} che consiste nell'assegnare ad ogni processo uno spazio virtuale
637 di indirizzamento lineare, in cui gli indirizzi vanno da zero ad un qualche
638 valore massimo.\footnote{nel caso di Linux fino al kernel 2.2 detto massimo
639 era, per macchine a 32bit, di 2Gb. Con il kernel 2.4 ed il supporto per la
640 \textit{high-memory} il limite è stato esteso anche per macchine a 32 bit.}
643 Come accennato nel cap.~\ref{cha:intro_unix} questo spazio di indirizzi è
644 virtuale e non corrisponde all'effettiva posizione dei dati nella RAM del
645 computer. In generale detto spazio non è neppure continuo, cioè non tutti gli
646 indirizzi possibili sono utilizzabili, e quelli usabili non sono
647 necessariamente adiacenti.
649 Per la gestione da parte del kernel la memoria viene divisa in pagine di
650 dimensione fissa. Inizialmente queste pagine erano di 4kb sulle macchine a 32
651 bit e di 8kb sulle alpha. Con le versioni più recenti del kernel è possibile
652 anche utilizzare pagine di dimensioni maggiori (di 4Mb, dette \textit{huge
653 page}), per sistemi con grandi quantitativi di memoria in cui l'uso di
654 pagine troppo piccole comporta una perdita di prestazioni. In alcuni sistemi
655 la costante \const{PAGE\_SIZE}, definita in \file{limits.h}, indica la
656 dimensione di una pagina in byte, con Linux questo non avviene e per ottenere
657 questa dimensione si deve ricorrere alla funzione \func{getpagesize} (vedi
658 sez.~\ref{sec:sys_memory_res}).
660 Ciascuna pagina di memoria nello spazio di indirizzi virtuale è associata ad
661 un supporto che può essere una pagina di memoria reale o ad un dispositivo di
662 stoccaggio secondario (come lo spazio disco riservato alla \textit{swap}, o i
663 file che contengono il codice). Per ciascun processo il kernel si cura di
664 mantenere un mappa di queste corrispondenze nella cosiddetta
665 \itindex{page~table} \textit{page table}.\footnote{questa è una
666 semplificazione brutale, il meccanismo è molto più complesso; una buona
667 trattazione di come Linux gestisce la memoria virtuale si trova su
670 Una stessa pagina di memoria reale può fare da supporto a diverse pagine di
671 memoria virtuale appartenenti a processi diversi, come accade in genere per le
672 pagine che contengono il codice delle librerie condivise. Ad esempio il codice
673 della funzione \func{printf} starà su una sola pagina di memoria reale che
674 farà da supporto a tutte le pagine di memoria virtuale di tutti i processi che
675 hanno detta funzione nel loro codice.
677 La corrispondenza fra le pagine della \index{memoria~virtuale} memoria
678 virtuale di un processo e quelle della memoria fisica della macchina viene
679 gestita in maniera trasparente dal kernel.\footnote{in genere con l'ausilio
680 dell'hardware di gestione della memoria (la \textit{Memory Management Unit}
681 del processore), con i kernel della serie 2.6 è comunque diventato possibile
682 utilizzare Linux anche su architetture che non dispongono di una MMU.}
683 Poiché in genere la memoria fisica è solo una piccola frazione della memoria
684 virtuale, è necessario un meccanismo che permetta di trasferire le pagine che
685 servono dal supporto su cui si trovano in memoria, eliminando quelle che non
686 servono. Questo meccanismo è detto \index{paginazione} \textsl{paginazione}
687 (o \textit{paging}), ed è uno dei compiti principali del kernel.
689 Quando un processo cerca di accedere ad una pagina che non è nella memoria
690 reale, avviene quello che viene chiamato un \itindex{page~fault} \textit{page
691 fault}; la gestione della memoria genera un'interruzione e passa il
692 controllo al kernel il quale sospende il processo e si incarica di mettere in
693 RAM la pagina richiesta, effettuando tutte le operazioni necessarie per
694 reperire lo spazio necessario, per poi restituire il controllo al processo.
696 Dal punto di vista di un processo questo meccanismo è completamente
697 trasparente, e tutto avviene come se tutte le pagine fossero sempre
698 disponibili in memoria. L'unica differenza avvertibile è quella dei tempi di
699 esecuzione, che passano dai pochi nanosecondi necessari per l'accesso in RAM
700 se la pagina è direttamente disponibile, a tempi estremamente più lunghi,
701 dovuti all'intervento del kernel, qualora sia necessario reperire pagine
702 riposte nella \textit{swap}.
704 Normalmente questo è il prezzo da pagare per avere un multitasking reale, ed
705 in genere il sistema è molto efficiente in questo lavoro; quando però ci siano
706 esigenze specifiche di prestazioni è possibile usare delle funzioni che
707 permettono di bloccare il meccanismo della \index{paginazione} paginazione e
708 mantenere fisse delle pagine in memoria (vedi sez.~\ref{sec:proc_mem_lock}).
711 \subsection{La struttura della memoria di un processo}
712 \label{sec:proc_mem_layout}
714 Benché lo spazio di indirizzi virtuali copra un intervallo molto ampio, solo
715 una parte di essi è effettivamente allocato ed utilizzabile dal processo; il
716 tentativo di accedere ad un indirizzo non allocato è un tipico errore che si
717 commette quando si è manipolato male un puntatore e genera quella che viene
718 chiamata una \itindex{segment~violation} \textit{segment violation}. Se si
719 tenta cioè di leggere o scrivere con un indirizzo per il quale non esiste
720 un'associazione nella memoria virtuale, il kernel risponde al relativo
721 \itindex{page~fault} \textit{page fault} mandando un segnale \signal{SIGSEGV}
722 al processo, che normalmente ne causa la terminazione immediata.
724 È pertanto importante capire come viene strutturata \index{memoria~virtuale}
725 la memoria virtuale di un processo. Essa viene divisa in \textsl{segmenti},
726 cioè un insieme contiguo di indirizzi virtuali ai quali il processo può
727 accedere. Solitamente un programma C viene suddiviso nei seguenti segmenti:
729 \item Il \index{segmento!testo} segmento di testo o \textit{text segment}.
730 Contiene il codice del programma, delle funzioni di librerie da esso
731 utilizzate, e le costanti. Normalmente viene condiviso fra tutti i processi
732 che eseguono lo stesso programma e nel caso delle librerie anche da processi
733 che eseguono altri programmi.
735 Quando l'architettura hardware lo supporta viene marcato in sola lettura per
736 evitare sovrascritture accidentali (o maliziose) che ne modifichino le
737 istruzioni. Viene allocato da \func{execve} all'avvio del programma e resta
738 invariato per tutto il tempo dell'esecuzione.
740 \item Il \index{segmento!dati} segmento dei dati o \textit{data
741 segment}. Contiene tutti i dati del programma, come le
742 \index{variabili!globali} variabili globali, cioè quelle definite al di
743 fuori di tutte le funzioni che compongono il programma, e le
744 \index{variabili!statiche} variabili statiche, cioè quelle dichiarate con
745 l'attributo \direct{static},\footnote{la direttiva \direct{static} indica al
746 compilatore C che una variabile così dichiarata all'interno di una
747 funzione deve essere mantenuta staticamente in memoria (nel
748 \index{segmento!dati} segmento dati appunto); questo significa che la
749 variabile verrà inizializzata una sola volta alla prima invocazione della
750 funzione e che il suo valore sarà mantenuto fra diverse esecuzioni della
751 funzione stessa, la differenza con una \index{variabili!globali} variabile
752 globale è che essa può essere vista solo all'interno della funzione in cui
753 è dichiarata.} e la memoria allocata dinamicamente. Di norma è diviso in
757 \item Il segmento dei dati inizializzati, che contiene le variabili il cui
758 valore è stato assegnato esplicitamente. Ad esempio se si definisce:
759 \includecodesnip{listati/pi.c}
760 questo valore sarà immagazzinato in questo segmento. La memoria di questo
761 segmento viene preallocata all'avvio del programma e inizializzata ai valori
763 \item Il segmento dei dati non inizializzati, che contiene le variabili il
764 cui valore non è stato assegnato esplicitamente. Ad esempio se si
766 \includecodesnip{listati/vect.c}
767 questo vettore sarà immagazzinato in questo segmento. Anch'esso viene
768 allocato all'avvio, e tutte le variabili vengono inizializzate a zero (ed
769 i puntatori a \val{NULL}).\footnote{si ricordi che questo vale solo per le
770 variabili che vanno nel \index{segmento!dati} segmento dati, e non è
771 affatto vero in generale.} Storicamente questa seconda parte del
772 \index{segmento!dati} segmento dati viene chiamata BSS (da \textit{Block
773 Started by Symbol}). La sua dimensione è fissa.
774 \item Lo \itindex{heap} \textit{heap}, detto anche \textit{free
775 store}. Tecnicamente lo si può considerare l'estensione del segmento dei
776 dati non inizializzati, a cui di solito è posto giusto di seguito. Questo
777 è il segmento che viene utilizzato per l'allocazione dinamica della
778 memoria. Lo \textit{heap} può essere ridimensionato allargandolo e
779 restringendolo per allocare e disallocare la memoria dinamica con le
780 apposite funzioni (vedi sez.~\ref{sec:proc_mem_alloc}), ma il suo limite
781 inferiore, quello adiacente al segmento dei dati non inizializzati, ha una
785 \item Il segmento di \itindex{stack} \textit{stack}, che contiene quello che
786 viene chiamato \textit{stack} del programma. Tutte le volte che si effettua
787 una chiamata ad una funzione è qui che viene salvato l'indirizzo di ritorno
788 e le informazioni dello stato del chiamante (come il contenuto di alcuni
789 registri della CPU), poi la funzione chiamata alloca qui lo spazio per le
790 sue variabili locali. Tutti questi dati vengono \textit{impilati} (da questo
791 viene il nome \itindex{stack} \textit{stack}) in sequenza uno sull'altro; in
792 questo modo le funzioni possono essere chiamate ricorsivamente. Al ritorno
793 della funzione lo spazio è automaticamente rilasciato e
794 ``\textsl{ripulito}''.\footnote{il compilatore si incarica di generare
795 automaticamente il codice necessario, seguendo quella che viene chiamata
796 una \textit{calling convention}; quella standard usata con il C ed il C++
797 è detta \textit{cdecl} e prevede che gli argomenti siano caricati nello
798 \textit{stack} dal chiamante da destra a sinistra, e che sia il chiamante
799 stesso ad eseguire la ripulitura dello \textit{stack} al ritorno della
800 funzione, se ne possono però utilizzare di alternative (ad esempio nel
801 Pascal gli argomenti sono inseriti da sinistra a destra ed è compito del
802 chiamato ripulire lo \textit{stack}), in genere non ci si deve preoccupare
803 di questo fintanto che non si mescolano funzioni scritte con linguaggi
806 La dimensione di questo segmento aumenta seguendo la crescita dello
807 \itindex{stack} \textit{stack} del programma, ma non viene ridotta quando
808 quest'ultimo si restringe.
813 % \includegraphics[height=12cm]{img/memory_layout}
815 \draw (0,0) rectangle (4,1);
816 \draw (2,0.5) node {\textit{text}};
817 \draw (0,1) rectangle (4,2.5);
818 \draw (2,1.75) node {dati inizializzati};
819 \draw (0,2.5) rectangle (4,5);
820 \draw (2,3.75) node {dati non inizializzati};
821 \draw (0,5) rectangle (4,9);
822 \draw[dashed] (0,6) -- (4,6);
823 \draw[dashed] (0,8) -- (4,8);
824 \draw (2,5.5) node {\textit{heap}};
825 \draw (2,8.5) node {\textit{stack}};
826 \draw [->] (2,6) -- (2,6.5);
827 \draw [->] (2,8) -- (2,7.5);
828 \draw (0,9) rectangle (4,10);
829 \draw (2,9.5) node {\textit{environment}};
830 \draw (4,0) node [anchor=west] {\texttt{0x08000000}};
831 \draw (4,5) node [anchor=west] {\texttt{0x08xxxxxx}};
832 \draw (4,9) node [anchor=west] {\texttt{0xC0000000}};
834 \caption{Disposizione tipica dei segmenti di memoria di un processo.}
835 \label{fig:proc_mem_layout}
838 Una disposizione tipica dei vari segmenti (testo, dati inizializzati e non
839 inizializzati, \itindex{heap} \textit{heap}, \itindex{stack} \textit{stack},
840 ecc.) è riportata in fig.~\ref{fig:proc_mem_layout}. Si noti come in figura
841 sia indicata una ulteriore regione, marcata \textit{environment}, che è quella
842 che contiene i dati relativi alle variabili di ambiente passate al programma
843 al suo avvio (torneremo su questo argomento in sez.~\ref{sec:proc_environ}).
845 Usando il comando \cmd{size} su un programma se ne può stampare le dimensioni
846 dei \index{segmento!testo} segmenti di testo e \index{segmento!dati} di dati
847 (solo però per i dati inizializzati ed il BSS, dato che lo \itindex{heap}
848 \textit{heap} ha una dimensione dinamica). Si tenga presente comunque che il
849 BSS, contrariamente al segmento dei dati inizializzati, non è mai salvato sul
850 file che contiene l'eseguibile, dato che viene sempre inizializzato a zero al
851 caricamento del programma.
854 \subsection{Allocazione della memoria per i programmi C}
855 \label{sec:proc_mem_alloc}
857 Il C supporta direttamente, come linguaggio di programmazione, soltanto due
858 modalità di allocazione della memoria: l'\textsl{allocazione statica} e
859 l'\textsl{allocazione automatica}.
861 L'\textsl{allocazione statica} è quella con cui sono memorizzate le
862 \index{variabili!globali} variabili globali e le \index{variabili!statiche}
863 variabili statiche, cioè le variabili il cui valore deve essere mantenuto per
864 tutta la durata del programma. Come accennato queste variabili vengono
865 allocate nel \index{segmento!dati} segmento dei dati all'avvio del programma
866 come parte delle operazioni svolte da \func{exec}, e lo spazio da loro
867 occupato non viene liberato fino alla sua conclusione.
869 L'\textsl{allocazione automatica} è quella che avviene per gli argomenti di
870 una funzione e per le sue variabili locali, quelle che vengono definite
871 all'interno della funzione che esistono solo per la durata della sua esecuzione
872 e che per questo vengono anche dette \index{variabili!automatiche}
873 \textsl{variabili automatiche}. Lo spazio per queste variabili viene allocato
874 nello \itindex{stack} \textit{stack} quando viene eseguita la funzione e
875 liberato quando si esce dalla medesima.
877 Esiste però un terzo tipo di allocazione, l'\textsl{allocazione dinamica}
878 della memoria, che non è prevista direttamente all'interno del linguaggio C,
879 ma che è necessaria quando il quantitativo di memoria che serve è
880 determinabile solo durante il corso dell'esecuzione del programma. Il C non
881 consente di usare variabili allocate dinamicamente, non è possibile cioè
882 definire in fase di programmazione una variabile le cui dimensioni possano
883 essere modificate durante l'esecuzione del programma. Per questo la libreria
884 standard del C fornisce una opportuna serie di funzioni per eseguire
885 l'allocazione dinamica di memoria, che come accennato avviene nello
886 \itindex{heap} \textit{heap}.
888 Le variabili il cui contenuto è allocato in questo modo non potranno essere
889 usate direttamente come le altre (quelle nello \itindex{stack}
890 \textit{stack}), ma l'accesso sarà possibile solo in maniera indiretta,
891 attraverso i puntatori alla memoria loro riservata che si sono ottenuti dalle
892 funzioni di allocazione.
894 Le funzioni previste dallo standard ANSI C per la gestione della memoria sono
895 quattro: \func{malloc}, \func{calloc}, \func{realloc} e \func{free}. Le prime
896 due, \funcd{malloc} e \funcd{calloc} allocano nuovo spazio di memoria; i
897 rispettivi prototipi sono:
901 \fdecl{void *calloc(size\_t nmemb, size\_t size)}
902 \fdesc{Alloca un'area di memoria inizializzata a 0.}
903 \fdecl{void *malloc(size\_t size)}
904 \fdesc{Alloca un'area di memoria non inizializzata.}
906 {Entrambe le funzioni restituiscono il puntatore alla zona di memoria allocata
907 in caso di successo e \val{NULL} in caso di fallimento, nel qual caso
908 \var{errno} assumerà il valore \errcode{ENOMEM}.}
911 In genere si usano \func{malloc} e \func{calloc} per allocare dinamicamente
912 un'area di memoria.\footnote{queste funzioni presentano un comportamento
913 diverso fra le \acr{glibc} e le \acr{uClib} quando il valore di \param{size}
914 è nullo. Nel primo caso viene comunque restituito un puntatore valido,
915 anche se non è chiaro a cosa esso possa fare riferimento, nel secondo caso
916 viene restituito \val{NULL}. Il comportamento è analogo con
917 \code{realloc(NULL, 0)}.} Dato che i puntatori ritornati sono di tipo
918 generico non è necessario effettuare un cast per assegnarli a puntatori al
919 tipo di variabile per la quale si effettua l'allocazione, inoltre le funzioni
920 garantiscono che i puntatori siano allineati correttamente per tutti i tipi di
921 dati; ad esempio sulle macchine a 32 bit in genere sono allineati a multipli
922 di 4 byte e sulle macchine a 64 bit a multipli di 8 byte.
924 Nel caso di \func{calloc} l'area di memoria viene allocata nello \textit{heap}
925 come un vettore di \param{nmemb} membri di \param{size} byte di dimensione, e
926 preventivamente inizializzata a zero, nel caso di \func{malloc} invece vengono
927 semplicemente allocati \param{size} byte e l'area di memoria non viene
930 Una volta che non sia più necessaria la memoria allocata dinamicamente deve
931 essere esplicitamente rilasciata usando la funzione \func{free},\footnote{le
932 glibc provvedono anche una funzione \func{cfree} definita per compatibilità
933 con SunOS, che è deprecata.} il suo prototipo è:
937 \fdecl{void free(void *ptr)}
938 \fdesc{Disalloca un'area di memoria precedentemente allocata.}
940 {La funzione non ritorna nulla e non riporta errori.}
943 Questa funzione vuole come argomento \var{ptr} il puntatore restituito da una
944 precedente chiamata ad una qualunque delle funzioni di allocazione che non sia
945 già stato liberato da un'altra chiamata a \func{free}. Se il valore
946 di \param{ptr} è \val{NULL} la funzione non fa niente, mentre se l'area di
947 memoria era già stata liberata da un precedente chiamata il comportamento
948 della funzione è dichiarato indefinito, ma in genere comporta la corruzione
949 dei dati di gestione dell'allocazione, che può dar luogo a problemi gravi, ad
950 esempio un \textit{segmentation fault} in una successiva chiamata di una di
953 Dato che questo errore, chiamato in gergo \itindex{double~free} \textit{double
954 free}, è abbastanza frequente, specie quando si manipolano vettori di
955 puntatori, e dato che le conseguenze possono essere pesanti ed inaspettate, si
956 suggerisce come soluzione precauzionale di assegnare sempre a \val{NULL} ogni
957 puntatore su cui sia stata eseguita \func{free} immediatamente dopo
958 l'esecuzione della funzione. In questo modo, dato che con un puntatore nullo
959 \func{free} non esegue nessuna operazione, si evitano i problemi del
960 \itindex{double~free} \textit{double free}.
962 Infine la funzione \funcd{realloc} consente di modificare, in genere di
963 aumentare, la dimensione di un'area di memoria precedentemente allocata; il
968 \fdecl{void *realloc(void *ptr, size\_t size)}
969 \fdesc{Cambia la dimensione di un'area di memoria precedentemente allocata.}
970 } {La funzione ritorna il puntatore alla zona di memoria allocata in caso
971 di successo e \val{NULL} per un errore, nel qual caso \var{errno}
972 assumerà il valore \errcode{ENOMEM}.}
975 La funzione vuole come primo argomento il puntatore restituito da una
976 precedente chiamata a \func{malloc} o \func{calloc} e come secondo argomento
977 la nuova dimensione (in byte) che si intende ottenere. Se si passa
978 per \param{ptr} il valore \val{NULL} allora la funzione si comporta come
979 \func{malloc}.\footnote{questo è vero per Linux e l'implementazione secondo lo
980 standard ANSI C, ma non è vero per alcune vecchie implementazioni, inoltre
981 alcune versioni delle librerie del C consentivano di usare \func{realloc}
982 anche per un puntatore liberato con \func{free} purché non ci fossero state
983 nel frattempo altre chiamate a funzioni di allocazione, questa funzionalità
984 è totalmente deprecata e non è consentita sotto Linux.}
986 La funzione si usa ad esempio quando si deve far crescere la dimensione di un
987 vettore. In questo caso se è disponibile dello spazio adiacente al precedente
988 la funzione lo utilizza, altrimenti rialloca altrove un blocco della
989 dimensione voluta, copiandoci automaticamente il contenuto; lo spazio aggiunto
990 non viene inizializzato. Se la funzione fallisce l'area di memoria originale
991 non viene assolutamente toccata.
993 Si deve sempre avere ben presente il fatto che il blocco di memoria restituito
994 da \func{realloc} può non essere un'estensione di quello che gli si è passato
995 in ingresso; per questo si dovrà \emph{sempre} eseguire la riassegnazione di
996 \param{ptr} al valore di ritorno della funzione, e reinizializzare o provvedere
997 ad un adeguato aggiornamento di tutti gli altri puntatori all'interno del
998 blocco di dati ridimensionato.
1000 La \acr{glibc} ha un'implementazione delle funzioni di allocazione che è
1001 controllabile dall'utente attraverso alcune variabili di ambiente (vedi
1002 sez.~\ref{sec:proc_environ}), in particolare diventa possibile tracciare
1003 questo tipo di errori usando la variabile di ambiente \val{MALLOC\_CHECK\_}
1004 che quando viene definita mette in uso una versione meno efficiente delle
1005 funzioni suddette, che però è più tollerante nei confronti di piccoli errori
1006 come quello dei \itindex{double~free} \textit{double~free} o i
1007 \itindex{buffer~overrun} \textit{buffer overrun} di un byte.\footnote{uno
1008 degli errori più comuni, causato ad esempio dalla scrittura di una stringa
1009 di dimensione pari a quella del buffer, in cui ci si dimentica dello zero di
1010 terminazione finale.} In particolare:
1012 \item se la variabile è posta a $0$ gli errori vengono ignorati;
1013 \item se la variabile è posta a $1$ viene stampato un avviso sullo
1014 \textit{standard error} (vedi sez.~\ref{sec:file_std_stream});
1015 \item se la variabile è posta a $2$ viene chiamata la funzione \func{abort}
1016 (vedi sez.~\ref{sec:sig_alarm_abort}), che in genere causa l'immediata
1017 terminazione del programma;
1018 \item se la variabile è posta a $3$ viene stampato l'avviso e chiamata
1022 L'errore di programmazione più comune e più difficile da risolvere che si
1023 incontra con le funzioni di allocazione è quando non viene opportunamente
1024 liberata la memoria non più utilizzata, quello che in inglese viene chiamato
1025 \itindex{memory~leak} \textit{memory leak}, cioè una \textsl{perdita di
1028 Un caso tipico che illustra il problema è quello in cui in una propria
1029 funzione si alloca della memoria per uso locale senza liberarla prima di
1030 uscire. La memoria resta così allocata fino alla terminazione del processo.
1031 Chiamate ripetute alla stessa funzione continueranno ad effettuare altre
1032 allocazioni, che si accumuleranno causando a lungo andare un esaurimento della
1033 memoria disponibile e la probabile impossibilità di proseguire l'esecuzione
1036 Il problema è che l'esaurimento della memoria può avvenire in qualunque
1037 momento, in corrispondenza ad una qualunque chiamata di \func{malloc} che può
1038 essere in una sezione del codice che non ha alcuna relazione con la funzione
1039 che contiene l'errore. Per questo motivo è sempre molto difficile trovare un
1040 \itindex{memory~leak} \textit{memory leak}.
1042 In C e C++ il problema è particolarmente sentito. In C++, per mezzo della
1043 programmazione ad oggetti, il problema dei \itindex{memory~leak}
1044 \textit{memory leak} si può notevolmente ridimensionare attraverso l'uso
1045 accurato di appositi oggetti come gli \textit{smartpointers}. Questo però in
1046 genere va a scapito delle prestazioni dell'applicazione in esecuzione.
1048 % TODO decidere cosa fare di questo che segue
1049 % In altri linguaggi come il java e recentemente il C\# il problema non si pone
1050 % nemmeno perché la gestione della memoria viene fatta totalmente in maniera
1051 % automatica, ovvero il programmatore non deve minimamente preoccuparsi di
1052 % liberare la memoria allocata precedentemente quando non serve più, poiché
1053 % l'infrastruttura del linguaggio gestisce automaticamente la cosiddetta
1054 % \index{\textit{garbage~collection}} \textit{garbage collection}. In tal caso,
1055 % attraverso meccanismi simili a quelli del \textit{reference counting}, quando
1056 % una zona di memoria precedentemente allocata non è più riferita da nessuna
1057 % parte del codice in esecuzione, può essere deallocata automaticamente in
1058 % qualunque momento dall'infrastruttura.
1060 % Anche questo va a scapito delle prestazioni dell'applicazione in esecuzione
1061 % (inoltre le applicazioni sviluppate con tali linguaggi di solito non sono
1062 % eseguibili compilati, come avviene invece per il C ed il C++, ed è necessaria
1063 % la presenza di una infrastruttura per la loro interpretazione e pertanto hanno
1064 % di per sé delle prestazioni più scadenti rispetto alle stesse applicazioni
1065 % compilate direttamente). Questo comporta però il problema della non
1066 % predicibilità del momento in cui viene deallocata la memoria precedentemente
1067 % allocata da un oggetto.
1069 Per limitare l'impatto di questi problemi, e semplificare la ricerca di
1070 eventuali errori, l'implementazione delle funzioni di allocazione nella
1071 \acr{glibc} mette a disposizione una serie di funzionalità che permettono di
1072 tracciare le allocazioni e le disallocazioni, e definisce anche una serie di
1073 possibili \textit{hook} (\textsl{ganci}) che permettono di sostituire alle
1074 funzioni di libreria una propria versione (che può essere più o meno
1075 specializzata per il debugging). Esistono varie librerie che forniscono dei
1076 sostituti opportuni delle funzioni di allocazione in grado, senza neanche
1077 ricompilare il programma,\footnote{esempi sono \textit{Dmalloc}
1078 \href{http://dmalloc.com/}{\textsf{http://dmalloc.com/}} di Gray Watson ed
1079 \textit{Electric Fence} di Bruce Perens.} di eseguire diagnostiche anche
1080 molto complesse riguardo l'allocazione della memoria. Vedremo alcune delle
1081 funzionalità di ausilio presenti nella \acr{glibc} in
1082 sez.~\ref{sec:proc_memory_adv_management}.
1084 Una possibile alternativa all'uso di \func{malloc}, per evitare di soffrire
1085 dei problemi di \itindex{memory~leak} \textit{memory leak} descritti in
1086 precedenza, è di allocare la memoria nel segmento di \itindex{stack}
1087 \textit{stack} della funzione corrente invece che nello \itindex{heap}
1088 \textit{heap}. Per farlo si può usare la funzione \funcd{alloca}, la cui
1089 sintassi è identica a quella di \func{malloc}; il suo prototipo è:
1093 \fdecl{void *alloca(size\_t size)}
1094 \fdesc{Alloca un'area di memoria nello \textit{stack}.}
1096 {La funzione ritorna il puntatore alla zona di memoria allocata, in caso
1097 di errore il comportamento è indefinito.}
1100 La funzione alloca la quantità di memoria (non inizializzata) richiesta
1101 dall'argomento \param{size} nel segmento di \itindex{stack} \textit{stack}
1102 della funzione chiamante. Con questa funzione non è più necessario liberare
1103 la memoria allocata, e quindi non esiste un analogo della \func{free}, in
1104 quanto essa viene rilasciata automaticamente al ritorno della funzione.
1106 Come è evidente questa funzione ha alcuni vantaggi interessanti, anzitutto
1107 permette di evitare alla radice i problemi di \itindex{memory~leak}
1108 \textit{memory leak}, dato che non serve più la deallocazione esplicita;
1109 inoltre la deallocazione automatica funziona anche quando si usa
1110 \func{longjmp} per uscire da una subroutine con un salto non locale da una
1111 funzione (vedi sez.~\ref{sec:proc_longjmp}). Un altro vantaggio è che in
1112 Linux la funzione è molto più veloce di \func{malloc} e non viene sprecato
1113 spazio, infatti non è necessario gestire un pool di memoria da riservare e si
1114 evitano così anche i problemi di frammentazione di quest'ultimo, che
1115 comportano inefficienze sia nell'allocazione della memoria che nell'esecuzione
1118 Gli svantaggi sono che questa funzione non è disponibile su tutti gli Unix, e
1119 non è inserita né nello standard POSIX né in SUSv3 (ma è presente in BSD), il
1120 suo utilizzo quindi limita la portabilità dei programmi. Inoltre la funzione
1121 non può essere usata nella lista degli argomenti di una funzione, perché lo
1122 spazio verrebbe allocato nel mezzo degli stessi. Inoltre non è chiaramente
1123 possibile usare \func{alloca} per allocare memoria che deve poi essere usata
1124 anche al di fuori della funzione in cui essa viene chiamata, dato che
1125 all'uscita dalla funzione lo spazio allocato diventerebbe libero, e potrebbe
1126 essere sovrascritto all'invocazione di nuove funzioni. Questo è lo stesso
1127 problema che si può avere con le \index{variabili!automatiche} variabili
1128 automatiche, su cui torneremo in sez.~\ref{sec:proc_var_passing}.
1130 Infine non esiste un modo di sapere se l'allocazione ha avuto successo, la
1131 funzione infatti viene realizzata inserendo del codice \textit{inline} nel
1132 programma\footnote{questo comporta anche il fatto che non è possibile
1133 sostituirla con una propria versione o modificarne il comportamento
1134 collegando il proprio programma con un'altra libreria.} che si limita a
1135 modificare il puntatore nello \itindex{stack} \textit{stack} e non c'è modo di
1136 sapere se se ne sono superate le dimensioni, per cui in caso di fallimento
1137 nell'allocazione il comportamento del programma può risultare indefinito,
1138 dando luogo ad una \itindex{segment~violation} \textit{segment violation} la
1139 prima volta che cercherà di accedere alla memoria non effettivamente
1142 Le due funzioni seguenti\footnote{le due funzioni sono state definite con BSD
1143 4.3, sono marcate obsolete in SUSv2 e non fanno parte delle librerie
1144 standard del C e mentre sono state esplicitamente rimosse dallo standard
1145 POSIX.1-2001.} vengono utilizzate soltanto quando è necessario effettuare
1146 direttamente la gestione della memoria associata allo spazio dati di un
1147 processo, per poterle utilizzare è necessario definire una della macro di
1148 funzionalità (vedi sez.~\ref{sec:intro_gcc_glibc_std}) fra
1149 \macro{\_BSD\_SOURCE}, \macro{\_SVID\_SOURCE} e \macro{\_XOPEN\_SOURCE} (ad un
1150 valore maggiore o uguale di 500). La prima funzione è \funcd{brk}, ed il suo
1155 \fdecl{int brk(void *addr)}
1156 \fdesc{Sposta la fine del segmento dati del processo.}
1158 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore,
1159 nel qual caso \var{errno} assumerà il valore \errcode{ENOMEM}.}
1162 La funzione è un'interfaccia all'omonima \textit{system call} ed imposta
1163 l'indirizzo finale del \index{segmento!dati} segmento dati di un processo (più
1164 precisamente dello \itindex{heap} \textit{heap}) all'indirizzo specificato
1165 da \param{addr}. Quest'ultimo deve essere un valore ragionevole, e la
1166 dimensione totale non deve comunque eccedere un eventuale limite (vedi
1167 sez.~\ref{sec:sys_resource_limit}) imposto sulle dimensioni massime del
1168 \index{segmento!dati} segmento dati del processo.
1170 Il valore di ritorno della funzione fa riferimento alla versione fornita dalla
1171 \acr{glibc}, in realtà in Linux la \textit{system call} corrispondente
1172 restituisce come valore di ritorno il nuovo valore della fine del
1173 \index{segmento!dati} segmento dati in caso di successo e quello corrente in
1174 caso di fallimento, è la funzione di interfaccia usata dalla \acr{glibc} che
1175 fornisce i valori di ritorno appena descritti; se si usano librerie diverse
1176 questo potrebbe non accadere.
1178 Una seconda funzione per la manipolazione diretta delle dimensioni
1179 \index{segmento!dati} del segmento dati\footnote{in questo caso si tratta
1180 soltanto di una funzione di libreria, anche se basata sulla stessa
1181 \textit{system call}.} è \funcd{sbrk}, ed il suo prototipo è:
1185 \fdecl{void *sbrk(intptr\_t increment)}
1186 \fdesc{Incrementa la dimensione del segmento dati del processo.}
1188 {La funzione ritorna il puntatore all'inizio della nuova zona di memoria
1189 allocata in caso di successo e \val{NULL} per un errore, nel qual
1190 caso \var{errno} assumerà il valore \errcode{ENOMEM}.}
1193 La funzione incrementa la dimensione dello \itindex{heap} \textit{heap} di un
1194 programma del valore indicato dall'argomento \param{increment}, restituendo il
1195 nuovo indirizzo finale dello stesso. L'argomento è definito come di tipo
1196 \type{intptr\_t}, ma a seconda della versione delle librerie e del sistema può
1197 essere indicato con una serie di tipi equivalenti come \type{ptrdiff\_t},
1198 \type{ssize\_t}, \ctyp{int}. Se invocata con un valore nullo la funzione
1199 permette di ottenere l'attuale posizione della fine del \index{segmento!dati}
1202 Queste due funzioni sono state deliberatamente escluse dallo standard POSIX.1
1203 dato che per i normali programmi è sempre opportuno usare le funzioni di
1204 allocazione standard descritte in precedenza, a meno di non voler realizzare
1205 per proprio conto un diverso meccanismo di gestione della memoria del segmento
1209 \subsection{Il controllo della memoria virtuale}
1210 \label{sec:proc_mem_lock}
1212 \index{memoria~virtuale|(}
1214 Come spiegato in sez.~\ref{sec:proc_mem_gen} il kernel gestisce la memoria
1215 virtuale in maniera trasparente ai processi, decidendo quando rimuovere pagine
1216 dalla memoria per metterle nell'area di \textit{swap}, sulla base
1217 dell'utilizzo corrente da parte dei vari processi.
1219 Nell'uso comune un processo non deve preoccuparsi di tutto ciò, in quanto il
1220 meccanismo della \index{paginazione} paginazione riporta in RAM, ed in maniera
1221 trasparente, tutte le pagine che gli occorrono; esistono però esigenze
1222 particolari in cui non si vuole che questo meccanismo si attivi. In generale i
1223 motivi per cui si possono avere di queste necessità sono due:
1225 \item \textsl{La velocità}. Il processo della \index{paginazione} paginazione
1226 è trasparente solo se il programma in esecuzione non è sensibile al tempo
1227 che occorre a riportare la pagina in memoria; per questo motivo processi
1228 critici che hanno esigenze di tempo reale o tolleranze critiche nelle
1229 risposte (ad esempio processi che trattano campionamenti sonori) possono non
1230 essere in grado di sopportare le variazioni della velocità di accesso dovuta
1233 In certi casi poi un programmatore può conoscere meglio dell'algoritmo di
1234 allocazione delle pagine le esigenze specifiche del suo programma e decidere
1235 quali pagine di memoria è opportuno che restino in memoria per un aumento
1236 delle prestazioni. In genere queste sono esigenze particolari e richiedono
1237 anche un aumento delle priorità in esecuzione del processo (vedi
1238 sez.~\ref{sec:proc_real_time}).
1240 \item \textsl{La sicurezza}. Se si hanno password o chiavi segrete in chiaro
1241 in memoria queste possono essere portate su disco dal meccanismo della
1242 \index{paginazione} paginazione. Questo rende più lungo il periodo di tempo
1243 in cui detti segreti sono presenti in chiaro e più complessa la loro
1244 cancellazione: un processo infatti può cancellare la memoria su cui scrive
1245 le sue variabili, ma non può toccare lo spazio disco su cui una pagina di
1246 memoria può essere stata salvata. Per questo motivo di solito i programmi
1247 di crittografia richiedono il blocco di alcune pagine di memoria.
1250 Per ottenere informazioni sulle modalità in cui un programma sta usando la
1251 memoria virtuale è disponibile una apposita funzione, \funcd{mincore}, che
1252 però non è standardizzata da POSIX e pertanto non è disponibile su tutte le
1253 versioni di kernel unix-like;\footnote{nel caso di Linux devono essere
1254 comunque definite le macro \macro{\_BSD\_SOURCE} e \macro{\_SVID\_SOURCE}.}
1260 \fdecl{int mincore(void *addr, size\_t length, unsigned char *vec)}
1261 \fdesc{Ritorna lo stato delle pagine di memoria occupate da un processo.}
1263 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1264 caso \var{errno} assumerà uno dei valori:
1266 \item[\errcode{EAGAIN}] il kernel è temporaneamente non in grado di fornire
1268 \item[\errcode{EFAULT}] \param{vec} punta ad un indirizzo non valido.
1269 \item[\errcode{EINVAL}] \param{addr} non è un multiplo delle dimensioni di
1271 \item[\errcode{ENOMEM}] o \param{addr}$+$\param{length} eccede la dimensione
1272 della memoria usata dal processo o l'intervallo di indirizzi specificato
1277 La funzione permette di ottenere le informazioni sullo stato della mappatura
1278 della memoria per il processo chiamante, specificando l'intervallo da
1279 esaminare con l'indirizzo iniziale, indicato con l'argomento \param{addr}, e
1280 la lunghezza, indicata con l'argomento \param{length}. L'indirizzo iniziale
1281 deve essere un multiplo delle dimensioni di una pagina, mentre la lunghezza
1282 può essere qualunque, fintanto che si resta nello spazio di indirizzi del
1283 processo,\footnote{in caso contrario si avrà un errore di \errcode{ENOMEM};
1284 fino al kernel 2.6.11 in questo caso veniva invece restituito
1285 \errcode{EINVAL}, in considerazione che il caso più comune in cui si
1286 verifica questo errore è quando si usa per sbaglio un valore negativo
1287 di \param{length}, che nel caso verrebbe interpretato come un intero
1288 positivo di grandi dimensioni.} ma il risultato verrà comunque fornito per
1289 l'intervallo compreso fino al multiplo successivo.
1291 I risultati della funzione vengono forniti nel vettore puntato da \param{vec},
1292 che deve essere allocato preventivamente e deve essere di dimensione
1293 sufficiente a contenere tanti byte quante sono le pagine contenute
1294 nell'intervallo di indirizzi specificato, la dimensione cioè deve essere
1295 almeno pari a \code{(length+PAGE\_SIZE-1)/PAGE\_SIZE}. Al ritorno della
1296 funzione il bit meno significativo di ciascun byte del vettore sarà acceso se
1297 la pagina di memoria corrispondente è al momento residente in memoria, o
1298 cancellato altrimenti. Il comportamento sugli altri bit è indefinito, essendo
1299 questi al momento riservati per usi futuri. Per questo motivo in genere è
1300 comunque opportuno inizializzare a zero il contenuto del vettore, così che le
1301 pagine attualmente residenti in memoria saranno indicata da un valore non
1302 nullo del byte corrispondente.
1304 Dato che lo stato della memoria di un processo può cambiare continuamente, il
1305 risultato di \func{mincore} è assolutamente provvisorio e lo stato delle
1306 pagine potrebbe essere già cambiato al ritorno stesso della funzione, a meno
1307 che, come vedremo ora, non si sia attivato il meccanismo che forza il
1308 mantenimento di una pagina sulla memoria.
1310 \itindbeg{memory~locking}
1312 Il meccanismo che previene la \index{paginazione} paginazione di parte della
1313 memoria virtuale di un processo è chiamato \textit{memory locking} (o
1314 \textsl{blocco della memoria}). Il blocco è sempre associato alle pagine della
1315 memoria virtuale del processo, e non al segmento reale di RAM su cui essa
1316 viene mantenuta. La regola è che se un segmento di RAM fa da supporto ad
1317 almeno una pagina bloccata allora esso viene escluso dal meccanismo della
1318 \index{paginazione} paginazione. I blocchi non si accumulano, se si blocca due
1319 volte la stessa pagina non è necessario sbloccarla due volte, una pagina o è
1322 Il \textit{memory lock} persiste fintanto che il processo che detiene la
1323 memoria bloccata non la sblocca. Chiaramente la terminazione del processo
1324 comporta anche la fine dell'uso della sua memoria virtuale, e quindi anche di
1325 tutti i suoi \textit{memory lock}. Inoltre i \textit{memory lock} non sono
1326 ereditati dai processi figli, ma siccome Linux usa il \itindex{copy~on~write}
1327 \textit{copy on write} (vedi sez.~\ref{sec:proc_fork}) gli indirizzi virtuali
1328 del figlio sono mantenuti sullo stesso segmento di RAM del padre, e quindi
1329 fintanto che un figlio non scrive su un segmento bloccato, può usufruire del
1330 \textit{memory lock} del padre. Infine i \textit{memory lock} vengono
1331 automaticamente rimossi se si pone in esecuzione un altro programma con
1332 \func{exec} (vedi sez.~\ref{sec:proc_exec}).
1334 Il sistema pone dei limiti all'ammontare di memoria di un processo che può
1335 essere bloccata e al totale di memoria fisica che si può dedicare a questo, lo
1336 standard POSIX.1 richiede che sia definita in \file{unistd.h} la macro
1337 \macro{\_POSIX\_MEMLOCK\_RANGE} per indicare la capacità di eseguire il
1338 \textit{memory locking}.
1340 Siccome la richiesta di un \textit{memory lock} da parte di un processo riduce
1341 la memoria fisica disponibile nel sistema per gli altri processi, questo ha un
1342 evidente impatto su tutti gli altri processi, per cui fino al kernel 2.6.9
1343 solo un processo dotato di privilegi amministrativi (la \itindex{capabilities}
1344 \textit{capability} \const{CAP\_IPC\_LOCK}, vedi
1345 sez.~\ref{sec:proc_capabilities}) aveva la capacità di bloccare una pagina di
1348 A partire dal kernel 2.6.9 anche un processo normale può bloccare la propria
1349 memoria\footnote{la funzionalità è stata introdotta per non essere costretti a
1350 dare privilegi eccessivi a programmi di crittografia, che necessitano di
1351 questa funzionalità, ma che devono essere usati da utenti normali.} ma
1352 mentre un processo privilegiato non ha limiti sulla quantità di memoria che
1353 può bloccare, un processo normale è soggetto al limite della risorsa
1354 \const{RLIMIT\_MEMLOCK} (vedi sez.~\ref{sec:sys_resource_limit}). In generale
1355 poi ogni processo può sbloccare le pagine relative alla propria memoria, se
1356 però diversi processi bloccano la stessa pagina questa resterà bloccata
1357 fintanto che ci sarà almeno un processo che la blocca.
1359 Le funzioni per bloccare e sbloccare la \index{paginazione} paginazione di
1360 singole sezioni di memoria sono rispettivamente \funcd{mlock} e
1361 \funcd{munlock}; i loro prototipi sono:
1363 % \headdecl{sys/mman.h}
1365 % \funcdecl{int mlock(const void *addr, size\_t len)}
1366 % Blocca la paginazione su un intervallo di memoria.
1368 % \funcdecl{int munlock(const void *addr, size\_t len)}
1369 % Rimuove il blocco della paginazione su un intervallo di memoria.
1371 % \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e $-1$ in
1372 % caso di errore, nel qual caso \var{errno} assumerà uno dei
1375 % \item[\errcode{ENOMEM}] alcuni indirizzi dell'intervallo specificato non
1376 % corrispondono allo spazio di indirizzi del processo o si è ecceduto
1377 % il numero massimo consentito di pagine bloccate.
1378 % \item[\errcode{EINVAL}] \param{len} non è un valore positivo.
1379 % \item[\errcode{EPERM}] con un kernel successivo al 2.6.9 il processo non è
1380 % privilegiato e si un limite nullo per \const{RLIMIT\_MEMLOCK}.
1382 % e, per \func{mlock}, anche \errval{EPERM} quando il processo non ha i
1383 % privilegi richiesti per l'operazione.}
1388 \fdecl{int mlock(const void *addr, size\_t len)}
1389 \fdesc{Blocca la paginazione su un intervallo di memoria.}
1391 \fdecl{int munlock(const void *addr, size\_t len)}
1392 \fdesc{Rimuove il blocco della paginazione su un intervallo di memoria.}
1394 {Entrambe le funzioni ritornano $0$ in caso di successo e $-1$ in caso di
1395 errore, nel qual caso \var{errno} assumerà uno dei valori:
1397 \item[\errcode{EINVAL}] \param{len} non è un valore positivo.
1398 \item[\errcode{ENOMEM}] alcuni indirizzi dell’intervallo specificato non
1399 corrispondono allo spazio di indirizzi del processo o si è superato il
1400 limite di \const{RLIMIT\_MEMLOCK} per un processo non privilegiato (solo
1401 per kernel a partire dal 2.6.9).
1402 \item[\errcode{EPERM}] il processo non è privilegiato (per kernel precedenti
1403 il 2.6.9) o si ha un limite nullo per \const{RLIMIT\_MEMLOCK} e
1404 il processo non è privilegiato (per kernel a partire dal 2.6.9).
1408 Le due funzioni permettono rispettivamente di bloccare e sbloccare la
1409 \index{paginazione} paginazione per l'intervallo di memoria iniziante
1410 all'indirizzo \param{addr} e lungo \param{len} byte. Tutte le pagine che
1411 contengono una parte dell'intervallo bloccato sono mantenute in RAM per tutta
1412 la durata del blocco. Con kernel diversi da Linux si può ottenere un errore di
1413 \errcode{EINVAL} se \param{addr} non è un multiplo della dimensione delle
1414 pagine di memoria, pertanto se si ha a cuore la portabilità si deve avere cura
1415 di allinearne correttamente il valore.
1417 Altre due funzioni, \funcd{mlockall} e \funcd{munlockall}, consentono di
1418 bloccare genericamente la \index{paginazione} paginazione per l'intero spazio
1419 di indirizzi di un processo. I prototipi di queste funzioni sono:
1423 \fdecl{int mlockall(int flags)}
1424 \fdesc{Blocca la paginazione per lo spazio di indirizzi del processo corrente.}
1425 \fdecl{int munlockall(void)}
1426 \fdesc{Sblocca la paginazione per lo spazio di indirizzi del processo corrente.}
1428 {Codici di ritorno ed errori sono gli stessi di \func{mlock} e \func{munlock},
1429 tranne per \errcode{EINVAL} che viene restituito solo se si è specificato
1430 con \func{mlockall} un valore sconosciuto per \param{flags}.}
1433 L'argomento \param{flags} di \func{mlockall} permette di controllarne il
1434 comportamento; esso deve essere specificato come maschera binaria dei valori
1435 espressi dalle costanti riportate in tab.~\ref{tab:mlockall_flags}.
1440 \begin{tabular}[c]{|l|p{8cm}|}
1442 \textbf{Valore} & \textbf{Significato} \\
1445 \const{MCL\_CURRENT}& blocca tutte le pagine correntemente mappate nello
1446 spazio di indirizzi del processo.\\
1447 \const{MCL\_FUTURE} & blocca tutte le pagine che verranno mappate nello
1448 spazio di indirizzi del processo.\\
1451 \caption{Valori e significato dell'argomento \param{flags} della funzione
1453 \label{tab:mlockall_flags}
1456 Con \func{mlockall} si possono bloccare tutte le pagine mappate nello spazio
1457 di indirizzi del processo, sia che comprendano il \index{segmento!dati}
1458 \index{segmento!testo} segmento di testo, di dati, lo \itindex{stack}
1459 \textit{stack}, lo \itindex{heap} \textit{heap} e pure le funzioni di libreria
1460 chiamate, i file mappati in memoria, i dati del kernel mappati in user space,
1461 la memoria condivisa. L'uso dell'argomento \param{flags} permette di
1462 selezionare con maggior finezza le pagine da bloccare, ad esempio usando
1463 \const{MCL\_FUTURE} ci si può limitare a tutte le pagine allocate a partire
1464 dalla chiamata della funzione.
1466 In ogni caso un processo real-time che deve entrare in una
1467 \index{sezione~critica} sezione critica deve provvedere a riservare memoria
1468 sufficiente prima dell'ingresso, per scongiurare l'occorrenza di un eventuale
1469 \itindex{page~fault} \textit{page fault} causato dal meccanismo di
1470 \itindex{copy~on~write} \textit{copy on write}. Infatti se nella
1471 \index{sezione~critica} sezione critica si va ad utilizzare memoria che non è
1472 ancora stata riportata in RAM si potrebbe avere un \itindex{page~fault}
1473 \textit{page fault} durante l'esecuzione della stessa, con conseguente
1474 rallentamento (probabilmente inaccettabile) dei tempi di esecuzione.
1476 In genere si ovvia a questa problematica chiamando una funzione che ha
1477 allocato una quantità sufficientemente ampia di \index{variabili!automatiche}
1478 variabili automatiche, in modo che esse vengano mappate in RAM dallo
1479 \itindex{stack} \textit{stack}, dopo di che, per essere sicuri che esse siano
1480 state effettivamente portate in memoria, ci si scrive sopra.
1482 \itindend{memory~locking}
1484 \index{memoria~virtuale|)}
1487 \subsection{Gestione avanzata dell'allocazione della memoria}
1488 \label{sec:proc_memory_adv_management}
1490 La trattazione delle funzioni di allocazione di sez.~\ref{sec:proc_mem_alloc}
1491 si è limitata a coprire le esigenze generiche di un programma, in cui non si
1492 hanno dei requisiti specifici e si lascia il controllo delle modalità di
1493 allocazione alle funzioni di libreria. Tuttavia esistono una serie di casi in
1494 cui può essere necessario avere un controllo più dettagliato delle modalità
1495 con cui la memoria viene allocata; nel qual caso potranno venire in aiuto le
1496 funzioni trattate in questa sezione.
1498 Le prime funzioni che tratteremo sono quelle che consentono di richiedere di
1499 allocare un blocco di memoria ``\textsl{allineato}'' ad un multiplo una certa
1500 dimensione. Questo tipo di esigenza emerge usualmente quando si devono
1501 allocare dei buffer da utilizzare per eseguire dell'I/O diretto su dispositivi
1502 a blocchi. In questo caso infatti il trasferimento di dati viene eseguito per
1503 blocchi di dimensione fissa, ed è richiesto che l'indirizzo di partenza del
1504 buffer sia un multiplo intero di questa dimensione, usualmente 512 byte. In
1505 tal caso l'uso di \func{malloc} non è sufficiente, ed occorre utilizzare una
1508 Tradizionalmente per rispondere a questa esigenza sono state create due
1509 funzioni diverse, \funcd{memalign} e \funcd{valloc}, oggi obsolete; i
1510 rispettivi prototipi sono:
1514 \fdecl{void *valloc(size\_t size)}
1515 \fdesc{Alloca un blocco di memoria allineato alla dimensione di una pagina di
1517 \fdecl{void *memalign(size\_t boundary, size\_t size)}
1518 \fdesc{Alloca un blocco di memoria allineato ad un multiplo
1519 di \param{boundary}.}
1521 {Entrambe le funzioni ritornano un puntatore al blocco di memoria allocato in
1522 caso di successo e \val{NULL} in caso di errore, nel qual caso \var{errno}
1523 assumerà uno dei valori:
1525 \item[\errcode{EINVAL}] \param{boundary} non è una potenza di due.
1526 \item[\errcode{ENOMEM}] non c'è memoria sufficiente per l'allocazione.
1530 Le funzioni restituiscono il puntatore al buffer di memoria allocata di
1531 dimensioni pari a \param{size}, che per \func{memalign} sarà un multiplo
1532 di \param{boundary} mentre per \func{valloc} un multiplo della dimensione di
1533 una pagina di memoria. Nel caso della versione fornita dalla \acr{glibc} la
1534 memoria allocata con queste funzioni deve essere liberata con \func{free},
1535 cosa che non è detto accada con altre implementazioni.
1537 Nessuna delle due funzioni ha una chiara standardizzazione e nessuna delle due
1538 compare in POSIX.1, inoltre ci sono indicazioni discordi sui file che ne
1539 contengono la definizione;\footnote{secondo SUSv2 \func{valloc} è definita in
1540 \texttt{stdlib.h}, mentre sia le \acr{glibc} che le precedenti \acr{libc4} e
1541 \acr{libc5} la dichiarano in \texttt{malloc.h}, lo stesso vale per
1542 \func{memalign} che in alcuni sistemi è dichiarata in \texttt{stdlib.h}.}
1543 per questo motivo il loro uso è sconsigliato, essendo state sostituite dalla
1544 nuova \funcd{posix\_memalign}, che è stata standardizzata in POSIX.1d; il suo
1549 \fdecl{posix\_memalign(void **memptr, size\_t alignment, size\_t size)}
1550 \fdesc{Alloca un buffer di memoria allineato ad un multiplo
1551 di \param{alignment}.}
1553 {Entrambe le funzioni ritornano un puntatore al blocco di memoria allocato in
1554 caso di successo e \val{NULL} in caso di errore, nel qual caso \var{errno}
1555 assumerà uno dei valori:
1557 \item[\errcode{EINVAL}] \param{alignment} non è potenza di due e multiplo
1558 di \code{sizeof(void *)}.
1559 \item[\errcode{ENOMEM}] non c'è memoria sufficiente per l'allocazione.
1563 La funzione restituisce il puntatore al buffer allocato di dimensioni pari
1564 a \param{size} nella variabile (di tipo \texttt{void *}) posta all'indirizzo
1565 indicato da \param{memptr}. La funzione fallisce nelle stesse condizioni delle
1566 due funzioni precedenti, ma a loro differenza restituisce direttamente come
1567 valore di ritorno il codice di errore. Come per le precedenti la memoria
1568 allocata con \func{posix\_memalign} deve essere disallocata con \func{free},
1569 che in questo caso però è quanto richiesto dallo standard. Si tenga presente
1570 infine che nessuna di queste funzioni inizializza il buffer di memoria
1571 allocato, il loro comportamento cioè è analogo, allineamento a parte, a quello
1574 Un secondo caso in cui risulta estremamente utile poter avere un maggior
1575 controllo delle modalità di allocazione della memoria è quello in cui cercano
1576 errori di programmazione. Esempi di questi errori sono i \itindex{double~free}
1577 \textit{double free}, o i cosiddetti \itindex{buffer~overrun} \textit{buffer
1578 overrun}, cioè le scritture su un buffer oltre le dimensioni della sua
1579 allocazione,\footnote{entrambe queste operazioni causano in genere la
1580 corruzione dei dati di controllo delle funzioni di allocazione, che vengono
1581 anch'essi mantenuti nello \itindex{heap} \textit{heap} per tenere traccia
1582 delle zone di memoria allocata.} o i classici \itindex{memory~leak}
1583 \textit{memory leak}.
1585 Abbiamo visto in sez.~\ref{sec:proc_mem_lock} come una prima funzionalità di
1586 ausilio nella ricerca di questi errori sia l'uso della variabile di ambiente
1587 \var{MALLOC\_CHECK\_}. Una modalità alternativa per effettuare dei controlli
1588 di consistenza sullo stato delle allocazioni di memoria eseguite con
1589 \func{malloc}, anche questa fornita come estensione specifica (e non standard)
1590 della \acr{glibc}, è quella di utilizzare la funzione \funcd{mcheck}, che deve
1591 essere chiamata prima di eseguire qualunque allocazione con \func{malloc}; il
1596 \fdecl{int mcheck(void (*abortfn) (enum mcheck\_status status))}
1597 \fdesc{Attiva i controlli di consistenza delle allocazioni di memoria.}
1599 {La funzione ritorna $0$ in caso di successo e $-1$ per un errorre;
1600 \var{errno} non viene impostata.}
1603 La funzione consente di registrare una funzione di emergenza che verrà
1604 eseguita tutte le volte che, in una successiva esecuzione di \func{malloc},
1605 venissero trovate delle inconsistenze, come delle operazioni di scrittura
1606 oltre i limiti dei buffer allocati. Per questo motivo la funzione deve essere
1607 chiamata prima di qualunque allocazione di memoria, altrimenti fallirà.
1609 Se come primo argomento di \func{mcheck} si passa \val{NULL} verrà utilizzata
1610 una funzione predefinita che stampa un messaggio di errore ed invoca la
1611 funzione \func{abort} (vedi sez.~\ref{sec:sig_alarm_abort}), altrimenti si
1612 dovrà creare una funzione personalizzata in grado di ricevere il tipo di
1613 errore ed agire di conseguenza.
1615 Nonostante la scarsa leggibilità del prototipo si tratta semplicemente di
1616 definire una funzione di tipo \code{void abortfn(enum mcheck\_status status)},
1617 che non deve restituire nulla e che deve avere un unico argomento di tipo
1618 \type{mcheck\_status}. In caso di errore la funzione verrà eseguita ricevendo
1619 un opportuno valore di \param{status} che è un tipo enumerato che può assumere
1620 soltanto i valori di tab.~\ref{tab:mcheck_status_value} che indicano la
1621 tipologia di errore riscontrata.
1626 \begin{tabular}[c]{|l|p{7cm}|}
1628 \textbf{Valore} & \textbf{Significato} \\
1631 \const{MCHECK\_OK} & riportato a \func{mprobe} se nessuna
1632 inconsistenza è presente.\\
1633 \const{MCHECK\_DISABLED}& riportato a \func{mprobe} se si è chiamata
1634 \func{mcheck} dopo aver già usato
1636 \const{MCHECK\_HEAD} & i dati immediatamente precedenti il buffer sono
1637 stati modificati, avviene in genere quando si
1638 decrementa eccessivamente il valore di un
1639 puntatore scrivendo poi prima dell'inizio del
1641 \const{MCHECK\_TAIL} & i dati immediatamente seguenti il buffer sono
1642 stati modificati, succede quando si va scrivere
1643 oltre la dimensione corretta del buffer.\\
1644 \const{MCHECK\_FREE} & il buffer è già stato disallocato.\\
1647 \caption{Valori dello stato dell'allocazione di memoria ottenibili dalla
1648 funzione di terminazione installata con \func{mcheck}.}
1649 \label{tab:mcheck_status_value}
1652 Una volta che si sia chiamata \func{mcheck} con successo si può anche
1653 controllare esplicitamente lo stato delle allocazioni senza aspettare un
1654 errore nelle relative funzioni utilizzando la funzione \funcd{mprobe}, il cui
1659 \fdecl{enum mcheck\_status mprobe(ptr)}
1660 \fdesc{Esegue un controllo di consistenza delle allocazioni.}
1662 {La funzione ritorna un codice fra quelli riportati in
1663 tab.~\ref{tab:mcheck_status_value} e non ha errori.}
1666 La funzione richiede che si passi come argomento un puntatore ad un blocco di
1667 memoria precedentemente allocato con \func{malloc} o \func{realloc}, e
1668 restituisce lo stesso codice di errore che si avrebbe per la funzione di
1669 emergenza ad una successiva chiamata di una funzione di allocazione, e poi i
1670 primi due codici che indicano rispettivamente quando tutto è a posto o il
1671 controllo non è possibile per non aver chiamato \func{mcheck} in tempo.
1673 % TODO: trattare le altre funzionalità avanzate di \func{malloc}, mallopt,
1674 % mtrace, muntrace, mallinfo e gli hook con le glibc 2.10 c'è pure malloc_info
1675 % a sostituire mallinfo, vedi http://udrepper.livejournal.com/20948.html
1678 \section{Argomenti, ambiente ed altre proprietà di un processo}
1679 \label{sec:proc_options}
1681 In questa sezione esamineremo le funzioni che permettono di gestire gli
1682 argomenti e le opzioni, e quelle che consentono di manipolare ed utilizzare le
1683 variabili di ambiente. Accenneremo infine alle modalità con cui si può gestire
1684 la localizzazione di un programma modificandone il comportamento a seconda
1685 della lingua o del paese a cui si vuole faccia riferimento nelle sue
1688 \subsection{Il formato degli argomenti}
1689 \label{sec:proc_par_format}
1691 Tutti i programmi hanno la possibilità di ricevere argomenti e opzioni quando
1692 vengono lanciati e come accennato in sez.~\ref{sec:proc_main} questo viene
1693 effettuato attraverso gli argomenti \param{argc} e \param{argv} ricevuti nella
1694 funzione \func{main} all'avvio del programma. Questi argomenti vengono passati
1695 al programma dalla shell o dal processo che esegue la \func{exec} (secondo le
1696 modalità che vedremo in sez.~\ref{sec:proc_exec}) quando questo viene messo in
1699 Nel caso più comune il passaggio di argomenti ed opzioni viene effettuato
1700 dalla shell, che si incarica di leggere la linea di comando con cui si lancia
1701 il programma e di effettuarne la scansione (il cosiddetto \textit{parsing})
1702 per individuare le parole che la compongono, ciascuna delle quali potrà essere
1703 considerata un argomento o un'opzione.
1705 Di norma per individuare le parole che andranno a costituire la lista degli
1706 argomenti viene usato come carattere di separazione lo spazio o il tabulatore,
1707 ma la cosa dipende ovviamente dalle modalità con cui si effettua la scansione
1708 e dalle convenzioni adottate dal programma che la esegue: ad esempio la shell
1709 consente di proteggere con opportuni caratteri di controllo argomenti che
1710 contengono degli spazi evitando di spezzarli in parole diverse.
1714 % \includegraphics[width=13cm]{img/argv_argc}
1715 % \includegraphics[width=13cm]{img/argv_argc}
1716 \begin{tikzpicture}[>=stealth]
1717 \draw (0.5,2.5) rectangle (3.5,3);
1718 \draw (2,2.75) node {\texttt{argc = 5}};
1719 \draw (5,2.5) rectangle (8,3);
1720 \draw (6.5,2.75) node {\texttt{argv[0]}};
1721 \draw [->] (8,2.75) -- (9,2.75);
1722 \draw (9,2.75) node [anchor=west] {\texttt{"touch"}};
1723 \draw (5,2) rectangle (8,2.5);
1724 \draw (6.5,2.25) node {\texttt{argv[1]}};
1725 \draw [->] (8,2.25) -- (9,2.25);
1726 \draw (9,2.25) node [anchor=west] {\texttt{"-r"}};
1727 \draw (5,1.5) rectangle (8,2);
1728 \draw (6.5,1.75) node {\texttt{argv[2]}};
1729 \draw [->] (8,1.75) -- (9,1.75);
1730 \draw (9,1.75) node [anchor=west] {\texttt{"riferimento.txt"}};
1731 \draw (5,1.0) rectangle (8,1.5);
1732 \draw (6.5,1.25) node {\texttt{argv[3]}};
1733 \draw [->] (8,1.25) -- (9,1.25);
1734 \draw (9,1.25) node [anchor=west] {\texttt{"-m"}};
1735 \draw (5,0.5) rectangle (8,1.0);
1736 \draw (6.5,0.75) node {\texttt{argv[4]}};
1737 \draw [->] (8,0.75) -- (9,0.75);
1738 \draw (9,0.75) node [anchor=west] {\texttt{"questofile.txt"}};
1739 \draw (4.25,3.5) node{\texttt{"touch -r riferimento.txt -m questofile.txt"}};
1742 \caption{Esempio dei valori di \param{argv} e \param{argc} generati nella
1743 scansione di una riga di comando.}
1744 \label{fig:proc_argv_argc}
1747 Indipendentemente da come viene eseguita, il risultato finale della scansione
1748 dovrà comunque essere la costruzione del vettore di puntatori \param{argv} in
1749 cui si devono inserire in successione i puntatori alle stringhe costituenti i
1750 vari argomenti ed opzioni da passare al programma, e della
1751 variabile \param{argc} che deve essere inizializzata al numero di stringhe
1752 contenute in \param{argv}. Nel caso della shell questo comporta ad esempio che
1753 il primo argomento sia sempre il nome del programma. Un esempio di questo
1754 meccanismo è mostrato in fig.~\ref{fig:proc_argv_argc}, che illustra il
1755 risultato della scansione di una riga di comando.
1758 \subsection{La gestione delle opzioni}
1759 \label{sec:proc_opt_handling}
1761 In generale un programma Unix riceve da linea di comando sia gli argomenti che
1762 le opzioni, queste ultime sono standardizzate per essere riconosciute come
1763 tali: un elemento di \param{argv} successivo al primo che inizia con il
1764 carattere ``\texttt{-}'' e che non sia un singolo ``\texttt{-}'' o un
1765 ``\texttt{-{}-}'' viene considerato un'opzione. In genere le opzioni sono
1766 costituite da una lettera singola (preceduta dal carattere ``\texttt{-}'') e
1767 possono avere o no un parametro associato. Un esempio tipico può essere quello
1768 mostrato in fig.~\ref{fig:proc_argv_argc}. In quel caso le opzioni sono
1769 \cmd{-r} e \cmd{-m} e la prima vuole un parametro mentre la seconda no
1770 (\cmd{questofile.txt} è un argomento del programma, non un parametro di
1773 Per gestire le opzioni all'interno degli argomenti a linea di comando passati
1774 in \param{argv} la libreria standard del C fornisce la funzione
1775 \funcd{getopt}, che ha il seguente prototipo:
1779 \fdecl{int getopt(int argc, char * const argv[], const char *optstring)}
1780 \fdesc{Esegue la scansione delle opzioni negli argomenti della funzione
1783 {Ritorna il carattere che segue l'opzione, ``\texttt{:}'' se manca un
1784 parametro all'opzione, ``\texttt{?}'' se l'opzione è sconosciuta, e $-1$ se
1785 non esistono altre opzioni.}
1788 Questa funzione prende come argomenti le due variabili \param{argc} e
1789 \param{argv} che devono essere quelle passate come argomenti di \func{main}
1790 all'esecuzione del programma, ed una stringa \param{optstring} che indica
1791 quali sono le opzioni valide. La funzione effettua la scansione della lista
1792 degli argomenti ricercando ogni stringa che comincia con il carattere
1793 ``\texttt{-}'' e ritorna ogni volta che trova un'opzione valida.
1795 La stringa \param{optstring} indica quali sono le opzioni riconosciute ed è
1796 costituita da tutti i caratteri usati per identificare le singole opzioni, se
1797 l'opzione ha un parametro al carattere deve essere fatto seguire il carattere
1798 di due punti (``\texttt{:}''); nel caso di fig.~\ref{fig:proc_argv_argc} ad
1799 esempio la stringa di opzioni avrebbe dovuto contenere \texttt{"r:m"}.
1801 La modalità di uso di \func{getopt} è pertanto quella di chiamare più volte la
1802 funzione all'interno di un ciclo, fintanto che essa non ritorna il valore $-1$
1803 che indica che non ci sono più opzioni. Nel caso si incontri un'opzione non
1804 dichiarata in \param{optstring} viene ritornato il carattere ``\texttt{?}''
1805 mentre se un'opzione che lo richiede non è seguita da un parametro viene
1806 ritornato il carattere ``\texttt{:}'', infine se viene incontrato il valore
1807 ``\texttt{-{}-}'' la scansione viene considerata conclusa, anche se vi sono
1808 altri elementi di \param{argv} che cominciano con il carattere ``\texttt{-}''.
1810 \begin{figure}[!htb]
1811 \footnotesize \centering
1812 \begin{minipage}[c]{\codesamplewidth}
1813 \includecodesample{listati/option_code.c}
1816 \caption{Esempio di codice per la gestione delle opzioni.}
1817 \label{fig:proc_options_code}
1820 Quando \func{getopt} trova un'opzione fra quelle indicate in \param{optstring}
1821 essa ritorna il valore numerico del carattere, in questo modo si possono
1822 eseguire azioni specifiche usando uno \instruction{switch}; la funzione
1823 inoltre inizializza alcune \index{variabili!globali} variabili globali:
1825 \item \var{char *optarg} contiene il puntatore alla stringa parametro
1827 \item \var{int optind} alla fine della scansione restituisce l'indice del
1828 primo elemento di \param{argv} che non è un'opzione.
1829 \item \var{int opterr} previene, se posto a zero, la stampa di un messaggio
1830 di errore in caso di riconoscimento di opzioni non definite.
1831 \item \var{int optopt} contiene il carattere dell'opzione non riconosciuta.
1834 In fig.~\ref{fig:proc_options_code} si è mostrata la sezione del programma
1835 \file{ForkTest.c}, che useremo nel prossimo capitolo per effettuare dei test
1836 sulla creazione dei processi, deputata alla decodifica delle opzioni a riga di
1837 comando da esso supportate.
1839 Si può notare che si è anzitutto (\texttt{\small 1}) disabilitata la stampa di
1840 messaggi di errore per opzioni non riconosciute, per poi passare al ciclo per
1841 la verifica delle opzioni (\texttt{\small 2-27}); per ciascuna delle opzioni
1842 possibili si è poi provveduto ad un'azione opportuna, ad esempio per le tre
1843 opzioni che prevedono un parametro si è effettuata la decodifica del medesimo,
1844 il cui indirizzo è contenuto nella variabile \var{optarg}), avvalorando la
1845 relativa variabile (\texttt{\small 12-14}, \texttt{\small 15-17} e
1846 \texttt{\small 18-20}). Completato il ciclo troveremo in \var{optind} l'indice
1847 in \code{argv[]} del primo degli argomenti rimanenti nella linea di comando.
1849 Normalmente \func{getopt} compie una permutazione degli elementi di
1850 \param{argv} cosicché alla fine della scansione gli elementi che non sono
1851 opzioni sono spostati in coda al vettore. Oltre a questa esistono altre due
1852 modalità di gestire gli elementi di \param{argv}; se \param{optstring} inizia
1853 con il carattere ``\texttt{+}'' (o è impostata la variabile di ambiente
1854 \macro{POSIXLY\_CORRECT}) la scansione viene fermata non appena si incontra un
1855 elemento che non è un'opzione.
1857 L'ultima modalità, usata quando un programma può gestire la mescolanza fra
1858 opzioni e argomenti, ma se li aspetta in un ordine definito, si attiva
1859 quando \param{optstring} inizia con il carattere ``\texttt{-}''. In questo caso
1860 ogni elemento che non è un'opzione viene considerato comunque un'opzione e
1861 associato ad un valore di ritorno pari ad 1, questo permette di identificare
1862 gli elementi che non sono opzioni, ma non effettua il riordinamento del
1863 vettore \param{argv}.
1866 \subsection{Le variabili di ambiente}
1867 \label{sec:proc_environ}
1869 \index{variabili!di~ambiente|(}
1870 Oltre agli argomenti passati a linea di comando esiste un'altra modalità che
1871 permette di trasferire ad un processo delle informazioni in modo da
1872 modificarne il comportamento. Ogni processo infatti riceve dal sistema, oltre
1873 alle variabili \param{argv} e \param{argc} anche un \textsl{ambiente} (in
1874 inglese \textit{environment}); questo viene espresso nella forma di una lista
1875 (chiamata \textit{environment list}) delle cosiddette \textsl{variabili di
1876 ambiente}, i valori di queste variabili possono essere poi usati dal
1879 Anche in questo caso la lista delle \textsl{variabili di ambiente} deve essere
1880 costruita ed utilizzata nella chiamata alla funzione \func{exec} (torneremo su
1881 questo in sez.~\ref{sec:proc_exec}) quando questo viene lanciato. Come per la
1882 lista degli argomenti anche questa lista è un vettore di puntatori a
1883 caratteri, ciascuno dei quali punta ad una stringa, terminata da un
1884 \val{NULL}. A differenza di \code{argv[]} in questo caso non si ha una
1885 lunghezza del vettore data da un equivalente di \param{argc}, ma la lista è
1886 terminata da un puntatore nullo.
1888 L'indirizzo della lista delle variabili di ambiente è passato attraverso la
1889 \index{variabili!globali} variabile globale \var{environ}, che viene definita
1890 automaticamente per ciascun processo, e a cui si può accedere attraverso una
1891 semplice dichiarazione del tipo:
1892 \includecodesnip{listati/env_ptr.c}
1893 un esempio della struttura di questa lista, contenente alcune delle variabili
1894 più comuni che normalmente sono definite dal sistema, è riportato in
1895 fig.~\ref{fig:proc_envirno_list}.
1898 % \includegraphics[width=15 cm]{img/environ_var}
1899 \begin{tikzpicture}[>=stealth]
1900 \draw (2,3.5) node {\textsf{Environment pointer}};
1901 \draw (6,3.5) node {\textsf{Environment list}};
1902 \draw (10.5,3.5) node {\textsf{Environment string}};
1903 \draw (0.5,2.5) rectangle (3.5,3);
1904 \draw (2,2.75) node {\texttt{environ}};
1905 \draw [->] (3.5,2.75) -- (4.5,2.75);
1906 \draw (4.5,2.5) rectangle (7.5,3);
1907 \draw (6,2.75) node {\texttt{environ[0]}};
1908 \draw (4.5,2) rectangle (7.5,2.5);
1909 \draw (6,2.25) node {\texttt{environ[1]}};
1910 \draw (4.5,1.5) rectangle (7.5,2);
1911 \draw (4.5,1) rectangle (7.5,1.5);
1912 \draw (4.5,0.5) rectangle (7.5,1);
1913 \draw (4.5,0) rectangle (7.5,0.5);
1914 \draw (6,0.25) node {\texttt{NULL}};
1915 \draw [->] (7.5,2.75) -- (8.5,2.75);
1916 \draw (8.5,2.75) node[right] {\texttt{HOME=/home/piccardi}};
1917 \draw [->] (7.5,2.25) -- (8.5,2.25);
1918 \draw (8.5,2.25) node[right] {\texttt{PATH=:/bin:/usr/bin}};
1919 \draw [->] (7.5,1.75) -- (8.5,1.75);
1920 \draw (8.5,1.75) node[right] {\texttt{SHELL=/bin/bash}};
1921 \draw [->] (7.5,1.25) -- (8.5,1.25);
1922 \draw (8.5,1.25) node[right] {\texttt{EDITOR=emacs}};
1923 \draw [->] (7.5,0.75) -- (8.5,0.75);
1924 \draw (8.5,0.75) node[right] {\texttt{OSTYPE=linux-gnu}};
1926 \caption{Esempio di lista delle variabili di ambiente.}
1927 \label{fig:proc_envirno_list}
1930 Per convenzione le stringhe che definiscono l'ambiente sono tutte del tipo
1931 \textsl{\texttt{NOME=valore}} ed in questa forma che le funzioni di gestione
1932 che vedremo a breve se le aspettano, se pertanto si dovesse costruire
1933 manualmente un ambiente si abbia cura di rispettare questa convenzione.
1934 Inoltre alcune variabili, come quelle elencate in
1935 fig.~\ref{fig:proc_envirno_list}, sono definite dal sistema per essere usate
1936 da diversi programmi e funzioni: per queste c'è l'ulteriore convenzione di
1937 usare nomi espressi in caratteri maiuscoli.\footnote{ma si tratta solo di una
1938 convenzione, niente vieta di usare caratteri minuscoli, come avviene in vari
1941 Il kernel non usa mai queste variabili, il loro uso e la loro interpretazione è
1942 riservata alle applicazioni e ad alcune funzioni di libreria; in genere esse
1943 costituiscono un modo comodo per definire un comportamento specifico senza
1944 dover ricorrere all'uso di opzioni a linea di comando o di file di
1945 configurazione. É di norma cura della shell, quando esegue un comando, passare
1946 queste variabili al programma messo in esecuzione attraverso un uso opportuno
1947 delle relative chiamate (si veda sez.~\ref{sec:proc_exec}).
1949 La shell ad esempio ne usa molte per il suo funzionamento, come \texttt{PATH}
1950 per indicare la lista delle directory in cui effettuare la ricerca dei comandi
1951 o \texttt{PS1} per impostare il proprio \textit{prompt}. Alcune di esse, come
1952 \texttt{HOME}, \texttt{USER}, ecc. sono invece definite al login (per i
1953 dettagli si veda sez.~\ref{sec:sess_login}), ed in genere è cura della propria
1954 distribuzione definire le opportune variabili di ambiente in uno script di
1955 avvio. Alcune servono poi come riferimento generico per molti programmi, come
1956 \texttt{EDITOR} che indica l'editor preferito da invocare in caso di
1957 necessità. Una in particolare, \texttt{LANG}, serve a controllare la
1958 localizzazione del programma (su cui torneremo in
1959 sez.~\ref{sec:proc_localization}) per adattarlo alla lingua ed alle convezioni
1962 Gli standard POSIX e XPG3 definiscono alcune di queste variabili (le più
1963 comuni), come riportato in tab.~\ref{tab:proc_env_var}. GNU/Linux le supporta
1964 tutte e ne definisce anche altre, in particolare poi alcune funzioni di
1965 libreria prevedono la presenza di specifiche variabili di ambiente che ne
1966 modificano il comportamento, come quelle usate per indicare una localizzazione
1967 e quelle per indicare un fuso orario; una lista più completa che comprende
1968 queste ed ulteriori variabili si può ottenere con il comando \cmd{man 7
1974 \begin{tabular}[c]{|l|c|c|c|l|}
1976 \textbf{Variabile} & \textbf{POSIX} & \textbf{XPG3}
1977 & \textbf{Linux} & \textbf{Descrizione} \\
1980 \texttt{USER} &$\bullet$&$\bullet$&$\bullet$& Nome utente\\
1981 \texttt{LOGNAME}&$\bullet$&$\bullet$&$\bullet$& Nome di login\\
1982 \texttt{HOME} &$\bullet$&$\bullet$&$\bullet$& Directory base
1984 \texttt{LANG} &$\bullet$&$\bullet$&$\bullet$& Localizzazione\\
1985 \texttt{PATH} &$\bullet$&$\bullet$&$\bullet$& Elenco delle directory
1987 \texttt{PWD} &$\bullet$&$\bullet$&$\bullet$& Directory corrente\\
1988 \texttt{SHELL} &$\bullet$&$\bullet$&$\bullet$& Shell in uso\\
1989 \texttt{TERM} &$\bullet$&$\bullet$&$\bullet$& Tipo di terminale\\
1990 \texttt{PAGER} &$\bullet$&$\bullet$&$\bullet$& Programma per vedere i
1992 \texttt{EDITOR} &$\bullet$&$\bullet$&$\bullet$& Editor preferito\\
1993 \texttt{BROWSER}&$\bullet$&$\bullet$&$\bullet$& Browser preferito\\
1994 \texttt{TMPDIR} &$\bullet$&$\bullet$&$\bullet$& Directory dei file
1998 \caption{Esempi delle variabili di ambiente più comuni definite da vari
2000 \label{tab:proc_env_var}
2003 Lo standard ANSI C prevede l'esistenza di un ambiente, e pur non entrando
2004 nelle specifiche di come sono strutturati i contenuti, definisce la funzione
2005 \funcd{getenv} che permette di ottenere i valori delle variabili di ambiente;
2010 \fdecl{char *getenv(const char *name)}
2011 \fdesc{Cerca una variabile di ambiente del processo.}
2013 {La funzione ritorna il puntatore alla stringa contenente il valore della
2014 variabile di ambiente in caso di successo e \val{NULL} per un errore.}
2017 La funzione effettua una ricerca nell'ambiente del processo cercando una
2018 variabile il cui nome corrisponda a quanto indicato con
2019 l'argomento \param{name}, ed in caso di successo ritorna il puntatore alla
2020 stringa che ne contiene il valore, nella forma ``\texttt{NOME=valore}''.
2025 \begin{tabular}[c]{|l|c|c|c|c|c|c|}
2027 \textbf{Funzione} & \textbf{ANSI C} & \textbf{POSIX.1} & \textbf{XPG3} &
2028 \textbf{SVr4} & \textbf{BSD} & \textbf{Linux} \\
2031 \func{getenv} & $\bullet$ & $\bullet$ & $\bullet$
2032 & $\bullet$ & $\bullet$ & $\bullet$ \\
2033 \func{setenv} & -- & -- & --
2034 & -- & $\bullet$ & $\bullet$ \\
2035 \func{unsetenv}& -- & -- & --
2036 & -- & $\bullet$ & $\bullet$ \\
2037 \func{putenv} & -- & opz. & $\bullet$
2038 & -- & $\bullet$ & $\bullet$ \\
2039 \func{clearenv}& -- & opz. & --
2040 & -- & -- & $\bullet$ \\
2043 \caption{Funzioni per la gestione delle variabili di ambiente.}
2044 \label{tab:proc_env_func}
2047 Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI
2048 C, nell'evoluzione dei sistemi Unix ne sono state proposte altre, da
2049 utilizzare per impostare, modificare e per cancellare le variabili di
2050 ambiente. Uno schema delle funzioni previste nei vari standard e disponibili
2051 in Linux è riportato in tab.~\ref{tab:proc_env_func}. Tutte le funzioni sono
2052 state comunque inserite nello standard POSIX.1-2001, ad eccetto di
2053 \func{clearenv} che è stata rigettata.
2055 In Linux sono definite tutte le funzioni elencate in
2056 tab.~\ref{tab:proc_env_func},\footnote{in realtà nelle libc4 e libc5 sono
2057 definite solo le prime quattro, \func{clearenv} è stata introdotta con la
2058 \acr{glibc} 2.0.} anche se parte delle funzionalità sono ridondanti. La
2059 prima funzione di manipolazione che prenderemo in considerazione è
2060 \funcd{putenv}, che consente di aggiungere, modificare e cancellare una
2061 variabile di ambiente; il suo prototipo è:
2064 \fdecl{int putenv(char *string)}
2065 \fdesc{Inserisce, modifica o rimuove una variabile d'ambiente.}
2067 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, che può
2068 essere solo \errval{ENOMEM}.}
2071 La funzione prende come argomento una stringa analoga a quella restituita da
2072 \func{getenv} e sempre nella forma ``\texttt{NOME=valore}''. Se la variabile
2073 specificata (nel caso \texttt{NOME}) non esiste la stringa sarà aggiunta
2074 all'ambiente, se invece esiste il suo valore sarà impostato a quello
2075 specificato dal contenuto di \param{string} (nel caso \texttt{valore}). Se
2076 invece si passa come argomento solo il nome di una variabile di ambiente
2077 (cioè \param{string} è nella forma ``\texttt{NOME}'' e non contiene il
2078 carattere ``\texttt{=}'') allora questa, se presente nell'ambiente, verrà
2081 Si tenga presente che, seguendo lo standard SUSv2, le \acr{glibc} successive
2082 alla versione 2.1.2 aggiungono direttamente \param{string} nella lista delle
2083 variabili di ambiente illustrata in fig.~\ref{fig:proc_envirno_list}
2084 sostituendo il relativo puntatore;\footnote{il comportamento è lo stesso delle
2085 vecchie \acr{libc4} e \acr{libc5}; nella \acr{glibc}, dalla versione 2.0
2086 alla 2.1.1, veniva invece fatta una copia, seguendo il comportamento di
2087 BSD4.4; dato che questo può dar luogo a perdite di memoria e non rispetta lo
2088 standard il comportamento è stato modificato a partire dalle 2.1.2,
2089 eliminando anche, sempre in conformità a SUSv2, l'attributo \direct{const}
2090 dal prototipo.} pertanto ogni cambiamento alla stringa in questione si
2091 riflette automaticamente sull'ambiente, e quindi si deve evitare di passare a
2092 questa funzione una \index{variabili!automatiche} variabile automatica (per
2093 evitare i problemi esposti in sez.~\ref{sec:proc_var_passing}). Benché non sia
2094 richiesto dallo standard nelle versioni della \acr{glibc} a partire dalla 2.1
2095 la funzione è rientrante (vedi sez.~\ref{sec:proc_reentrant}).
2097 Infine quando una chiamata a \func{putenv} comporta la necessità di creare una
2098 nuova versione del vettore \var{environ} questo sarà allocato automaticamente,
2099 ma la versione corrente sarà deallocata solo se anch'essa è risultante da
2100 un'allocazione fatta in precedenza da un'altra \func{putenv}. Questo avviene
2101 perché il vettore delle variabili di ambiente iniziale, creato dalla chiamata
2102 ad \func{exec} (vedi sez.~\ref{sec:proc_exec}) è piazzato nella memoria al di
2103 sopra dello \itindex{stack} \textit{stack}, (vedi
2104 fig.~\ref{fig:proc_mem_layout}) e non nello \itindex{heap} \textit{heap} e
2105 quindi non può essere deallocato. Inoltre la memoria associata alle variabili
2106 di ambiente eliminate non viene liberata.
2108 Come alternativa a \func{putenv} si può usare la funzione \funcd{setenv} che
2109 però consente solo di aggiungere o modificare una variabile di ambiente; il
2114 \fdecl{int setenv(const char *name, const char *value, int overwrite)}
2115 \fdesc{Inserisce o modifica una variabile di ambiente.}
2117 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore,
2118 nel qual caso \var{errno} assumerà uno dei valori:
2120 \item[\errcode{EINVAL}] \param{name} è \val{NULL} o una stringa di lunghezza
2121 nulla o che contiene il carattere ``\texttt{=}''.
2122 \item[\errcode{ENOMEM}] non c'è memoria sufficiente per aggiungere una nuova
2123 variabile all'ambiente.
2127 La funzione consente di specificare separatamente nome e valore della
2128 variabile di ambiente da aggiungere negli argomenti \param{name}
2129 e \param{value}. Se la variabile è già presente nell'ambiente
2130 l'argomento \param{overwrite} specifica il comportamento della funzione, se
2131 diverso da zero sarà sovrascritta, se uguale a zero sarà lasciata immutata. A
2132 differenza di \func{putenv} la funzione esegue delle copie del contenuto degli
2133 argomenti \param{name} e \param{value} e non è necessario preoccuparsi di
2134 allocarli in maniera permanente.
2136 La cancellazione di una variabile di ambiente viene invece gestita
2137 esplicitamente con \funcd{unsetenv}, il cui prototipo è:
2141 \fdecl{int unsetenv(const char *name)}
2142 \fdesc{Rimuove una variabile di ambiente.}
2144 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore,
2145 nel qual caso \var{errno} assumerà uno dei valori:
2147 \item[\errcode{EINVAL}] \param{name} è \val{NULL} o una stringa di lunghezza
2148 nulla o che contiene il carattere ``\texttt{=}''.
2152 La funzione richiede soltanto il nome della variabile di ambiente
2153 nell'argomento \param{name}, se la variabile non esiste la funzione ritorna
2154 comunque con un valore di successo.\footnote{questo con le versioni della
2155 \acr{glibc} successive la 2.2.2, per le precedenti \func{unsetenv} era
2156 definita come \texttt{void} e non restituiva nessuna informazione.}
2158 L'ultima funzione per la gestione dell'ambiente è
2159 \funcd{clearenv},\footnote{che come accennato è l'unica non presente nello
2160 standard POSIX.1-2000, ed è disponibili solo per versioni della \acr{glibc}
2161 a partire dalla 2.0; per poterla utilizzare occorre aver definito le macro
2162 \macro{\_SVID\_SOURCE} e \macro{\_XOPEN\_SOURCE}.} che viene usata per
2163 cancellare completamente tutto l'ambiente; il suo prototipo è:
2167 \fdecl{int clearenv(void)}
2168 \fdesc{Cancella tutto l'ambiente.}
2170 {La funzione ritorna $0$ in caso di successo e un valore diverso da zero per
2174 In genere si usa questa funzione in maniera precauzionale per evitare i
2175 problemi di sicurezza connessi nel trasmettere ai programmi che si invocano un
2176 ambiente che può contenere dei dati non controllati, le cui variabili possono
2177 causare effetti indesiderati. Con l'uso della funzione si provvede alla
2178 cancellazione di tutto l'ambiente originale in modo da poterne costruirne una
2179 versione ``\textsl{sicura}'' da zero.
2181 \index{variabili!di~ambiente|)}
2184 \subsection{La localizzazione}
2185 \label{sec:proc_localization}
2187 Abbiamo accennato in sez.~\ref{sec:proc_environ} come la variabile di ambiente
2188 \texttt{LANG} sia usata per indicare ai processi il valore della cosiddetta
2189 \textsl{localizzazione}. Si tratta di una funzionalità fornita dalle librerie
2190 di sistema\footnote{prenderemo in esame soltanto il caso della \acr{glibc}.}
2191 che consente di gestire in maniera automatica sia la lingua in cui vengono
2192 stampati i vari messaggi (come i messaggi associati agli errori che vedremo in
2193 sez.~\ref{sec:sys_strerror}) che le convenzioni usate nei vari paesi per una
2194 serie di aspetti come il formato dell'ora, quello delle date, gli ordinamenti
2195 alfabetici, le espressioni della valute, ecc.
2199 % La localizzazione di un programma si può selezionare con la
2201 % In realtà perché un programma sia effettivamente localizzato non è sufficiente
2203 % TODO trattare, quando ci sarà tempo, setlocale ed il resto
2206 %\subsection{Opzioni in formato esteso}
2207 %\label{sec:proc_opt_extended}
2209 %Oltre alla modalità ordinaria di gestione delle opzioni trattata in
2210 %sez.~\ref{sec:proc_opt_handling} le \acr{glibc} forniscono una modalità
2211 %alternativa costituita dalle cosiddette \textit{long-options}, che consente di
2212 %esprimere le opzioni in una forma più descrittiva che nel caso più generale è
2213 %qualcosa del tipo di ``\texttt{-{}-option-name=parameter}''.
2215 %(NdA: questa parte verrà inserita in seguito).
2217 % TODO opzioni in formato esteso
2219 \section{Problematiche di programmazione generica}
2220 \label{sec:proc_gen_prog}
2222 Benché questo non sia un libro sul linguaggio C, è opportuno affrontare alcune
2223 delle problematiche generali che possono emergere nella programmazione con
2224 questo linguaggio e di quali precauzioni o accorgimenti occorre prendere per
2225 risolverle. Queste problematiche non sono specifiche di sistemi unix-like o
2226 multitasking, ma avendo trattato in questo capitolo il comportamento dei
2227 processi visti come entità a sé stanti, le riportiamo qui.
2230 \subsection{Il passaggio di variabili e valori di ritorno nelle funzioni}
2231 \label{sec:proc_var_passing}
2233 Una delle caratteristiche standard del C è che le variabili vengono passate
2234 alle funzioni che si invocano in un programma attraverso un meccanismo che
2235 viene chiamato \textit{by value}, diverso ad esempio da quanto avviene con il
2236 Fortran, dove le variabili sono passate, come suol dirsi, \textit{by
2237 reference}, o dal C++ dove la modalità del passaggio può essere controllata
2238 con l'operatore \cmd{\&}.
2240 Il passaggio di una variabile \textit{by value} significa che in realtà quello
2241 che viene passato alla funzione è una copia del valore attuale di quella
2242 variabile, copia che la funzione potrà modificare a piacere, senza che il
2243 valore originale nella funzione chiamante venga toccato. In questo modo non
2244 occorre preoccuparsi di eventuali effetti delle operazioni svolte nella
2245 funzione stessa sulla variabile passata come argomento.
2247 Questo però va inteso nella maniera corretta. Il passaggio \textit{by value}
2248 vale per qualunque variabile, puntatori compresi; quando però in una funzione
2249 si usano dei puntatori (ad esempio per scrivere in un buffer) in realtà si va
2250 a modificare la zona di memoria a cui essi puntano, per cui anche se i
2251 puntatori sono copie, i dati a cui essi puntano saranno sempre gli stessi, e
2252 le eventuali modifiche avranno effetto e saranno visibili anche nella funzione
2255 Nella maggior parte delle funzioni di libreria e delle \textit{system call} i
2256 puntatori vengono usati per scambiare dati (attraverso i buffer o le strutture
2257 a cui fanno riferimento) e le variabili normali vengono usate per specificare
2258 argomenti; in genere le informazioni a riguardo dei risultati vengono passate
2259 alla funzione chiamante attraverso il valore di ritorno. È buona norma
2260 seguire questa pratica anche nella programmazione normale.
2262 Talvolta però è necessario che la funzione possa restituire indietro alla
2263 funzione chiamante un valore relativo ad uno dei suoi argomenti usato anche in
2264 ingresso. Per far questo si usa il cosiddetto \itindex{value~result~argument}
2265 \textit{value result argument}, si passa cioè, invece di una normale
2266 variabile, un puntatore alla stessa. Gli esempi di questa modalità di
2267 passaggio sono moltissimi, ad esempio essa viene usata nelle funzioni che
2268 gestiscono i socket (in sez.~\ref{sec:TCP_functions}), in cui, per permettere
2269 al kernel di restituire informazioni sulle dimensioni delle strutture degli
2270 indirizzi utilizzate, viene usato proprio questo meccanismo.
2272 Occorre tenere ben presente questa differenza, perché le variabili passate in
2273 maniera ordinaria, che vengono inserite nello \textit{stack}, cessano di
2274 esistere al ritorno di una funzione, ed ogni loro eventuale modifica
2275 all'interno della stessa sparisce con la conclusione della stessa, per poter
2276 passare delle informazioni occorre quindi usare un puntatore che faccia
2277 riferimento ad un indirizzo accessibile alla funzione chiamante.
2279 Questo requisito di accessibilità è fondamentale, infatti dei possibili
2280 problemi che si possono avere con il passaggio dei dati è quello di restituire
2281 alla funzione chiamante dei dati che sono contenuti in una
2282 \index{variabili!automatiche} variabile automatica. Ovviamente quando la
2283 funzione ritorna la sezione dello \itindex{stack} \textit{stack} che conteneva
2284 la \index{variabili!automatiche} variabile automatica (si ricordi quanto detto
2285 in sez.~\ref{sec:proc_mem_alloc}) verrà liberata automaticamente e potrà
2286 essere riutilizzata all'invocazione di un'altra funzione, con le immaginabili
2287 conseguenze, quasi invariabilmente catastrofiche, di sovrapposizione e
2288 sovrascrittura dei dati.
2290 Per questo una delle regole fondamentali della programmazione in C è che
2291 all'uscita di una funzione non deve restare nessun riferimento alle sue
2292 \index{variabili!automatiche} variabili locali. Qualora sia necessario
2293 utilizzare delle variabili che devono essere viste anche dalla funzione
2294 chiamante queste devono essere allocate esplicitamente, o in maniera statica
2295 usando variabili globali o dichiarate come \direct{extern},\footnote{la
2296 direttiva \direct{extern} informa il compilatore che la variabile che si è
2297 dichiarata in una funzione non è da considerarsi locale, ma globale, e per
2298 questo allocata staticamente e visibile da tutte le funzioni dello stesso
2299 programma.} o dinamicamente con una delle funzioni della famiglia
2300 \func{malloc}, passando opportunamente il relativo puntatore fra le funzioni.
2303 \subsection{Il passaggio di un numero variabile di argomenti}
2304 \label{sec:proc_variadic}
2306 \index{funzioni!variadic|(}
2308 Come vedremo nei capitoli successivi, non sempre è possibile specificare un
2309 numero fisso di argomenti per una funzione. Lo standard ISO C prevede nella
2310 sua sintassi la possibilità di definire delle \textit{variadic function} che
2311 abbiano un numero variabile di argomenti, attraverso l'uso nella dichiarazione
2312 della funzione dello speciale costrutto ``\texttt{...}'', che viene chiamato
2315 Lo standard però non provvede a livello di linguaggio alcun meccanismo con cui
2316 dette funzioni possono accedere ai loro argomenti. L'accesso viene pertanto
2317 realizzato a livello della libreria standard del C che fornisce gli strumenti
2318 adeguati. L'uso di una \textit{variadic function} prevede quindi tre punti:
2320 \item \textsl{dichiarare} la funzione come \textit{variadic} usando un
2321 prototipo che contenga una \textit{ellipsis};
2322 \item \textsl{definire} la funzione come \textit{variadic} usando la stessa
2323 \textit{ellipsis}, ed utilizzare le apposite macro che consentono la
2324 gestione di un numero variabile di argomenti;
2325 \item \textsl{invocare} la funzione specificando prima gli argomenti fissi, ed
2326 a seguire quelli addizionali.
2329 Lo standard ISO C prevede che una \textit{variadic function} abbia sempre
2330 almeno un argomento fisso. Prima di effettuare la dichiarazione deve essere
2331 incluso l'apposito \textit{header file} \file{stdarg.h}; un esempio di
2332 dichiarazione è il prototipo della funzione \func{execl} che vedremo in
2333 sez.~\ref{sec:proc_exec}:
2334 \includecodesnip{listati/exec_sample.c}
2335 in questo caso la funzione prende due argomenti fissi ed un numero variabile
2336 di altri argomenti, che andranno a costituire gli elementi successivi al primo
2337 del vettore \param{argv} passato al nuovo processo. Lo standard ISO C richiede
2338 inoltre che l'ultimo degli argomenti fissi sia di tipo
2339 \textit{self-promoting}\footnote{il linguaggio C prevede che quando si
2340 mescolano vari tipi di dati, alcuni di essi possano essere \textsl{promossi}
2341 per compatibilità; ad esempio i tipi \ctyp{float} vengono convertiti
2342 automaticamente a \ctyp{double} ed i \ctyp{char} e gli \ctyp{short} ad
2343 \ctyp{int}. Un tipo \textit{self-promoting} è un tipo che verrebbe promosso
2344 a sé stesso.} il che esclude vettori, puntatori a funzioni e interi di tipo
2345 \ctyp{char} o \ctyp{short} (con segno o meno). Una restrizione ulteriore di
2346 alcuni compilatori è di non dichiarare l'ultimo argomento fisso come variabile
2347 di tipo \direct{register}.\footnote{la direttiva \direct{register} del
2348 compilatore chiede che la variabile dichiarata tale sia mantenuta, nei
2349 limiti del possibile, all'interno di un registro del processore; questa
2350 direttiva è originaria dell'epoca dai primi compilatori, quando stava al
2351 programmatore scrivere codice ottimizzato, riservando esplicitamente alle
2352 variabili più usate l'uso dei registri del processore, oggi questa direttiva
2353 è in disuso pressoché completo dato che tutti i compilatori sono normalmente
2354 in grado di valutare con maggior efficacia degli stessi programmatori quando
2355 sia il caso di eseguire questa ottimizzazione.}
2357 Una volta dichiarata la funzione il secondo passo è accedere ai vari argomenti
2358 quando la si va a definire. Gli argomenti fissi infatti hanno un loro nome, ma
2359 quelli variabili vengono indicati in maniera generica dalla
2360 \textit{ellipsis}. L'unica modalità in cui essi possono essere recuperati è
2361 pertanto quella sequenziale, in cui vengono estratti dallo \itindex{stack}
2362 \textit{stack} secondo l'ordine in cui sono stati scritti nel prototipo della
2365 Per fare questo in \file{stdarg.h} sono definite delle macro specifiche,
2366 previste dallo standard ISO C89, che consentono di eseguire questa operazione.
2367 La prima di queste macro è \macro{va\_start}, che inizializza opportunamente
2368 una lista degli argomenti, la sua definizione è:
2373 \fdecl{void va\_start(va\_list ap, last)}
2374 \fdesc{Inizializza una lista degli argomenti di una funzione
2379 La macro inizializza il puntatore alla lista di argomenti \param{ap} che
2380 deve essere una apposita variabile di tipo \type{va\_list}; il
2381 parametro \param{last} deve indicare il nome dell'ultimo degli argomenti fissi
2382 dichiarati nel prototipo della funzione \textit{variadic}.
2384 La seconda macro di gestione delle liste di argomenti di una funzione
2385 \textit{variadic} è \macro{va\_arg}, che restituisce in successione un
2386 argomento della lista; la sua definizione è:
2391 \fdecl{type va\_arg(va\_list ap, type)}
2392 \fdesc{Restituisce il valore del successivo argomento opzionale.}
2396 La macro restituisce il valore di un argomento, modificando opportunamente la
2397 lista \param{ap} perché una chiamata successiva restituisca l'argomento
2398 seguente. La macro richiede che si specifichi il tipo dell'argomento che si
2399 andrà ad estrarre attraverso il parametro \param{type} che sarà anche il tipo
2400 del valore da essa restituito. Si ricordi che il tipo deve essere
2401 \textit{self-promoting}.
2403 In generale è perfettamente legittimo richiedere meno argomenti di quelli che
2404 potrebbero essere stati effettivamente forniti, per cui nella esecuzione delle
2405 \macro{va\_arg} ci si può fermare in qualunque momento ed i restanti argomenti
2406 saranno ignorati. Se invece si richiedono più argomenti di quelli
2407 effettivamente forniti si otterranno dei valori indefiniti. Si avranno
2408 risultati indefiniti anche quando si chiama \macro{va\_arg} specificando un
2409 tipo che non corrisponde a quello usato per il corrispondente argomento.
2411 Infine una volta completata l'estrazione occorre indicare che si sono concluse
2412 le operazioni con la macro \macro{va\_end}, la cui definizione è:
2417 \fdecl{void va\_end(va\_list ap)}
2418 \fdesc{Conclude l'estrazione degli argomenti di una funzione
2423 Dopo l'uso di \macro{va\_end} la variabile \param{ap} diventa indefinita e
2424 successive chiamate a \macro{va\_arg} non funzioneranno. Nel caso del
2425 \cmd{gcc} l'uso di \macro{va\_end} può risultare inutile, ma è comunque
2426 necessario usarla per chiarezza del codice, per compatibilità con diverse
2427 implementazioni e per eventuali eventuali modifiche future a questo
2430 Riassumendo la procedura da seguire per effettuare l'estrazione degli
2431 argomenti di una funzione \textit{variadic} è la seguente:
2433 \item inizializzare una lista degli argomenti attraverso la macro
2435 \item accedere agli argomenti con chiamate successive alla macro
2436 \macro{va\_arg}: la prima chiamata restituirà il primo argomento, la seconda
2437 il secondo e così via;
2438 \item dichiarare la conclusione dell'estrazione degli argomenti invocando la
2439 macro \macro{va\_end}.
2442 Si tenga presente che si possono usare anche più liste degli argomenti,
2443 ciascuna di esse andrà inizializzata con \macro{va\_start} e letta con
2444 \macro{va\_arg}, e ciascuna potrà essere usata per scandire la lista degli
2445 argomenti in modo indipendente. Infine ciascuna scansione dovrà essere
2446 terminata con \macro{va\_end}.
2448 Un limite di queste macro è che i passi 1) e 3) devono essere eseguiti nel
2449 corpo principale della funzione, il passo 2) invece può essere eseguito anche
2450 in un'altra funzione, passandole lista degli argomenti \param{ap}. In questo
2451 caso però al ritorno della funzione \macro{va\_arg} non può più essere usata
2452 (anche se non si era completata l'estrazione) dato che il valore di \param{ap}
2453 risulterebbe indefinito.
2455 Esistono dei casi in cui è necessario eseguire più volte la scansione degli
2456 argomenti e poter memorizzare una posizione durante la stessa. In questo caso
2457 sembrerebbe naturale copiarsi la lista degli argomenti \param{ap} con una
2458 semplice assegnazione ad un'altra variabile dello stesso tipo. Dato che una
2459 delle realizzazioni più comuni di \type{va\_list} è quella di un puntatore
2460 nello \itindex{stack} \textit{stack} all'indirizzo dove sono stati salvati gli
2461 argomenti, è assolutamente normale pensare di poter effettuare questa
2464 In generale però possono esistere anche realizzazioni diverse, ed è per questo
2465 motivo che invece che di un semplice puntatore viene \type{va\_list} è quello
2466 che viene chiamato un \index{tipo!opaco} \textsl{tipo opaco}. Si chiamano così
2467 quei tipi di dati, in genere usati da una libreria, la cui struttura interna
2468 non deve essere vista dal programma chiamante (da cui deriva il nome opaco)
2469 che li devono utilizzare solo attraverso dalle opportune funzioni di
2472 Per questo motivo una variabile di tipo \type{va\_list} non può essere
2473 assegnata direttamente ad un'altra variabile dello stesso tipo, ma lo standard
2474 ISO C99\footnote{alcuni sistemi che non hanno questa macro provvedono al suo
2475 posto \macro{\_\_va\_copy} che era il nome proposto in una bozza dello
2476 standard.} ha previsto una macro ulteriore che permette di eseguire la
2477 copia di una lista degli argomenti:
2482 \fdecl{void va\_copy(va\_list dest, va\_list src)}
2483 \fdesc{Copia la lista degli argomenti di una funzione \textit{variadic}.}
2487 La macro copia l'attuale della lista degli argomenti \param{src} su una nuova
2488 lista \param{dest}. Anche in questo caso è buona norma chiudere ogni
2489 esecuzione di una \macro{va\_copy} con una corrispondente \macro{va\_end} sul
2490 nuovo puntatore alla lista degli argomenti.
2492 La chiamata di una funzione con un numero variabile di argomenti, posto che la
2493 si sia dichiarata e definita come tale, non prevede nulla di particolare;
2494 l'invocazione è identica alle altre, con gli argomenti, sia quelli fissi che
2495 quelli opzionali, separati da virgole. Quello che però è necessario tenere
2496 presente è come verranno convertiti gli argomenti variabili.
2498 In Linux gli argomenti dello stesso tipo sono passati allo stesso modo, sia
2499 che siano fissi sia che siano opzionali (alcuni sistemi trattano diversamente
2500 gli opzionali), ma dato che il prototipo non può specificare il tipo degli
2501 argomenti opzionali, questi verranno sempre promossi, pertanto nella ricezione
2502 dei medesimi occorrerà tenerne conto (ad esempio un \ctyp{char} verrà visto da
2503 \macro{va\_arg} come \ctyp{int}).
2505 Un altro dei problemi che si devono affrontare con le funzioni con un numero
2506 variabile di argomenti è che non esiste un modo generico che permetta di
2507 stabilire quanti sono gli argomenti effettivamente passati in una chiamata.
2509 Esistono varie modalità per affrontare questo problema; una delle più
2510 immediate è quella di specificare il numero degli argomenti opzionali come uno
2511 degli argomenti fissi. Una variazione di questo metodo è l'uso di un argomento
2512 fisso per specificare anche il tipo degli argomenti variabili, come fa la
2513 stringa di formato per \func{printf} (vedi sez.~\ref{sec:file_formatted_io}).
2515 Infine una ulteriore modalità diversa, che può essere applicata solo quando il
2516 tipo degli argomenti lo rende possibile, è quella che prevede di usare un
2517 valore speciale per l'ultimo argomento, come fa ad esempio \func{execl} che
2518 usa un puntatore \val{NULL} per indicare la fine della lista degli argomenti
2519 (vedi sez.~\ref{sec:proc_exec}).
2521 \index{funzioni!variadic|)}
2523 \subsection{Il controllo di flusso non locale}
2524 \label{sec:proc_longjmp}
2526 Il controllo del flusso di un programma in genere viene effettuato con le
2527 varie istruzioni del linguaggio C; fra queste la più bistrattata è il
2528 \instruction{goto}, che viene deprecato in favore dei costrutti della
2529 programmazione strutturata, che rendono il codice più leggibile e
2530 mantenibile. Esiste però un caso in cui l'uso di questa istruzione porta
2531 all'implementazione più efficiente e più chiara anche dal punto di vista della
2532 struttura del programma: quello dell'uscita in caso di errore.
2534 \index{salto~non-locale|(}
2536 Il C però non consente di effettuare un salto ad una etichetta definita in
2537 un'altra funzione, per cui se l'errore avviene in una funzione, e la sua
2538 gestione ordinaria è in un'altra, occorre usare quello che viene chiamato un
2539 \textsl{salto non-locale}. Il caso classico in cui si ha questa necessità,
2540 citato sia in \cite{APUE} che in \cite{glibc}, è quello di un programma nel
2541 cui corpo principale vengono letti dei dati in ingresso sui quali viene
2542 eseguita, tramite una serie di funzioni di analisi, una scansione dei
2543 contenuti, da cui si ottengono le indicazioni per l'esecuzione di opportune
2546 Dato che l'analisi può risultare molto complessa, ed opportunamente suddivisa
2547 in fasi diverse, la rilevazione di un errore nei dati in ingresso può accadere
2548 all'interno di funzioni profondamente annidate l'una nell'altra. In questo
2549 caso si dovrebbe gestire, per ciascuna fase, tutta la casistica del passaggio
2550 all'indietro di tutti gli errori rilevabili dalle funzioni usate nelle fasi
2551 successive. Questo comporterebbe una notevole complessità, mentre sarebbe
2552 molto più comodo poter tornare direttamente al ciclo di lettura principale,
2553 scartando l'input come errato.\footnote{a meno che, come precisa \cite{glibc},
2554 alla chiusura di ciascuna fase non siano associate operazioni di pulizia
2555 specifiche (come deallocazioni, chiusure di file, ecc.), che non potrebbero
2556 essere eseguite con un salto non-locale.}
2558 Tutto ciò può essere realizzato proprio con un salto non-locale; questo di
2559 norma viene realizzato salvando il contesto dello \itindex{stack}
2560 \textit{stack} nel punto in cui si vuole tornare in caso di errore, e
2561 ripristinandolo, in modo da tornare quando serve nella funzione da cui si era
2562 partiti. La funzione che permette di salvare il contesto dello
2563 \itindex{stack} \textit{stack} è \funcd{setjmp}, il cui prototipo è:
2567 \fdecl{int setjmp(jmp\_buf env)}
2568 \fdesc{Salva il contesto dello \textit{stack}.}
2570 {La funzione ritorna $0$ quando è chiamata direttamente ed un valore diverso
2571 da zero quando ritorna da una chiamata di \func{longjmp} che usa il contesto
2572 salvato in precedenza.}
2575 Quando si esegue la funzione il contesto corrente dello \itindex{stack}
2576 \textit{stack} viene salvato nell'argomento \param{env}, una variabile di tipo
2577 \type{jmp\_buf}\footnote{anche questo è un classico esempio di variabile di
2578 \index{tipo!opaco} \textsl{tipo opaco}.} che deve essere stata definita in
2579 precedenza. In genere le variabili di tipo \type{jmp\_buf} vengono definite
2580 come \index{variabili!globali} variabili globali in modo da poter essere viste
2581 in tutte le funzioni del programma.
2583 Quando viene eseguita direttamente la funzione ritorna sempre zero, un valore
2584 diverso da zero viene restituito solo quando il ritorno è dovuto ad una
2585 chiamata di \func{longjmp} in un'altra parte del programma che ripristina lo
2586 \itindex{stack} \textit{stack} effettuando il salto non-locale. Si tenga conto
2587 che il contesto salvato in \param{env} viene invalidato se la funzione che ha
2588 chiamato \func{setjmp} ritorna, nel qual caso un successivo uso di
2589 \func{longjmp} può comportare conseguenze imprevedibili (e di norma fatali)
2592 Come accennato per effettuare un salto non-locale ad un punto precedentemente
2593 stabilito con \func{setjmp} si usa la funzione \funcd{longjmp}; il suo
2598 \fdecl{void longjmp(jmp\_buf env, int val)}
2599 \fdesc{Ripristina il contesto dello stack.}
2601 {La funzione non ritorna.}
2604 La funzione ripristina il contesto dello \itindex{stack} \textit{stack}
2605 salvato da una chiamata a \func{setjmp} nell'argomento \param{env}. Dopo
2606 l'esecuzione della funzione il programma prosegue nel codice successivo alla
2607 chiamata della \func{setjmp} con cui si era salvato \param{env}, che
2608 restituirà il valore dell'argomento \param{val} invece di zero. Il valore
2609 dell'argomento \param{val} deve essere sempre diverso da zero, se si è
2610 specificato 0 sarà comunque restituito 1 al suo posto.
2612 In sostanza l'esecuzione di \func{longjmp} è analoga a quella di una
2613 istruzione \instruction{return}, solo che invece di ritornare alla riga
2614 successiva della funzione chiamante, il programma in questo caso ritorna alla
2615 posizione della relativa \func{setjmp}. L'altra differenza fondamentale con
2616 \instruction{return} è che il ritorno può essere effettuato anche attraverso
2617 diversi livelli di funzioni annidate.
2619 L'implementazione di queste funzioni comporta alcune restrizioni dato che esse
2620 interagiscono direttamente con la gestione dello \itindex{stack}
2621 \textit{stack} ed il funzionamento del compilatore stesso. In particolare
2622 \func{setjmp} è implementata con una macro, pertanto non si può cercare di
2623 ottenerne l'indirizzo, ed inoltre le chiamate a questa funzione sono sicure
2624 solo in uno dei seguenti casi:
2626 \item come espressione di controllo in un comando condizionale, di selezione o
2627 di iterazione (come \instruction{if}, \instruction{switch} o
2628 \instruction{while});
2629 \item come operando per un operatore di uguaglianza o confronto in una
2630 espressione di controllo di un comando condizionale, di selezione o di
2632 \item come operando per l'operatore di negazione (\code{!}) in una espressione
2633 di controllo di un comando condizionale, di selezione o di iterazione;
2634 \item come espressione a sé stante.
2637 In generale, dato che l'unica differenza fra la chiamata diretta e quella
2638 ottenuta nell'uscita con un \func{longjmp} è costituita dal valore di ritorno
2639 di \func{setjmp}, pertanto quest'ultima viene usualmente chiamata all'interno
2640 di un una istruzione \instruction{if} che permetta di distinguere i due casi.
2642 Uno dei punti critici dei salti non-locali è quello del valore delle
2643 variabili, ed in particolare quello delle \index{variabili!automatiche}
2644 variabili automatiche della funzione a cui si ritorna. In generale le
2645 \index{variabili!globali} variabili globali e \index{variabili!statiche}
2646 statiche mantengono i valori che avevano al momento della chiamata di
2647 \func{longjmp}, ma quelli delle \index{variabili!automatiche} variabili
2648 automatiche (o di quelle dichiarate \direct{register}) sono in genere
2651 Quello che succede infatti è che i valori delle variabili che sono tenute in
2652 memoria manterranno il valore avuto al momento della chiamata di
2653 \func{longjmp}, mentre quelli tenuti nei registri del processore (che nella
2654 chiamata ad un'altra funzione vengono salvati nel contesto nello
2655 \itindex{stack} \textit{stack}) torneranno al valore avuto al momento della
2656 chiamata di \func{setjmp}; per questo quando si vuole avere un comportamento
2657 coerente si può bloccare l'ottimizzazione che porta le variabili nei registri
2658 dichiarandole tutte come \direct{volatile}.\footnote{la direttiva
2659 \direct{volatile} informa il compilatore che la variabile che è dichiarata
2660 può essere modificata, durante l'esecuzione del nostro, da altri programmi.
2661 Per questo motivo occorre dire al compilatore che non deve essere mai
2662 utilizzata l'ottimizzazione per cui quanto opportuno essa viene mantenuta in
2663 un registro, poiché in questo modo si perderebbero le eventuali modifiche
2664 fatte dagli altri programmi (che avvengono solo in una copia posta in
2667 \index{salto~non-locale|)}
2670 \subsection{La \textit{endianness}}
2671 \label{sec:sock_endianness}
2673 \itindbeg{endianness}
2675 Un altro dei problemi di programmazione che può dar luogo ad effetti
2676 imprevisti è quello relativo alla cosiddetta \textit{endianness}. Questa è una
2677 caratteristica generale dell'architettura hardware di un computer che dipende
2678 dal fatto che la rappresentazione di un numero binario può essere fatta in due
2679 modi, chiamati rispettivamente \textit{big endian} e \textit{little endian} a
2680 seconda di come i singoli bit vengono aggregati per formare le variabili
2681 intere (ed in genere in diretta corrispondenza a come sono poi in realtà
2682 cablati sui bus interni del computer).
2684 \begin{figure}[!htb]
2685 \centering \includegraphics[height=3cm]{img/endianness}
2686 \caption{Schema della disposizione dei dati in memoria a seconda della
2687 \textit{endianness}.}
2688 \label{fig:sock_endianness}
2691 Per capire meglio il problema si consideri un intero a 32 bit scritto in una
2692 locazione di memoria posta ad un certo indirizzo. Come illustrato in
2693 fig.~\ref{fig:sock_endianness} i singoli bit possono essere disposti in memoria
2694 in due modi: a partire dal più significativo o a partire dal meno
2695 significativo. Così nel primo caso si troverà il byte che contiene i bit più
2696 significativi all'indirizzo menzionato e il byte con i bit meno significativi
2697 nell'indirizzo successivo; questo ordinamento è detto \textit{big endian},
2698 dato che si trova per prima la parte più grande. Il caso opposto, in cui si
2699 parte dal bit meno significativo è detto per lo stesso motivo \textit{little
2702 Si può allora verificare quale tipo di \textit{endianness} usa il proprio
2703 computer con un programma elementare che si limita ad assegnare un valore ad
2704 una variabile per poi ristamparne il contenuto leggendolo un byte alla volta.
2705 Il codice di detto programma, \file{endtest.c}, è nei sorgenti allegati,
2706 allora se lo eseguiamo su un normale PC compatibile, che è \textit{little
2707 endian} otterremo qualcosa del tipo:
2709 [piccardi@gont sources]$ ./endtest
2713 Using value ABCDEF01
2719 mentre su un vecchio Macintosh con PowerPC, che è \textit{big endian} avremo
2722 piccardi@anarres:~/gapil/sources$ ./endtest
2726 Using value ABCDEF01
2733 L'attenzione alla \textit{endianness} nella programmazione è importante, perché
2734 se si fanno assunzioni relative alla propria architettura non è detto che
2735 queste restino valide su un'altra architettura. Inoltre, come vedremo ad
2736 esempio in sez.~\ref{sec:sock_addr_func}, si possono avere problemi quando ci
2737 si trova a usare valori di un formato con una infrastruttura che ne usa
2740 La \textit{endianness} di un computer dipende essenzialmente dalla architettura
2741 hardware usata; Intel e Digital usano il \textit{little endian}, Motorola,
2742 IBM, Sun (sostanzialmente tutti gli altri) usano il \textit{big endian}. Il
2743 formato dei dati contenuti nelle intestazioni dei protocolli di rete (il
2744 cosiddetto \textit{network order}) è anch'esso \textit{big endian}; altri
2745 esempi di uso di questi due diversi formati sono quello del bus PCI, che è
2746 \textit{little endian}, o quello del bus VME che è \textit{big endian}.
2748 Esistono poi anche dei processori che possono scegliere il tipo di formato
2749 all'avvio e alcuni che, come il PowerPC o l'Intel i860, possono pure passare
2750 da un tipo di ordinamento all'altro con una specifica istruzione. In ogni caso
2751 in Linux l'ordinamento è definito dall'architettura e dopo l'avvio del sistema
2752 in genere resta sempre lo stesso,\footnote{su architettura PowerPC è possibile
2753 cambiarlo, si veda sez.~\ref{sec:process_prctl}.} anche quando il processore
2754 permetterebbe di eseguire questi cambiamenti.
2756 \begin{figure}[!htbp]
2757 \footnotesize \centering
2758 \begin{minipage}[c]{\codesamplewidth}
2759 \includecodesample{listati/endian.c}
2762 \caption{La funzione \func{endian}, usata per controllare il tipo di
2763 architettura della macchina.}
2764 \label{fig:sock_endian_code}
2767 Per controllare quale tipo di ordinamento si ha sul proprio computer si è
2768 scritta una piccola funzione di controllo, il cui codice è riportato
2769 fig.~\ref{fig:sock_endian_code}, che restituisce un valore nullo (falso) se
2770 l'architettura è \textit{big endian} ed uno non nullo (vero) se l'architettura
2771 è \textit{little endian}.
2773 Come si vede la funzione è molto semplice, e si limita, una volta assegnato
2774 (\texttt{\small 9}) un valore di test pari a \texttt{0xABCD} ad una variabile
2775 di tipo \ctyp{short} (cioè a 16 bit), a ricostruirne una copia byte a byte.
2776 Per questo prima (\texttt{\small 10}) si definisce il puntatore \var{ptr} per
2777 accedere al contenuto della prima variabile, ed infine calcola (\texttt{\small
2778 11}) il valore della seconda assumendo che il primo byte sia quello meno
2779 significativo (cioè, per quanto visto in fig.~\ref{fig:sock_endianness}, che sia
2780 \textit{little endian}). Infine la funzione restituisce (\texttt{\small 12})
2781 il valore del confronto delle due variabili.
2783 In generale non ci si deve preoccupare della \textit{endianness} all'interno
2784 di un programma fintanto che questo non deve generare o manipolare dei dati
2785 che sono scambiati con altre macchine, ad esempio tramite via rete o tramite
2786 dei file binari. Nel primo caso la scelta è già stata fatta nella
2787 standardizzazione dei protocolli, che hanno adottato il \textit{big endian}
2788 (che viene detto anche per questo \textit{network order} e vedremo in
2789 sez.~\ref{sec:sock_func_ord} le funzioni di conversione che devono essere
2792 Nel secondo caso occorre sapere quale \textit{endianness} è stata usata nei
2793 dati memorizzati sul file e tenerne conto nella rilettura e nella
2794 manipolazione e relativa modifica (e salvataggio). La gran parte dei formati
2795 binari standardizzati specificano quale \textit{endianness} viene utilizzata e
2796 basterà identificare qual'è, se se ne deve definire uno per i propri scopi
2797 basterà scegliere una volta per tutte quale usare e attenersi alla scelta.
2799 \itindend{endianness}
2802 % LocalWords: like exec kernel thread main ld linux static linker char envp Gb
2803 % LocalWords: sez POSIX exit system call cap abort shell diff errno stdlib int
2804 % LocalWords: SUCCESS FAILURE void atexit stream fclose unistd descriptor init
2805 % LocalWords: SIGCHLD wait function glibc SunOS arg argp execve fig high kb Mb
2806 % LocalWords: memory alpha swap table printf Unit MMU paging fault SIGSEGV BSS
2807 % LocalWords: multitasking text segment NULL Block Started Symbol fill black
2808 % LocalWords: heap stack calling convention size malloc calloc realloc nmemb
2809 % LocalWords: ENOMEM ptr uClib cfree error leak smartpointers hook Dmalloc brk
2810 % LocalWords: Gray Watson Electric Fence Bruce Perens sbrk longjmp SUSv BSD ap
2811 % LocalWords: ptrdiff increment locking lock copy write capabilities IPC mlock
2812 % LocalWords: capability MEMLOCK limits getpagesize RLIMIT munlock sys const
2813 % LocalWords: addr len EINVAL EPERM mlockall munlockall flags l'OR CURRENT IFS
2814 % LocalWords: argc argv parsing questofile txt getopt optstring switch optarg
2815 % LocalWords: optind opterr optopt ForkTest POSIXLY CORRECT long options NdA
2816 % LocalWords: option parameter list environ PATH HOME XPG tab LOGNAME LANG PWD
2817 % LocalWords: TERM PAGER TMPDIR getenv name SVr setenv unsetenv putenv opz gcc
2818 % LocalWords: clearenv libc value overwrite string reference result argument
2819 % LocalWords: socket variadic ellipsis header stdarg execl self promoting last
2820 % LocalWords: float double short register type dest src extern setjmp jmp buf
2821 % LocalWords: env return if while Di page cdecl rectangle node anchor west PS
2822 % LocalWords: environment rounded corners dashed south width height draw east
2823 % LocalWords: exithandler handler violation inline SOURCE SVID XOPEN mincore
2824 % LocalWords: length unsigned vec EFAULT EAGAIN dell'I memalign valloc posix
2825 % LocalWords: boundary memptr alignment sizeof overrun mcheck abortfn enum big
2826 % LocalWords: mprobe DISABLED HEAD TAIL touch right emacs OSTYPE endianness IBM
2827 % LocalWords: endian little endtest Macintosh PowerPC Intel Digital Motorola
2828 % LocalWords: Sun order VME loader Windows DLL shared objects PRELOAD termios
2829 % LocalWords: is to LC SIG str mem wcs assert ctype dirent fcntl signal stdio
2830 % LocalWords: times library utmp syscall number Filesystem Hierarchy pathname
2831 % LocalWords: context assembler sysconf fork Dinamic huge segmentation program
2832 % LocalWords: break store Using
2834 %%% Local Variables:
2836 %%% TeX-master: "gapil"