+le differenze invece sono:
+\begin{itemize}
+\item il valore di ritorno di \func{fork}.
+\item il \textit{process id}.
+\item il \textit{parent process id} (quello del figlio viene settato al
+ \acr{pid} del padre).
+\item i valori dei tempi di esecuzione (\var{tms\_utime}, \var{tms\_stime},
+ \var{tms\_cutime}, \var{tms\_uetime}) che nel figlio sono posti a zero.
+\item i \textit{file lock}, che non vengono ereditati dal figlio.
+\item gli allarmi pendenti, che per il figlio vengono cancellati.
+\end{itemize}
+
+
+\subsection{La funzione \func{vfork}}
+\label{sec:proc_vfork}
+
+La funzione \func{vfork} è esattamente identica a \func{fork} ed ha la stessa
+semantica e gli stessi errori; la sola differenza è che non viene creata la
+tabella delle pagine né la struttura dei task per il nuovo processo. Il
+processo padre è posto in attesa fintanto che il figlio non ha eseguito una
+\func{execve} o non è uscito con una \func{\_exit}. Il figlio condivide la
+memoria del padre (e modifiche possono avere effetti imprevedibili) e non deve
+ritornare o uscire con \func{exit} ma usare esplicitamente \func{\_exit}.
+
+Questa funzione è un rimasuglio dei vecchi tempi in cui eseguire una
+\func{fork} comportava anche la copia completa del segmento dati del processo
+padre, che costituiva un inutile appesantimento in tutti quei casi in cui la
+\func{fork} veniva fatto solo per poi eseguire una \func{exec}. La funzione
+venne introdotta in BSD per migliorare le prestazioni.
+
+Dato che Linux supporta il \textit{copy on write} la perdita di prestazioni è
+assolutamente trascurabile, e l'uso di questa funzione (che resta un caso
+speciale della funzione \func{clone}), è deprecato, per questo eviteremo di
+trattarla ulteriormente.
+
+
+\subsection{La conclusione di un processo.}
+\label{sec:proc_termination}
+
+In \secref{sec:proc_conclusion} abbiamo già affrontato le tre modalità con cui
+si conclude un programma in maniera normale: la chiamata di \func{exit} (che
+esegue le funzioni registrate e chiude gli stream), il ritorno dalla funzione
+\func{main} (equivalente alla chiamata di \func{exit}), e la chiamata ad
+\func{\_exit} (che esegue direttamente la terminazione del processo).
+
+Ma oltre alla conclusione normale abbiamo accennato che esistono anche delle
+modalità di conclusione anomala; queste sono in sostanza due: il programma può
+chiamare la funzione \func{abort} per invocare una chiusura anomala, o essere
+terminato da un segnale. In realtà anche la prima modalità si riconduce alla
+seconda, dato che \func{abort} si limita a generare il segnale
+\macro{SIGABRT}.
+
+Qualunque sia la modalità di conclusione di un processo, il kernel esegue
+comunque una serie di operazioni: chiude tutti i file aperti, rilascia la
+memoria che stava usando, e così via. Ma per ciascuna delle varie modalità
+di chiusura al padre deve essere riportato come il figlio è terminato.
+
+Nel caso di conclusione normale per riportare lo stato di uscita del processo
+viene usato l'\textit{exit status} specificato dal valore passato alle
+funzioni \func{exit} o \func{\_exit} (o dal valore di ritorno per
+\func{main}). Ma se il processo viene concluso in maniera anomala è il kernel
+che deve generare un \textit{termination status} per indicare le ragioni della
+conclusione anomala. Si noti che si è distinto fra \textit{exit status} e
+\textit{termination status} in quanto anche in caso di conclusione normale, il
+kernel usa il primo per produrre il secondo.
+
+In ogni caso il valore dello stato di conclusione del processo può essere
+letto attraverso le funzioni \func{wait} o \func{waitpid}.
+