--- /dev/null
+\chapter{I processi}
+\label{cha:process}
+
+Come accennato nell'introduzione in un sistema unix ogni attività del sistema
+viene svolta tramite i processi. Questo significa che quando un programma
+viene posto in esecuzione, viene fatto partire un processo che si incarica di
+eseguirne il codice. In sostanza i processi costituiscono l'unità base per
+l'allocazione e l'uso delle risorse del sistema.
+
+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{Una panoramica sui concetti base}
+\label{sec:proc_gen}
+
+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.
+
+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.
+
+I processi vengono creati dalla funzione \texttt{fork}; in genere questa è una
+system call, 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.
+
+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.
+
+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.
+
+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} permette 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 viene eseguito un altro programma).
+
+
+\section{Identificazione}
+\label{sec:proc_id}
+
+Come detto 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 getpid(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{Provilegi e permessi}
+\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.
+
+
+
projects / gapil.git / blobdiff