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{Una panoramica sui concetti base}
  15 \label{sec:prochand_gen}
  16
  17 Una delle caratteristiche essenziali di unix (che esamineremo in dettaglio più
  18 avanti) è che ogni processo può a sua volta generare altri processi figli
  19 (\textit{child}): questo è ad esempio quello che fa la shell quando mette in
  20 esecuzione il programma che gli indichiamo nella linea di comando.
  21
  22 Una seconda caratteristica è che ogni processo viene sempre generato in tale
  23 modo da un processo genitore (\textit{parent}) attraverso una apposita system
  24 call. Questo vale per tutti i processi, tranne per un processo speciale, che
  25 normalmente è \texttt{/sbin/init}, che invece viene lanciato dal kernel finita
  26 la fase di avvio e che quindi non è figlio di nessuno.
  27
  28 Tutto ciò significa che, come per i file su disco, i processi sono organizzati
  29 gerarchicamente dalla relazione fra genitori e figli; alla base dell'albero in
  30 questo caso c'è init che è progenitore di ogni altro processo.
  31
  32
  33 \section{Gli identificatori dei processi}
  34 \label{sec:prochand_id}
  35
  36 Ogni processo viene identificato dal sistema da un numero identificativo
  37 unico, il \textit{process id} o \textit{pid}. Questo viene assegnato in forma
  38 progressiva ogni volta che un nuovo processo viene creato, fino ad un limite
  39 massimo (in genere essendo detto numero memorizzato in un intero a 16 bit si
  40 arriva a 32767) oltre il quale si riparte dal numero più basso disponibile
  41 (FIXME: verificare, non sono sicuro).  Per questo motivo processo il processo
  42 di avvio (init) ha sempre il pid uguale a uno.
  43
  44 Ogni processo è identificato univocamente dal sistema per il suo
  45 pid; quest'ultimo è un apposito tipo di dato, il \texttt{pid\_t} che in
  46 genere è un intero con segno (nel caso di Linux e delle glibc il tipo usato è
  47 \texttt{int}.
  48
  49 Tutti i processi inoltre portano traccia del pid del genitore, chiamato in
  50 genere \textit{ppid} (da \textit{Parente Process Id}). Questi identificativi
  51 possono essere ottenuti da un programma usando le funzioni:
  52 \begin{functions}
  53 \headdecl{sys/types.h}
  54 \headdecl{unistd.h}
  55 \funcdecl{pid\_t getpid(void)} restituisce il pid del processo corrente.
  56 \funcdecl{pid\_t getppid(void)} restituisce il pid del padre del processo
  57     corrente.
  58 \end{functions}
  59
  60
  61 \section{Il controllo dei processi}
  62 \label{sec:prochand_control}
  63
  64 Esamineremo in questa sezione le varie funzioni per il controllo dei processi:
  65 la loro creazione, la terminazione, l'esecuzione di altri programmi. Prima di
  66 trattare in dettaglio le singole funzioni, faremo un'introduzione generale ai
  67 concetti che stanno alla base della gestione dei processi in unix.
  68
  69 \subsection{Una panoramica}
  70 \label{sec:prochand_control_overview}
  71
  72 I processi vengono creati dalla funzione \texttt{fork}; in genere questa è una
  73 system call, ma Linux però usa un'altra nomenclatura, e la funzione fork è
  74 basata a sua volta sulla system call \texttt{clone}, che viene usata anche per
  75 generare i \textit{thread}.  Il processo figlio creato dalla \textit{fork} è
  76 una copia identica del processo processo padre, solo che ha un suo pid
  77 proprio.
  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 fork chiamando la
  81 funzione \texttt{wait} o la funzione \texttt{waitpid}, che restituiscono anche
  82 una informazione abbastanza limitata (il codice di uscita) sulle cause della
  83 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 \texttt{exit} (si veda
  87 quanto discusso in \secref{sec:proc_termination}). La vita del processo
  88 però termina solo quando viene chiamata la quando la sua conclusione viene
  89 ricevuta dal processo padre, a quel punto tutte le risorse allocate nel
  90 sistema ad esso 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 di
  94 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 questo si usa la seconda funzione fondamentale per programmazione coi processi
  97 che è la \texttt{exec}.
  98
  99 Il programma che un processo sta eseguendo si chiama immagine del processo
 100 (\textit{process image}), le funzioni della famiglia \func{exec} permettono
 101 di caricare un'altro programma da disco sostituendo quest'ultimo alla process
 102 image corrente, questo fa si che la precedente immagine venga completamente
 103 cancellata e quando il nuovo programma esce anche il processo termina, senza
 104 ritornare 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 \subsection{La funzione \func{fork}}
 113 \label{sec:prochand_fork}
 114
 115 La funzione \func{fork}
 116
 117
 118 Dopo l'esecuzione di una fork sia il processo padre che il processo figlio
 119 continuano ad essere eseguiti normalmente, ed il processo figlio esegue
 120 esattamente lo stesso codice del padre. La sola differenza è che nel processo
 121 padre il valore di ritorno della funzione fork è il pid del processo figlio,
 122 mentre nel figlio è zero; in questo modo il programma può identificare se
 123 viene eseguito dal padre o dal figlio.
 124
 125
 126
 127
 128 \subsection{Le funzioni \texttt{wait} e  \texttt{waitpid}}
 129 \label{sec:prochand_wait}
 130
 131 \subsection{Le funzioni \texttt{exec}}
 132 \label{sec:prochand_exec}
 133
 134
 135
 136
 137 \section{Il controllo di accesso}
 138 \label{sec:prochand_perms}
 139
 140 Va messo qui tutta la storia su effective, real, saved uid, e pure le cose di
 141 Linux come il filesystem uid.
 142
 143 \subsection{Le funzioni \texttt{setuid} e \texttt{setgid}}
 144 \label{sec:prochand_setuid}
 145
 146
 147 \subsection{Le funzioni \texttt{seteuid} e \texttt{setegid}}
 148 \label{sec:prochand_seteuid}
 149