1dddba1edf3092f2fd1ee7b33b1e0dd1b4de49b4
[gapil.git] / 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 Il fatto che il \acr{pid} sia un numero univoco per il sistema lo rende il
154 candidato ideale per generare ultieriori indicatori associati al processo di
155 cui diventa possibile garantire l'unicità: ad esempio la funzione
156 \func{tmpname} (si veda \secref{sec:file_temp_file}) usa il \acr{pid} per
157 generare un pathname univoco, che non potrà essere replicato da un'altro
158 processo che usi la stessa funzione. 
159
160
161 \subsection{Utente e gruppo di un processo}
162 \label{sec:proc_user_group}
163
164 Come accennato in \secref{sec:intro_multiuser} ad ogni utente ed gruppo sono
165 associati due identificatori univoci, lo \acr{uid} e il \acr{gid} che li
166 contraddistinguono nei confonti del kernel. Questi identificatori stanno alla
167 base del sistema di permessi e protezioni di un sistema unix.
168
169  a ciascun
170 processo venfon
171
172
173 Come accennato in \secref{sec:file_perm_overview} a processo viene associato
174 un certo numero di identificatori (riportati in \ntab) che vengono usati sia
175 per il controllo di accesso ai file che per la gestione dei privilegi
176 associati ai processi stessi.
177
178
179 \begin{table}[htb]
180   \centering
181   \begin{tabular}[c]{|c|l|l|}
182     \hline
183     Sigla & Significato & Utilizzo \\ 
184     \hline
185     \hline
186     \acr{ruid} & \textit{real user id} & indica l'utente reale che ha lanciato
187     il programma\\ 
188     \acr{rgid} & \textit{real group id} & indica il gruppo reale dell'utente 
189     che ha lanciato il programma \\ 
190     \acr{euid} & \textit{effective user id} & indica l'utente effettivo usato
191     dal programma \\ 
192     \acr{egid} & \textit{effective group id} & indica il gruppo effettivo usato
193     dal programma \\ 
194                & \textit{supplementary group id} & indica i gruppi cui
195     l'utente appartiene  \\ 
196     \acr{suid} & \textit{saved user id} & indica l'utente  \\ 
197     \acr{sgid} & \textit{daved group id} & indica il gruppo  \\ 
198     \acr{fsuid} & \textit{filesystem user id} & indica l'utente effettivo per
199     il filesystem \\ 
200     \acr{fsgid} & \textit{filesystem group id} & indica il gruppo effettivo
201     per il filesystem  \\ 
202     \hline
203   \end{tabular}
204   \caption{Identificatori di utente e gruppo associati a ciascun processo.}
205   \label{tab:proc_uid_gid}
206 \end{table}
207
208
209
210
211
212 \subsection{La funzione \func{fork}}
213 \label{sec:proc_fork}
214
215 La funzione \func{fork} è la funzione fondamentale della gestione dei processi
216 in unix; come si è detto l'unico modo di creare un nuovo processo è attraverso
217 l'uso di questa funzione, che è quindi la base per il multitasking; il protipo
218 della funzione è:
219
220 \begin{functions}
221   \headdecl{sys/types.h} 
222   \headdecl{unistd.h} 
223   
224   \funcdecl{pid\_t fork(void)} 
225
226   Le funzioni restituiscono zero in caso di successo e -1 per un errore, in
227   caso di errore \texttt{errno} può assumere i valori:
228   \begin{errlist}
229   \item \macro{EAGAIN}
230   \item \macro{ENOMEM}
231   \end{errlist}
232 \end{functions}
233
234
235 Dopo l'esecuzione di una fork sia il processo padre che il processo figlio
236 continuano ad essere eseguiti normalmente, ed il processo figlio esegue
237 esattamente lo stesso codice del padre. La sola differenza è che nel processo
238 padre il valore di ritorno della funzione fork è il pid del processo figlio,
239 mentre nel figlio è zero; in questo modo il programma può identificare se
240 viene eseguito dal padre o dal figlio. 
241
242
243
244
245 \subsection{Le funzioni \texttt{wait} e  \texttt{waitpid}}
246 \label{sec:proc_wait}
247
248 \subsection{Le funzioni \texttt{exec}}
249 \label{sec:proc_exec}
250
251
252
253
254 \section{Il controllo di accesso}
255 \label{sec:proc_perms}
256
257
258
259
260
261 Come accennato in \secref{sec:file_perm_overview} ciascun processo porta con
262 se un gruppo di identificatori (riportati in \ntab) utilizzati per i controllo
263 degli accessi, 
264
265
266 \begin{table}[htb]
267   \centering
268   \begin{tabular}[c]{|c|l|l|}
269     \hline
270     Sigla & Significato & Utilizzo \\ 
271     \hline
272     \hline
273     \acr{ruid} & \textit{real user id} & indica l'utente reale \\ 
274     \acr{rgid} & \textit{real group id} & indica il gruppo reale \\ 
275     \acr{euid} & \textit{effective user id} & indica l'utente reale \\ 
276     \acr{egid} & \textit{effective group id} & indica il gruppo reale \\ 
277                & \textit{supplementaru group id} & indica il gruppo  \\ 
278     \acr{suid} & \textit{saved user id} & indica l'utente reale \\ 
279     \acr{sgid} & \textit{daved group id} & indica il gruppo reale \\ 
280     \acr{fsuid} & \textit{real user id} & indica l'utente reale \\ 
281     \acr{fsgid} & \textit{real group id} & indica il gruppo reale \\ 
282     \hline
283   \end{tabular}
284   \caption{Identificatori di utente e gruppo associati a ciascun processo.}
285   \label{tab:proc_uid_gid}
286 \end{table}
287
288
289 \subsection{Le funzioni \texttt{setuid} e \texttt{setgid}}
290 \label{sec:proc_setuid}
291
292
293 \subsection{Le funzioni \texttt{seteuid} e \texttt{setegid}}
294 \label{sec:proc_seteuid}
295