\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:prochand_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:prochand_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{functions}
\incldecl{sys/types.h}
\incldecl{unistd.h}
\funcdecl{pid\_t getpid(void)} restituisce il pid del processo corrente.
\funcdecl{pid\_t getppid(void)} restituisce il pid del padre del processo
    corrente.
\end{}


\section{Il controllo dei processi}
\label{sec:prochand_control}

Esamineremo in questa sezione le varie funzioni per il controllo dei processi:
la loro creazione, la terminazione, l'esecuzione di altri programmi. Prima di
trattare in dettaglio le singole funzioni, faremo un'introduzione generale ai
concetti che stanno alla base della gestione dei processi in unix.

\subsection{Una panoramica}
\label{sec:prochand_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} (si veda
quanto discusso in \secref{sec:proc_termination}). 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, normalmente si genera un secondo processo per affidargli 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 \func{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 \func{fork} e la \func{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 \func{fork}}
\label{sec:prochand_fork}

La funzione \func{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:prochand_wait}

\subsection{Le funzioni \texttt{exec}}
\label{sec:prochand_exec}


\section{Il controllo di accesso}
\label{sec:prochand_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:prochand_setuid}


\subsection{Le funzioni \texttt{seteuid} e \texttt{setegid}}
\label{sec:prochand_setuid}

