Ricominciato coi process group
[gapil.git] / process.tex
1 \chapter{L'interfaccia base con i processi}
2 \label{cha:process_interface}
3
4 Come accennato nell'introduzione il \textsl{processo} è l'unità di base con
5 cui un sistema unix-like alloca ed utilizza le risorse.  Questo capitolo
6 tratterà l'interfaccia base fra il sistema e i processi, come vengono passati
7 i parametri, come viene gestita e allocata la memoria, come un processo può
8 richiedere servizi al sistema e cosa deve fare quando ha finito la sua
9 esecuzione. Nella sezione finale accenneremo ad alcune problematiche generiche
10 di programmazione.
11
12 In genere un programma viene eseguito quando un processo lo fa partire
13 eseguendo una funzione della famiglia \func{exec}; torneremo su questo e sulla
14 creazione e gestione dei processi nel prossimo capitolo. In questo
15 affronteremo l'avvio e il funzionamento di un singolo processo partendo dal
16 punto di vista del programma che viene messo in esecuzione.
17
18
19 \section{Esecuzione e conclusione di un programma}
20
21 Uno dei concetti base di Unix è che un processo esegue sempre uno ed un solo
22 programma: si possono avere più processi che eseguono lo stesso programma ma
23 ciascun processo vedrà la sua copia del codice (in realtà il kernel fa sì che
24 tutte le parti uguali siano condivise), avrà un suo spazio di indirizzi,
25 variabili proprie e sarà eseguito in maniera completamente indipendente da
26 tutti gli altri.\footnote{questo non è del tutto vero nel caso di un programma
27   \textit{multi-thread}, ma la gestione dei \textit{thread} in Linux sarà
28   trattata a parte.}
29
30
31 \subsection{La funzione \func{main}} 
32 \label{sec:proc_main}
33
34 Quando un programma viene lanciato il kernel esegue un'opportuna routine di
35 avvio, usando il programma \cmd{ld-linux.so}.  Questo programma prima carica
36 le librerie condivise che servono al programma, poi effettua il link dinamico
37 del codice e alla fine lo esegue. Infatti, a meno di non aver specificato il
38 flag \texttt{-static} durante la compilazione, tutti i programmi in Linux sono
39 incompleti e necessitano di essere linkati alle librerie condivise quando
40 vengono avviati.  La procedura è controllata da alcune variabili di ambiente e
41 dal contenuto di \file{/etc/ld.so.conf}. I dettagli sono riportati nella man
42 page di \cmd{ld.so}.
43
44 Il sistema fa partire qualunque programma chiamando la funzione \func{main};
45 sta al programmatore chiamare così la funzione principale del programma da cui
46 si suppone iniziare l'esecuzione; in ogni caso senza questa funzione lo stesso
47 linker darebbe luogo ad errori.
48
49 Lo standard ISO C specifica che la funzione \func{main} può non avere 
50 argomenti o prendere due argomenti che rappresentano gli argomenti passati da
51 linea di comando, in sostanza un prototipo che va sempre bene è il seguente:
52 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
53     int main (int argc, char *argv[])
54 \end{lstlisting}
55
56 In realtà nei sistemi Unix esiste un'altro modo per definire la funzione
57 \func{main}, che prevede la presenza di un terzo parametro, \var{char
58   *envp[]}, che fornisce l'\textsl{ambiente} (vedi \secref{sec:proc_environ})
59 del programma; questa forma però non è prevista dallo standard POSIX.1 per cui
60 se si vogliono scrivere programmi portabili è meglio evitarla.
61
62
63 \subsection{Come chiudere un programma}
64 \label{sec:proc_conclusion}
65
66 Normalmente un programma finisce è quando la funzione \func{main} ritorna, una
67 modalità equivalente di chiudere il programma è quella di chiamare
68 direttamente la funzione \func{exit} (che viene comunque chiamata
69 automaticamente quando \func{main} ritorna).  Una forma alternativa è quella
70 di chiamare direttamente la system call \func{\_exit}, che restituisce il
71 controllo direttamente alla routine di conclusione dei processi del kernel.
72
73 Oltre alla conclusione ``normale'' esiste anche la possibilità di una
74 conclusione ``anomala'' del programma a causa della ricezione di un segnale
75 (si veda \capref{cha:signals}) o della chiamata alla funzione \func{abort};
76 torneremo su questo in \secref{sec:proc_termination}.
77
78 Il valore di ritorno della funzione \func{main}, o quello usato nelle chiamate
79 ad \func{exit} e \func{\_exit}, viene chiamato \textsl{stato di uscita} (o
80 \textit{exit status}) e passato al processo che aveva lanciato il programma
81 (in genere la shell). In generale si usa questo valore per fornire
82 informazioni sulla riuscita o il fallimento del programma; l'informazione è
83 necessariamente generica, ed il valore deve essere compreso fra 0 e 255.
84
85 La convenzione in uso pressoché universale è quella di restituire 0 in caso di
86 successo e 1 in caso di fallimento; l'unica eccezione è per i programmi che
87 effettuano dei confronti (come \cmd{diff}), che usano 0 per indicare la
88 corrispondenza, 1 per indicare la non corrispondenza e 2 per indicare
89 l'incapacità di effettuare il confronto. È opportuno adottare una di queste
90 convenzioni a seconda dei casi.  Si tenga presente che se si raggiunge la fine
91 della funzione \func{main} senza ritornare esplicitamente si ha un valore di
92 uscita indefinito, è pertanto consigliabile di concludere sempre in maniera
93 esplicita detta funzione.
94
95 Un'altra convenzione riserva i valori da 128 a 256 per usi speciali: ad
96 esempio 128 viene usato per indicare l'incapacità di eseguire un altro
97 programma in un sottoprocesso. Benché questa convenzione non sia
98 universalmente seguita è una buona idea tenerne conto.
99
100 Si tenga presente inoltre che non è una buona idea usare il codice di errore
101 restituito dalla variabile \var{errno} (per i dettagli si veda
102 \secref{sec:sys_errors}) come stato di uscita. In generale infatti una shell
103 non si cura del valore se non per vedere se è diverso da zero; inoltre il
104 valore dello stato di uscita è sempre troncato ad 8 bit, per cui si potrebbe
105 incorrere nel caso in cui restituendo un codice di errore 256, si otterrebbe
106 uno stato di uscita uguale a zero, che verrebbe interpretato come un successo.
107
108 In \file{stdlib.h} sono definite, seguendo lo standard POSIX, le due macro
109 \macro{EXIT\_SUCCESS} e \macro{EXIT\_FAILURE}, da usare sempre per specificare
110 lo stato di uscita di un processo. In Linux esse sono poste rispettivamente ai
111 valori di tipo \ctyp{int} 0 e 1.
112
113
114 \subsection{Le funzioni \func{exit} e \func{\_exit}}
115 \label{sec:proc_exit}
116
117 Come accennato le funzioni usate per effettuare un'uscita ``normale'' da un
118 programma sono due, la prima è la funzione \func{exit} che è definita dallo
119 standard ANSI C ed il cui prototipo è:
120 \begin{prototype}{stdlib.h}{void exit(int status)}
121   Causa la conclusione ordinaria del programma restituendo il valore
122   \var{status} al processo padre.
123
124   \bodydesc{La funzione non ritorna. Il processo viene terminato.}
125 \end{prototype}
126
127 La funzione \func{exit} è pensata per eseguire una conclusione pulita di un
128 programma che usi le librerie standard del C; essa esegue tutte le funzioni
129 che sono state registrate con \func{atexit} e \func{on\_exit} (vedi
130 \secref{sec:proc_atexit}), e chiude tutti gli stream effettuando il
131 salvataggio dei dati sospesi (chiamando \func{fclose}, vedi
132 \secref{sec:file_fopen}), infine passa il controllo al kernel chiamando
133 \func{\_exit} e passando \param{status} come stato di uscita.
134
135 La system call \func{\_exit} restituisce direttamente il controllo al kernel,
136 concludendo immediatamente il processo; i dati sospesi nei buffer degli stream
137 non vengono salvati e le eventuali funzioni registrate con \func{atexit} e
138 \func{on\_exit} non vengono eseguite. Il prototipo della funzione è:
139 \begin{prototype}{unistd.h}{void \_exit(int status)}
140   Causa la conclusione immediata del programma restituendo \param{status} al
141   processo padre come stato di uscita.
142
143   \bodydesc{La funzione non ritorna. Il processo viene terminato.}
144 \end{prototype}
145
146 La funzione chiude tutti i file descriptor appartenenti al processo (si tenga
147 presente che questo non comporta il salvataggio dei dati bufferizzati degli
148 stream), fa sì che ogni figlio del processo sia ereditato da \cmd{init} (vedi
149 \secref{cha:process_handling}), manda un segnale \macro{SIGCHLD} al processo
150 padre (vedi \secref{sec:sig_job_control}) ed infine ritorna lo stato di uscita
151 specificato in \param{status} che può essere raccolto usando la funzione
152 \func{wait} (vedi \secref{sec:proc_wait}).
153
154
155 \subsection{Le funzioni \func{atexit} e \func{on\_exit}}
156 \label{sec:proc_atexit}
157
158 Un'esigenza comune che si incontra nella programmazione è quella di dover
159 effettuare una serie di operazioni di pulizia (ad esempio salvare dei dati,
160 ripristinare delle impostazioni, eliminare dei file temporanei, ecc.) prima
161 della conclusione di un programma. In genere queste operazioni vengono fatte
162 in un'apposita sezione del programma, ma quando si realizza una libreria
163 diventa antipatico dover richiedere una chiamata esplicita ad una funzione di
164 pulizia al programmatore che la utilizza.
165
166 È invece molto meno soggetto ad errori, e completamente trasparente
167 all'utente, avere la possibilità di effettuare automaticamente la chiamata ad
168 una funzione che effettui tali operazioni all'uscita dal programma. A questo
169 scopo lo standard ANSI C prevede la possibilità di registrare un certo numero
170 funzioni che verranno eseguite all'uscita dal programma (sia per la chiamata
171 ad \func{exit} che per il ritorno di \func{main}). La prima funzione che si
172 può utilizzare a tal fine è:
173 \begin{prototype}{stdlib.h}{void atexit(void (*function)(void))}
174   Registra la funzione \param{function} per essere chiamata all'uscita dal
175   programma. 
176   
177   \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
178     fallimento, \var{errno} non viene impostata.}
179 \end{prototype}
180 \noindent la funzione richiede come argomento l'indirizzo della opportuna
181 funzione di pulizia da chiamare all'uscita, che non deve prendere argomenti e
182 non deve ritornare niente (deve essere essere cioè definita come \code{void
183   function(void)}).
184
185 Un'estensione di \func{atexit} è la funzione \func{on\_exit}, che le
186 \acr{glibc} includono per compatibilità con SunOS, ma che non è detto sia
187 definita su altri sistemi; il suo prototipo è:
188 \begin{prototype}{stdlib.h}
189 {void on\_exit(void (*function)(int status, void *arg), void *arg)}
190   Registra la funzione \param{function} per essere chiamata all'uscita dal
191   programma. Tutte le funzioni registrate vengono chiamate in ordine inverso
192   rispetto a quello di registrazione.
193   
194   \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
195     fallimento, \var{errno} non viene impostata.}
196 \end{prototype}
197
198 In questo caso la funzione da chiamare prende due parametri, il primo dei
199 quali sarà inizializzato allo stato di uscita con cui è stata chiamata
200 \func{exit} ed il secondo al puntatore generico specificato come secondo
201 argomento nella chiamata di \func{on\_exit}. Così diventa possibile passare
202 dei dati alla funzione di chiusura.
203
204 Nella sequenza di chiusura tutte le funzioni registrate verranno chiamate in
205 ordine inverso rispetto a quello di registrazione (ed una stessa funzione
206 registrata più volte sarà chiamata più volte); poi verranno chiusi tutti gli
207 stream aperti, infine verrà chiamata \func{\_exit}.
208
209
210 \subsection{Conclusioni}
211 \label{sec:proc_term_conclusion}
212
213 Data l'importanza dell'argomento è opportuno sottolineare ancora una volta che
214 in un sistema Unix l'unico modo in cui un programma può essere eseguito dal
215 kernel è attraverso la chiamata alla system call \func{execve} (o attraverso
216 una delle funzioni della famiglia \func{exec} che vedremo in
217 \secref{sec:proc_exec}).
218
219 Allo stesso modo l'unico modo in cui un programma può concludere
220 volontariamente la sua esecuzione è attraverso una chiamata alla system call
221 \func{\_exit}, o esplicitamente, o in maniera indiretta attraverso l'uso di
222 \func{exit} o il ritorno di \func{main}.
223
224 Uno schema riassuntivo che illustra le modalità con cui si avvia e conclude
225 normalmente un programma è riportato in \nfig.
226
227 \begin{figure}[htb]
228   \centering
229   \includegraphics[width=12cm]{img/proc_beginend}
230   \caption{Schema dell'avvio e della conclusione di un programma.}
231   \label{fig:proc_prog_start_stop}
232 \end{figure}
233
234 Si ricordi infine che un programma può anche essere interrotto dall'esterno
235 attraverso l'uso di un segnale (modalità di conclusione non mostrata in
236 \curfig); torneremo su questo aspetto in \capref{cha:signals}.
237
238
239
240 \section{I processi e l'uso della memoria}
241 \label{sec:proc_memory}
242
243 Una delle risorse base che ciascun processo ha a disposizione è la memoria, e
244 la gestione della memoria è appunto uno degli aspetti più complessi di un
245 sistema unix-like. In questa sezione, dopo una breve introduzione ai concetti
246 base, esamineremo come la memoria viene vista da parte di un programma in
247 esecuzione, e le varie funzioni utilizzabili per la sua gestione.
248
249
250 \subsection{I concetti generali}
251 \label{sec:proc_mem_gen}
252
253 Ci sono vari modi in cui i vari sistemi organizzano la memoria (ed i dettagli
254 di basso livello dipendono spesso in maniera diretta dall'architettura
255 dell'hardware), ma quello più tipico, usato dai sistemi unix-like come Linux è
256 la cosiddetta \textsl{memoria virtuale}\index{memoria virtuale} che consiste
257 nell'assegnare ad ogni processo uno spazio virtuale di indirizzamento lineare,
258 in cui gli indirizzi vanno da zero ad un qualche valore massimo.\footnote{nel
259   caso di Linux fino al kernel 2.2 detto massimo era, per macchine a 32bit, di
260   2Gb, con il kernel 2.4 ed il supporto per la \textit{high-memory} il limite
261   è stato esteso.}
262
263 Come accennato in \capref{cha:intro_unix} questo spazio di indirizzi è
264 virtuale e non corrisponde all'effettiva posizione dei dati nella RAM del
265 computer; in genere detto spazio non è neppure continuo (cioè non tutti gli
266 indirizzi possibili sono utilizzabili, e quelli usabili non sono
267 necessariamente adiacenti).
268
269 Per la gestione da parte del kernel la memoria virtuale viene divisa in pagine
270 di dimensione fissa (che ad esempio sono di 4kb su macchine a 32 bit e 8kb
271 sulle alpha, valori strettamente connessi all'hardware di gestione della
272 memoria), e ciascuna pagina della memoria virtuale è associata ad un supporto
273 che può essere una pagina di memoria reale o ad un dispositivo di stoccaggio
274 secondario (in genere lo spazio disco riservato alla swap, o i file che
275 contengono il codice).
276
277 Lo stesso pezzo di memoria reale (o di spazio disco) può fare da supporto a
278 diverse pagine di memoria virtuale appartenenti a processi diversi (come
279 accade in genere per le pagine che contengono il codice delle librerie
280 condivise). Ad esempio il codice della funzione \func{printf} starà su una
281 sola pagina di memoria reale che farà da supporto a tutte le pagine di memoria
282 virtuale di tutti i processi che hanno detta funzione nel loro codice.
283
284 La corrispondenza fra le pagine della memoria virtuale e quelle della memoria
285 fisica della macchina viene gestita in maniera trasparente dall'hardware di
286 gestione della memoria (la \textit{Memory Management Unit} del processore).
287 Poiché in genere la memoria fisica è solo una piccola frazione della memoria
288 virtuale, è necessario un meccanismo che permetta di trasferire le pagine che
289 servono dal supporto su cui si trovano in memoria, eliminando quelle che non
290 servono. Questo meccanismo è detto \textsl{paginazione}\index{paginazione} (o
291 \textit{paging}), ed è uno dei compiti principali del kernel.
292
293 Quando un processo cerca di accedere ad una pagina che non è nella memoria
294 reale, avviene quello che viene chiamato un 
295 \textit{page fault}\index{page fault}; 
296 l'hardware di gestione della memoria genera un'interruzione e passa
297 il controllo al kernel il quale sospende il processo e si incarica di mettere
298 in RAM la pagina richiesta (effettuando tutte le operazioni necessarie per
299 reperire lo spazio necessario), per poi restituire il controllo al processo.
300
301 Dal punto di vista di un processo questo meccanismo è completamente
302 trasparente, e tutto avviene come se tutte le pagine fossero sempre
303 disponibili in memoria.  L'unica differenza avvertibile è quella dei tempi di
304 esecuzione, che passano dai pochi nanosecondi necessari per l'accesso in RAM,
305 a tempi molto più lunghi, dovuti all'intervento del kernel. 
306
307 Normalmente questo è il prezzo da pagare per avere un multitasking reale, ed
308 in genere il sistema è molto efficiente in questo lavoro; quando però ci siano
309 esigenze specifiche di prestazioni è possibile usare delle funzioni che
310 permettono di bloccare il meccanismo della paginazione e mantenere fisse delle
311 pagine in memoria (vedi \ref{sec:proc_mem_lock}).
312
313
314 \subsection{La struttura della memoria di un processo}
315 \label{sec:proc_mem_layout}
316
317 Benché lo spazio di indirizzi virtuali copra un intervallo molto ampio, solo
318 una parte di essi è effettivamente allocato ed utilizzabile dal processo; il
319 tentativo di accedere ad un indirizzo non allocato è un tipico errore che si
320 commette quando si è manipolato male un puntatore e genera quello che viene
321 chiamato un \textit{segmentation fault}. Se si tenta cioè di leggere o
322 scrivere da un indirizzo per il quale non esiste un'associazione della pagina
323 virtuale, il kernel risponde al relativo \textit{page fault}\index{page fault}
324 mandando un segnale \macro{SIGSEGV} al processo, che normalmente ne causa la
325 terminazione immediata.
326
327 È pertanto importante capire come viene strutturata \textsl{la memoria
328   virtuale}\index{page fault} di un processo. Essa viene divisa in
329 \textsl{segmenti}, cioè un insieme contiguo di indirizzi virtuali ai quali il
330 processo può accedere.  Solitamente un programma C viene suddiviso nei
331 seguenti segmenti:
332
333 \begin{enumerate}
334 \item Il segmento di testo o \textit{text segment}. Contiene il codice del
335   programma, delle funzioni di librerie da esso utilizzate, e le costanti.
336   Normalmente viene condiviso fra tutti i processi che eseguono lo stesso
337   programma (e anche da processi che eseguono altri programmi nel caso delle
338   librerie).  Viene marcato in sola lettura per evitare sovrascritture
339   accidentali (o maliziose) che ne modifichino le istruzioni.
340   
341   Viene allocato da \func{exec} all'avvio del programma e resta invariato
342   per tutto il tempo dell'esecuzione.
343   
344 \item Il segmento dei dati o \textit{data segment}. Contiene le variabili
345   globali (cioè quelle definite al di fuori di tutte le funzioni che
346   compongono il programma) e le variabili statiche (cioè quelle dichiarate con
347   l'attributo \ctyp{static}). Di norma è diviso in due parti.
348   
349   La prima parte è il segmento dei dati inizializzati, che contiene le
350   variabili il cui valore è stato assegnato esplicitamente. Ad esempio
351   se si definisce:
352   \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
353     double pi = 3.14;
354   \end{lstlisting}
355   questo valore sarà immagazzinato in questo segmento. La memoria di questo
356   segmento viene preallocata all'avvio del programma e inizializzata ai valori
357   specificati.
358   
359   La seconda parte è il segmento dei dati non inizializzati, che contiene le
360   variabili il cui valore non è stato assegnato esplicitamente. Ad esempio se
361   si definisce:
362   \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
363     int vect[100];
364   \end{lstlisting}
365   questo vettore sarà immagazzinato in questo segmento. Anch'esso viene
366   allocato all'avvio, e tutte le variabili vengono inizializzate a zero (ed i
367   puntatori a \macro{NULL}).\footnote{si ricordi che questo vale solo per le
368     variabili che vanno nel segmento dati, e non è affatto vero in generale.}
369    
370   Storicamente questo segmento viene chiamato BBS (da \textit{block started by
371     symbol}). La sua dimensione è fissa.
372   
373 \item Lo \textit{heap}. Tecnicamente lo si può considerare l'estensione del
374   segmento dati, a cui di solito è posto giusto di seguito. È qui che avviene
375   l'allocazione dinamica della memoria; può essere ridimensionato allocando e
376   disallocando la memoria dinamica con le apposite funzioni (vedi
377   \secref{sec:proc_mem_alloc}), ma il suo limite inferiore (quello adiacente
378   al segmento dati) ha una posizione fissa.
379   
380 \item Il segmento di \textit{stack}, che contiene lo \textit{stack} del
381   programma.  Tutte le volte che si effettua una chiamata ad una funzione è
382   qui che viene salvato l'indirizzo di ritorno e le informazioni dello stato
383   del chiamante (tipo il contenuto di alcuni registri della CPU). Poi la
384   funzione chiamata alloca qui lo spazio per le sue variabili locali: in
385   questo modo le funzioni possono essere chiamate ricorsivamente. Al ritorno
386   della funzione lo spazio è automaticamente rilasciato. Al ritorno della
387   funzione lo spazio è automaticamente ripulito. La pulizia in C e C++ viene
388   fatta dal chiamante.\footnote{a meno che non sia stato specificato
389     l'utilizzo di una calling convention diversa da quella standard.}
390   
391   La dimensione di questo segmento aumenta seguendo la crescita dello stack
392   del programma, ma non viene ridotta quando quest'ultimo si restringe.
393 \end{enumerate}
394
395 \begin{figure}[htb]
396   \centering
397   \includegraphics[width=5cm]{img/memory_layout}
398   \caption{Disposizione tipica dei segmenti di memoria di un processo.}
399   \label{fig:proc_mem_layout}
400 \end{figure}
401
402 Una disposizione tipica di questi segmenti è riportata in
403 \figref{fig:proc_mem_layout}. Usando il comando \cmd{size} su un programma se
404 ne può stampare le dimensioni dei segmenti di testo e di dati (inizializzati e
405 BSS); si tenga presente però che il BSS non è mai salvato sul file che
406 contiene l'eseguibile, dato che viene sempre inizializzato a zero al
407 caricamento del programma.
408
409
410 \subsection{Allocazione della memoria per i programmi C}
411 \label{sec:proc_mem_alloc}
412
413 Il C supporta, a livello di linguaggio, soltanto due modalità di allocazione
414 della memoria: l'\textsl{allocazione statica} e l'\textsl{allocazione
415   automatica}.
416
417 L'\textsl{allocazione statica} è quella con cui sono memorizzate le variabili
418 globali e le variabili statiche, cioè le variabili il cui valore deve essere
419 mantenuto per tutta la durata del programma. Come accennato queste variabili
420 vengono allocate nel segmento dei dati all'avvio del programma (come parte
421 delle operazioni svolte da \func{exec}) e lo spazio da loro occupato non viene
422 liberato fino alla sua conclusione.
423
424 L'\textsl{allocazione automatica} è quella che avviene per gli argomenti di
425 una funzione e per le sue variabili locali (le cosiddette \textsl{variabili
426   automatiche}), che esistono solo per la durata della funzione.  Lo spazio
427 per queste variabili viene allocato nello stack quando viene eseguita la
428 funzione e liberato quando si esce dalla medesima.
429
430 Esiste però un terzo tipo di allocazione, l'\textsl{allocazione dinamica della
431   memoria}, che non è prevista direttamente all'interno del linguaggio C, ma
432 che è necessaria quando il quantitativo di memoria che serve è determinabile
433 solo durante il corso dell'esecuzione del programma.
434
435 Il C non consente di usare variabili allocate dinamicamente, non è possibile
436 cioè definire in fase di programmazione una variabile le cui dimensioni
437 possano essere modificate durante l'esecuzione del programma. Per questo le
438 librerie del C forniscono una serie opportuna di funzioni per eseguire
439 l'allocazione dinamica di memoria (in genere nello heap). Le variabili il
440 cui contenuto è allocato in questo modo non potranno essere usate direttamente
441 come le altre, ma l'accesso sarà possibile solo in maniera indiretta,
442 attraverso dei puntatori.
443
444
445 \subsection{Le funzioni \func{malloc}, \func{calloc}, \func{realloc} e
446   \func{free}}
447 \label{sec:proc_mem_malloc}
448
449 Le funzioni previste dallo standard ANSI C per la gestione della memoria sono
450 quattro: \func{malloc}, \func{calloc}, \func{realloc} e \func{free}, i loro
451 prototipi sono i seguenti:
452 \begin{functions}
453 \headdecl{stdlib.h}
454 \funcdecl{void *calloc(size\_t size)}
455   Alloca \var{size} byte nello heap. La memoria viene inizializzata a 0.
456   
457   La funzione restituisce il puntatore alla zona di memoria allocata in caso
458   di successo e \macro{NULL} in caso di fallimento, nel qual caso
459   \var{errno} viene impostata a \macro{ENOMEM}.
460 \funcdecl{void *malloc(size\_t size)}
461   Alloca \var{size} byte nello heap. La memoria non viene inizializzata.
462
463   La funzione restituisce il puntatore alla zona di memoria allocata in caso
464   di successo e \macro{NULL} in caso di fallimento, nel qual caso
465   \var{errno} viene impostata a \macro{ENOMEM}.
466 \funcdecl{void *realloc(void *ptr, size\_t size)}
467   Cambia la dimensione del blocco allocato all'indirizzo \var{ptr}
468   portandola a \var{size}.
469
470   La funzione restituisce il puntatore alla zona di memoria allocata in caso
471   di successo e \macro{NULL} in caso di fallimento, nel qual caso
472   \var{errno} viene impostata a \macro{ENOMEM}.
473 \funcdecl{void free(void *ptr)}
474   Disalloca lo spazio di memoria puntato da \var{ptr}.
475
476   La funzione non ritorna nulla e non riporta errori.
477 \end{functions}
478 Il puntatore ritornato dalle funzioni di allocazione è garantito essere sempre
479 allineato correttamente per tutti i tipi di dati; ad esempio sulle macchine a
480 32 bit in genere è allineato a multipli di 4 byte e sulle macchine a 64 bit a
481 multipli di 8 byte.
482
483 In genere su usano le funzioni \func{malloc} e \func{calloc} per allocare
484 dinamicamente la memoria necessaria al programma, e siccome i puntatori
485 ritornati sono di tipo generico non è necessario effettuare un cast per
486 assegnarli a puntatori al tipo di variabile per la quale si effettua
487 l'allocazione.
488
489 La memoria allocata dinamicamente deve essere esplicitamente rilasciata usando
490 \func{free}\footnote{le glibc provvedono anche una funzione \func{cfree}
491   definita per compatibilità con SunOS, che è deprecata.} una volta che non
492 sia più necessaria. Questa funzione vuole come parametro un puntatore
493 restituito da una precedente chiamata a una qualunque delle funzioni di
494 allocazione che non sia già stato liberato da un'altra chiamata a \func{free},
495 in caso contrario il comportamento della funzione è indefinito.
496
497 La funzione \func{realloc} si usa invece per cambiare (in genere aumentare) la
498 dimensione di un'area di memoria precedentemente allocata, la funzione vuole
499 in ingresso il puntatore restituito dalla precedente chiamata ad una
500 \func{malloc} (se è passato un valore \macro{NULL} allora la funzione si
501 comporta come \func{malloc},\footnote{questo è vero per Linux e
502   l'implementazione secondo lo standard ANSI C, ma non è vero per alcune
503   vecchie implementazioni, inoltre alcune versioni delle librerie del C
504   consentivano di usare \func{realloc} anche per un puntatore liberato con
505   \func{free} purché non ci fossero state nel frattempo altre chiamate a
506   funzioni di allocazione, questa funzionalità è totalmente deprecata e non è
507   consentita sotto Linux.}) ad esempio quando si deve far crescere la
508 dimensione di un vettore. In questo caso se è disponibile dello spazio
509 adiacente al precedente la funzione lo utilizza, altrimenti rialloca altrove
510 un blocco della dimensione voluta, copiandoci automaticamente il contenuto; lo
511 spazio aggiunto non viene inizializzato.
512
513 Si deve sempre avere ben presente il fatto che il blocco di memoria restituito
514 da \func{realloc} può non essere un'estensione di quello che gli si è passato
515 in ingresso; per questo si dovrà \emph{sempre} eseguire la riassegnazione di
516 \var{ptr} al valore di ritorno della funzione, e reinizializzare o provvedere
517 ad un adeguato aggiornamento di tutti gli altri puntatori all'interno del
518 blocco di dati ridimensionato.
519
520 Un errore abbastanza frequente (specie se si ha a che fare con array di
521 puntatori) è quello di chiamare \func{free} più di una volta sullo stesso
522 puntatore; per evitare questo problema una soluzione di ripiego è quella di
523 assegnare sempre a \macro{NULL} ogni puntatore liberato con \func{free}, dato
524 che, quando il parametro è un puntatore nullo, \func{free} non esegue nessuna
525 operazione.
526
527 Le \acr{glibc} hanno un'implementazione delle routine di allocazione che è
528 controllabile dall'utente attraverso alcune variabili di ambiente, in
529 particolare diventa possibile tracciare questo tipo di errori usando la
530 variabile \macro{MALLOC\_CHECK\_} che quando viene definita mette in uso una
531 versione meno efficiente delle funzioni suddette, che però è più tollerante
532 nei confronti di piccoli errori come quello di chiamate doppie a \func{free}.
533 In particolare:
534 \begin{itemize*}
535 \item se la variabile è posta a zero gli errori vengono ignorati.
536 \item se è posta ad 1 viene stampato un avviso sullo \textit{standard error}
537   (vedi \secref{sec:file_std_stream}).
538 \item se è posta a 2 viene chiamata \func{abort}, che in genere causa
539   l'immediata conclusione del programma.
540 \end{itemize*}
541
542 Il problema più comune e più difficile da risolvere che si incontra con le
543 routine di allocazione è quando non viene opportunamente liberata la memoria
544 non più utilizzata, quello che in inglese viene chiamato \textit{memory-leak},
545 (cioè \textsl{perdita di memoria}).
546
547 Un caso tipico che illustra il problema è quello in cui in una subroutine si
548 alloca della memoria per uso locale senza liberarla prima di uscire. La
549 memoria resta così allocata fino alla terminazione del processo.  Chiamate
550 ripetute alla stessa subroutine continueranno ad effettuare altre allocazioni,
551 causando a lungo andare un esaurimento della memoria disponibile (e la
552 probabile l'impossibilità di proseguire l'esecuzione programma).
553
554 Il problema è che l'esaurimento della memoria può avvenire in qualunque
555 momento, in corrispondenza ad una qualunque chiamata di \func{malloc}, che può
556 essere in una sezione del codice che non ha alcuna relazione con la subroutine
557 che contiene l'errore. Per questo motivo è sempre molto difficile trovare un
558 \textit{memory leak}.
559
560 Per ovviare a questi problemi l'implementazione delle routine di allocazione
561 delle \acr{glibc} mette a disposizione una serie di funzionalità che
562 permettono di tracciare le allocazioni e le disallocazione, e definisce anche
563 una serie di possibili \textit{hook} (\textsl{ganci}) che permettono di
564 sostituire alle funzioni di libreria una propria versione (che può essere più
565 o meno specializzata per il debugging).
566
567
568 \subsection{La funzione \func{alloca}}  
569 \label{sec:proc_mem_alloca}
570
571 Una possibile alternativa all'uso di \func{malloc}, che non soffre dei
572 problemi di memory leak descritti in precedenza, è la funzione \func{alloca},
573 che invece di allocare la memoria nello heap usa il segmento di stack della
574 funzione corrente. La sintassi è identica a quella di \func{malloc}, il suo
575 prototipo è:
576 \begin{prototype}{stdlib.h}{void *alloca(size\_t size)}
577   Alloca \var{size} byte nel segmento di stack della funzione chiamante.
578   La memoria non viene inizializzata.
579
580   La funzione restituisce il puntatore alla zona di memoria allocata in caso
581   di successo e \macro{NULL} in caso di fallimento, nel qual caso
582   \var{errno} viene impostata a \macro{ENOMEM}.
583 \end{prototype}
584 \noindent ma in questo caso non è più necessario liberare la memoria (e quindi
585 non esiste un analogo della \func{free}) in quanto essa viene rilasciata 
586 automaticamente al ritorno della funzione.
587
588 Come è evidente questa funzione ha molti vantaggi, anzitutto permette di
589 evitare alla radice i problemi di memory leak, dato che non serve più la
590 deallocazione esplicita; inoltre la deallocazione automatica funziona anche
591 quando si usa \func{longjmp} per uscire da una subroutine con un salto non
592 locale da una funzione (vedi \secref{sec:proc_longjmp}).
593
594 Un altro vantaggio è che in Linux la funzione è molto più veloce di
595 \func{malloc} e non viene sprecato spazio, infatti non è necessario gestire un
596 pool di memoria da riservare e si evitano così anche i problemi di
597 frammentazione di quest'ultimo, che comportano inefficienze sia
598 nell'allocazione della memoria che nell'esecuzione dell'allocazione.
599
600 Gli svantaggi sono che questa funzione non è disponibile su tutti gli Unix, e
601 non è inserita né nello standard POSIX né in SUSv3 (ma è presente in BSD), il
602 suo utilizzo quindi limita la portabilità dei programmi. Inoltre la funzione
603 non può essere usata nella lista degli argomenti di una funzione, perché lo
604 spazio verrebbe allocato nel mezzo degli stessi.
605
606 % Questo è riportato solo dal manuale delle glibc, nelle pagine di manuale non c'è 
607 % traccia di tutto ciò
608 %
609 %Inoltre se si
610 %cerca di allocare troppa memoria non si ottiene un messaggio di errore, ma un
611 %segnale di \textit{segment violation} analogo a quello che si avrebbe da una
612 %ricorsione infinita.
613
614 Inoltre non è chiaramente possibile usare \func{alloca} per allocare memoria
615 che deve poi essere usata anche al di fuori della funzione in cui essa viene
616 chiamata, dato che all'uscita dalla funzione lo spazio allocato diventerebbe
617 libero, e potrebbe essere sovrascritto all'invocazione di nuove funzioni.
618 Questo è lo stesso problema che si può avere con le variabili automatiche, su
619 cui torneremo in \secref{sec:proc_auto_var}.
620
621
622 \subsection{Le funzioni \func{brk} e \func{sbrk}}  
623 \label{sec:proc_mem_sbrk}
624
625 L'uso di queste funzioni è necessario solo quando si voglia accedere alle
626 analoghe system call a cui fanno da interfaccia. I loro prototipi sono:
627 \begin{functions}
628   \headdecl{unistd.h}
629   \funcdecl{int brk(void *end\_data\_segment)}
630   Sposta la fine del segmento dei dati all'indirizzo specificato da
631   \var{end\_data\_segment}.
632   
633   La funzione restituisce 0 in caso di successo e -1 in caso di
634     fallimento, nel qual caso \var{errno} viene impostata a \macro{ENOMEM}.
635
636   \funcdecl{void *sbrk(ptrdiff\_t increment)} Incrementa lo spazio dati di un
637   programma di \var{increment}. Un valore zero restituisce l'attuale posizione
638   della fine del segmento dati.
639   
640   La funzione restituisce il puntatore all'inizio della nuova zona di memoria
641   allocata in caso di successo e \macro{NULL} in caso di fallimento, nel qual
642   caso \macro{errno} viene impostata a \macro{ENOMEM}.
643 \end{functions}
644 \noindent in genere si usa \func{sbrk} con un valore zero per ottenere
645 l'attuale posizione della fine del segmento dati.
646
647 Queste funzioni sono state deliberatamente escluse dallo standard POSIX.1 e
648 per i programmi normali è sempre opportuno usare le funzioni di allocazione
649 standard descritte in precedenza, che sono costruite su di esse.  L'uso di
650 queste funzione è ristretto alle specifiche necessità di chi debba
651 implementare una sua versione delle routine di allocazione.  
652
653
654 % \subsection{La personalizzazione delle funzioni di allocazione} 
655 % \label{sec:proc_mem_malloc_custom}
656
657
658 \subsection{Il controllo della memoria virtuale\index{memoria virtuale}}  
659 \label{sec:proc_mem_lock}
660
661 Come spiegato in \secref{sec:proc_mem_gen} il kernel gestisce la memoria
662 virtuale in maniera trasparente ai processi, decidendo quando rimuovere pagine
663 dalla memoria per metterle nello swap, sulla base dell'utilizzo corrente da
664 parte dei vari processi.
665
666 Nell'uso comune un processo non deve preoccuparsi di tutto ciò, in quanto il
667 meccanismo della paginazione\index{paginazione} riporta in RAM, ed in maniera
668 trasparente, tutte le pagine che gli occorrono; esistono però esigenze
669 particolari in cui non si vuole che questo meccanismo si attivi. In generale i
670 motivi per cui si possono avere di queste necessità sono due:
671 \begin{itemize}
672 \item \textsl{La velocità}. Il processo della paginazione è trasparente solo
673   se il programma in esecuzione non è sensibile al tempo che occorre a
674   riportare la pagina in memoria; per questo motivo processi critici che hanno
675   esigenze di tempo reale o tolleranze critiche nelle risposte (ad esempio
676   processi che trattano campionamenti sonori) possono non essere in grado di
677   sopportare le variazioni della velocità di accesso dovuta alla paginazione.
678   
679   In certi casi poi un programmatore può conoscere meglio dell'algoritmo di
680   allocazione delle pagine le esigenze specifiche del suo programma e decidere
681   quali pagine di memoria è opportuno che restino in memoria per un aumento
682   delle prestazioni. In genere queste sono esigenze particolari e richiedono
683   anche un aumento delle priorità in esecuzione del processo (vedi
684   \secref{sec:proc_real_time}).
685   
686 \item \textsl{La sicurezza}. Se si hanno password o chiavi segrete in chiaro
687   in memoria queste possono essere portate su disco dal meccanismo della
688   paginazione. Questo rende più lungo il periodo di tempo in cui detti segreti
689   sono presenti in chiaro e più complessa la loro cancellazione (ad un
690   processo è possibile cancellare la memoria su cui scrive le sue variabili,
691   ma non può toccare lo spazio disco su cui una pagina di memoria può essere
692   stata salvata). Per questo motivo di solito i programmi di crittografia
693   richiedono il blocco di alcune pagine di memoria.
694 \end{itemize}
695
696 Il meccanismo che previene la paginazione di parte della memoria virtuale di
697 un processo è chiamato \textit{memory locking} (o \textsl{blocco della
698   memoria}). Il blocco è sempre associato alle pagine della memoria virtuale
699 del processo, e non al segmento reale di RAM su cui essa viene mantenuta.
700
701 La regola è che se un segmento di RAM fa da supporto ad almeno una pagina
702 bloccata allora esso viene escluso dal meccanismo della paginazione. I blocchi
703 non si accumulano, se si blocca due volte la stessa pagina non è necessario
704 sbloccarla due volte, una pagina o è bloccata oppure no.
705
706 Il \textit{memory lock} persiste fintanto che il processo che detiene la
707 memoria bloccata non la sblocca. Chiaramente la terminazione del processo
708 comporta anche la fine dell'uso della sua memoria virtuale, e quindi anche di
709 tutti i suoi \textit{memory lock}.
710
711 I \textit{memory lock} non sono ereditati dai processi figli.\footnote{ma
712   siccome Linux usa il \textit{copy on write}\index{copy on write} (vedi
713   \secref{sec:proc_fork}) gli indirizzi virtuali del figlio sono mantenuti
714   sullo stesso segmento di RAM del padre, quindi fintanto che un figlio non
715   scrive su un segmento, può usufruire del memory lock del padre.}  Siccome la
716 presenza di un \textit{memory lock} riduce la memoria disponibile al sistema,
717 con un impatto su tutti gli altri processi, solo l'amministratore ha la
718 capacità di bloccare una pagina. Ogni processo può però sbloccare le pagine
719 relative alla propria memoria.
720
721 Il sistema pone dei limiti all'ammontare di memoria di un processo che può
722 essere bloccata e al totale di memoria fisica che può dedicare a questo, lo
723 standard POSIX.1 richiede che sia definita in \file{unistd.h} la costante
724 \macro{\_POSIX\_MEMLOCK\_RANGE} per indicare la capacità di eseguire il
725 \textit{memory locking} e la costante \macro{PAGESIZE} in \file{limits.h} per
726 indicare la dimensione di una pagina in byte.
727
728 Le funzioni per bloccare e sbloccare singole sezioni di memoria sono
729 \func{mlock} e \func{munlock}; i loro prototipi sono:
730 \begin{functions}
731   \headdecl{sys/mman.h} 
732
733   \funcdecl{int mlock(const void *addr, size\_t len)}
734   Blocca la paginazione per l'intervallo di memoria da \var{addr} per
735   \var{len} byte. Tutte le pagine che contengono una parte dell'intervallo
736   sono mantenute in RAM per tutta la durata del blocco.
737
738   \funcdecl{int munlock(const void *addr, size\_t len)}
739   Sblocca l'intervallo di memoria da \var{addr} per \var{len} byte.  
740
741   
742   \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 in
743     caso di errore, nel qual caso \var{errno} è impostata ad uno dei
744     valori seguenti:
745   \begin{errlist}
746   \item[\macro{ENOMEM}] alcuni indirizzi dell'intervallo specificato non
747     corrispondono allo spazio di indirizzi del processo o si è ecceduto
748     il numero massimo consentito di pagine bloccate.
749   \item[\macro{EINVAL}] \var{len} non è un valore positivo.
750   \end{errlist}
751   e, per \func{mlock}, anche \macro{EPERM} quando il processo non ha i
752   privilegi richiesti per l'operazione.}
753 \end{functions}
754
755 Altre due funzioni, \func{mlockall} e \func{munlockall}, consentono di
756 bloccare genericamente lo spazio di indirizzi di un processo.  I prototipi di
757 queste funzioni sono:
758
759 \begin{functions}
760   \headdecl{sys/mman.h} 
761
762   \funcdecl{int mlockall(int flags)}
763   Blocca la paginazione per lo spazio di indirizzi del processo corrente. 
764   
765   \funcdecl{int munlockall(void)}
766   Sblocca la paginazione per lo spazio di indirizzi del processo corrente. 
767   
768   \bodydesc{Codici di ritorno ed errori sono gli stessi di \func{mlock}
769     e \func{munlock}.}
770 \end{functions}
771
772 Il parametro \var{flags} di \func{mlockall} permette di controllarne il
773 comportamento; esso può essere specificato come l'OR aritmetico delle due
774 costanti: 
775 \begin{basedescript}{\desclabelwidth{2.5cm}}
776 \item[\macro{MCL\_CURRENT}] blocca tutte le pagine correntemente mappate nello
777   spazio di indirizzi del processo.
778 \item[\macro{MCL\_FUTURE}] blocca tutte le pagine che saranno mappate nello
779   spazio di indirizzi del processo.
780 \end{basedescript}
781
782 Con \func{mlockall} si può bloccare tutte le pagine mappate nello spazio di
783 indirizzi del processo, sia che comprendano il segmento di testo, di dati, lo
784 stack, lo heap e pure le funzioni di libreria chiamate, i file mappati in
785 memoria, i dati del kernel mappati in user space, la memoria condivisa.  L'uso
786 dei flag permette di selezionare con maggior finezza le pagine da bloccare, ad
787 esempio limitandosi a tutte le pagine allocate a partire da un certo momento.
788
789 In ogni caso un processo real-time che deve entrare in una sezione critica
790 deve provvedere a riservare memoria sufficiente prima dell'ingresso, per
791 scongiurare in partenza un eventuale page fault\index{page fault} causato dal
792 meccanismo di \textit{copy on write}\index{copy on write}.  Infatti se nella
793 sezione critica si va ad utilizzare memoria che non è ancora stata riportata
794 in RAM si potrebbe avere un page fault durante l'esecuzione della stessa, con
795 conseguente rallentamento (probabilmente inaccettabile) dei tempi di
796 esecuzione.
797
798 In genere si ovvia a questa problematica chiamando una funzione che ha
799 allocato una quantità sufficientemente ampia di variabili automatiche, in modo
800 che esse vengano mappate in RAM dallo stack, dopo di che, per essere sicuri
801 che esse siano state effettivamente portate in memoria, ci si scrive sopra.
802
803
804
805 \section{Parametri, opzioni ed ambiente di un processo}
806 \label{sec:proc_options}
807
808 Tutti i programmi hanno la possibilità di ricevere parametri e opzioni quando
809 vengono lanciati. Il passaggio dei parametri è effettuato attraverso gli
810 argomenti \var{argc} e \var{argv} della funzione \func{main}, che vengono
811 passati al programma dalla shell (o dal processo che esegue la \func{exec},
812 secondo le modalità che vedremo in \secref{sec:proc_exec}) quando questo viene
813 messo in esecuzione. 
814
815 Oltre al passaggio dei parametri, un'altra modalità che permette di passare
816 delle informazioni che modifichino il comportamento di un programma è quello
817 dell'uso del cosiddetto \textit{environment} (cioè l'uso delle
818 \textsl{variabili di ambiente}). In questa sezione esamineremo le funzioni che
819 permettono di gestire parametri e opzioni, e quelle che consentono di
820 manipolare ed utilizzare le variabili di ambiente.
821
822
823 \subsection{Il formato dei parametri}
824 \label{sec:proc_par_format}
825 In genere passaggio dei parametri al programma viene effettuato dalla shell,
826 che si incarica di leggere la linea di comando e di effettuarne la scansione
827 (il cosiddetto \textit{parsing}) per individuare le parole che la compongono,
828 ciascuna delle quali viene considerata un parametro. Di norma per individuare
829 le parole viene usato come carattere di separazione lo spazio o il tabulatore,
830 ma il comportamento è modificabile attraverso l'impostazione della variabile
831 di ambiente \cmd{IFS}.
832
833 \begin{figure}[htb]
834   \centering
835   \includegraphics[width=11cm]{img/argv_argc}
836   \caption{Esempio dei valori di \var{argv} e \var{argc} generati nella 
837     scansione di una riga di comando.}
838   \label{fig:proc_argv_argc}
839 \end{figure}
840
841 Nella scansione viene costruito il vettore di puntatori \var{argv} inserendo
842 in successione il puntatore alla stringa costituente l'$n$-simo parametro; la
843 variabile \var{argc} viene inizializzata al numero di parametri trovati, in
844 questo modo il primo parametro è sempre il nome del programma; un esempio di
845 questo meccanismo è mostrato in \curfig.
846
847
848 \subsection{La gestione delle opzioni}
849 \label{sec:proc_opt_handling}
850
851 In generale un programma Unix riceve da linea di comando sia gli argomenti che
852 le opzioni, queste ultime sono standardizzate per essere riconosciute come
853 tali: un elemento di \var{argv} che inizia con \texttt{-} e che non sia un
854 singolo \texttt{-} o un \texttt{--} viene considerato un'opzione.  In genere
855 le opzioni sono costituite da una lettera singola (preceduta dal \cmd{-}) e
856 possono avere o no un parametro associato; un comando tipico può essere quello
857 mostrato in \figref{fig:proc_argv_argc}. In quel caso le opzioni sono \cmd{-r}
858 ed \cmd{-m} e la prima vuole un parametro mentre la seconda no
859 (\cmd{questofile.txt} è un argomento del programma, non un parametro di
860 \cmd{-m}).
861
862 Per gestire le opzioni all'interno dei argomenti a linea di comando passati in
863 \var{argv} le librerie standard del C forniscono la funzione \func{getopt}
864 che ha il seguente prototipo:
865 \begin{prototype}{unistd.h}
866 {int getopt(int argc, char *const argv[], const char *optstring)}
867 Esegue il parsing degli argomenti passati da linea di comando
868 riconoscendo le possibili opzioni segnalate con \var{optstring}.
869
870 \bodydesc{Ritorna il carattere che segue l'opzione, \cmd{':'} se manca un
871   parametro all'opzione, \cmd{'?'} se l'opzione è sconosciuta, e -1 se non
872   esistono altre opzioni.}
873 \end{prototype}
874
875 Questa funzione prende come argomenti le due variabili \var{argc} e \var{argv}
876 passate a \func{main} ed una stringa che indica quali sono le opzioni valide;
877 la funzione effettua la scansione della lista degli argomenti ricercando ogni
878 stringa che comincia con \cmd{-} e ritorna ogni volta che trova un'opzione
879 valida.
880
881 La stringa \var{optstring} indica quali sono le opzioni riconosciute ed è
882 costituita da tutti i caratteri usati per identificare le singole opzioni, se
883 l'opzione ha un parametro al carattere deve essere fatto seguire un segno di
884 due punti \var{':'}; nel caso di \figref{fig:proc_argv_argc} ad esempio la
885 stringa di opzioni avrebbe dovuto contenere \var{"r:m"}.
886
887 La modalità di uso di \func{getopt} è pertanto quella di chiamare più volte la
888 funzione all'interno di un ciclo, fintanto che essa non ritorna il valore -1
889 che indica che non ci sono più opzioni. Nel caso si incontri un'opzione non
890 dichiarata in \var{optstring} viene ritornato il carattere \texttt{'?'}
891 mentre se un opzione che lo richiede non è seguita da un parametro viene
892 ritornato il carattere \texttt{':'}, infine se viene incontrato il valore
893 \cmd{--} la scansione viene considerata conclusa, anche se vi sono altri
894 elementi di \var{argv} che cominciano con il carattere \texttt{'-'}.
895
896 \begin{figure}[htb]
897   \footnotesize
898     \begin{lstlisting}{}
899     opterr = 0;  /* don't want writing to stderr */
900     while ( (i = getopt(argc, argv, "hp:c:e:")) != -1) {
901         switch (i) {
902         /* 
903          * Handling options 
904          */ 
905         case 'h':   /* help option */
906             printf("Wrong -h option use\n");
907             usage();
908             return -1;
909             break;
910         case 'c':   /* take wait time for childen */
911             wait_child = strtol(optarg, NULL, 10);    /* convert input */
912             break;
913         case 'p':   /* take wait time for childen */
914             wait_parent = strtol(optarg, NULL, 10);   /* convert input */
915             break;
916         case 'e':   /* take wait before parent exit */
917             wait_end = strtol(optarg, NULL, 10);      /* convert input */
918             break;
919         case '?':   /* unrecognized options */
920             printf("Unrecognized options -%c\n",optopt);
921             usage();
922         default:    /* should not reached */
923             usage();
924         }
925     }
926     debug("Optind %d, argc %d\n",optind,argc);
927   \end{lstlisting}
928   \caption{Esempio di codice per la gestione delle opzioni.}
929   \label{fig:proc_options_code}
930 \end{figure}
931
932 Quando la funzione trova un'opzione essa ritorna il valore numerico del
933 carattere, in questo modo si possono eseguire azioni specifiche usando uno
934 \code{switch}; \func{getopt} inoltre inizializza alcune variabili globali:
935 \begin{itemize*}
936 \item \var{char *optarg} contiene il puntatore alla stringa parametro
937   dell'opzione.
938 \item \var{int optind} alla fine della scansione restituisce l'indice del
939   primo elemento di \var{argv} che non è un'opzione.
940 \item \var{int opterr} previene, se posto a zero, la stampa di un messaggio
941   di errore in caso di riconoscimento di opzioni non definite.
942 \item \var{int optopt} contiene il carattere dell'opzione non riconosciuta.
943 \end{itemize*}
944
945 In \figref{fig:proc_options_code} è mostrata la sezione del programma
946 \file{ForkTest.c} (che useremo nel prossimo capitolo per effettuare dei test
947 sulla creazione dei processi) deputata alla decodifica delle opzioni a riga di
948 comando. 
949
950 Anzitutto si può notare che si è anzitutto (\texttt{\small 1}) disabilitata la
951 stampa di messaggi di errore per opzioni non riconosciute, per poi passare al
952 ciclo per la verifica delle opzioni (\texttt{\small 2-27}); per ciascuna delle
953 opzioni possibili si è poi provveduto ad un'azione opportuna, ad esempio per
954 le tre opzioni che prevedono un parametro si è effettuata la decodifica del
955 medesimo (il cui indirizzo è contenuto nella variabile \var{optarg})
956 avvalorando la relativa variabile (\texttt{\small 12-14}, \texttt{\small
957   15-17} e \texttt{\small 18-20}). Completato il ciclo troveremo in
958 \var{optind} l'indice in \var{argv[]} del primo degli argomenti rimanenti
959 nella linea di comando.
960
961 Normalmente \func{getopt} compie una permutazione degli elementi di \var{argv}
962 così che alla fine della scansione gli elementi che non sono opzioni sono
963 spostati in coda al vettore. Oltre a questa esistono altre due modalità di
964 gestire gli elementi di \var{argv}; se \var{optstring} inizia con il carattere
965 \texttt{'+'} (o è impostata la variabile di ambiente \macro{POSIXLY\_CORRECT})
966 la scansione viene fermata non appena si incontra un elemento che non è
967 un'opzione. L'ultima modalità, usata quando un programma può gestire la
968 mescolanza fra opzioni e argomenti, ma se li aspetta in un ordine definito, si
969 attiva quando \var{optstring} inizia con il carattere \texttt{'-'}. In questo
970 caso ogni elemento che non è un'opzione viene considerato comunque un'opzione
971 e associato ad un valore di ritorno pari ad 1, questo permette di identificare
972 gli elementi che non sono opzioni, ma non effettua il riordinamento del
973 vettore \var{argv}.
974
975
976 \subsection{Opzioni in formato esteso}
977 \label{sec:proc_opt_extended}
978
979 Un'estensione di questo schema è costituito dalle cosiddette
980 \textit{long-options} espresse nella forma \cmd{--option=parameter}, anche la
981 gestione di queste ultime è stata standardizzata attraverso l'uso di una
982 versione estesa di \func{getopt}.
983
984 (NdA: da finire).
985
986
987 \subsection{Le variabili di ambiente}
988 \label{sec:proc_environ}
989
990 Oltre agli argomenti passati a linea di comando ogni processo riceve dal
991 sistema un \textsl{ambiente}, nella forma di una lista di variabili (detta
992 \textit{environment list}) messa a disposizione dal processo, e costruita
993 nella chiamata alla funzione \func{exec} quando questo viene lanciato.
994
995 Come per la lista dei parametri anche questa lista è un array di puntatori a
996 caratteri, ciascuno dei quali punta ad una stringa, terminata da un
997 \macro{NULL}. A differenza di \var{argv[]} in questo caso non si ha una
998 lunghezza dell'array data da un equivalente di \var{argc}, ma la lista è
999 terminata da un puntatore nullo.
1000
1001 L'indirizzo della lista delle variabili di ambiente è passato attraverso la
1002 variabile globale \var{environ}, a cui si può accedere attraverso una semplice
1003 dichiarazione del tipo:
1004 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
1005 extern char ** environ;
1006 \end{lstlisting}
1007 un esempio del contenuto dell'ambiente, in si è riportato un estratto delle
1008 variabili che normalmente sono definite dal sistema, è riportato in \nfig.
1009 \begin{figure}[htb]
1010   \centering
1011   \includegraphics[width=11cm]{img/environ_var}
1012   \caption{Esempio di lista delle variabili di ambiente.}
1013   \label{fig:proc_envirno_list}
1014 \end{figure}
1015
1016 Per convenzione le stringhe che definiscono l'ambiente sono tutte del tipo
1017 \textsl{\texttt{nome=valore}}. Inoltre alcune variabili, come quelle elencate
1018 in \curfig, sono definite dal sistema per essere usate da diversi programmi e
1019 funzioni: per queste c'è l'ulteriore convenzione di usare nomi espressi in
1020 caratteri maiuscoli.
1021
1022 Il kernel non usa mai queste variabili, il loro uso e la loro interpretazione è
1023 riservata alle applicazioni e ad alcune funzioni di libreria; in genere esse
1024 costituiscono un modo comodo per definire un comportamento specifico senza
1025 dover ricorrere all'uso di opzioni a linea di comando o di file di
1026 configurazione. 
1027
1028 La shell ad esempio ne usa molte per il suo funzionamento (come \var{PATH} per
1029 la ricerca dei comandi, o \cmd{IFS} per la scansione degli argomenti), e
1030 alcune di esse (come \var{HOME}, \var{USER}, etc.)  sono definite al login. In
1031 genere è cura dell'amministratore definire le opportune variabili di ambiente
1032 in uno script di avvio. Alcune servono poi come riferimento generico per molti
1033 programmi (come \var{EDITOR} che indica l'editor preferito da invocare in caso
1034 di necessità).
1035
1036 Gli standard POSIX e XPG3 definiscono alcune di queste variabili (le più
1037 comuni), come riportato in \ntab. GNU/Linux le supporta tutte e ne definisce
1038 anche altre: per una lista più completa si può controllare \cmd{man environ}.
1039
1040 \begin{table}[htb]
1041   \centering
1042   \begin{tabular}[c]{|l|c|c|c|p{7cm}|}
1043     \hline
1044     \textbf{Variabile} & \textbf{POSIX} & \textbf{XPG3} 
1045     & \textbf{Linux} & \textbf{Descrizione} \\
1046     \hline
1047     \hline
1048     \macro{USER} & $\bullet$ & $\bullet$ & $\bullet$ & Nome utente\\
1049     \macro{LOGNAME} & $\bullet$ & $\bullet$ & $\bullet$ & Nome di login\\
1050     \macro{HOME} & $\bullet$ & $\bullet$ & $\bullet$ & 
1051     Directory base dell'utente\\
1052     \macro{LANG} & $\bullet$ & $\bullet$ & $\bullet$ & Localizzazione\\
1053     \macro{PATH} & $\bullet$ & $\bullet$ & $\bullet$ & Elenco delle directory
1054     dei programmi\\
1055     \macro{PWD} & $\bullet$ & $\bullet$ & $\bullet$ & Directory corrente\\
1056     \macro{SHELL} & $\bullet$ & $\bullet$ & $\bullet$ & Shell in uso\\
1057     \macro{TERM} & $\bullet$ & $\bullet$ & $\bullet$ & Tipo di terminale\\
1058     \macro{PAGER} & $\bullet$ & $\bullet$ & $\bullet$ & Programma per vedere i
1059     testi\\
1060     \macro{EDITOR} & $\bullet$ & $\bullet$ & $\bullet$ & Editor preferito\\
1061     \macro{BROWSER} & $\bullet$ & $\bullet$ & $\bullet$ & Browser preferito\\
1062     \hline
1063   \end{tabular}
1064   \caption{Variabili di ambiente più comuni definite da vari standard.}
1065   \label{tab:proc_env_var}
1066 \end{table}
1067
1068 Lo standard ANSI C prevede l'esistenza di un ambiente, pur non entrando nelle
1069 specifiche di come sono strutturati i contenuti, e definisce la funzione
1070 \func{getenv} che permette di ottenere i valori delle variabili di ambiente,
1071 il cui prototipo è:
1072 \begin{prototype}{stdlib.h}{char *getenv(const char *name)}
1073   Esamina l'ambiente del processo cercando una stringa che corrisponda a
1074   quella specificata da \param{name}. 
1075   
1076   \bodydesc{La funzione ritorna \macro{NULL} se non trova nulla, o il
1077     puntatore alla stringa che corrisponde (di solito nella forma
1078     \cmd{NOME=valore}).}
1079 \end{prototype}
1080
1081 Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI
1082 C, nell'evoluzione dei sistemi Unix ne sono state proposte altre, da
1083 utilizzare per impostare e per cancellare le variabili di ambiente. Uno schema
1084 delle funzioni previste nei vari standard e disponibili in Linux è riportato
1085 in \ntab.
1086
1087 \begin{table}[htb]
1088   \centering
1089   \begin{tabular}[c]{|l|c|c|c|c|c|c|}
1090     \hline
1091     \textbf{Funzione} & \textbf{ANSI C} & \textbf{POSIX.1} & \textbf{XPG3} & 
1092     \textbf{SVr4} & \textbf{BSD} & \textbf{Linux} \\
1093     \hline
1094     \hline
1095     \func{getenv} & $\bullet$ &  $\bullet$ & $\bullet$ & 
1096       $\bullet$ & $\bullet$ & $\bullet$ \\
1097     \func{setenv} &   &   &    & 
1098         & $\bullet$ & $\bullet$ \\
1099     \func{unsetenv} &  &   &    & 
1100         & $\bullet$ & $\bullet$ \\
1101     \func{putenv} &  & opz.  & $\bullet$ & 
1102         & $\bullet$ & $\bullet$ \\
1103     \func{clearenv} &  & opz.  &    & 
1104         &  &  \\
1105     \hline
1106   \end{tabular}
1107   \caption{Funzioni per la gestione delle variabili di ambiente.}
1108   \label{tab:proc_env_func}
1109 \end{table}
1110
1111 In Linux solo le prime quattro funzioni di \curtab\ sono definite,
1112 \func{getenv} l'abbiamo già esaminata; delle tre restanti le prime due,
1113 \func{putenv} e \func{setenv}, servono per assegnare nuove variabili di
1114 ambiente, i loro prototipi sono i seguenti:
1115 \begin{functions}
1116   \headdecl{stdlib.h} 
1117   
1118   \funcdecl{int setenv(const char *name, const char *value, int overwrite)}
1119   Imposta la variabile di ambiente \param{name} al valore \param{value}.
1120   
1121   \funcdecl{int putenv(char *string)} Aggiunge la stringa \param{string}
1122   all'ambiente.
1123   
1124   \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 per un
1125     errore, che è sempre \macro{ENOMEM}.}
1126 \end{functions}
1127 \noindent la terza, \func{unsetenv}, serve a cancellare una variabile di
1128 ambiente; il suo prototipo è:
1129 \begin{functions}
1130   \headdecl{stdlib.h}
1131   
1132   \funcdecl{void unsetenv(const char *name)} Rimuove la variabile di ambiente
1133   \param{name}.
1134 \end{functions}
1135 \noindent questa funzione elimina ogni occorrenza della variabile specificata;
1136 se essa non esiste non succede nulla. Non è prevista (dato che la funzione è
1137 \ctyp{void}) nessuna segnalazione di errore.
1138
1139 Per modificare o aggiungere una variabile di ambiente si possono usare sia
1140 \func{setenv} che \func{putenv}. La prima permette di specificare
1141 separatamente nome e valore della variabile di ambiente, inoltre il valore di
1142 \param{overwrite} specifica il comportamento della funzione nel caso la
1143 variabile esista già, sovrascrivendola se diverso da zero, lasciandola
1144 immutata se uguale a zero.
1145
1146 La seconda funzione prende come parametro una stringa analoga quella
1147 restituita da \func{getenv}, e sempre nella forma \var{NOME=valore}. Se la
1148 variabile specificata non esiste la stringa sarà aggiunta all'ambiente, se
1149 invece esiste il suo valore sarà impostato a quello specificato da
1150 \param{string}. Si tenga presente che, seguendo lo standard SUSv2, le
1151 \acr{glibc} successive alla versione 2.1.2 aggiungono\footnote{il
1152   comportamento è lo stesso delle vecchie \acr{libc4} e \acr{libc5}; nelle
1153   \acr{glibc}, dalla versione 2.0 alla 2.1.1, veniva invece fatta una copia,
1154   seguendo il comportamento di BSD4.4; dato che questo può dar luogo a perdite
1155   di memoria e non rispetta lo standard. Il comportamento è stato modificato a
1156   partire dalle 2.1.2, eliminando anche, sempre in conformità a SUSv2,
1157   l'attributo \ctyp{const} dal prototipo.} \param{string} alla lista delle
1158 variabili di ambiente; pertanto ogni cambiamento alla stringa in questione si
1159 riflette automaticamente sull'ambiente, e quindi si deve evitare di passare a
1160 questa funzione una variabile automatica (per evitare i problemi esposti in
1161 \secref{sec:proc_auto_var}).
1162
1163 Si tenga infine presente che se si passa a \func{putenv} solo il nome di una
1164 variabile (cioè \param{string} è nella forma \texttt{NAME} e non contiene un
1165 \texttt{=}) allora questa viene cancellata dall'ambiente. Infine se la
1166 chiamata di \func{putenv} comporta la necessità di allocare una nuova versione
1167 del vettore \var{environ} questo sarà allocato, ma la versione corrente sarà
1168 deallocata solo se anch'essa è risultante da un'allocazione fatta in
1169 precedenza da un'altra \func{putenv}. Questo perché il vettore delle variabili
1170 di ambiente iniziale, creato dalla chiamata ad \func{exec} (vedi
1171 \secref{sec:proc_exec}) è piazzato al di sopra dello stack, (vedi
1172 \figref{fig:proc_mem_layout}) e non nello heap e non può essere deallocato.
1173 Inoltre la memoria associata alle variabili di ambiente eliminate non viene
1174 liberata.
1175
1176
1177 \section{Problematiche di programmazione generica}
1178 \label{sec:proc_gen_prog}
1179
1180 Benché questo non sia un libro di C, è opportuno affrontare alcune delle
1181 problematiche generali che possono emergere nella programmazione e di quali
1182 precauzioni o accorgimenti occorre prendere per risolverle. Queste
1183 problematiche non sono specifiche di sistemi unix-like o multitasking, ma
1184 avendo trattato in questo capitolo il comportamento dei processi visti come
1185 entità a sé stanti, le riportiamo qui.
1186
1187
1188 \subsection{Il passaggio delle variabili e dei valori di ritorno}
1189 \label{sec:proc_var_passing}
1190
1191 Una delle caratteristiche standard del C è che le variabili vengono passate
1192 alle subroutine attraverso un meccanismo che viene chiamato \textit{by value}
1193 (diverso ad esempio da quanto avviene con il Fortran, dove le variabili sono
1194 passate, come suol dirsi, \textit{by reference}, o dal C++ dove la modalità
1195 del passaggio può essere controllata con l'operatore \cmd{\&}).
1196
1197 Il passaggio di una variabile \textit{by value} significa che in realtà quello
1198 che viene passato alla subroutine è una copia del valore attuale di quella
1199 variabile, copia che la subroutine potrà modificare a piacere, senza che il
1200 valore originale nella routine chiamante venga toccato. In questo modo non
1201 occorre preoccuparsi di eventuali effetti delle operazioni della subroutine
1202 sulla variabile passata come parametro.
1203
1204 Questo però va inteso nella maniera corretta. Il passaggio \textit{by value}
1205 vale per qualunque variabile, puntatori compresi; quando però in una
1206 subroutine si usano dei puntatori (ad esempio per scrivere in un buffer) in
1207 realtà si va a modificare la zona di memoria a cui essi puntano, per cui anche
1208 se i puntatori sono copie, i dati a cui essi puntano sono sempre gli stessi, e
1209 le eventuali modifiche avranno effetto e saranno visibili anche nella routine
1210 chiamante.
1211
1212 Nella maggior parte delle funzioni di libreria e delle system call i puntatori
1213 vengono usati per scambiare dati (attraverso buffer o strutture) e le
1214 variabili semplici vengono usate per specificare parametri; in genere le
1215 informazioni a riguardo dei risultati vengono passate alla routine chiamante
1216 attraverso il valore di ritorno.  È buona norma seguire questa pratica anche
1217 nella programmazione normale.
1218
1219 Talvolta però è necessario che la funzione possa restituire indietro alla
1220 funzione chiamante un valore relativo ad uno dei suoi parametri.  Per far
1221 questo si usa il cosiddetto \textit{value result argument}, si passa cioè,
1222 invece di una normale variabile, un puntatore alla stessa; vedremo alcuni
1223 esempi di questa modalità nelle funzioni che gestiscono i socket (in
1224 \secref{sec:TCPel_functions}), in cui, per permettere al kernel di restituire
1225 informazioni sulle dimensioni delle strutture degli indirizzi utilizzate,
1226 viene usato questo meccanismo.
1227
1228
1229 \subsection{Il passaggio di un numero variabile di argomenti}
1230 \label{sec:proc_variadic}
1231
1232 Come vedremo nei capitoli successivi, non sempre è possibile specificare un
1233 numero fisso di parametri per una funzione.  Lo standard ISO C prevede nella
1234 sua sintassi la possibilità di definire delle \textit{variadic function} che
1235 abbiano un numero variabile di argomenti, attraverso l'uso della
1236 \textit{ellipsis} \var{...} nella dichiarazione della funzione; ma non
1237 provvede a livello di linguaggio alcun meccanismo con cui dette funzioni
1238 possono accedere ai loro argomenti.
1239
1240 L'accesso viene invece realizzato dalle librerie standard che provvedono gli
1241 strumenti adeguati.  L'uso delle \textit{variadic function} prevede tre punti:
1242 \begin{itemize*}
1243 \item \textsl{Dichiarare} la funzione come \textit{variadic} usando un
1244   prototipo che contenga una \textit{ellipsis}.
1245 \item \textsl{Definire} la funzione come \textit{variadic} usando lo stesso
1246   \textit{ellipsis}, ed utilizzare le apposite macro che consentono la
1247   gestione di un numero variabile di argomenti.
1248 \item \textsl{Chiamare} la funzione specificando prima gli argomenti fissi, e
1249   a seguire gli addizionali.
1250 \end{itemize*}
1251
1252 Lo standard ISO C prevede che una \textit{variadic function} abbia sempre
1253 almeno un argomento fisso; prima di effettuare la dichiarazione deve essere
1254 incluso l'apposito header file \file{stdarg.h}; un esempio di dichiarazione è
1255 il prototipo della funzione \func{execl} che vedremo in
1256 \secref{sec:proc_exec}:
1257 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
1258   int execl(const char *path, const char *arg, ...);
1259 \end{lstlisting}
1260 in questo caso la funzione prende due parametri fissi ed un numero variabile
1261 di altri parametri (che verranno a costituire gli elementi successivi al primo
1262 del vettore \var{argv} passato al nuovo processo). Lo standard ISO C richiede
1263 inoltre che l'ultimo degli argomenti fissi sia di tipo
1264 \textit{self-promoting}\footnote{il linguaggio C prevede che quando si
1265   mescolano vari tipi di dati, alcuni di essi possano essere \textsl{promossi}
1266   per compatibilità; ad esempio i tipi \ctyp{float} vengono convertiti
1267   automaticamente a \ctyp{double} ed i \ctyp{char} e gli \ctyp{short} ad
1268   \ctyp{int}. Un tipo \textit{self-promoting} è un tipo che verrebbe promosso
1269   a sé stesso.} il che esclude array, puntatori a funzioni e interi di tipo
1270 \ctyp{char} o \ctyp{short} (con segno o meno). Una restrizione ulteriore di
1271 alcuni compilatori è di non dichiarare l'ultimo parametro fisso come
1272 \ctyp{register}.
1273
1274 Una volta dichiarata la funzione il secondo passo è accedere ai vari parametri
1275 quando la si va a definire. I parametri fissi infatti hanno un loro nome, ma
1276 quelli variabili vengono indicati in maniera generica dalla ellipsis.
1277
1278 L'unica modalità in cui essi possono essere recuperati è pertanto quella
1279 sequenziale; essi verranno estratti dallo stack secondo l'ordine in cui sono
1280 stati scritti. Per fare questo in \file{stdarg.h} sono definite delle apposite
1281 macro; la procedura da seguire è la seguente:
1282 \begin{enumerate*}
1283 \item Inizializzare un puntatore alla lista degli argomenti di tipo
1284   \type{va\_list} attraverso la macro \macro{va\_start}.
1285 \item Accedere ai vari argomenti opzionali con chiamate successive alla macro
1286   \macro{va\_arg}, la prima chiamata restituirà il primo argomento, la seconda
1287   il secondo e così via.
1288 \item Dichiarare la conclusione dell'estrazione dei parametri invocando la
1289   macro \macro{va\_end}.
1290 \end{enumerate*}
1291 in generale è perfettamente legittimo richiedere meno argomenti di quelli che
1292 potrebbero essere stati effettivamente forniti, e nella esecuzione delle
1293 \macro{va\_arg} ci si può fermare in qualunque momento ed i restanti argomenti
1294 saranno ignorati; se invece si richiedono più argomenti di quelli forniti si
1295 otterranno dei valori indefiniti. Nel caso del \cmd{gcc} l'uso della macro
1296 \macro{va\_end} è inutile, ma si consiglia di usarlo ugualmente per
1297 compatibilità.
1298
1299 Le definizioni delle tre macro sono le seguenti:
1300 \begin{functions}
1301   \headdecl{stdarg.h}
1302   
1303   \funcdecl{void va\_start(va\_list ap, last)} Inizializza il puntatore alla
1304   lista di argomenti \param{ap}; il parametro \param{last} \emph{deve} essere
1305   l'ultimo dei parametri fissi.
1306   
1307   \funcdecl{type va\_arg(va\_list ap, type)} Restituisce il valore del
1308   successivo parametro opzionale, modificando opportunamente \param{ap}; la
1309   macro richiede che si specifichi il tipo dell'argomento attraverso il
1310   parametro \param{type} che deve essere il nome del tipo dell'argomento in
1311   questione. Il tipo deve essere \textit{self-promoting}.
1312
1313   \funcdecl{void va\_end(va\_list ap)} Conclude l'uso di \param{ap}.
1314 \end{functions}
1315
1316 In generale si possono avere più puntatori alla lista degli argomenti,
1317 ciascuno andrà inizializzato con \macro{va\_start} e letto con \macro{va\_arg}
1318 e ciascuno potrà scandire la lista degli argomenti per conto suo. 
1319
1320 Dopo l'uso di \macro{va\_end} la variabile \var{ap} diventa indefinita e
1321 successive chiamate a \macro{va\_arg} non funzioneranno. Si avranno risultati
1322 indefiniti anche chiamando \macro{va\_arg} specificando un tipo che non
1323 corrisponde a quello del parametro.
1324
1325 Un altro limite delle macro è che i passi 1) e 3) devono essere eseguiti nel
1326 corpo principale della funzione, il passo 2) invece può essere eseguito anche
1327 in una subroutine passandole il puntatore alla lista di argomenti; in questo
1328 caso però si richiede che al ritorno della funzione il puntatore non venga più
1329 usato (lo standard richiederebbe la chiamata esplicita di \macro{va\_end}),
1330 dato che il valore di \var{ap} risulterebbe indefinito.
1331
1332 Esistono dei casi in cui è necessario eseguire più volte la scansione dei
1333 parametri e poter memorizzare una posizione durante la stessa.  La cosa più
1334 naturale in questo caso sembrerebbe quella di copiarsi il puntatore alla lista
1335 degli argomenti con una semplice assegnazione. Dato che una delle
1336 realizzazioni più comuni di \macro{va\_list} è quella di un puntatore nello
1337 stack all'indirizzo dove sono stati salvati i parametri, è assolutamente
1338 normale pensare di poter effettuare questa operazione.
1339
1340 In generale però possono esistere anche realizzazioni diverse, per questo
1341 motivo \macro{va\_list} è definito come \textsl{tipo opaco} e non può essere
1342 assegnato direttamente ad un altra variabile dello stesso tipo. Per risolvere
1343 questo problema lo standard ISO C99\footnote{alcuni sistemi che non hanno
1344   questa macro provvedono al suo posto \macro{\_\_va\_copy} che era il nome
1345   proposto in una bozza dello standard.} ha previsto una macro ulteriore che
1346 permette di eseguire la copia di un puntatore alla lista degli argomenti:
1347 \begin{prototype}{stdarg.h}{void va\_copy(va\_list dest, va\_list src)}
1348   Copia l'attuale valore \param{src} del puntatore alla lista degli argomenti
1349   su \param{dest}.
1350 \end{prototype}
1351 \noindent anche in questo caso è buona norma chiudere ogni esecuzione di una
1352 \macro{va\_copy} con una corrispondente \macro{va\_end} sul nuovo puntatore
1353 alla lista degli argomenti.
1354
1355 La chiamata di una funzione con un numero variabile di argomenti, posto che la
1356 si sia dichiarata e definita come tale, non prevede nulla di particolare;
1357 l'invocazione è identica alle altre, con i parametri, sia quelli fissi che
1358 quelli opzionali, separati da virgole. Quello che però è necessario tenere
1359 presente è come verranno convertiti gli argomenti variabili. 
1360
1361 In Linux gli argomenti dello stesso tipo sono passati allo stesso modo, sia
1362 che siano fissi sia che siano opzionali (alcuni sistemi trattano diversamente
1363 gli opzionali), ma dato che il prototipo non può specificare il tipo degli
1364 argomenti opzionali, questi verranno sempre promossi, pertanto nella ricezione
1365 dei medesimi occorrerà tenerne conto (ad esempio un \ctyp{char} verrà visto da
1366 \macro{va\_arg} come \ctyp{int}).
1367
1368 Uno dei problemi che si devono affrontare con le funzioni con un numero
1369 variabile di argomenti è che non esiste un modo generico che permetta di
1370 stabilire quanti sono i parametri passati effettivamente in una chiamata.
1371
1372 Esistono varie modalità per affrontare questo problema; una delle più
1373 immediate è quella di specificare il numero degli argomenti opzionali come uno
1374 degli argomenti fissi. Una variazione di questo metodo è l'uso di un parametro
1375 per specificare anche il tipo degli argomenti (come fa la stringa di formato
1376 per \func{printf}).
1377
1378 Una modalità diversa, che può essere applicata solo quando il tipo dei
1379 parametri lo rende possibile, è quella che prevede di usare un valore speciale
1380 come ultimo argomento (come fa ad esempio \func{execl} che usa un puntatore
1381 \macro{NULL} per indicare la fine della lista degli argomenti).
1382
1383
1384 \subsection{Potenziali problemi con le variabili automatiche}
1385 \label{sec:proc_auto_var}
1386
1387 Uno dei possibili problemi che si possono avere con le subroutine è quello di
1388 restituire alla funzione chiamante dei dati che sono contenuti in una
1389 variabile automatica.  Ovviamente quando la subroutine ritorna la sezione
1390 dello stack che conteneva la variabile automatica potrà essere riutilizzata da
1391 una nuova funzione, con le immaginabili conseguenze di sovrapposizione e
1392 sovrascrittura dei dati.
1393
1394 Per questo una delle regole fondamentali della programmazione in C è che
1395 all'uscita di una funzione non deve restare nessun riferimento alle variabili
1396 locali; qualora sia necessario utilizzare variabili che possano essere viste
1397 anche dalla funzione chiamante queste devono essere allocate esplicitamente, o
1398 in maniera statica (usando variabili di tipo \ctyp{static} o \ctyp{extern}), o
1399 dinamicamente con una delle funzioni della famiglia \func{malloc}.
1400
1401
1402 \subsection{Il controllo di flusso non locale}
1403 \label{sec:proc_longjmp}
1404
1405 Il controllo del flusso di un programma in genere viene effettuato con le
1406 varie istruzioni del linguaggio C; fra queste la più bistrattata è il
1407 \code{goto}, che viene deprecato in favore dei costrutti della programmazione
1408 strutturata, che rendono il codice più leggibile e mantenibile . Esiste però
1409 un caso in cui l'uso di questa istruzione porta all'implementazione più
1410 efficiente e chiara anche dal punto di vista della struttura del programma:
1411 quello dell'uscita in caso di errore.
1412
1413 Il C però non consente di effettuare un salto ad una label definita in
1414 un'altra funzione, per cui se l'errore avviene in una funzione e la sua
1415 gestione ordinaria è in un'altra occorre usare quello che viene chiamato un
1416 \textsl{salto non-locale}.  Il caso classico in cui si ha questa necessità,
1417 citato sia da \cite{APUE} che da da \cite{glibc}, è quello di un programma nel
1418 cui corpo principale in cui viene letto un input del quale viene eseguita,
1419 attraverso una serie di funzioni di analisi, una scansione dei contenuti da cui
1420 ottenere le indicazioni per l'esecuzione di opportune operazioni.
1421
1422 Dato che l'analisi può risultare molto complessa, ed opportunamente suddivisa
1423 in fasi diverse, la rilevazione di un errore nell'input può accadere
1424 all'interno di funzioni profondamente annidate l'una nell'altra. In questo
1425 caso si dovrebbe per ciascuna fase dover gestire tutta la casistica del
1426 passaggio all'indietro di tutti gli errori rilevabili dalle funzioni usate
1427 nelle fasi successive, mentre sarebbe molto più comodo poter tornare
1428 direttamente al ciclo di lettura principale, scartando l'input come
1429 errato.\footnote{a meno che, come precisa \cite{glibc}, alla chiusura di
1430   ciascuna fase non siano associate operazioni di pulizia specifiche (come
1431   deallocazioni, chiusure di file, ecc.), che non potrebbero essere eseguite
1432   con un salto non-locale.}
1433
1434 Tutto ciò può essere realizzato salvando il contesto dello stack nel punto in
1435 cui si vuole tornare in caso di errore, e ripristinandolo quando l'occorrenza
1436 capita. La funzione che permette di salvare il contesto dello stack è
1437 \func{setjmp}, il cui prototipo è:
1438 \begin{functions}
1439   \headdecl{setjmp.h}
1440   \funcdecl{void setjmp(jmp\_buf env)}
1441   
1442   Salva il contesto dello stack in \param{env} per un successivo uso da parte
1443   di \func{longjmp}. 
1444
1445   \bodydesc{La funzione ritorna zero quando è chiamata direttamente e un
1446     valore diverso da zero quando ritorna da una chiamata di \func{longjmp}
1447     che usa il contesto salvato in precedenza.}
1448 \end{functions}
1449
1450 Quando si esegue la funzione il contesto viene salvato in appositi oggetti (di
1451 tipo \type{jmp\_buf}), passati come primo argomento alla funzione, in genere
1452 questi vengono definiti come variabili globali in modo da poter essere visti
1453 in tutte le funzioni del programma.
1454
1455 Quando viene eseguita direttamente la funzione ritorna sempre zero, un valore
1456 diverso da zero viene restituito solo quando il ritorno è dovuto ad una
1457 chiamata di \func{longjmp} in un'altra parte del programma. Si tenga conto che
1458 il contesto salvato in \param{env} viene invalidato se la routine che ha
1459 chiamato \func{setjmp} ritorna, nel qual caso l'uso di \func{longjmp} può
1460 comportare conseguenze imprevedibili (e di norma fatali per il processo).
1461   
1462 Come accennato per effettuare un salto non-locale ad un punto precedentemente
1463 stabilito con \func{setjmp} si usa la funzione \func{longjmp}; il suo
1464 prototipo è:
1465 \begin{functions}
1466   \headdecl{setjmp.h}
1467   \funcdecl{void longjmp(jmp\_buf env, int val)}
1468   
1469   Ripristina il contesto dello stack salvato nell'ultima chiamata di
1470   \func{setjmp} con l'argomento \param{env}.
1471   
1472   \bodydesc{La funzione non ritorna.}
1473 \end{functions}
1474
1475 Dopo l'esecuzione della funzione programma prosegue dal codice successivo al
1476 ritorno della \func{setjmp} con cui si era salvato \param{env}, che restituirà
1477 il valore \param{val} invece di zero.  Il valore di \param{val} specificato
1478 nella chiamata deve essere diverso da zero, se si è specificato 0 sarà
1479 comunque restituito 1 al suo posto.
1480
1481 In sostanza un \func{longjmp} è analogo ad un \code{return}, solo che invece
1482 di ritornare alla riga successiva della funzione chiamante, il programma
1483 ritorna alla posizione della relativa \func{setjmp}, ed il ritorno può essere
1484 effettuato anche attraverso diversi livelli di funzioni annidate.
1485
1486 L'implementazione di queste funzioni comporta alcune restrizioni dato che esse
1487 interagiscono direttamente con la gestione dello stack ed il funzionamento del
1488 compilatore stesso. In particolare \func{setjmp} è implementata con una macro,
1489 pertanto non si può cercare di ottenerne l'indirizzo, ed inoltre delle
1490 chiamate a questa funzione sono sicure solo in uno dei seguenti casi:
1491 \begin{itemize}
1492 \item come espressione di controllo in un comando condizionale, di selezione
1493   o di iterazione (come \code{if}, \code{switch} o \code{while}).
1494 \item come operando per un operatore di uguaglianza o confronto in una
1495   espressione di controllo di un comando condizionale, di selezione o di
1496   iterazione.
1497 \item come operando per l'operatore di negazione (\code{!}) in una espressione
1498   di controllo di un comando condizionale, di selezione o di iterazione.
1499 \item come espressione a sé stante.
1500 \end{itemize}
1501
1502 In generale, dato che l'unica differenza fra la chiamata diretta e quella
1503 ottenuta da un \func{longjmp}, è il valore di ritorno di \func{setjmp}, essa è
1504 usualmente chiamata all'interno di un comando \code{if}. 
1505
1506 Uno dei punti critici dei salti non-locali è quello del valore delle
1507 variabili, ed in particolare quello delle variabili automatiche della funzione
1508 a cui si ritorna. In generale le variabili globali e statiche mantengono i
1509 valori che avevano al momento della chiamata di \func{longjmp}, ma quelli
1510 delle variabili automatiche (o di quelle dichiarate \code{register}) sono in
1511 genere indeterminati.
1512
1513 Quello che succede infatti è che i valori delle variabili che sono tenute in
1514 memoria manterranno il valore avuto al momento della chiamata di
1515 \func{longjmp}, mentre quelli tenuti nei registri del processore (che nella
1516 chiamata ad un'altra funzioni vengono salvati nel contesto nello stack)
1517 torneranno al valore avuto al momento della chiamata di \func{setjmp}; per
1518 questo quando si vuole avere un comportamento coerente si può bloccare
1519 l'ottimizzazione che porta le variabili nei registri dichiarandole tutte come
1520 \code{volatile}.
1521
1522
1523
1524 %%% Local Variables: 
1525 %%% mode: latex
1526 %%% TeX-master: "gapil"
1527 %%% End: