+Come accennato funzioni per l'uscita ``normale'' da un programma sono due, la
+prima è la funzione \func{exit} che è definita dallo standard ANSI C; il
+prototipo della funzione è il seguente:
+\begin{prototype}{stdlib.h}{void exit(int status)}
+ Causa la conclusione ordinaria del programma restituendo il valore
+ \var{status} al processo padre.
+
+ La funzione non ritorna. Il processo viene terminato
+\end{prototype}
+
+La funzione \func{exit} è pensata per una conclusione pulita di un programma
+che usa le librerie standard del C; essa esegue tutte le funzioni che sono
+state registrate con \func{atexit} e \func{on\_exit} (vedi
+\secref{sec:proc_atexit}), e chiude tutti gli stream di I/O effettuando il
+salvataggio dei dati sospesi (chiamando \func{fclose}, vedi
+\secref{sec:file_fclose}), infine ripassa il controllo al kernel chiamando
+\func{\_exit} e passando il valore \var{status} come stato di uscita.
+
+La system call \func{\_exit} restituisce direttamente il controllo al
+kernel, concludendo immediatamente il processo, le eventuali funzioni
+registrate con \func{atexit} e \func{on\_exit} non vengono eseguite. Il
+prototipo della funzione è il seguente:
+\begin{prototype}{unistd.h}{void \_exit(int status)}
+ Causa la conclusione immediata del programma restituendo il valore
+ \var{status} al processo padre.
+
+ La funzione non ritorna. Il processo viene terminato.
+\end{prototype}
+
+La funzione chiude tutti i file descriptor appartenenti al processo (si tenga
+presente che questo non comporta il salvataggio dei dati bufferizzati degli
+stream), fa si che ogni figlio del processo sia ereditato da \cmd{init}
+(vedi \secref{cha:process_handling}), manda un segnale \macro{SIGCHLD} al
+processo padre (vedi \ref{sec:sig_job_control}) ed infine ritorna lo stato di
+uscita specificato in \var{status} che può essere raccolto usando la
+funzione \func{wait} (vedi \secref{sec:proc_wait}).
+
+
+\subsection{Le funzioni \func{atexit} e \func{on\_exit}}
+\label{sec:proc_atexit}
+
+Come accennato l'uso di \func{exit} al posto della \func{\_exit} è fatto
+principalmente per permettere una uscita pulita dalle funzioni delle librerie
+standard del C (in particolare per quel che riguarda la chiusura degli
+stream).
+
+Quando si realizza una libreria da usare in varie applicazioni può essere
+perciò utile evitare di richiedere di chiamare esplicitamente un funzione di
+uscita che esegua tutte le operazioni di pulizia prima di uscire (come quella
+di salvare eventuali dati sospesi). È invece molto meno soggetto ad errori e
+completamente trasparente all'utente poter effettuare una chiamata automatica
+di una funzione che effettui tali operazioni all'uscita dal programma.
+
+A questo scopo lo standard ANSI C prevede la possibilità di registrare un
+certo numero funzioni che verranno eseguite all'uscita dal programma (sia per
+la chiamata ad \func{exit} che per il ritorno di \func{main}). La prima
+funzione che si può utilizzare a tal fine è:
+\begin{prototype}{stdlib.h}{void atexit(void (*function)(void))}
+ Registra la funzione \var{function} per essere chiamata all'uscita dal
+ programma.
+
+ La funzione restituisce 0 in caso di successo e -1 in caso di fallimento,
+ \texttt{errno} non viene settata.
+\end{prototype}
+
+La funzione richiede come argomento l'indirizzo della opportuna da chiamare
+all'uscita che non deve prendere argomenti e non deve ritornare niente. Una
+estensione di \func{atexit} è la funzione \func{on\_exit} (che la glibc
+include per compatibilità con SunOS e che non è detto sia definita su altri
+sistemi), il cui prototipo è:
+\begin{prototype}{stdlib.h}
+{void on\_exit(void (*function)(int status, void *arg), void *arg)}
+ Registra la funzione \var{function} per essere chiamata all'uscita dal
+ programma. Tutte le funzioni registrate vengono chiamate in ordine inverso
+ rispetto a quello di registrazione.
+
+ La funzione restituisce 0 in caso di successo e -1 in caso di fallimento,
+ \var{errno} non viene settata.
+\end{prototype}
+
+In questo caso la funzione da chiamare prende due parametri, il primo dei
+quali sarà inizializzato allo stato di uscita con cui è stata chiamata
+\func{exit} ed il secondo al puntatore generico specificato come secondo
+argomento nella chiamata di \func{on\_exit}.
+
+Nella sequenza di chiusura tutte le funzioni registrate verranno chiamate in
+ordine inverso rispetto a quello di registrazione (ed una stessa funzione
+registrata più volte sarà chiamata più volte); poi verranno chiusi tutti gli
+stream aperti, infine verrà chiamata \func{\_exit}.
+
+
+\subsection{Conclusioni}
+\label{sec:proc_term_conclusion}
+
+Data l'importanza dell'argomento è opportuno sottolineare ancora una volta che
+in un sistema unix l'unico modo in cui un programma può essere eseguito dal
+kernel è attraverso la chiamata alla system call \func{execve} (in genere
+attraverso una delle funzioni \func{exec} che vedremo in
+\secref{sec:proc_exec}).
+
+Allo stesso modo l'unico modo in cui un programma può concludere
+volontariamente la sua esecuzione è attraverso una chiamata alla system call
+\func{\_exit} sia esplicitamente o che in maniera indiretta attraverso l'uso
+di \func{exit} o il ritorno della funzione \func{main}.
+
+Lo schema delle modalità con cui si avvia e conclude normalmente un programma
+è riportato in \nfig.
+
+\begin{figure}[htb]
+ \centering
+ \includegraphics[width=12cm]{img/proc_beginend}
+ \caption{Schema dell'avvio e della conclusione di un programma.}
+ \label{fig:proc_prog_start_stop}
+\end{figure}
+
+
+Si ricordi infine che un programma può anche essere interrotto dall'esterno
+attraverso l'uso di un segnale (modalità di conclusione non mostrata in
+\curfig); torneremo su questo aspetto in \secref{cha:signals}.
+
+
+
+\section{I processi e l'uso della memoria}
+\label{sec:proc_memory}
+
+Una delle risorse base che ciascun processo ha a disposizione è la memoria, ed
+uno degli aspetti più complessi di un sistema unix (ed in particolar modo di
+Linux) è appunto la gestione della memoria. Qui ci occuperemo però di come la
+memoria viene vista dal punto di vista di un programma in esecuzione in un
+processo.
+
+
+\subsection{I concetti generali}
+\label{sec:proc_mem_gen}
+
+Ci sono vari modi in cui i vari sistemi organizzano la memoria (ed i dettagli
+di basso livello dipendono in maniera diretta dall'architettura
+dell'hardware), ma quello più tipico, usato da unix (e da Linux) è quello di
+assegnare ad ogni processo uno spazio virtuale di indirizzamento lineare in
+cui gli indirizzi vanno da zero ad un qualche valore massimo (nel caso di
+Linux fino al kernel 2.2 detto massimo era per macchine a 32bit di 2Gb, con il
+kernel 2.4 il limite è stato esteso).
+
+Come accennato nell'introduzione questo spazio di indirizzi è virtuale e non
+corrisponde all'effettiva posizione dei dati nella RAM del computer; in genere
+detto spazio non è neanche continuo (cioè non tutti gli indirizzi sono
+utilizzabili e/o utilizzati).
+
+La memoria virtuale viene divisa in pagine di dimensione fissa (che ad esempio
+sono di 4kb su macchine a 32 bit e 8kb sulle alpha, valori strettamente
+connessi all'hardware di gestione della memoria), e ciascuna pagina della
+memoria virtuale è associata ad un supporto che può essere una pagina di
+memoria reale o ad un dispositivo di stoccaggio secondario (in genere lo
+spazio disco riservato alla swap, o i file che contengono il codice).
+
+Lo stesso pezzo di memoria reale (o di spazio disco) può fare da supporto a
+diverse pagine di memoria virtuale appartenenti a processi diversi (come
+accade in genere per le pagine che contengono il codice delle librerie
+condivise). Ad esempio il codice della funzione \func{printf} starà su una
+sola pagina di memoria reale che farà da supporto a tutte le pagine di memoria
+virtuale di tutti i processi hanno detta funzione nel loro codice.
+
+La corrispondenza fra le pagine della memoria virtuale e quelle della memoria
+fisica della macchina viene gestita in maniera trasparente dall'hardware di
+gestione della memoria (la \textit{Memory Management Unit} del processore),
+ma poiché in genere quest'ultima è solo una piccola frazione della memoria
+virtuale è necessario un meccanismo che permetta di trasferire le pagine
+virtuali che servono dal supporto su cui si trovano in memoria, eliminando
+quelle che non servono. Questo meccanismo è detto \textit{paging}, ed è uno
+dei compiti principali del kernel.
+
+Quando un processo cerca di accedere ad una pagina che non è nella memoria
+reale, avviene quello che viene chiamato un \textit{page fault}; l'hardware di
+gestione della memoria (la MMU del processore) genera una interruzione e passa
+il controllo al kernel il quale sospende il processo e si incarica di mettere
+in RAM la pagina richiesta (effettuando tutte le operazioni necessarie per
+reperire lo spazio necessario), per poi restituire il controllo al
+processo.
+
+Dal punto di vista di un processo questo meccanismo è completamente
+trasparente e tutto avviene come se tutte le pagine fossero sempre disponibili
+in memoria. L'unica differenza avvertibile è quella dei tempi di esecuzione,
+che passano dai pochi nanosecondi necessari per l'accesso a tempi molto più
+lunghi, dovuti all'intervento del kernel. Normalmente questo è il prezzo da
+pagare per avere un multitasking reale, ed in genere il sistema è molto
+efficiente in questo lavoro; quando però ci siano esigenze specifiche di
+prestazioni è possibile usare delle funzioni che permettono di bloccare il
+meccanismo del paging e mantenere fisse delle pagine in memoria (vedi
+\ref{sec:proc_mem_lock}).
+
+
+\subsection{La struttura della memoria di un processo}
+\label{sec:proc_mem_layout}
+
+Benché lo spazio di indirizzi virtuali copra un intervallo molto ampio, solo
+una parte di essi è effettivamente allocato ed utilizzabile dal processo; il
+tentativo di accedere ad un indirizzo non allocato è un tipico errore che si
+commette quando si è manipolato male un puntatore e genera quello che viene
+chiamato un \textit{segmentation fault}. Se si tenta cioè di leggere o
+scrivere da un indirizzo per il quale non esiste una associazione della pagina
+virtuale il kernel risponde al relativo \textit{page fault}, mandando un
+segnale \macro{SIGSEGV} al processo, che normalmente ne causa la terminazione
+immediata.
+
+È pertanto importante capire come viene strutturata la memoria virtuale di un
+processo; essa viene divisa in \textsl{segmenti}, cioè un insieme contiguo di
+indirizzi virtuali ai quali il processo può accedere. Solitamente un
+programma C viene suddiviso nei seguenti segmenti:
+
+\begin{enumerate}
+\item Il segmento di testo (\textit{text segment}). Contiene il codice
+ macchina del programma e le costanti statiche. Normalmente viene condiviso,
+ in modo che più processi (anche diversi nel caso di librerie) possano
+ utilizzarlo, e viene marcato in sola lettura per evitare sovrascritture
+ accidentali (o maliziose) che ne modifichino le istruzioni.
+
+ Viene allocato da \func{exec} all'avvio del programma e resta invariato
+ per tutto il tempo dell'esecuzione.
+
+\item Il segmento dei dati (\textit{data segment}). Contiene le variabili
+ globali (cioè quelle definite al di fuori di tutte le funzioni). Di norma è
+ diviso in due parti.
+
+ La prima parte è il segmento dei dati inizializzati, che contiene le
+ variabili globali il cui valore è stato assegnato esplicitamente. Ad esempio
+ se si definisce:
+\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
+ double pi = 3.14;
+\end{lstlisting}
+ questo valore sarà immagazzinato in questo segmento. La memoria di questo
+ segmento viene preallocato dalla \func{exec} e inizializzata ai valori
+ specificati.
+
+ La seconda parte è il segmento dei dati non inizializzati, che contiene le
+ variabili globali il cui valore è stato non è assegnato esplicitamente. Ad
+ esempio se si definisce:
+\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
+ int vect[100];
+\end{lstlisting}
+ questo valore sarà immagazzinato in questo segmento. Anch'esso viene
+ allocato all'avvio, e tutte le variabili vengono inizializzate a
+ zero (ed i puntatori a \macro{NULL}).
+
+ Storicamente questo segmento viene chiamato BBS (da \textit{block started by
+ symbol}. La sua dimensione è fissa.
+
+\item Lo \textit{heap}. Tecnicamente lo si può considerare l'estensione del
+ segmento dati, a cui di solito è posto giusto di seguito. È qui che avviene
+ l'allocazione dinamica della memoria; può essere ridimensionato allocando e
+ disallocando la memoria dinamica con le apposite funzioni (vedi
+ \secref{sec:proc_mem_alloc}), ma il suo limite inferiore (quello adiacente
+ al segmento dati) ha una posizione fissa.
+
+\item Il segmento di \textit{stack}, che contiene lo \textit{stack} del
+ programma. Tutte le volte che si effettua una chiamata ad una funzione è
+ qui che viene salvato l'indirizzo di ritorno e le informazioni dello stato
+ del chiamante (tipo il contenuto di alcuni registri della CPU); poi la
+ funzione chiamata alloca qui lo spazio per le sue variabili locali, in
+ questo modo le funzioni possono essere chiamate ricorsivamente. Al ritorno
+ della funzione lo spazio è automaticamente rilasciato.
+
+ La dimensione di questo segmento aumenta seguendo la crescita dello stack
+ del programma, ma non viene ridotta quando quest'ultimo si restringe.
+\end{enumerate}
+
+\begin{figure}[htb]
+ \centering
+ \includegraphics[width=5cm]{img/memory_layout}
+ \caption{Disposizione tipica dei segmenti di memoria di un processo}
+ \label{fig:proc_mem_layout}
+\end{figure}
+
+Una disposizione tipica di questi segmenti è riportata in \nfig. Usando il
+comando \cmd{size} su un programma se ne può stampare le dimensioni dei
+segmenti di testo e di dati (inizializzati e BSS); il BSS però non è mai
+salvato sul file, in quanto viene inizializzato a zero al caricamento del
+programma.
+
+
+\subsection{Allocazione della memoria per i programmi C}
+\label{sec:proc_mem_alloc}
+
+Il C supporta due tipi di allocazione della memoria, l'allocazione statica è
+quella in cui vanno le variabili globali e le variabili statiche (e viene
+effettuata nel segmento dei dati), lo spazio per queste variabili viene
+allocati all'avvio del programma (come parte delle operazioni svolte da
+\func{exec}) e non viene liberato fino alla sua conclusione.
+
+L'allocazione automatica è quella che avviene per le cosiddette variabili
+automatiche, cioè gli argomenti delle funzioni o le variabili locali. Lo
+spazio per queste variabili viene allocato nello stack quando viene eseguito
+comando di invocazione della funzione e liberato quando si esce dalla
+medesima.
+
+Esiste però un terzo tipo di allocazione, che non è prevista dal linguaggio C,
+che è l'allocazione dinamica della memoria, necessaria quando il quantitativo
+di memoria che serve è determinabile solo in corso di esecuzione del
+programma.
+
+Il C non consente di usare variabili allocate dinamicamente, non è possibile
+cioè definire in fase di programmazione una variabile le cui dimensioni
+possano essere modificate durante l'esecuzione del programma; però le librerie
+del C forniscono una serie opportuna di funzioni per permettere l'allocazione
+dinamica di spazio in memoria (in genere nello heap, usando la system call
+\func{sbrk}), solo che a questo punto detto spazio sarà accessibile solo in
+maniera indiretta attraverso dei puntatori.
+
+
+\subsection{Le funzioni \func{malloc}, \func{calloc}, \func{realloc} e
+ \func{free}}
+\label{sec:proc_mem_malloc}
+
+Le funzioni previste dallo standard ANSI C per la gestione della memoria sono
+quattro, i prototipi sono i seguenti:
+\begin{functions}
+\headdecl{stdlib.h}
+\funcdecl{void *calloc(size\_t size)}
+ Alloca \var{size} byte nello heap. La memoria viene inizializzata a 0.
+
+ La funzione restituisce il puntatore alla zona di memoria allocata in caso
+ di successo e \macro{NULL} in caso di fallimento, nel qual caso
+ \var{errno} viene settata a \macro{ENOMEM}.
+\funcdecl{void *malloc(size\_t size)}
+ Alloca \var{size} byte nello heap. La memoria non viene inizializzata.
+
+ La funzione restituisce il puntatore alla zona di memoria allocata in caso
+ di successo e \macro{NULL} in caso di fallimento, nel qual caso
+ \var{errno} viene settata a \macro{ENOMEM}.
+\funcdecl{void *realloc(void *ptr, size\_t size)}
+ Cambia la dimensione del blocco allocato all'indirizzo \var{ptr}
+ portandola a \var{size}.
+
+ La funzione restituisce il puntatore alla zona di memoria allocata in caso
+ di successo e \macro{NULL} in caso di fallimento, nel qual caso
+ \var{errno} viene settata a \macro{ENOMEM}.
+\funcdecl{void free(void *ptr)}
+ Disalloca lo spazio di memoria puntato da \var{ptr}.
+
+ La funzione non ritorna nulla e non riporta errori.
+\end{functions}
+Il puntatore che le funzioni di allocazione ritornano è garantito essere
+sempre correttamente allineato per tutti i tipi di dati; ad esempio sulle
+macchine a 32 bit in genere è allineato a multipli di 4 byte e sulle macchine
+a 64 bit a multipli di 8 byte.
+
+In genere su usano le funzioni \func{malloc} e \func{calloc} per allocare
+dinamicamente la memoria necessaria al programma, siccome i puntatori
+ritornati sono di tipo generico non è necessario effettuare un cast per
+assegnarli a puntatori al tipo di variabile per la quale si effettua la
+allocazione.
+
+La memoria allocata dinamicamente deve essere esplicitamente rilasciata usando
+\func{free}\footnote{le glibc provvedono anche una funzione \func{cfree}
+ definita per compatibilità con SunOS, che è deprecata} una volta che non
+sia più necessaria. Questa funzione vuole come parametro un puntatore
+restituito da una precedente chiamata a una qualunque delle funzioni di
+allocazione e che non sia già stato liberato da un'altra chiamata a
+\func{free}, in caso contrario il comportamento della funzione è indefinito.
+
+La funzione \func{realloc} si usa invece per cambiare (in genere aumentare)
+la dimensione di un'area di memoria precedentemente allocata, la funzione
+vuole in ingresso il puntatore restituito dalla precedente chiamata ad una
+\func{malloc} (se è passato un valore \macro{NULL} allora la funzione si
+comporta come \func{malloc}\footnote{questo è vero per Linux e
+ l'implementazione secondo lo standard ANSI C, ma non è vero per alcune
+ vecchie implementazioni, inoltre alcune versioni delle librerie del C
+ consentivano di usare \func{realloc} anche per un puntatore liberato con
+ \func{free} purché non ci fossero state altre chiamate a funzioni di
+ allocazione, questa funzionalità è totalmente deprecata e non è consentita
+ sotto Linux}), ad esempio quando si deve far crescere la dimensione di un
+vettore; in questo caso se è disponibile dello spazio adiacente al precedente
+la funzione lo utilizza, altrimenti rialloca altrove un blocco della dimensione
+voluta copiandoci automaticamente il contenuto, lo spazio aggiunto non viene
+inizializzato.
+
+Si deve sempre avere ben presente il fatto che il blocco di memoria restituito
+da \func{realloc} può non essere una estensione di quello che gli si è passato
+come parametro; pertanto esso deve essere trattato allo stesso modo di una
+nuova allocazione; in particolare si dovrà \emph{sempre} eseguire la
+riassegnazione di \var{ptr} al valore di ritorno della funzione, e
+reinizializzare (o provvedere ad un adeguato aggiornamento qualora ancora
+servano) tutti gli altri puntatori al blocco di dati ridimensionato.
+
+Uno degli errori più comuni (specie se si ha a che fare con array di
+puntatori) è infatti quello di chiamare \func{free} più di una volta sullo
+stesso puntatore; per evitare questo problema una soluzione di ripiego è
+quella di assegnare sempre a \macro{NULL} ogni puntatore liberato con
+\func{free}, dato che, quando il parametro è un puntatore nullo,
+\func{free} non esegue nessuna operazione.
+
+Linux e le glibc hanno una implementazione delle routine di allocazione che è
+controllabile dall'utente attraverso alcune variabili di ambiente, in
+particolare diventa possibile tracciare questo tipo di errori usando la
+variabile \macro{MALLOC\_CHECK\_} che quando viene settata mette in uso una
+versione meno efficiente delle funzioni, che però è più tollerante nei
+confronti di piccoli errori come quello di chiamate doppie a \func{free}; in
+particolare:
+\begin{itemize*}
+\item se la variabile è posta a zero gli errori vengono ignorati.
+\item se è posta ad 1 viene stampato un avviso sullo \textit{standard error}
+ (vedi \secref{sec:file_std_stream}).
+\item se è posta a 2 viene chiamata \func{abort}, che in genere causa
+ l'immediata conclusione del programma.
+\end{itemize*}
+
+Il problema più comune e più difficile da tracciare che si incontra con
+l'allocazione della memoria è però quando la memoria non più utilizzata non
+viene opportunamente liberata (quello che in inglese viene chiamato
+\textit{memory-leak}, traducibile come \textsl{perdita di memoria}).
+
+Un caso tipico è quando l'allocazione viene fatta da una subroutine per un uso
+locale, ma la memoria non viene liberata una volta usata; chiamate ripetute
+alla stessa subroutine causeranno a lungo andare un esaurimento della memoria
+disponibile, con un conseguente crash dell'applicazione che può avvenire in
+qualunque momento, e senza nessuna relazione con la subroutine che contiene
+l'errore.
+
+Per questo motivo l'implementazione delle routine di allocazione delle glibc
+mette a disposizione una serie di funzionalità (su cui torneremo in
+\secref{sec:xxx_advanced}) che permettono di tracciare le allocazioni e
+le disallocazione, e definisce anche una serie di possibili agganci che
+permettono di sostituire alle funzioni di libreria una propria versione (che
+può essere più o meno specializzata per il debugging).
+
+
+\subsection{La funzione \func{alloca}}
+\label{sec:proc_mem_alloca}
+
+Una alternativa possibile all'uso di \func{malloc}, che non soffre del tipo
+di problemi di memory leak descritti in precedenza è la funzione
+\func{alloca} che invece che allocare la memoria nello heap usa lo il
+segmento di stack della funzione corrente. La sintassi è identica:
+\begin{prototype}{stdlib.h}{void *alloca(size\_t size)}
+ Alloca \var{size} byte nel segmento di stack della funzione chiamante.
+ La memoria non viene inizializzata.
+
+ La funzione restituisce il puntatore alla zona di memoria allocata in caso
+ di successo e \macro{NULL} in caso di fallimento, nel qual caso
+ \var{errno} viene settata a \macro{ENOMEM}.
+\end{prototype}
+\noindent ma in questo caso non è più necessario liberare la memoria in quanto
+questa viene rilasciata automaticamente al ritorno della funzione.
+
+Come è evidente questa funzione ha molti vantaggi, e permette di evitare i
+problemi di memory leak non essendo più necessaria la deallocazione esplicita;
+una delle ragioni principali per usarla è però che funziona anche quando si
+usa \func{longjmp} per uscire con un salto non locale da una funzione (vedi
+\secref{sec:proc_longjmp}),
+
+Un altro vantaggio e che in Linux la funzione è molto veloce e non viene
+sprecato spazio, infatti non è necessario gestire un pool di memoria da
+riservare e si evitano anche i problemi di frammentazione di quest'ultimo che
+comportano inefficienze sia nell'allocazione della memoria che nell'esecuzione
+della funzione.
+
+Gli svantaggi sono che questa funzione non è disponibile su tutti gli unix,
+(quando non è possibile aumentare le dimensioni dello stack una volta chiamata
+una funzione) e quindi l'uso limita la portabilità dei programmi, inoltre se
+si cerca di allocare troppa memoria non si ottiene un messaggio di errore, ma
+un segnale di \textit{segment violation} analogo a quello che si avrebbe da
+una ricorsione infinita.
+
+Inoltre non è chiaramente possibile usare questa funzione per allocare memoria
+che deve poi essere usata anche al di fuori della funzione in cui questa viene
+chiamata, in quanto all'uscita dalla funzione lo spazio allocato diventerebbe
+libero, e potrebbe essere sovrascritto all'invocazione di nuove funzioni con
+conseguenze imprevedibili. Questo è lo stesso problema potenziale che si può
+avere con le variabili automatiche, su cui torneremo in
+\secref{sec:proc_auto_var}.
+
+
+\subsection{Le funzioni \func{brk} e \func{sbrk}}
+\label{sec:proc_mem_sbrk}