prochand.tex

   1 \chapter{La gestione dei processi}
   2 \label{cha:process_handling}
   3
   4 Come accennato nell'introduzione in un sistema unix ogni attività del sistema
   5 viene svolta tramite i processi.  In sostanza i processi costituiscono l'unità
   6 base per l'allocazione e l'uso delle risorse del sistema.
   7
   8 Nel precedente capitolo abbiamo visto come funziona un singolo processo, in
   9 questo capitolo affronteremo i dettagli della creazione e della distruzione
  10 dei processi, della gestione dei loro attributi e privilegi, e di tutte le
  11 funzioni a questo connesse.
  12
  13
  14 \section{Introduzione}
  15 \label{sec:proc_gen}
  16
  17 Partiremo con una introduzione generale ai concetti che stanno alla base della
  18 gestione dei processi in unix. Introdurremo in questa sezione l'architettura
  19 della gestione dei processi e le sue principali caratteristiche, e daremo una
  20 panoramica sull'uso delle principali funzioni per la gestione dei processi.
  21
  22 \subsection{La gerarchia dei processi}
  23 \label{sec:proc_hierarchy}
  24
  25 A differenza di quanto avviene in altri sistemi (ad esempio nel VMS la
  26 generazione di nuovi processi è un'operazione privilegiata) una delle
  27 caratteristiche di unix (che esamineremo in dettaglio più avanti) è che
  28 qualunque processo può a sua volta generarne altri, detti processi figli
  29 (\textit{child process}). Ogni processo è identificato presso il sistema da un
  30 numero unico, il \acr{pid} (da \textit{process identifier}).
  31
  32 Una seconda caratteristica è che la generazione di un processo è una
  33 operazione separata rispetto al lancio di un programma. In genere la sequenza
  34 è sempre quella di creare un nuovo processo, il quale si eseguirà, in un passo
  35 successivo, il programma voluto: questo è ad esempio quello che fa la shell
  36 quando mette in esecuzione il programma che gli indichiamo nella linea di
  37 comando.
  38
  39 Una terza caratteristica è che ogni processo viene sempre generato da un altro
  40 che viene chiamato processo genitore (\textit{parent process}). Questo vale
  41 per tutti i processi, con una eccezione (dato che ci deve essere un punto di
  42 partenza), esiste sempre infatti un processo speciale, che normalmente è
  43 \cmd{/sbin/init}, che viene lanciato dal kernel quando questo ha finito la
  44 fase di avvio, esso essendo il primo processo lanciato ha sempre il \acr{pid}
  45 uguale a 1 e non è figlio di nessuno.
  46
  47 Questo è ovviamente un processo speciale, che in genere si occupa di far
  48 partire tutti gli processi altri necessari al funzionamento del sistema,
  49 inoltre \cmd{init} è essenziale per svolgere una serie di compiti
  50 amministrativi nelle operazioni ordinarie del sistema (torneremo si alcuni di
  51 essi in \secref{}) e non può mai essere terminato. La struttura del sistema
  52 comunque consente di lanciare al posto di \cmd{init} qualunque altro programma
  53 (e in casi di emergenza, ad esempio se il file di \cmd{init} si fosse
  54 corrotto, è possibile farlo ad esempio passando la riga \cmd{init=/bin/sh}
  55 all'avvio).
  56
  57
  58 Dato che tutti i processi successivi sono comunque generati da \cmd{init} o da
  59 suoi figli tutto ciò comporta che, i processi sono organizzati gerarchicamente
  60 dalla relazione fra genitori e figli, in maniera analoga a come i file sono
  61 organizzati in un albero di directory con alla base \file{/} (si veda
  62 \secref{sec:file_file_struct}); in questo caso alla base dell'albero c'è il
  63 processo \cmd{init} che è progenitore di ogni altro processo\footnote{in
  64   realtà questo non è del tutto vero, in Linux ci sono alcuni processi che pur
  65   comparendo come figli di init (ad esempio in \cmd{pstree}) sono generati
  66   direttamente dal kernel, come \cmd{keventd}, \cmd{kswapd}, etc.}.
  67
  68
  69 \subsection{Una panoramica sulle funzioni di gestione}
  70 \label{sec:proc_handling_intro}
  71
  72 I processi vengono creati dalla funzione \func{fork}; in molti unix questa è
  73 una system call, Linux però usa un'altra nomenclatura, e la funzione fork è
  74 basata a sua volta sulla system call \func{clone}, che viene usata anche per
  75 generare i \textit{thread}.  Il processo figlio creato dalla \func{fork} è una
  76 copia identica del processo processo padre, ma ha nuovo \acr{pid} e viene
  77 eseguito in maniera indipendente (le differenze fra padre e figlio sono
  78 affrontate in dettaglio in \secref{sec:proc_fork}).
  79
  80 Se si vuole che il processo padre si fermi fino alla conclusione del processo
  81 figlio questo deve essere specificato subito dopo la \func{fork} chiamando la
  82 funzione \func{wait} o la funzione \func{waitpid}; queste funzioni
  83 restituiscono anche una informazione abbastanza limitata (il codice di uscita)
  84 sulle cause della terminazione del processo.
  85
  86 Quando un processo ha concluso il suo compito o ha incontrato un errore non
  87 risolvibile esso può essere terminato con la funzione \func{exit} (si veda
  88 quanto discusso in \secref{sec:proc_termination}). La vita del processo però
  89 termina solo quando la notifica della sua conclusione viene ricevuta dal
  90 processo padre, a quel punto tutte le risorse allocate nel sistema ad esso
  91 associate vengono rilasciate.
  92
  93 Avere due processi che eseguono esattamente lo stesso codice non è molto
  94 utile, normalmente si genera un secondo processo per affidargli l'esecuzione
  95 di un compito specifico (ad esempio gestire una connessione dopo che questa è
  96 stata stabilita), o fargli eseguire (come fa la shell) un altro programma. Per
  97 quest'ultimo caso si usa la seconda funzione fondamentale per programmazione
  98 coi processi che è la \func{exec}.
  99
 100 Il programma che un processo sta eseguendo si chiama immagine del processo (o
 101 \textit{process image}), le funzioni della famiglia \func{exec} permettono di
 102 caricare un'altro programma da disco sostituendo quest'ultimo all'immagine
 103 corrente; questo fa si che l'immagine precedente venga completamente
 104 cancellata. Questo significa che quando il nuovo programma esce anche il
 105 processo termina, e non si può tornare alla precedente immagine.
 106
 107 Per questo motivo la \func{fork} e la \func{exec} sono funzioni molto
 108 particolari con caratteristiche uniche rispetto a tutte le altre, infatti la
 109 prima ritorna due volte (nel processo padre e nel figlio) mentre la seconda
 110 non ritorna mai (in quanto con essa viene eseguito un altro programma).
 111
 112
 113 \section{Il controllo dei processi}
 114 \label{sec:proc_control}
 115
 116 Esamineremo in questa sezione le varie funzioni per il controllo dei processi:
 117 la loro creazione, la terminazione, l'esecuzione di altri programmi. Prima di
 118 trattare in dettaglio le singole funzioni,
 119
 120 \subsection{Gli identificatori dei processi}
 121 \label{sec:proc_id}
 122
 123 Come accennato ogni processo viene identificato dal sistema da un numero
 124 identificativo unico, il \textit{process id} o \acr{pid}. Questo viene
 125 assegnato in forma progressiva ogni volta che un nuovo processo viene creato,
 126 fino ad un limite massimo (in genere essendo detto numero memorizzato in un
 127 intero a 16 bit si arriva a 32767) oltre il quale si riparte dal numero più
 128 basso disponibile (FIXME: verificare, non sono sicuro).  Per questo motivo
 129 processo il processo di avvio (init) ha sempre il pid uguale a uno.
 130
 131 Ogni processo è identificato univocamente dal sistema per il suo pid;
 132 quest'ultimo è un tipo di dato standard, il \texttt{pid\_t} che in genere è un
 133 intero con segno (nel caso di Linux e delle glibc il tipo usato è
 134 \texttt{int}).
 135
 136 Tutti i processi inoltre portano traccia del pid del genitore, chiamato in
 137 genere \textit{ppid} (da \textit{Parente Process Id}). Questi identificativi
 138 possono essere ottenuti da un programma usando le funzioni:
 139 \begin{functions}
 140 \headdecl{sys/types.h}
 141 \headdecl{unistd.h}
 142 \funcdecl{pid\_t getpid(void)} restituisce il pid del processo corrente.
 143 \funcdecl{pid\_t getppid(void)} restituisce il pid del padre del processo
 144     corrente.
 145 \end{functions}
 146
 147
 148
 149 \subsection{La funzione \func{fork}}
 150 \label{sec:proc_fork}
 151
 152 La funzione \func{fork}
 153
 154
 155 Dopo l'esecuzione di una fork sia il processo padre che il processo figlio
 156 continuano ad essere eseguiti normalmente, ed il processo figlio esegue
 157 esattamente lo stesso codice del padre. La sola differenza è che nel processo
 158 padre il valore di ritorno della funzione fork è il pid del processo figlio,
 159 mentre nel figlio è zero; in questo modo il programma può identificare se
 160 viene eseguito dal padre o dal figlio.
 161
 162
 163
 164
 165 \subsection{Le funzioni \texttt{wait} e  \texttt{waitpid}}
 166 \label{sec:proc_wait}
 167
 168 \subsection{Le funzioni \texttt{exec}}
 169 \label{sec:proc_exec}
 170
 171
 172
 173
 174 \section{Il controllo di accesso}
 175 \label{sec:proc_perms}
 176
 177 Va messo qui tutta la storia su effective, real, saved uid, e pure le cose di
 178 Linux come il filesystem uid.
 179
 180 \subsection{Le funzioni \texttt{setuid} e \texttt{setgid}}
 181 \label{sec:proc_setuid}
 182
 183
 184 \subsection{Le funzioni \texttt{seteuid} e \texttt{setegid}}
 185 \label{sec:proc_seteuid}
 186