+\chapter{La gestione dei processi}
+\label{cha:process_handling}
+
+Come accennato nell'introduzione in un sistema unix ogni attività del sistema
+viene svolta tramite i processi. In sostanza i processi costituiscono l'unità
+base per l'allocazione e l'uso delle risorse del sistema.
+
+Nel precedente capitolo abbiamo visto come funziona un singolo processo, in
+questo capitolo affronteremo i dettagli della creazione e della distruzione
+dei processi, della gestione dei loro attributi e privilegi, e di tutte le
+funzioni a questo connesse.
+
+
+\section{Una panoramica sui concetti base}
+\label{sec:proc_gen}
+
+Una delle caratteristiche essenziali di unix (che esamineremo in dettaglio più
+avanti) è che ogni processo può a sua volta generare altri processi figli
+(\textit{child}): questo è ad esempio quello che fa la shell quando mette in
+esecuzione il programma che gli indichiamo nella linea di comando.
+
+Una seconda caratteristica è che ogni processo viene sempre generato in tale
+modo da un processo genitore (\textit{parent}) attraverso una apposita system
+call. Questo vale per tutti i processi, tranne per un processo speciale, che
+normalmente è \texttt{/sbin/init}, che invece viene lanciato dal kernel finita
+la fase di avvio e che quindi non è figlio di nessuno.
+
+Tutto ciò significa che, come per i file su disco, i processi sono organizzati
+gerarchicamente dalla relazione fra genitori e figli; alla base dell'albero in
+questo caso c'è init che è progenitore di ogni altro processo.
+
+
+\section{Gli identificatori dei processi}
+\label{sec:proc_id}
+
+Ogni processo viene identificato dal sistema da un numero identificativo
+unico, il \textit{process id} o \textit{pid}. Questo viene assegnato in forma
+progressiva ogni volta che un nuovo processo viene creato, fino ad un limite
+massimo (in genere essendo detto numero memorizzato in un intero a 16 bit si
+arriva a 32767) oltre il quale si riparte dal numero più basso disponibile
+(FIXME: verificare, non sono sicuro). Per questo motivo processo il processo
+di avvio (init) ha sempre il pid uguale a uno.
+
+Ogni processo è identificato univocamente dal sistema per il suo
+pid; quest'ultimo è un apposito tipo di dato, il \texttt{pid\_t} che in
+genere è un intero con segno (nel caso di Linux e delle glibc il tipo usato è
+\texttt{int}.
+
+Tutti i processi inoltre portano traccia del pid del genitore, chiamato in
+genere \textit{ppid} (da \textit{Parente Process Id}). Questi identificativi
+possono essere ottenuti da un programma usando le funzioni:
+\begin{itemize}
+ \item \texttt{pid\_t getpid(void)} restituisce il pid del processo corrente.
+
+ \item \texttt{pid\_t getppid(void)} restituisce il pid del padre del processo
+ corrente.
+
+\end{itemize}
+(per l'accesso a queste funzioni e ai relativi tipi di dati occorre includere
+gli header files \texttt{unistd.h} e \texttt{sys/types.h}).
+
+
+
+\section{Il controllo dei processi}
+\label{sec:proc_control}
+
+Esamineremo in questa sezione le varie funzioni per il controllo dei processi:
+la lore creazione, la terminazione, l'esecuzione di altri programmi. Prima di
+trattare in dettaglio le singole funzioni, faremo un'introduzione generale ai
+contetti che stanno alla base della gestione dei processi in unix.
+
+\subsection{Una panoramica}
+\label{sec:proc_control_overview}
+
+I processi vengono creati dalla funzione \texttt{fork}; in genere questa è una
+system call, ma linux però usa un'altra nomenclatura, e la funzione fork è
+basata a sua volta sulla system call \texttt{clone}, che viene usata anche per
+generare i \textit{thread}. Il processo figlio creato dalla \textit{fork} è
+una copia identica del processo processo padre, solo che ha un suo pid
+proprio.
+
+Se si vuole che il processo padre si fermi fino alla conclusione del processo
+figlio questo deve essere specificato subito dopo la fork chiamando la
+funzione \texttt{wait} o la funzione \texttt{waitpid}, che restituiscono anche
+una informazione abbastanza limitata (il codice di uscita) sulle cause della
+terminazione del processo.
+
+Quando un processo ha concluso il suo compito o ha incontrato un errore non
+risolvibile esso può essere terminato con la funzione \texttt{exit} (la
+questione è più complessa ma ci torneremo più avanti). La vita del processo
+però termina solo quando viene chiamata la quando la sua conclusione viene
+ricevuta dal processo padre, a quel punto tutte le risorse allocate nel
+sistema ad esso associate vengono rilasciate.
+
+Avere due processi che eseguono esattamente lo stesso codice non è molto
+utile, mormalmente si genera un secondo processo per affidagli l'esecuzione di
+un compito specifico (ad esempio gestire una connessione dopo che questa è
+stata stabilita), o fargli eseguire (come fa la shell) un altro programma. Per
+questo si usa la seconda funzione fondamentale per programmazione coi processi
+che è la \texttt{exec}.
+
+Il programma che un processo sta eseguendo si chiama immagine del processo
+(\textit{process image}), le funzioni della famiglia \textit{exec} permettono
+di caricare un'altro programma da disco sostituendo quest'ultimo alla process
+image corrente, questo fa si che la precedente immagine venga completamente
+cancellata e quando il nuovo programma esce anche il processo termina, senza
+ritornare alla precedente immagine.
+
+Per questo motivo la \texttt{fork} e la \texttt{exec} sono funzioni molto
+particolari con caratteristiche uniche rispetto a tutte le altre, infatti la
+prima ritorna due volte (nel processo padre e nel figlio) mentre la seconda
+non ritorna mai (in quanto con essa viene eseguito un altro programma).
+
+
+\subsection{La funzione \texttt{fork}}
+\label{sec:proc_fork}
+
+
+Dopo l'esecuzione di una fork sia il processo padre che il processo figlio
+continuano ad essere eseguiti normalmente, ed il processo figlio esegue
+esattamente lo stesso codice del padre. La sola differenza è che nel processo
+padre il valore di ritorno della funzione fork è il pid del processo figlio,
+mentre nel figlio è zero; in questo modo il programma può identificare se
+viene eseguito dal padre o dal figlio.
+
+
+
+
+\subsection{Le funzioni \texttt{wait} e \texttt{waitpid}}
+\label{sec:proc_wait}
+
+\subsection{Le funzioni \texttt{exec}}
+\label{sec:proc_exec}
+
+
+
+
+
+
+\section{Il controllo di accesso}
+\label{sec:process_perms}
+
+Va messo qui tutta la storia su effective, real, saved uid, e pure le cose di
+linux come il filesystem uid.
+
+
+\subsection{Le funzioni \texttt{setuid} e \texttt{setgid}}
+\label{sec:proc_setuid}
+
+
+\subsection{Le funzioni \texttt{seteuid} e \texttt{setegid}}
+\label{sec:proc_setuid}
+
+
+