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 Dato che tutti i processi successivi sono comunque generati da \cmd{init} o da
  58 suoi figli tutto ciò comporta che, i processi sono organizzati gerarchicamente
  59 dalla relazione fra genitori e figli, in maniera analoga a come i file sono
  60 organizzati in un albero di directory con alla base \file{/} (si veda
  61 \secref{sec:file_file_struct}); in questo caso alla base dell'albero c'è il
  62 processo \cmd{init} che è progenitore di ogni altro processo\footnote{in
  63   realtà questo non è del tutto vero, in Linux ci sono alcuni processi che pur
  64   comparendo come figli di init (ad esempio in \cmd{pstree}) sono generati
  65   direttamente dal kernel, come \cmd{keventd}, \cmd{kswapd}, etc.}.
  66
  67
  68 \subsection{Una panoramica sulle funzioni di gestione}
  69 \label{sec:proc_handling_intro}
  70
  71 I processi vengono creati dalla funzione \func{fork}; in molti unix questa è
  72 una system call, Linux però usa un'altra nomenclatura, e la funzione fork è
  73 basata a sua volta sulla system call \func{clone}, che viene usata anche per
  74 generare i \textit{thread}.  Il processo figlio creato dalla \func{fork} è una
  75 copia identica del processo processo padre, ma ha nuovo \acr{pid} e viene
  76 eseguito in maniera indipendente (le differenze fra padre e figlio sono
  77 affrontate in dettaglio in \secref{sec:proc_fork}).
  78
  79 Se si vuole che il processo padre si fermi fino alla conclusione del processo
  80 figlio questo deve essere specificato subito dopo la \func{fork} chiamando la
  81 funzione \func{wait} o la funzione \func{waitpid}; queste funzioni
  82 restituiscono anche una informazione abbastanza limitata (il codice di uscita)
  83 sulle cause della terminazione del processo.
  84
  85 Quando un processo ha concluso il suo compito o ha incontrato un errore non
  86 risolvibile esso può essere terminato con la funzione \func{exit} (si veda
  87 quanto discusso in \secref{sec:proc_termination}). La vita del processo però
  88 termina solo quando la notifica della sua conclusione viene ricevuta dal
  89 processo padre, a quel punto tutte le risorse allocate nel sistema ad esso
  90 associate vengono rilasciate.
  91
  92 Avere due processi che eseguono esattamente lo stesso codice non è molto
  93 utile, normalmente si genera un secondo processo per affidargli l'esecuzione
  94 di un compito specifico (ad esempio gestire una connessione dopo che questa è
  95 stata stabilita), o fargli eseguire (come fa la shell) un altro programma. Per
  96 quest'ultimo caso si usa la seconda funzione fondamentale per programmazione
  97 coi processi che è la \func{exec}.
  98
  99 Il programma che un processo sta eseguendo si chiama immagine del processo (o
 100 \textit{process image}), le funzioni della famiglia \func{exec} permettono di
 101 caricare un'altro programma da disco sostituendo quest'ultimo all'immagine
 102 corrente; questo fa si che l'immagine precedente venga completamente
 103 cancellata. Questo significa che quando il nuovo programma esce anche il
 104 processo termina, e non si può tornare alla precedente immagine.
 105
 106 Per questo motivo la \func{fork} e la \func{exec} sono funzioni molto
 107 particolari con caratteristiche uniche rispetto a tutte le altre, infatti la
 108 prima ritorna due volte (nel processo padre e nel figlio) mentre la seconda
 109 non ritorna mai (in quanto con essa viene eseguito un altro programma).
 110
 111
 112
 113 \section{La gestione dei processi}
 114 \label{sec:proc_handling}
 115
 116 In questa sezione tratteremo le funzioni per la gestione dei processi, a
 117 partire dalle funzioni elementari che permettono di leggerne gli
 118 identificatori, alle varie funzioni di manipolazione dei processi, che
 119 riguardano la lore creazione, terminazione, e la messa in esecuzione di altri
 120 programmi.
 121
 122
 123 \subsection{Gli identificatori dei processi}
 124 \label{sec:proc_pid}
 125
 126 Come accennato nell'introduzione ogni processo viene identificato dal sistema
 127 da un numero identificativo unico, il \textit{process id} o \acr{pid};
 128 quest'ultimo è un tipo di dato standard, il \type{pid\_t} che in genere è un
 129 intero con segno (nel caso di Linux e delle glibc il tipo usato è \type{int}).
 130
 131 Il \acr{pid} viene assegnato in forma progressiva ogni volta che un nuovo
 132 processo viene creato, fino ad un limite massimo (in genere essendo detto
 133 numero memorizzato in un intero a 16 bit si arriva a 32767) oltre il quale si
 134 riparte dal numero più basso disponibile (FIXME: verificare, non sono sicuro).
 135 Per questo motivo processo il processo di avvio (\cmd{init}) ha sempre il
 136 \acr{pid} uguale a uno.
 137
 138 Tutti i processi inoltre memorizzano anche il \acr{pid} del genitore da cui
 139 sono stati creati, questo viene chiamato in genere \acr{ppid} (da
 140 \textit{parent process id}) ed è normalmente utilizzato per il controllo di
 141 sessione.  Questi due identificativi possono essere ottenuti da programma
 142 usando le funzioni:
 143 \begin{functions}
 144 \headdecl{sys/types.h}
 145 \headdecl{unistd.h}
 146 \funcdecl{pid\_t getpid(void)} restituisce il pid del processo corrente.
 147 \funcdecl{pid\_t getppid(void)} restituisce il pid del padre del processo
 148     corrente.
 149
 150 Entrambe le funzioni non riportano condizioni di errore.
 151 \end{functions}
 152
 153
 154
 155
 156 \subsection{Utente e gruppo di un processo}
 157 \label{sec:proc_user_group}
 158
 159
 160
 161 Come accennato in \secref{sec:file_perm_overview} ciascun processo porta con
 162 se un gruppo di identificatori (riportati in \ntab) che indicano l'utente che
 163 lo ha posto in esecuzione, e sono usati per il controllo di accesso.
 164
 165 \begin{table}[htb]
 166   \centering
 167   \begin{tabular}[c]{|c|l|l|}
 168     \hline
 169     Sigla & Significato & Utilizzo \\
 170     \hline
 171     \hline
 172     \acr{ruid} & \textit{real user id} & indica l'utente reale che ha lanciato
 173     il programma\\
 174     \acr{rgid} & \textit{real group id} & indica il gruppo reale dell'utente
 175     che ha lanciato il programma \\
 176     \acr{euid} & \textit{effective user id} & indica l'utente effettivo usato
 177     dal programma \\
 178     \acr{egid} & \textit{effective group id} & indica il gruppo effettivo usato
 179     dal programma \\
 180                & \textit{supplementary group id} & indica i gruppi cui
 181     l'utente appartiene  \\
 182     \acr{suid} & \textit{saved user id} & indica l'utente  \\
 183     \acr{sgid} & \textit{daved group id} & indica il gruppo  \\
 184     \acr{fsuid} & \textit{filesystem user id} & indica l'utente effettivo per
 185     il filesystem \\
 186     \acr{fsgid} & \textit{filesystem group id} & indica il gruppo effettivo
 187     per il filesystem  \\
 188     \hline
 189   \end{tabular}
 190   \caption{Identificatori di utente e gruppo associati a ciascun processo.}
 191   \label{tab:proc_uid_gid}
 192 \end{table}
 193
 194
 195 <<<<<<< prochand.tex
 196 =======
 197 Il fatto che il \acr{pid} sia un numero univoco per il sistema lo rende il
 198 candidato ideale per generare ultieriori indicatori associati al processo di
 199 cui diventa possibile garantire l'unicità: ad esempio la funzione
 200 \func{tmpname} (si veda \secref{sec:file_temp_file}) usa il \acr{pid} per
 201 generare un pathname univoco, che non potrà essere replicato da un'altro
 202 processo che usi la stessa funzione.
 203 >>>>>>> 1.12
 204
 205
 206 <<<<<<< prochand.tex
 207
 208 =======
 209 >>>>>>> 1.12
 210 \subsection{La funzione \func{fork}}
 211 \label{sec:proc_fork}
 212
 213 La funzione \func{fork} è la funzione fondamentale della gestione dei processi
 214 in unix; come si è detto l'unico modo di creare un nuovo processo è attraverso
 215 l'uso di questa funzione, che è quindi la base per il multitasking; il protipo
 216 della funzione è:
 217
 218 \begin{functions}
 219   \headdecl{sys/types.h}
 220   \headdecl{unistd.h}
 221
 222   \funcdecl{pid\_t fork(void)}
 223
 224   Le funzioni restituiscono zero in caso di successo e -1 per un errore, in
 225   caso di errore \texttt{errno} può assumere i valori:
 226   \begin{errlist}
 227   \item \macro{EAGAIN}
 228   \item \macro{ENOMEM}
 229   \end{errlist}
 230 \end{functions}
 231
 232
 233 Dopo l'esecuzione di una fork sia il processo padre che il processo figlio
 234 continuano ad essere eseguiti normalmente, ed il processo figlio esegue
 235 esattamente lo stesso codice del padre. La sola differenza è che nel processo
 236 padre il valore di ritorno della funzione fork è il pid del processo figlio,
 237 mentre nel figlio è zero; in questo modo il programma può identificare se
 238 viene eseguito dal padre o dal figlio.
 239
 240
 241
 242
 243 \subsection{Le funzioni \texttt{wait} e  \texttt{waitpid}}
 244 \label{sec:proc_wait}
 245
 246 \subsection{Le funzioni \texttt{exec}}
 247 \label{sec:proc_exec}
 248
 249
 250
 251
 252 \section{Il controllo di accesso}
 253 \label{sec:proc_perms}
 254
 255
 256
 257
 258
 259 Come accennato in \secref{sec:file_perm_overview} ciascun processo porta con
 260 se un gruppo di identificatori (riportati in \ntab) utilizzati per i controllo
 261 degli accessi,
 262
 263
 264 \begin{table}[htb]
 265   \centering
 266   \begin{tabular}[c]{|c|l|l|}
 267     \hline
 268     Sigla & Significato & Utilizzo \\
 269     \hline
 270     \hline
 271     \acr{ruid} & \textit{real user id} & indica l'utente reale \\
 272     \acr{rgid} & \textit{real group id} & indica il gruppo reale \\
 273     \acr{euid} & \textit{effective user id} & indica l'utente reale \\
 274     \acr{egid} & \textit{effective group id} & indica il gruppo reale \\
 275                & \textit{supplementaru group id} & indica il gruppo  \\
 276     \acr{suid} & \textit{saved user id} & indica l'utente reale \\
 277     \acr{sgid} & \textit{daved group id} & indica il gruppo reale \\
 278     \acr{fsuid} & \textit{real user id} & indica l'utente reale \\
 279     \acr{fsgid} & \textit{real group id} & indica il gruppo reale \\
 280     \hline
 281   \end{tabular}
 282   \caption{Identificatori di utente e gruppo associati a ciascun processo.}
 283   \label{tab:proc_uid_gid}
 284 \end{table}
 285
 286
 287 \subsection{Le funzioni \texttt{setuid} e \texttt{setgid}}
 288 \label{sec:proc_setuid}
 289
 290
 291 \subsection{Le funzioni \texttt{seteuid} e \texttt{setegid}}
 292 \label{sec:proc_seteuid}
 293