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{itemize}
  53   \item \texttt{pid\_t getpid(void)} restituisce il pid del processo corrente.
  54
  55   \item \texttt{pid\_t getppid(void)} restituisce il pid del padre del processo
  56     corrente.
  57
  58 \end{itemize}
  59 (per l'accesso a queste funzioni e ai relativi tipi di dati occorre includere
  60 gli header files \texttt{unistd.h} e \texttt{sys/types.h}).
  61
  62
  63
  64 \section{Il controllo dei processi}
  65 \label{sec:prochand_control}
  66
  67 Esamineremo in questa sezione le varie funzioni per il controllo dei processi:
  68 la lore creazione, la terminazione, l'esecuzione di altri programmi. Prima di
  69 trattare in dettaglio le singole funzioni, faremo un'introduzione generale ai
  70 contetti che stanno alla base della gestione dei processi in unix.
  71
  72 \subsection{Una panoramica}
  73 \label{sec:prochand_control_overview}
  74
  75 I processi vengono creati dalla funzione \texttt{fork}; in genere questa è una
  76 system call, ma linux però usa un'altra nomenclatura, e la funzione fork è
  77 basata a sua volta sulla system call \texttt{clone}, che viene usata anche per
  78 generare i \textit{thread}.  Il processo figlio creato dalla \textit{fork} è
  79 una copia identica del processo processo padre, solo che ha un suo pid
  80 proprio.
  81
  82 Se si vuole che il processo padre si fermi fino alla conclusione del processo
  83 figlio questo deve essere specificato subito dopo la fork chiamando la
  84 funzione \texttt{wait} o la funzione \texttt{waitpid}, che restituiscono anche
  85 una informazione abbastanza limitata (il codice di uscita) sulle cause della
  86 terminazione del processo.
  87
  88 Quando un processo ha concluso il suo compito o ha incontrato un errore non
  89 risolvibile esso può essere terminato con la funzione \texttt{exit} (la
  90 questione è più complessa ma ci torneremo più avanti). La vita del processo
  91 però termina solo quando viene chiamata la quando la sua conclusione viene
  92 ricevuta dal processo padre, a quel punto tutte le risorse allocate nel
  93 sistema ad esso associate vengono rilasciate.
  94
  95 Avere due processi che eseguono esattamente lo stesso codice non è molto
  96 utile, mormalmente si genera un secondo processo per affidagli l'esecuzione di
  97 un compito specifico (ad esempio gestire una connessione dopo che questa è
  98 stata stabilita), o fargli eseguire (come fa la shell) un altro programma. Per
  99 questo si usa la seconda funzione fondamentale per programmazione coi processi
 100 che è la \texttt{exec}.
 101
 102 Il programma che un processo sta eseguendo si chiama immagine del processo
 103 (\textit{process image}), le funzioni della famiglia \textit{exec} permettono
 104 di caricare un'altro programma da disco sostituendo quest'ultimo alla process
 105 image corrente, questo fa si che la precedente immagine venga completamente
 106 cancellata e quando il nuovo programma esce anche il processo termina, senza
 107 ritornare alla precedente immagine.
 108
 109 Per questo motivo la \texttt{fork} e la \texttt{exec} sono funzioni molto
 110 particolari con caratteristiche uniche rispetto a tutte le altre, infatti la
 111 prima ritorna due volte (nel processo padre e nel figlio) mentre la seconda
 112 non ritorna mai (in quanto con essa viene eseguito un altro programma).
 113
 114
 115 \subsection{La funzione \texttt{fork}}
 116 \label{sec:prochand_fork}
 117
 118
 119 Dopo l'esecuzione di una fork sia il processo padre che il processo figlio
 120 continuano ad essere eseguiti normalmente, ed il processo figlio esegue
 121 esattamente lo stesso codice del padre. La sola differenza è che nel processo
 122 padre il valore di ritorno della funzione fork è il pid del processo figlio,
 123 mentre nel figlio è zero; in questo modo il programma può identificare se
 124 viene eseguito dal padre o dal figlio.
 125
 126
 127
 128
 129 \subsection{Le funzioni \texttt{wait} e  \texttt{waitpid}}
 130 \label{sec:prochand_wait}
 131
 132 \subsection{Le funzioni \texttt{exec}}
 133 \label{sec:prochand_exec}
 134
 135
 136 \section{Il controllo di accesso}
 137 \label{sec:prochand_perms}
 138
 139 Va messo qui tutta la storia su effective, real, saved uid, e pure le cose di
 140 linux come il filesystem uid.
 141
 142 \subsection{Le funzioni \texttt{setuid} e \texttt{setgid}}
 143 \label{sec:prochand_setuid}
 144
 145
 146 \subsection{Le funzioni \texttt{seteuid} e \texttt{setegid}}
 147 \label{sec:prochand_setuid}
 148