1 \chapter{L'interfaccia base con i processi}
2 \label{cha:process_interface}
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
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.
19 \section{Esecuzione e conclusione di un programma}
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à
31 \subsection{La funzione \func{main}}
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
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.
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[])
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.
63 \subsection{Come chiudere un programma}
64 \label{sec:proc_conclusion}
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.
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}.
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.
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.
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.
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.
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.
114 \subsection{Le funzioni \func{exit} e \func{\_exit}}
115 \label{sec:proc_exit}
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.
124 \bodydesc{La funzione non ritorna. Il processo viene terminato.}
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.
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.
143 \bodydesc{La funzione non ritorna. Il processo viene terminato.}
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}).
155 \subsection{Le funzioni \func{atexit} e \func{on\_exit}}
156 \label{sec:proc_atexit}
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.
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
177 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
178 fallimento, \var{errno} non viene modificata.}
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
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.
194 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
195 fallimento, \var{errno} non viene modificata.}
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.
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}.
210 \subsection{Conclusioni}
211 \label{sec:proc_term_conclusion}
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}).
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}.
224 Uno schema riassuntivo che illustra le modalità con cui si avvia e conclude
225 normalmente un programma è riportato in \figref{fig:proc_prog_start_stop}.
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}
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 \figref{fig:proc_prog_start_stop}); torneremo su questo aspetto in
237 \capref{cha:signals}.
241 \section{I processi e l'uso della memoria}
242 \label{sec:proc_memory}
244 Una delle risorse base che ciascun processo ha a disposizione è la memoria, e
245 la gestione della memoria è appunto uno degli aspetti più complessi di un
246 sistema unix-like. In questa sezione, dopo una breve introduzione ai concetti
247 base, esamineremo come la memoria viene vista da parte di un programma in
248 esecuzione, e le varie funzioni utilizzabili per la sua gestione.
251 \subsection{I concetti generali}
252 \label{sec:proc_mem_gen}
254 Ci sono vari modi in cui i vari sistemi organizzano la memoria (ed i dettagli
255 di basso livello dipendono spesso in maniera diretta dall'architettura
256 dell'hardware), ma quello più tipico, usato dai sistemi unix-like come Linux è
257 la cosiddetta \textsl{memoria virtuale}\index{memoria virtuale} che consiste
258 nell'assegnare ad ogni processo uno spazio virtuale di indirizzamento lineare,
259 in cui gli indirizzi vanno da zero ad un qualche valore massimo.\footnote{nel
260 caso di Linux fino al kernel 2.2 detto massimo era, per macchine a 32bit, di
261 2Gb, con il kernel 2.4 ed il supporto per la \textit{high-memory} il limite
264 Come accennato in \capref{cha:intro_unix} questo spazio di indirizzi è
265 virtuale e non corrisponde all'effettiva posizione dei dati nella RAM del
266 computer; in genere detto spazio non è neppure continuo (cioè non tutti gli
267 indirizzi possibili sono utilizzabili, e quelli usabili non sono
268 necessariamente adiacenti).
270 Per la gestione da parte del kernel la memoria virtuale viene divisa in pagine
271 di dimensione fissa (che ad esempio sono di 4kb su macchine a 32 bit e 8kb
272 sulle alpha, valori strettamente connessi all'hardware di gestione della
273 memoria), e ciascuna pagina della memoria virtuale è associata ad un supporto
274 che può essere una pagina di memoria reale o ad un dispositivo di stoccaggio
275 secondario (in genere lo spazio disco riservato alla swap, o i file che
276 contengono il codice).
278 Lo stesso pezzo di memoria reale (o di spazio disco) può fare da supporto a
279 diverse pagine di memoria virtuale appartenenti a processi diversi (come
280 accade in genere per le pagine che contengono il codice delle librerie
281 condivise). Ad esempio il codice della funzione \func{printf} starà su una
282 sola pagina di memoria reale che farà da supporto a tutte le pagine di memoria
283 virtuale di tutti i processi che hanno detta funzione nel loro codice.
285 La corrispondenza fra le pagine della memoria virtuale e quelle della memoria
286 fisica della macchina viene gestita in maniera trasparente dall'hardware di
287 gestione della memoria (la \textit{Memory Management Unit} del processore).
288 Poiché in genere la memoria fisica è solo una piccola frazione della memoria
289 virtuale, è necessario un meccanismo che permetta di trasferire le pagine che
290 servono dal supporto su cui si trovano in memoria, eliminando quelle che non
291 servono. Questo meccanismo è detto \textsl{paginazione}\index{paginazione} (o
292 \textit{paging}), ed è uno dei compiti principali del kernel.
294 Quando un processo cerca di accedere ad una pagina che non è nella memoria
295 reale, avviene quello che viene chiamato un
296 \textit{page fault}\index{page fault};
297 l'hardware di gestione della memoria genera un'interruzione e passa
298 il controllo al kernel il quale sospende il processo e si incarica di mettere
299 in RAM la pagina richiesta (effettuando tutte le operazioni necessarie per
300 reperire lo spazio necessario), per poi restituire il controllo al processo.
302 Dal punto di vista di un processo questo meccanismo è completamente
303 trasparente, e tutto avviene come se tutte le pagine fossero sempre
304 disponibili in memoria. L'unica differenza avvertibile è quella dei tempi di
305 esecuzione, che passano dai pochi nanosecondi necessari per l'accesso in RAM,
306 a tempi molto più lunghi, dovuti all'intervento del kernel.
308 Normalmente questo è il prezzo da pagare per avere un multitasking reale, ed
309 in genere il sistema è molto efficiente in questo lavoro; quando però ci siano
310 esigenze specifiche di prestazioni è possibile usare delle funzioni che
311 permettono di bloccare il meccanismo della paginazione e mantenere fisse delle
312 pagine in memoria (vedi \ref{sec:proc_mem_lock}).
315 \subsection{La struttura della memoria di un processo}
316 \label{sec:proc_mem_layout}
318 Benché lo spazio di indirizzi virtuali copra un intervallo molto ampio, solo
319 una parte di essi è effettivamente allocato ed utilizzabile dal processo; il
320 tentativo di accedere ad un indirizzo non allocato è un tipico errore che si
321 commette quando si è manipolato male un puntatore e genera quello che viene
322 chiamato un \textit{segmentation fault}. Se si tenta cioè di leggere o
323 scrivere da un indirizzo per il quale non esiste un'associazione della pagina
324 virtuale, il kernel risponde al relativo \textit{page fault}\index{page fault}
325 mandando un segnale \macro{SIGSEGV} al processo, che normalmente ne causa la
326 terminazione immediata.
328 È pertanto importante capire come viene strutturata \textsl{la memoria
329 virtuale}\index{page fault} di un processo. Essa viene divisa in
330 \textsl{segmenti}, cioè un insieme contiguo di indirizzi virtuali ai quali il
331 processo può accedere. Solitamente un programma C viene suddiviso nei
335 \item Il segmento di testo o \textit{text segment}. Contiene il codice del
336 programma, delle funzioni di librerie da esso utilizzate, e le costanti.
337 Normalmente viene condiviso fra tutti i processi che eseguono lo stesso
338 programma (e anche da processi che eseguono altri programmi nel caso delle
339 librerie). Viene marcato in sola lettura per evitare sovrascritture
340 accidentali (o maliziose) che ne modifichino le istruzioni.
342 Viene allocato da \func{exec} all'avvio del programma e resta invariato
343 per tutto il tempo dell'esecuzione.
345 \item Il segmento dei dati o \textit{data segment}. Contiene le variabili
346 globali (cioè quelle definite al di fuori di tutte le funzioni che
347 compongono il programma) e le variabili statiche (cioè quelle dichiarate con
348 l'attributo \ctyp{static}). Di norma è diviso in due parti.
350 La prima parte è il segmento dei dati inizializzati, che contiene le
351 variabili il cui valore è stato assegnato esplicitamente. Ad esempio
353 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
356 questo valore sarà immagazzinato in questo segmento. La memoria di questo
357 segmento viene preallocata all'avvio del programma e inizializzata ai valori
360 La seconda parte è il segmento dei dati non inizializzati, che contiene le
361 variabili il cui valore non è stato assegnato esplicitamente. Ad esempio se
363 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
366 questo vettore sarà immagazzinato in questo segmento. Anch'esso viene
367 allocato all'avvio, e tutte le variabili vengono inizializzate a zero (ed i
368 puntatori a \macro{NULL}).\footnote{si ricordi che questo vale solo per le
369 variabili che vanno nel segmento dati, e non è affatto vero in generale.}
371 Storicamente questo segmento viene chiamato BBS (da \textit{block started by
372 symbol}). La sua dimensione è fissa.
374 \item Lo \textit{heap}. Tecnicamente lo si può considerare l'estensione del
375 segmento dati, a cui di solito è posto giusto di seguito. È qui che avviene
376 l'allocazione dinamica della memoria; può essere ridimensionato allocando e
377 disallocando la memoria dinamica con le apposite funzioni (vedi
378 \secref{sec:proc_mem_alloc}), ma il suo limite inferiore (quello adiacente
379 al segmento dati) ha una posizione fissa.
381 \item Il segmento di \textit{stack}, che contiene lo \textit{stack} del
382 programma. Tutte le volte che si effettua una chiamata ad una funzione è
383 qui che viene salvato l'indirizzo di ritorno e le informazioni dello stato
384 del chiamante (tipo il contenuto di alcuni registri della CPU). Poi la
385 funzione chiamata alloca qui lo spazio per le sue variabili locali: in
386 questo modo le funzioni possono essere chiamate ricorsivamente. Al ritorno
387 della funzione lo spazio è automaticamente rilasciato e ``ripulito''. La
388 pulizia in C e C++ viene fatta dal chiamante.\footnote{a meno che non sia
389 stato specificato l'utilizzo di una calling convention diversa da quella
392 La dimensione di questo segmento aumenta seguendo la crescita dello stack
393 del programma, ma non viene ridotta quando quest'ultimo si restringe.
398 \includegraphics[width=5cm]{img/memory_layout}
399 \caption{Disposizione tipica dei segmenti di memoria di un processo.}
400 \label{fig:proc_mem_layout}
403 Una disposizione tipica di questi segmenti è riportata in
404 \figref{fig:proc_mem_layout}. Usando il comando \cmd{size} su un programma se
405 ne può stampare le dimensioni dei segmenti di testo e di dati (inizializzati e
406 BSS); si tenga presente però che il BSS non è mai salvato sul file che
407 contiene l'eseguibile, dato che viene sempre inizializzato a zero al
408 caricamento del programma.
411 \subsection{Allocazione della memoria per i programmi C}
412 \label{sec:proc_mem_alloc}
414 Il C supporta, a livello di linguaggio, soltanto due modalità di allocazione
415 della memoria: l'\textsl{allocazione statica} e l'\textsl{allocazione
418 L'\textsl{allocazione statica} è quella con cui sono memorizzate le variabili
419 globali e le variabili statiche, cioè le variabili il cui valore deve essere
420 mantenuto per tutta la durata del programma. Come accennato queste variabili
421 vengono allocate nel segmento dei dati all'avvio del programma (come parte
422 delle operazioni svolte da \func{exec}) e lo spazio da loro occupato non viene
423 liberato fino alla sua conclusione.
425 L'\textsl{allocazione automatica} è quella che avviene per gli argomenti di
426 una funzione e per le sue variabili locali (le cosiddette \textsl{variabili
427 automatiche}), che esistono solo per la durata della funzione. Lo spazio
428 per queste variabili viene allocato nello stack quando viene eseguita la
429 funzione e liberato quando si esce dalla medesima.
431 Esiste però un terzo tipo di allocazione, l'\textsl{allocazione dinamica della
432 memoria}, che non è prevista direttamente all'interno del linguaggio C, ma
433 che è necessaria quando il quantitativo di memoria che serve è determinabile
434 solo durante il corso dell'esecuzione del programma.
436 Il C non consente di usare variabili allocate dinamicamente, non è possibile
437 cioè definire in fase di programmazione una variabile le cui dimensioni
438 possano essere modificate durante l'esecuzione del programma. Per questo le
439 librerie del C forniscono una serie opportuna di funzioni per eseguire
440 l'allocazione dinamica di memoria (in genere nello heap). Le variabili il
441 cui contenuto è allocato in questo modo non potranno essere usate direttamente
442 come le altre, ma l'accesso sarà possibile solo in maniera indiretta,
443 attraverso dei puntatori.
446 \subsection{Le funzioni \func{malloc}, \func{calloc}, \func{realloc} e
448 \label{sec:proc_mem_malloc}
450 Le funzioni previste dallo standard ANSI C per la gestione della memoria sono
451 quattro: \func{malloc}, \func{calloc}, \func{realloc} e \func{free}, i loro
452 prototipi sono i seguenti:
455 \funcdecl{void *calloc(size\_t size)}
456 Alloca \var{size} byte nello heap. La memoria viene inizializzata a 0.
458 La funzione restituisce il puntatore alla zona di memoria allocata in caso
459 di successo e \macro{NULL} in caso di fallimento, nel qual caso
460 \var{errno} assumerà il valore \macro{ENOMEM}.
461 \funcdecl{void *malloc(size\_t size)}
462 Alloca \var{size} byte nello heap. La memoria non viene inizializzata.
464 La funzione restituisce il puntatore alla zona di memoria allocata in caso
465 di successo e \macro{NULL} in caso di fallimento, nel qual caso
466 \var{errno} assumerà il valore \macro{ENOMEM}.
467 \funcdecl{void *realloc(void *ptr, size\_t size)}
468 Cambia la dimensione del blocco allocato all'indirizzo \var{ptr}
469 portandola a \var{size}.
471 La funzione restituisce il puntatore alla zona di memoria allocata in caso
472 di successo e \macro{NULL} in caso di fallimento, nel qual caso
473 \var{errno} assumerà il valore \macro{ENOMEM}.
474 \funcdecl{void free(void *ptr)}
475 Disalloca lo spazio di memoria puntato da \var{ptr}.
477 La funzione non ritorna nulla e non riporta errori.
479 Il puntatore ritornato dalle funzioni di allocazione è garantito essere sempre
480 allineato correttamente per tutti i tipi di dati; ad esempio sulle macchine a
481 32 bit in genere è allineato a multipli di 4 byte e sulle macchine a 64 bit a
484 In genere si usano le funzioni \func{malloc} e \func{calloc} per allocare
485 dinamicamente la memoria necessaria al programma, e siccome i puntatori
486 ritornati sono di tipo generico non è necessario effettuare un cast per
487 assegnarli a puntatori al tipo di variabile per la quale si effettua
490 La memoria allocata dinamicamente deve essere esplicitamente rilasciata usando
491 \func{free}\footnote{le glibc provvedono anche una funzione \func{cfree}
492 definita per compatibilità con SunOS, che è deprecata.} una volta che non
493 sia più necessaria. Questa funzione vuole come parametro un puntatore
494 restituito da una precedente chiamata a una qualunque delle funzioni di
495 allocazione che non sia già stato liberato da un'altra chiamata a \func{free},
496 in caso contrario il comportamento della funzione è indefinito.
498 La funzione \func{realloc} si usa invece per cambiare (in genere aumentare) la
499 dimensione di un'area di memoria precedentemente allocata, la funzione vuole
500 in ingresso il puntatore restituito dalla precedente chiamata ad una
501 \func{malloc} (se è passato un valore \macro{NULL} allora la funzione si
502 comporta come \func{malloc})\footnote{questo è vero per Linux e
503 l'implementazione secondo lo standard ANSI C, ma non è vero per alcune
504 vecchie implementazioni, inoltre alcune versioni delle librerie del C
505 consentivano di usare \func{realloc} anche per un puntatore liberato con
506 \func{free} purché non ci fossero state nel frattempo altre chiamate a
507 funzioni di allocazione, questa funzionalità è totalmente deprecata e non è
508 consentita sotto Linux.} ad esempio quando si deve far crescere la
509 dimensione di un vettore. In questo caso se è disponibile dello spazio
510 adiacente al precedente la funzione lo utilizza, altrimenti rialloca altrove
511 un blocco della dimensione voluta, copiandoci automaticamente il contenuto; lo
512 spazio aggiunto non viene inizializzato.
514 Si deve sempre avere ben presente il fatto che il blocco di memoria restituito
515 da \func{realloc} può non essere un'estensione di quello che gli si è passato
516 in ingresso; per questo si dovrà \emph{sempre} eseguire la riassegnazione di
517 \var{ptr} al valore di ritorno della funzione, e reinizializzare o provvedere
518 ad un adeguato aggiornamento di tutti gli altri puntatori all'interno del
519 blocco di dati ridimensionato.
521 Un errore abbastanza frequente (specie se si ha a che fare con array di
522 puntatori) è quello di chiamare \func{free} più di una volta sullo stesso
523 puntatore; per evitare questo problema una soluzione di ripiego è quella di
524 assegnare sempre a \macro{NULL} ogni puntatore liberato con \func{free}, dato
525 che, quando il parametro è un puntatore nullo, \func{free} non esegue nessuna
528 Le \acr{glibc} hanno un'implementazione delle routine di allocazione che è
529 controllabile dall'utente attraverso alcune variabili di ambiente, in
530 particolare diventa possibile tracciare questo tipo di errori usando la
531 variabile \macro{MALLOC\_CHECK\_} che quando viene definita mette in uso una
532 versione meno efficiente delle funzioni suddette, che però è più tollerante
533 nei confronti di piccoli errori come quello di chiamate doppie a \func{free}.
536 \item se la variabile è posta a zero gli errori vengono ignorati.
537 \item se è posta ad 1 viene stampato un avviso sullo \textit{standard error}
538 (vedi \secref{sec:file_std_stream}).
539 \item se è posta a 2 viene chiamata \func{abort}, che in genere causa
540 l'immediata conclusione del programma.
543 Il problema più comune e più difficile da risolvere che si incontra con le
544 routine di allocazione è quando non viene opportunamente liberata la memoria
545 non più utilizzata, quello che in inglese viene chiamato \textit{memory-leak},
546 cioè una \textsl{perdita di memoria}.
548 Un caso tipico che illustra il problema è quello in cui in una subroutine si
549 alloca della memoria per uso locale senza liberarla prima di uscire. La
550 memoria resta così allocata fino alla terminazione del processo. Chiamate
551 ripetute alla stessa subroutine continueranno ad effettuare altre allocazioni,
552 causando a lungo andare un esaurimento della memoria disponibile (e la
553 probabile impossibilità di proseguire l'esecuzione del programma).
555 Il problema è che l'esaurimento della memoria può avvenire in qualunque
556 momento, in corrispondenza ad una qualunque chiamata di \func{malloc}, che può
557 essere in una sezione del codice che non ha alcuna relazione con la subroutine
558 che contiene l'errore. Per questo motivo è sempre molto difficile trovare un
559 \textit{memory leak}.
561 In C e C++ il problema è particolarmente sentito. In C++, per mezzo della
562 programmazione ad oggetti, il problema dei \textit{memory leak} è notevolmente
563 ridimensionato attraverso l'uso accurato di appositi oggetti come gli
564 \textit{smartpointers}. Questo però va a scapito delle performance
565 dell'applicazione in esecuzione.
567 In altri linguaggi come il java e recentemente il C\# il problema non si pone
568 nemmeno perché la gestione della memoria viene fatta totalmente in maniera
569 automatica, ovvero il programmatore non deve minimamente preoccuparsi di
570 liberare la memoria allocata precedentemente quando non serve più, poiché il
571 framework gestisce automaticamente la cosiddetta \textit{garbage collection}.
572 In tal caso, attraverso meccanismi simili a quelli del \textit{reference
573 counting}, quando una zona di memoria precedentemente allocata non è più
574 riferita da nessuna parte del codice in esecuzione, può essere deallocata
575 automaticamente in qualunque momento dall'infrastruttura.
577 Anche questo va a scapito delle performance dell'applicazione in esecuzione
578 (inoltre le applicazioni sviluppate con tali linguaggi di solito non sono
579 eseguibili compilati, come avviene invece per il C ed il C++, ed è necessaria
580 la presenza di una infrastruttura per la loro interpretazione e pertanto hanno
581 di per sé delle performance più scadenti rispetto alle stesse applicazioni
582 compilate direttamente). Questo comporta però il problema della non
583 predicibilità del momento in cui viene deallocata la memoria precedentemente
584 allocata da un oggetto.
586 Per limitare l'impatto di questi problemi, e semplificare la ricerca di
587 eventuali errori, l'implementazione delle routine di allocazione delle
588 \acr{glibc} mette a disposizione una serie di funzionalità che permettono di
589 tracciare le allocazioni e le disallocazione, e definisce anche una serie di
590 possibili \textit{hook} (\textsl{ganci}) che permettono di sostituire alle
591 funzioni di libreria una propria versione (che può essere più o meno
592 specializzata per il debugging). Esistono varie librerie che forniscono dei
593 sostituti opportuni delle routine di allocazione in grado, senza neanche
594 ricompilare il programma,\footnote{esempi sono \textit{Dmalloc}
595 \href{http://dmalloc.com/}{http://dmalloc.com/} di Gray Watson ed
596 \textit{Electric Fence} di Bruce Perens.} di eseguire diagnostiche anche
597 molto complesse riguardo l'allocazione della memoria.
601 \subsection{La funzione \func{alloca}}
602 \label{sec:proc_mem_alloca}
604 Una possibile alternativa all'uso di \func{malloc}, che non soffre dei
605 problemi di \textit{memory leak} descritti in precedenza, è la funzione
606 \func{alloca}, che invece di allocare la memoria nello heap usa il segmento di
607 stack della funzione corrente. La sintassi è identica a quella di
608 \func{malloc}, il suo prototipo è:
609 \begin{prototype}{stdlib.h}{void *alloca(size\_t size)}
610 Alloca \var{size} byte nel segmento di stack della funzione chiamante.
611 La memoria non viene inizializzata.
613 La funzione restituisce il puntatore alla zona di memoria allocata in caso
614 di successo e \macro{NULL} in caso di fallimento, nel qual caso
615 \var{errno} assumerà il valore \macro{ENOMEM}.
617 \noindent ma in questo caso non è più necessario liberare la memoria (e quindi
618 non esiste un analogo della \func{free}) in quanto essa viene rilasciata
619 automaticamente al ritorno della funzione.
621 Come è evidente questa funzione ha molti vantaggi, anzitutto permette di
622 evitare alla radice i problemi di memory leak, dato che non serve più la
623 deallocazione esplicita; inoltre la deallocazione automatica funziona anche
624 quando si usa \func{longjmp} per uscire da una subroutine con un salto non
625 locale da una funzione (vedi \secref{sec:proc_longjmp}).
627 Un altro vantaggio è che in Linux la funzione è molto più veloce di
628 \func{malloc} e non viene sprecato spazio, infatti non è necessario gestire un
629 pool di memoria da riservare e si evitano così anche i problemi di
630 frammentazione di quest'ultimo, che comportano inefficienze sia
631 nell'allocazione della memoria che nell'esecuzione dell'allocazione.
633 Gli svantaggi sono che questa funzione non è disponibile su tutti gli Unix, e
634 non è inserita né nello standard POSIX né in SUSv3 (ma è presente in BSD), il
635 suo utilizzo quindi limita la portabilità dei programmi. Inoltre la funzione
636 non può essere usata nella lista degli argomenti di una funzione, perché lo
637 spazio verrebbe allocato nel mezzo degli stessi.
639 % Questo è riportato solo dal manuale delle glibc, nelle pagine di manuale non c'è
640 % traccia di tutto ciò
643 %cerca di allocare troppa memoria non si ottiene un messaggio di errore, ma un
644 %segnale di \textit{segment violation} analogo a quello che si avrebbe da una
645 %ricorsione infinita.
647 Inoltre non è chiaramente possibile usare \func{alloca} per allocare memoria
648 che deve poi essere usata anche al di fuori della funzione in cui essa viene
649 chiamata, dato che all'uscita dalla funzione lo spazio allocato diventerebbe
650 libero, e potrebbe essere sovrascritto all'invocazione di nuove funzioni.
651 Questo è lo stesso problema che si può avere con le variabili automatiche, su
652 cui torneremo in \secref{sec:proc_auto_var}.
655 \subsection{Le funzioni \func{brk} e \func{sbrk}}
656 \label{sec:proc_mem_sbrk}
658 L'uso di queste funzioni è necessario solo quando si voglia accedere alle
659 analoghe system call a cui fanno da interfaccia. I loro prototipi sono:
662 \funcdecl{int brk(void *end\_data\_segment)}
663 Sposta la fine del segmento dei dati all'indirizzo specificato da
664 \var{end\_data\_segment}.
666 La funzione restituisce 0 in caso di successo e -1 in caso di
667 fallimento, nel qual caso \var{errno} assumerà il valore \macro{ENOMEM}.
669 \funcdecl{void *sbrk(ptrdiff\_t increment)} Incrementa lo spazio dati di un
670 programma di \var{increment}. Un valore zero restituisce l'attuale posizione
671 della fine del segmento dati.
673 La funzione restituisce il puntatore all'inizio della nuova zona di memoria
674 allocata in caso di successo e \macro{NULL} in caso di fallimento, nel qual
675 caso \macro{errno} assumerà il valore \macro{ENOMEM}.
677 \noindent in genere si usa \func{sbrk} con un valore zero per ottenere
678 l'attuale posizione della fine del segmento dati.
680 Queste funzioni sono state deliberatamente escluse dallo standard POSIX.1 e
681 per i programmi normali è sempre opportuno usare le funzioni di allocazione
682 standard descritte in precedenza, che sono costruite su di esse. L'uso di
683 queste funzioni è ristretto alle specifiche necessità di chi debba
684 implementare una sua versione delle routine di allocazione.
687 % \subsection{La personalizzazione delle funzioni di allocazione}
688 % \label{sec:proc_mem_malloc_custom}
691 \subsection{Il controllo della memoria virtuale\index{memoria virtuale}}
692 \label{sec:proc_mem_lock}
694 Come spiegato in \secref{sec:proc_mem_gen} il kernel gestisce la memoria
695 virtuale in maniera trasparente ai processi, decidendo quando rimuovere pagine
696 dalla memoria per metterle nello swap, sulla base dell'utilizzo corrente da
697 parte dei vari processi.
699 Nell'uso comune un processo non deve preoccuparsi di tutto ciò, in quanto il
700 meccanismo della paginazione\index{paginazione} riporta in RAM, ed in maniera
701 trasparente, tutte le pagine che gli occorrono; esistono però esigenze
702 particolari in cui non si vuole che questo meccanismo si attivi. In generale i
703 motivi per cui si possono avere di queste necessità sono due:
705 \item \textsl{La velocità}. Il processo della paginazione è trasparente solo
706 se il programma in esecuzione non è sensibile al tempo che occorre a
707 riportare la pagina in memoria; per questo motivo processi critici che hanno
708 esigenze di tempo reale o tolleranze critiche nelle risposte (ad esempio
709 processi che trattano campionamenti sonori) possono non essere in grado di
710 sopportare le variazioni della velocità di accesso dovuta alla paginazione.
712 In certi casi poi un programmatore può conoscere meglio dell'algoritmo di
713 allocazione delle pagine le esigenze specifiche del suo programma e decidere
714 quali pagine di memoria è opportuno che restino in memoria per un aumento
715 delle prestazioni. In genere queste sono esigenze particolari e richiedono
716 anche un aumento delle priorità in esecuzione del processo (vedi
717 \secref{sec:proc_real_time}).
719 \item \textsl{La sicurezza}. Se si hanno password o chiavi segrete in chiaro
720 in memoria queste possono essere portate su disco dal meccanismo della
721 paginazione. Questo rende più lungo il periodo di tempo in cui detti segreti
722 sono presenti in chiaro e più complessa la loro cancellazione (un processo
723 può cancellare la memoria su cui scrive le sue variabili, ma non può toccare
724 lo spazio disco su cui una pagina di memoria può essere stata salvata). Per
725 questo motivo di solito i programmi di crittografia richiedono il blocco di
726 alcune pagine di memoria.
729 Il meccanismo che previene la paginazione di parte della memoria virtuale di
730 un processo è chiamato \textit{memory locking} (o \textsl{blocco della
731 memoria}). Il blocco è sempre associato alle pagine della memoria virtuale
732 del processo, e non al segmento reale di RAM su cui essa viene mantenuta.
734 La regola è che se un segmento di RAM fa da supporto ad almeno una pagina
735 bloccata allora esso viene escluso dal meccanismo della paginazione. I blocchi
736 non si accumulano, se si blocca due volte la stessa pagina non è necessario
737 sbloccarla due volte, una pagina o è bloccata oppure no.
739 Il \textit{memory lock} persiste fintanto che il processo che detiene la
740 memoria bloccata non la sblocca. Chiaramente la terminazione del processo
741 comporta anche la fine dell'uso della sua memoria virtuale, e quindi anche di
742 tutti i suoi \textit{memory lock}.
744 I \textit{memory lock} non sono ereditati dai processi figli.\footnote{ma
745 siccome Linux usa il \textit{copy on write}\index{copy on write} (vedi
746 \secref{sec:proc_fork}) gli indirizzi virtuali del figlio sono mantenuti
747 sullo stesso segmento di RAM del padre, quindi fintanto che un figlio non
748 scrive su un segmento, può usufruire del memory lock del padre.} Siccome la
749 presenza di un \textit{memory lock} riduce la memoria disponibile al sistema,
750 con un impatto su tutti gli altri processi, solo l'amministratore ha la
751 capacità di bloccare una pagina. Ogni processo può però sbloccare le pagine
752 relative alla propria memoria.
754 Il sistema pone dei limiti all'ammontare di memoria di un processo che può
755 essere bloccata e al totale di memoria fisica che può dedicare a questo, lo
756 standard POSIX.1 richiede che sia definita in \file{unistd.h} la costante
757 \macro{\_POSIX\_MEMLOCK\_RANGE} per indicare la capacità di eseguire il
758 \textit{memory locking} e la costante \macro{PAGESIZE} in \file{limits.h} per
759 indicare la dimensione di una pagina in byte.
761 Le funzioni per bloccare e sbloccare singole sezioni di memoria sono
762 \func{mlock} e \func{munlock}; i loro prototipi sono:
764 \headdecl{sys/mman.h}
766 \funcdecl{int mlock(const void *addr, size\_t len)}
767 Blocca la paginazione per l'intervallo di memoria da \var{addr} per
768 \var{len} byte. Tutte le pagine che contengono una parte dell'intervallo
769 sono mantenute in RAM per tutta la durata del blocco.
771 \funcdecl{int munlock(const void *addr, size\_t len)}
772 Sblocca l'intervallo di memoria da \var{addr} per \var{len} byte.
775 \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 in
776 caso di errore, nel qual caso \var{errno} assumerà uno dei
779 \item[\macro{ENOMEM}] alcuni indirizzi dell'intervallo specificato non
780 corrispondono allo spazio di indirizzi del processo o si è ecceduto
781 il numero massimo consentito di pagine bloccate.
782 \item[\macro{EINVAL}] \var{len} non è un valore positivo.
784 e, per \func{mlock}, anche \macro{EPERM} quando il processo non ha i
785 privilegi richiesti per l'operazione.}
788 Altre due funzioni, \func{mlockall} e \func{munlockall}, consentono di
789 bloccare genericamente lo spazio di indirizzi di un processo. I prototipi di
790 queste funzioni sono:
793 \headdecl{sys/mman.h}
795 \funcdecl{int mlockall(int flags)}
796 Blocca la paginazione per lo spazio di indirizzi del processo corrente.
798 \funcdecl{int munlockall(void)}
799 Sblocca la paginazione per lo spazio di indirizzi del processo corrente.
801 \bodydesc{Codici di ritorno ed errori sono gli stessi di \func{mlock}
805 Il parametro \var{flags} di \func{mlockall} permette di controllarne il
806 comportamento; esso può essere specificato come l'OR aritmetico delle due
808 \begin{basedescript}{\desclabelwidth{2.5cm}}
809 \item[\macro{MCL\_CURRENT}] blocca tutte le pagine correntemente mappate nello
810 spazio di indirizzi del processo.
811 \item[\macro{MCL\_FUTURE}] blocca tutte le pagine che saranno mappate nello
812 spazio di indirizzi del processo.
815 Con \func{mlockall} si può bloccare tutte le pagine mappate nello spazio di
816 indirizzi del processo, sia che comprendano il segmento di testo, di dati, lo
817 stack, lo heap e pure le funzioni di libreria chiamate, i file mappati in
818 memoria, i dati del kernel mappati in user space, la memoria condivisa. L'uso
819 dei flag permette di selezionare con maggior finezza le pagine da bloccare, ad
820 esempio limitandosi a tutte le pagine allocate a partire da un certo momento.
822 In ogni caso un processo real-time che deve entrare in una sezione critica
823 deve provvedere a riservare memoria sufficiente prima dell'ingresso, per
824 scongiurare in partenza un eventuale page fault\index{page fault} causato dal
825 meccanismo di \textit{copy on write}\index{copy on write}. Infatti se nella
826 sezione critica si va ad utilizzare memoria che non è ancora stata riportata
827 in RAM si potrebbe avere un page fault durante l'esecuzione della stessa, con
828 conseguente rallentamento (probabilmente inaccettabile) dei tempi di
831 In genere si ovvia a questa problematica chiamando una funzione che ha
832 allocato una quantità sufficientemente ampia di variabili automatiche, in modo
833 che esse vengano mappate in RAM dallo stack, dopo di che, per essere sicuri
834 che esse siano state effettivamente portate in memoria, ci si scrive sopra.
838 \section{Parametri, opzioni ed ambiente di un processo}
839 \label{sec:proc_options}
841 Tutti i programmi hanno la possibilità di ricevere parametri e opzioni quando
842 vengono lanciati. Il passaggio dei parametri è effettuato attraverso gli
843 argomenti \var{argc} e \var{argv} della funzione \func{main}, che vengono
844 passati al programma dalla shell (o dal processo che esegue la \func{exec},
845 secondo le modalità che vedremo in \secref{sec:proc_exec}) quando questo viene
848 Oltre al passaggio dei parametri, un'altra modalità che permette di passare
849 delle informazioni che modifichino il comportamento di un programma è quello
850 dell'uso del cosiddetto \textit{environment} (cioè l'uso delle
851 \textsl{variabili di ambiente}). In questa sezione esamineremo le funzioni che
852 permettono di gestire parametri ed opzioni, e quelle che consentono di
853 manipolare ed utilizzare le variabili di ambiente.
856 \subsection{Il formato dei parametri}
857 \label{sec:proc_par_format}
858 In genere passaggio dei parametri al programma viene effettuato dalla shell,
859 che si incarica di leggere la linea di comando e di effettuarne la scansione
860 (il cosiddetto \textit{parsing}) per individuare le parole che la compongono,
861 ciascuna delle quali viene considerata un parametro. Di norma per individuare
862 le parole viene usato come carattere di separazione lo spazio o il tabulatore,
863 ma il comportamento è modificabile attraverso l'impostazione della variabile
864 di ambiente \cmd{IFS}.
868 \includegraphics[width=11cm]{img/argv_argc}
869 \caption{Esempio dei valori di \var{argv} e \var{argc} generati nella
870 scansione di una riga di comando.}
871 \label{fig:proc_argv_argc}
874 Nella scansione viene costruito il vettore di puntatori \var{argv} inserendo
875 in successione il puntatore alla stringa costituente l'$n$-simo parametro; la
876 variabile \var{argc} viene inizializzata al numero di parametri trovati, in
877 questo modo il primo parametro è sempre il nome del programma; un esempio di
878 questo meccanismo è mostrato in \figref{fig:proc_argv_argc}.
881 \subsection{La gestione delle opzioni}
882 \label{sec:proc_opt_handling}
884 In generale un programma Unix riceve da linea di comando sia gli argomenti che
885 le opzioni, queste ultime sono standardizzate per essere riconosciute come
886 tali: un elemento di \var{argv} che inizia con il carattere \texttt{'-'} e che
887 non sia un singolo \texttt{'-'} o un \texttt{'--'} viene considerato
888 un'opzione. In genere le opzioni sono costituite da una lettera singola
889 (preceduta dal carattere \cmd{'-'}) e possono avere o no un parametro
890 associato; un comando tipico può essere quello mostrato in
891 \figref{fig:proc_argv_argc}. In quel caso le opzioni sono \cmd{-r} e \cmd{-m}
892 e la prima vuole un parametro mentre la seconda no (\cmd{questofile.txt} è un
893 argomento del programma, non un parametro di \cmd{-m}).
895 Per gestire le opzioni all'interno dei argomenti a linea di comando passati in
896 \var{argv} le librerie standard del C forniscono la funzione \func{getopt}
897 che ha il seguente prototipo:
898 \begin{prototype}{unistd.h}
899 {int getopt(int argc, char *const argv[], const char *optstring)}
900 Esegue il parsing degli argomenti passati da linea di comando
901 riconoscendo le possibili opzioni segnalate con \var{optstring}.
903 \bodydesc{Ritorna il carattere che segue l'opzione, \cmd{':'} se manca un
904 parametro all'opzione, \cmd{'?'} se l'opzione è sconosciuta, e -1 se non
905 esistono altre opzioni.}
908 Questa funzione prende come argomenti le due variabili \var{argc} e \var{argv}
909 passate a \func{main} ed una stringa che indica quali sono le opzioni valide;
910 la funzione effettua la scansione della lista degli argomenti ricercando ogni
911 stringa che comincia con \cmd{-} e ritorna ogni volta che trova un'opzione
914 La stringa \var{optstring} indica quali sono le opzioni riconosciute ed è
915 costituita da tutti i caratteri usati per identificare le singole opzioni, se
916 l'opzione ha un parametro al carattere deve essere fatto seguire un segno di
917 due punti \texttt{':'}; nel caso di \figref{fig:proc_argv_argc} ad esempio la
918 stringa di opzioni avrebbe dovuto contenere \texttt{"r:m"}.
920 La modalità di uso di \func{getopt} è pertanto quella di chiamare più volte la
921 funzione all'interno di un ciclo, fintanto che essa non ritorna il valore -1
922 che indica che non ci sono più opzioni. Nel caso si incontri un'opzione non
923 dichiarata in \var{optstring} viene ritornato il carattere \texttt{'?'}
924 mentre se un opzione che lo richiede non è seguita da un parametro viene
925 ritornato il carattere \texttt{':'}, infine se viene incontrato il valore
926 \texttt{'--'} la scansione viene considerata conclusa, anche se vi sono altri
927 elementi di \var{argv} che cominciano con il carattere \texttt{'-'}.
932 opterr = 0; /* don't want writing to stderr */
933 while ( (i = getopt(argc, argv, "hp:c:e:")) != -1) {
938 case 'h': /* help option */
939 printf("Wrong -h option use\n");
943 case 'c': /* take wait time for childen */
944 wait_child = strtol(optarg, NULL, 10); /* convert input */
946 case 'p': /* take wait time for childen */
947 wait_parent = strtol(optarg, NULL, 10); /* convert input */
949 case 'e': /* take wait before parent exit */
950 wait_end = strtol(optarg, NULL, 10); /* convert input */
952 case '?': /* unrecognized options */
953 printf("Unrecognized options -%c\n",optopt);
955 default: /* should not reached */
959 debug("Optind %d, argc %d\n",optind,argc);
961 \caption{Esempio di codice per la gestione delle opzioni.}
962 \label{fig:proc_options_code}
965 Quando la funzione trova un'opzione essa ritorna il valore numerico del
966 carattere, in questo modo si possono eseguire azioni specifiche usando uno
967 \code{switch}; \func{getopt} inoltre inizializza alcune variabili globali:
969 \item \var{char *optarg} contiene il puntatore alla stringa parametro
971 \item \var{int optind} alla fine della scansione restituisce l'indice del
972 primo elemento di \var{argv} che non è un'opzione.
973 \item \var{int opterr} previene, se posto a zero, la stampa di un messaggio
974 di errore in caso di riconoscimento di opzioni non definite.
975 \item \var{int optopt} contiene il carattere dell'opzione non riconosciuta.
978 In \figref{fig:proc_options_code} è mostrata la sezione del programma
979 \file{ForkTest.c} (che useremo nel prossimo capitolo per effettuare dei test
980 sulla creazione dei processi) deputata alla decodifica delle opzioni a riga di
983 Si può notare che si è anzitutto (\texttt{\small 1}) disabilitata la stampa di
984 messaggi di errore per opzioni non riconosciute, per poi passare al ciclo per
985 la verifica delle opzioni (\texttt{\small 2-27}); per ciascuna delle opzioni
986 possibili si è poi provveduto ad un'azione opportuna, ad esempio per le tre
987 opzioni che prevedono un parametro si è effettuata la decodifica del medesimo
988 (il cui indirizzo è contenuto nella variabile \var{optarg}) avvalorando la
989 relativa variabile (\texttt{\small 12-14}, \texttt{\small 15-17} e
990 \texttt{\small 18-20}). Completato il ciclo troveremo in \var{optind} l'indice
991 in \var{argv[]} del primo degli argomenti rimanenti nella linea di comando.
993 Normalmente \func{getopt} compie una permutazione degli elementi di \var{argv}
994 cosicché alla fine della scansione gli elementi che non sono opzioni sono
995 spostati in coda al vettore. Oltre a questa esistono altre due modalità di
996 gestire gli elementi di \var{argv}; se \var{optstring} inizia con il carattere
997 \texttt{'+'} (o è impostata la variabile di ambiente \macro{POSIXLY\_CORRECT})
998 la scansione viene fermata non appena si incontra un elemento che non è
999 un'opzione. L'ultima modalità, usata quando un programma può gestire la
1000 mescolanza fra opzioni e argomenti, ma se li aspetta in un ordine definito, si
1001 attiva quando \var{optstring} inizia con il carattere \texttt{'-'}. In questo
1002 caso ogni elemento che non è un'opzione viene considerato comunque un'opzione
1003 e associato ad un valore di ritorno pari ad 1, questo permette di identificare
1004 gli elementi che non sono opzioni, ma non effettua il riordinamento del
1008 \subsection{Opzioni in formato esteso}
1009 \label{sec:proc_opt_extended}
1011 Un'estensione di questo schema è costituito dalle cosiddette
1012 \textit{long-options} espresse nella forma \cmd{--option=parameter}, anche la
1013 gestione di queste ultime è stata standardizzata attraverso l'uso di una
1014 versione estesa di \func{getopt}.
1019 \subsection{Le variabili di ambiente}
1020 \label{sec:proc_environ}
1022 Oltre agli argomenti passati a linea di comando ogni processo riceve dal
1023 sistema un \textsl{ambiente}, nella forma di una lista di variabili (detta
1024 \textit{environment list}) messa a disposizione dal processo, e costruita
1025 nella chiamata alla funzione \func{exec} quando questo viene lanciato.
1027 Come per la lista dei parametri anche questa lista è un array di puntatori a
1028 caratteri, ciascuno dei quali punta ad una stringa, terminata da un
1029 \macro{NULL}. A differenza di \var{argv[]} in questo caso non si ha una
1030 lunghezza dell'array data da un equivalente di \var{argc}, ma la lista è
1031 terminata da un puntatore nullo.
1033 L'indirizzo della lista delle variabili di ambiente è passato attraverso la
1034 variabile globale \var{environ}, a cui si può accedere attraverso una semplice
1035 dichiarazione del tipo:
1036 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
1037 extern char ** environ;
1039 un esempio della struttura di questa lista, contenente alcune delle variabili
1040 più comuni che normalmente sono definite dal sistema, è riportato in
1041 \figref{fig:proc_envirno_list}.
1044 \includegraphics[width=11cm]{img/environ_var}
1045 \caption{Esempio di lista delle variabili di ambiente.}
1046 \label{fig:proc_envirno_list}
1049 Per convenzione le stringhe che definiscono l'ambiente sono tutte del tipo
1050 \textsl{\texttt{nome=valore}}. Inoltre alcune variabili, come quelle elencate
1051 in \figref{fig:proc_envirno_list}, sono definite dal sistema per essere usate
1052 da diversi programmi e funzioni: per queste c'è l'ulteriore convenzione di
1053 usare nomi espressi in caratteri maiuscoli.
1055 Il kernel non usa mai queste variabili, il loro uso e la loro interpretazione è
1056 riservata alle applicazioni e ad alcune funzioni di libreria; in genere esse
1057 costituiscono un modo comodo per definire un comportamento specifico senza
1058 dover ricorrere all'uso di opzioni a linea di comando o di file di
1061 La shell ad esempio ne usa molte per il suo funzionamento (come \var{PATH} per
1062 la ricerca dei comandi, o \cmd{IFS} per la scansione degli argomenti), e
1063 alcune di esse (come \var{HOME}, \var{USER}, etc.) sono definite al login (per
1064 i dettagli si veda \secref{sec:sess_login}). In genere è cura
1065 dell'amministratore definire le opportune variabili di ambiente in uno script
1066 di avvio. Alcune servono poi come riferimento generico per molti programmi
1067 (come \var{EDITOR} che indica l'editor preferito da invocare in caso di
1070 Gli standard POSIX e XPG3 definiscono alcune di queste variabili (le più
1071 comuni), come riportato in \tabref{tab:proc_env_var}. GNU/Linux le supporta
1072 tutte e ne definisce anche altre: per una lista più completa si può
1073 controllare \cmd{man environ}.
1078 \begin{tabular}[c]{|l|c|c|c|p{7cm}|}
1080 \textbf{Variabile} & \textbf{POSIX} & \textbf{XPG3}
1081 & \textbf{Linux} & \textbf{Descrizione} \\
1084 \macro{USER} & $\bullet$ & $\bullet$ & $\bullet$ & Nome utente\\
1085 \macro{LOGNAME} & $\bullet$ & $\bullet$ & $\bullet$ & Nome di login\\
1086 \macro{HOME} & $\bullet$ & $\bullet$ & $\bullet$ &
1087 Directory base dell'utente\\
1088 \macro{LANG} & $\bullet$ & $\bullet$ & $\bullet$ & Localizzazione\\
1089 \macro{PATH} & $\bullet$ & $\bullet$ & $\bullet$ & Elenco delle directory
1091 \macro{PWD} & $\bullet$ & $\bullet$ & $\bullet$ & Directory corrente\\
1092 \macro{SHELL} & $\bullet$ & $\bullet$ & $\bullet$ & Shell in uso\\
1093 \macro{TERM} & $\bullet$ & $\bullet$ & $\bullet$ & Tipo di terminale\\
1094 \macro{PAGER} & $\bullet$ & $\bullet$ & $\bullet$ & Programma per vedere i
1096 \macro{EDITOR} & $\bullet$ & $\bullet$ & $\bullet$ & Editor preferito\\
1097 \macro{BROWSER} & $\bullet$ & $\bullet$ & $\bullet$ & Browser preferito\\
1100 \caption{Variabili di ambiente più comuni definite da vari standard.}
1101 \label{tab:proc_env_var}
1104 Lo standard ANSI C prevede l'esistenza di un ambiente, pur non entrando nelle
1105 specifiche di come sono strutturati i contenuti, e definisce la funzione
1106 \func{getenv} che permette di ottenere i valori delle variabili di ambiente,
1108 \begin{prototype}{stdlib.h}{char *getenv(const char *name)}
1109 Esamina l'ambiente del processo cercando una stringa che corrisponda a
1110 quella specificata da \param{name}.
1112 \bodydesc{La funzione ritorna \macro{NULL} se non trova nulla, o il
1113 puntatore alla stringa che corrisponde (di solito nella forma
1114 \cmd{NOME=valore}).}
1117 Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI
1118 C, nell'evoluzione dei sistemi Unix ne sono state proposte altre, da
1119 utilizzare per impostare e per cancellare le variabili di ambiente. Uno schema
1120 delle funzioni previste nei vari standard e disponibili in Linux è riportato
1121 in \tabref{tab:proc_env_func}.
1126 \begin{tabular}[c]{|l|c|c|c|c|c|c|}
1128 \textbf{Funzione} & \textbf{ANSI C} & \textbf{POSIX.1} & \textbf{XPG3} &
1129 \textbf{SVr4} & \textbf{BSD} & \textbf{Linux} \\
1132 \func{getenv} & $\bullet$ & $\bullet$ & $\bullet$ &
1133 $\bullet$ & $\bullet$ & $\bullet$ \\
1134 \func{setenv} & & & &
1135 & $\bullet$ & $\bullet$ \\
1136 \func{unsetenv} & & & &
1137 & $\bullet$ & $\bullet$ \\
1138 \func{putenv} & & opz. & $\bullet$ &
1139 & $\bullet$ & $\bullet$ \\
1140 \func{clearenv} & & opz. & &
1144 \caption{Funzioni per la gestione delle variabili di ambiente.}
1145 \label{tab:proc_env_func}
1148 In Linux solo le prime quattro funzioni di \tabref{tab:proc_env_func} sono
1149 definite, \func{getenv} l'abbiamo già esaminata; delle tre restanti le prime
1150 due, \func{putenv} e \func{setenv}, servono per assegnare nuove variabili di
1151 ambiente, i loro prototipi sono i seguenti:
1155 \funcdecl{int setenv(const char *name, const char *value, int overwrite)}
1156 Imposta la variabile di ambiente \param{name} al valore \param{value}.
1158 \funcdecl{int putenv(char *string)} Aggiunge la stringa \param{string}
1161 \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 per un
1162 errore, che è sempre \macro{ENOMEM}.}
1164 \noindent la terza, \func{unsetenv}, serve a cancellare una variabile di
1165 ambiente; il suo prototipo è:
1169 \funcdecl{void unsetenv(const char *name)} Rimuove la variabile di ambiente
1172 \noindent questa funzione elimina ogni occorrenza della variabile specificata;
1173 se essa non esiste non succede nulla. Non è prevista (dato che la funzione è
1174 \ctyp{void}) nessuna segnalazione di errore.
1176 Per modificare o aggiungere una variabile di ambiente si possono usare sia
1177 \func{setenv} che \func{putenv}. La prima permette di specificare
1178 separatamente nome e valore della variabile di ambiente, inoltre il valore di
1179 \param{overwrite} specifica il comportamento della funzione nel caso la
1180 variabile esista già, sovrascrivendola se diverso da zero, lasciandola
1181 immutata se uguale a zero.
1183 La seconda funzione prende come parametro una stringa analoga quella
1184 restituita da \func{getenv}, e sempre nella forma \var{NOME=valore}. Se la
1185 variabile specificata non esiste la stringa sarà aggiunta all'ambiente, se
1186 invece esiste il suo valore sarà impostato a quello specificato da
1187 \param{string}. Si tenga presente che, seguendo lo standard SUSv2, le
1188 \acr{glibc} successive alla versione 2.1.2 aggiungono\footnote{il
1189 comportamento è lo stesso delle vecchie \acr{libc4} e \acr{libc5}; nelle
1190 \acr{glibc}, dalla versione 2.0 alla 2.1.1, veniva invece fatta una copia,
1191 seguendo il comportamento di BSD4.4; dato che questo può dar luogo a perdite
1192 di memoria e non rispetta lo standard. Il comportamento è stato modificato a
1193 partire dalle 2.1.2, eliminando anche, sempre in conformità a SUSv2,
1194 l'attributo \ctyp{const} dal prototipo.} \param{string} alla lista delle
1195 variabili di ambiente; pertanto ogni cambiamento alla stringa in questione si
1196 riflette automaticamente sull'ambiente, e quindi si deve evitare di passare a
1197 questa funzione una variabile automatica (per evitare i problemi esposti in
1198 \secref{sec:proc_auto_var}).
1200 Si tenga infine presente che se si passa a \func{putenv} solo il nome di una
1201 variabile (cioè \param{string} è nella forma \texttt{NAME} e non contiene un
1202 carattere \texttt{'='}) allora questa viene cancellata dall'ambiente. Infine
1203 se la chiamata di \func{putenv} comporta la necessità di allocare una nuova
1204 versione del vettore \var{environ} questo sarà allocato, ma la versione
1205 corrente sarà deallocata solo se anch'essa è risultante da un'allocazione
1206 fatta in precedenza da un'altra \func{putenv}. Questo perché il vettore delle
1207 variabili di ambiente iniziale, creato dalla chiamata ad \func{exec} (vedi
1208 \secref{sec:proc_exec}) è piazzato al di sopra dello stack, (vedi
1209 \figref{fig:proc_mem_layout}) e non nello heap e non può essere deallocato.
1210 Inoltre la memoria associata alle variabili di ambiente eliminate non viene
1214 \section{Problematiche di programmazione generica}
1215 \label{sec:proc_gen_prog}
1217 Benché questo non sia un libro di C, è opportuno affrontare alcune delle
1218 problematiche generali che possono emergere nella programmazione e di quali
1219 precauzioni o accorgimenti occorre prendere per risolverle. Queste
1220 problematiche non sono specifiche di sistemi unix-like o multitasking, ma
1221 avendo trattato in questo capitolo il comportamento dei processi visti come
1222 entità a sé stanti, le riportiamo qui.
1225 \subsection{Il passaggio delle variabili e dei valori di ritorno}
1226 \label{sec:proc_var_passing}
1228 Una delle caratteristiche standard del C è che le variabili vengono passate
1229 alle subroutine attraverso un meccanismo che viene chiamato \textit{by value}
1230 (diverso ad esempio da quanto avviene con il Fortran, dove le variabili sono
1231 passate, come suol dirsi, \textit{by reference}, o dal C++ dove la modalità
1232 del passaggio può essere controllata con l'operatore \cmd{\&}).
1234 Il passaggio di una variabile \textit{by value} significa che in realtà quello
1235 che viene passato alla subroutine è una copia del valore attuale di quella
1236 variabile, copia che la subroutine potrà modificare a piacere, senza che il
1237 valore originale nella routine chiamante venga toccato. In questo modo non
1238 occorre preoccuparsi di eventuali effetti delle operazioni della subroutine
1239 sulla variabile passata come parametro.
1241 Questo però va inteso nella maniera corretta. Il passaggio \textit{by value}
1242 vale per qualunque variabile, puntatori compresi; quando però in una
1243 subroutine si usano dei puntatori (ad esempio per scrivere in un buffer) in
1244 realtà si va a modificare la zona di memoria a cui essi puntano, per cui anche
1245 se i puntatori sono copie, i dati a cui essi puntano sono sempre gli stessi, e
1246 le eventuali modifiche avranno effetto e saranno visibili anche nella routine
1249 Nella maggior parte delle funzioni di libreria e delle system call i puntatori
1250 vengono usati per scambiare dati (attraverso buffer o strutture) e le
1251 variabili semplici vengono usate per specificare parametri; in genere le
1252 informazioni a riguardo dei risultati vengono passate alla routine chiamante
1253 attraverso il valore di ritorno. È buona norma seguire questa pratica anche
1254 nella programmazione normale.
1256 Talvolta però è necessario che la funzione possa restituire indietro alla
1257 funzione chiamante un valore relativo ad uno dei suoi parametri. Per far
1258 questo si usa il cosiddetto \textit{value result argument}, si passa cioè,
1259 invece di una normale variabile, un puntatore alla stessa; vedremo alcuni
1260 esempi di questa modalità nelle funzioni che gestiscono i socket (in
1261 \secref{sec:TCPel_functions}), in cui, per permettere al kernel di restituire
1262 informazioni sulle dimensioni delle strutture degli indirizzi utilizzate,
1263 viene usato questo meccanismo.
1266 \subsection{Il passaggio di un numero variabile di argomenti}
1267 \label{sec:proc_variadic}
1269 Come vedremo nei capitoli successivi, non sempre è possibile specificare un
1270 numero fisso di parametri per una funzione. Lo standard ISO C prevede nella
1271 sua sintassi la possibilità di definire delle \textit{variadic function} che
1272 abbiano un numero variabile di argomenti, attraverso l'uso della
1273 \textit{ellipsis} \var{...} nella dichiarazione della funzione; ma non
1274 provvede a livello di linguaggio alcun meccanismo con cui dette funzioni
1275 possono accedere ai loro argomenti.
1277 L'accesso viene invece realizzato dalle librerie standard che provvedono gli
1278 strumenti adeguati. L'uso delle \textit{variadic function} prevede tre punti:
1280 \item \textsl{Dichiarare} la funzione come \textit{variadic} usando un
1281 prototipo che contenga una \textit{ellipsis}.
1282 \item \textsl{Definire} la funzione come \textit{variadic} usando lo stesso
1283 \textit{ellipsis}, ed utilizzare le apposite macro che consentono la
1284 gestione di un numero variabile di argomenti.
1285 \item \textsl{Chiamare} la funzione specificando prima gli argomenti fissi, e
1286 a seguire gli addizionali.
1289 Lo standard ISO C prevede che una \textit{variadic function} abbia sempre
1290 almeno un argomento fisso; prima di effettuare la dichiarazione deve essere
1291 incluso l'apposito header file \file{stdarg.h}; un esempio di dichiarazione è
1292 il prototipo della funzione \func{execl} che vedremo in
1293 \secref{sec:proc_exec}:
1294 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
1295 int execl(const char *path, const char *arg, ...);
1297 in questo caso la funzione prende due parametri fissi ed un numero variabile
1298 di altri parametri (che verranno a costituire gli elementi successivi al primo
1299 del vettore \var{argv} passato al nuovo processo). Lo standard ISO C richiede
1300 inoltre che l'ultimo degli argomenti fissi sia di tipo
1301 \textit{self-promoting}\footnote{il linguaggio C prevede che quando si
1302 mescolano vari tipi di dati, alcuni di essi possano essere \textsl{promossi}
1303 per compatibilità; ad esempio i tipi \ctyp{float} vengono convertiti
1304 automaticamente a \ctyp{double} ed i \ctyp{char} e gli \ctyp{short} ad
1305 \ctyp{int}. Un tipo \textit{self-promoting} è un tipo che verrebbe promosso
1306 a sé stesso.} il che esclude array, puntatori a funzioni e interi di tipo
1307 \ctyp{char} o \ctyp{short} (con segno o meno). Una restrizione ulteriore di
1308 alcuni compilatori è di non dichiarare l'ultimo parametro fisso come
1311 Una volta dichiarata la funzione il secondo passo è accedere ai vari parametri
1312 quando la si va a definire. I parametri fissi infatti hanno un loro nome, ma
1313 quelli variabili vengono indicati in maniera generica dalla ellipsis.
1315 L'unica modalità in cui essi possono essere recuperati è pertanto quella
1316 sequenziale; essi verranno estratti dallo stack secondo l'ordine in cui sono
1317 stati scritti. Per fare questo in \file{stdarg.h} sono definite delle apposite
1318 macro; la procedura da seguire è la seguente:
1320 \item Inizializzare un puntatore alla lista degli argomenti di tipo
1321 \type{va\_list} attraverso la macro \macro{va\_start}.
1322 \item Accedere ai vari argomenti opzionali con chiamate successive alla macro
1323 \macro{va\_arg}, la prima chiamata restituirà il primo argomento, la seconda
1324 il secondo e così via.
1325 \item Dichiarare la conclusione dell'estrazione dei parametri invocando la
1326 macro \macro{va\_end}.
1328 in generale è perfettamente legittimo richiedere meno argomenti di quelli che
1329 potrebbero essere stati effettivamente forniti, e nella esecuzione delle
1330 \macro{va\_arg} ci si può fermare in qualunque momento ed i restanti argomenti
1331 saranno ignorati; se invece si richiedono più argomenti di quelli forniti si
1332 otterranno dei valori indefiniti. Nel caso del \cmd{gcc} l'uso della macro
1333 \macro{va\_end} è inutile, ma si consiglia di usarlo ugualmente per
1336 Le definizioni delle tre macro sono le seguenti:
1340 \funcdecl{void va\_start(va\_list ap, last)} Inizializza il puntatore alla
1341 lista di argomenti \param{ap}; il parametro \param{last} \emph{deve} essere
1342 l'ultimo dei parametri fissi.
1344 \funcdecl{type va\_arg(va\_list ap, type)} Restituisce il valore del
1345 successivo parametro opzionale, modificando opportunamente \param{ap}; la
1346 macro richiede che si specifichi il tipo dell'argomento attraverso il
1347 parametro \param{type} che deve essere il nome del tipo dell'argomento in
1348 questione. Il tipo deve essere \textit{self-promoting}.
1350 \funcdecl{void va\_end(va\_list ap)} Conclude l'uso di \param{ap}.
1353 In generale si possono avere più puntatori alla lista degli argomenti,
1354 ciascuno andrà inizializzato con \macro{va\_start} e letto con \macro{va\_arg}
1355 e ciascuno potrà scandire la lista degli argomenti per conto suo.
1357 Dopo l'uso di \macro{va\_end} la variabile \var{ap} diventa indefinita e
1358 successive chiamate a \macro{va\_arg} non funzioneranno. Si avranno risultati
1359 indefiniti anche chiamando \macro{va\_arg} specificando un tipo che non
1360 corrisponde a quello del parametro.
1362 Un altro limite delle macro è che i passi 1) e 3) devono essere eseguiti nel
1363 corpo principale della funzione, il passo 2) invece può essere eseguito anche
1364 in una subroutine passandole il puntatore alla lista di argomenti; in questo
1365 caso però si richiede che al ritorno della funzione il puntatore non venga più
1366 usato (lo standard richiederebbe la chiamata esplicita di \macro{va\_end}),
1367 dato che il valore di \var{ap} risulterebbe indefinito.
1369 Esistono dei casi in cui è necessario eseguire più volte la scansione dei
1370 parametri e poter memorizzare una posizione durante la stessa. La cosa più
1371 naturale in questo caso sembrerebbe quella di copiarsi il puntatore alla lista
1372 degli argomenti con una semplice assegnazione. Dato che una delle
1373 realizzazioni più comuni di \macro{va\_list} è quella di un puntatore nello
1374 stack all'indirizzo dove sono stati salvati i parametri, è assolutamente
1375 normale pensare di poter effettuare questa operazione.
1377 In generale però possono esistere anche realizzazioni diverse, per questo
1378 motivo \macro{va\_list} è definito come \textsl{tipo opaco} e non può essere
1379 assegnato direttamente ad un'altra variabile dello stesso tipo. Per risolvere
1380 questo problema lo standard ISO C99\footnote{alcuni sistemi che non hanno
1381 questa macro provvedono al suo posto \macro{\_\_va\_copy} che era il nome
1382 proposto in una bozza dello standard.} ha previsto una macro ulteriore che
1383 permette di eseguire la copia di un puntatore alla lista degli argomenti:
1384 \begin{prototype}{stdarg.h}{void va\_copy(va\_list dest, va\_list src)}
1385 Copia l'attuale valore \param{src} del puntatore alla lista degli argomenti
1388 \noindent anche in questo caso è buona norma chiudere ogni esecuzione di una
1389 \macro{va\_copy} con una corrispondente \macro{va\_end} sul nuovo puntatore
1390 alla lista degli argomenti.
1392 La chiamata di una funzione con un numero variabile di argomenti, posto che la
1393 si sia dichiarata e definita come tale, non prevede nulla di particolare;
1394 l'invocazione è identica alle altre, con i parametri, sia quelli fissi che
1395 quelli opzionali, separati da virgole. Quello che però è necessario tenere
1396 presente è come verranno convertiti gli argomenti variabili.
1398 In Linux gli argomenti dello stesso tipo sono passati allo stesso modo, sia
1399 che siano fissi sia che siano opzionali (alcuni sistemi trattano diversamente
1400 gli opzionali), ma dato che il prototipo non può specificare il tipo degli
1401 argomenti opzionali, questi verranno sempre promossi, pertanto nella ricezione
1402 dei medesimi occorrerà tenerne conto (ad esempio un \ctyp{char} verrà visto da
1403 \macro{va\_arg} come \ctyp{int}).
1405 Uno dei problemi che si devono affrontare con le funzioni con un numero
1406 variabile di argomenti è che non esiste un modo generico che permetta di
1407 stabilire quanti sono i parametri passati effettivamente in una chiamata.
1409 Esistono varie modalità per affrontare questo problema; una delle più
1410 immediate è quella di specificare il numero degli argomenti opzionali come uno
1411 degli argomenti fissi. Una variazione di questo metodo è l'uso di un parametro
1412 per specificare anche il tipo degli argomenti (come fa la stringa di formato
1415 Una modalità diversa, che può essere applicata solo quando il tipo dei
1416 parametri lo rende possibile, è quella che prevede di usare un valore speciale
1417 come ultimo argomento (come fa ad esempio \func{execl} che usa un puntatore
1418 \macro{NULL} per indicare la fine della lista degli argomenti).
1421 \subsection{Potenziali problemi con le variabili automatiche}
1422 \label{sec:proc_auto_var}
1424 Uno dei possibili problemi che si possono avere con le subroutine è quello di
1425 restituire alla funzione chiamante dei dati che sono contenuti in una
1426 variabile automatica. Ovviamente quando la subroutine ritorna la sezione
1427 dello stack che conteneva la variabile automatica potrà essere riutilizzata da
1428 una nuova funzione, con le immaginabili conseguenze di sovrapposizione e
1429 sovrascrittura dei dati.
1431 Per questo una delle regole fondamentali della programmazione in C è che
1432 all'uscita di una funzione non deve restare nessun riferimento alle variabili
1433 locali; qualora sia necessario utilizzare variabili che possano essere viste
1434 anche dalla funzione chiamante queste devono essere allocate esplicitamente, o
1435 in maniera statica (usando variabili di tipo \ctyp{static} o \ctyp{extern}), o
1436 dinamicamente con una delle funzioni della famiglia \func{malloc}.
1439 \subsection{Il controllo di flusso non locale}
1440 \label{sec:proc_longjmp}
1442 Il controllo del flusso di un programma in genere viene effettuato con le
1443 varie istruzioni del linguaggio C; fra queste la più bistrattata è il
1444 \code{goto}, che viene deprecato in favore dei costrutti della programmazione
1445 strutturata, che rendono il codice più leggibile e mantenibile . Esiste però
1446 un caso in cui l'uso di questa istruzione porta all'implementazione più
1447 efficiente e chiara anche dal punto di vista della struttura del programma:
1448 quello dell'uscita in caso di errore.
1450 Il C però non consente di effettuare un salto ad una label definita in
1451 un'altra funzione, per cui se l'errore avviene in una funzione e la sua
1452 gestione ordinaria è in un'altra occorre usare quello che viene chiamato un
1453 \textsl{salto non-locale}. Il caso classico in cui si ha questa necessità,
1454 citato sia da \cite{APUE} che da da \cite{glibc}, è quello di un programma nel
1455 cui corpo principale in cui viene letto un input del quale viene eseguita,
1456 attraverso una serie di funzioni di analisi, una scansione dei contenuti da cui
1457 ottenere le indicazioni per l'esecuzione di opportune operazioni.
1459 Dato che l'analisi può risultare molto complessa, ed opportunamente suddivisa
1460 in fasi diverse, la rilevazione di un errore nell'input può accadere
1461 all'interno di funzioni profondamente annidate l'una nell'altra. In questo
1462 caso si dovrebbe gestire, per ciascuna fase, tutta la casistica del passaggio
1463 all'indietro di tutti gli errori rilevabili dalle funzioni usate nelle fasi
1464 successive, mentre sarebbe molto più comodo poter tornare direttamente al
1465 ciclo di lettura principale, scartando l'input come errato.\footnote{a meno
1466 che, come precisa \cite{glibc}, alla chiusura di ciascuna fase non siano
1467 associate operazioni di pulizia specifiche (come deallocazioni, chiusure di
1468 file, ecc.), che non potrebbero essere eseguite con un salto non-locale.}
1470 Tutto ciò può essere realizzato salvando il contesto dello stack nel punto in
1471 cui si vuole tornare in caso di errore, e ripristinandolo quando l'occorrenza
1472 capita. La funzione che permette di salvare il contesto dello stack è
1473 \func{setjmp}, il cui prototipo è:
1476 \funcdecl{void setjmp(jmp\_buf env)}
1478 Salva il contesto dello stack in \param{env} per un successivo uso da parte
1481 \bodydesc{La funzione ritorna zero quando è chiamata direttamente e un
1482 valore diverso da zero quando ritorna da una chiamata di \func{longjmp}
1483 che usa il contesto salvato in precedenza.}
1486 Quando si esegue la funzione il contesto viene salvato in appositi oggetti (di
1487 tipo \type{jmp\_buf}), passati come primo argomento alla funzione, in genere
1488 questi vengono definiti come variabili globali in modo da poter essere visti
1489 in tutte le funzioni del programma.
1491 Quando viene eseguita direttamente la funzione ritorna sempre zero, un valore
1492 diverso da zero viene restituito solo quando il ritorno è dovuto ad una
1493 chiamata di \func{longjmp} in un'altra parte del programma. Si tenga conto che
1494 il contesto salvato in \param{env} viene invalidato se la routine che ha
1495 chiamato \func{setjmp} ritorna, nel qual caso l'uso di \func{longjmp} può
1496 comportare conseguenze imprevedibili (e di norma fatali per il processo).
1498 Come accennato per effettuare un salto non-locale ad un punto precedentemente
1499 stabilito con \func{setjmp} si usa la funzione \func{longjmp}; il suo
1503 \funcdecl{void longjmp(jmp\_buf env, int val)}
1505 Ripristina il contesto dello stack salvato nell'ultima chiamata di
1506 \func{setjmp} con l'argomento \param{env}.
1508 \bodydesc{La funzione non ritorna.}
1511 Dopo l'esecuzione della funzione programma prosegue dal codice successivo al
1512 ritorno della \func{setjmp} con cui si era salvato \param{env}, che restituirà
1513 il valore \param{val} invece di zero. Il valore di \param{val} specificato
1514 nella chiamata deve essere diverso da zero, se si è specificato 0 sarà
1515 comunque restituito 1 al suo posto.
1517 In sostanza un \func{longjmp} è analogo ad un \code{return}, solo che invece
1518 di ritornare alla riga successiva della funzione chiamante, il programma
1519 ritorna alla posizione della relativa \func{setjmp}, ed il ritorno può essere
1520 effettuato anche attraverso diversi livelli di funzioni annidate.
1522 L'implementazione di queste funzioni comporta alcune restrizioni dato che esse
1523 interagiscono direttamente con la gestione dello stack ed il funzionamento del
1524 compilatore stesso. In particolare \func{setjmp} è implementata con una macro,
1525 pertanto non si può cercare di ottenerne l'indirizzo, ed inoltre delle
1526 chiamate a questa funzione sono sicure solo in uno dei seguenti casi:
1528 \item come espressione di controllo in un comando condizionale, di selezione
1529 o di iterazione (come \code{if}, \code{switch} o \code{while}).
1530 \item come operando per un operatore di uguaglianza o confronto in una
1531 espressione di controllo di un comando condizionale, di selezione o di
1533 \item come operando per l'operatore di negazione (\code{!}) in una espressione
1534 di controllo di un comando condizionale, di selezione o di iterazione.
1535 \item come espressione a sé stante.
1538 In generale, dato che l'unica differenza fra la chiamata diretta e quella
1539 ottenuta da un \func{longjmp}, è il valore di ritorno di \func{setjmp}, essa è
1540 usualmente chiamata all'interno di un comando \code{if}.
1542 Uno dei punti critici dei salti non-locali è quello del valore delle
1543 variabili, ed in particolare quello delle variabili automatiche della funzione
1544 a cui si ritorna. In generale le variabili globali e statiche mantengono i
1545 valori che avevano al momento della chiamata di \func{longjmp}, ma quelli
1546 delle variabili automatiche (o di quelle dichiarate \code{register}) sono in
1547 genere indeterminati.
1549 Quello che succede infatti è che i valori delle variabili che sono tenute in
1550 memoria manterranno il valore avuto al momento della chiamata di
1551 \func{longjmp}, mentre quelli tenuti nei registri del processore (che nella
1552 chiamata ad un'altra funzioni vengono salvati nel contesto nello stack)
1553 torneranno al valore avuto al momento della chiamata di \func{setjmp}; per
1554 questo quando si vuole avere un comportamento coerente si può bloccare
1555 l'ottimizzazione che porta le variabili nei registri dichiarandole tutte come
1560 %%% Local Variables:
1562 %%% TeX-master: "gapil"