process.tex

   1 \chapter{I processi}
   2 \label{cha:process}
   3
   4 Come accennato nell'introduzione in un sistema unix ogni attività del sistema
   5 viene svolta tramite i processi. Questo significa che quando un programma
   6 viene posto in esecuzione, viene fatto partire un processo che si incarica di
   7 eseguirne il codice. In sostanza i processi costituiscono l'unità base per
   8 l'allocazione e l'uso delle risorse del sistema.
   9
  10 In questo capitolo affronteremo i dettagli della creazione e della distruzione
  11 dei processi, della gestione dei loro attributi e privilegi, e di tutte le
  12 funzioni a questo connesse.
  13
  14
  15 \section{Una panoramica sui concetti base}
  16 \label{sec:proc_gen}
  17
  18 Una delle caratteristiche essenziali di unix (che esamineremo in dettaglio più
  19 avanti) è che ogni processo può a sua volta generare altri processi figli
  20 (\textit{child}): questo è ad esempio quello che fa la shell quando mette in
  21 esecuzione il programma che gli indichiamo nella linea di comando.
  22
  23 Una seconda caratteristica è che ogni processo viene sempre generato in tale
  24 modo da un processo genitore (\textit{parent}) attraverso una apposita system
  25 call. Questo vale per tutti i processi, tranne per un processo speciale, che
  26 normalmente è \texttt{/sbin/init}, che invece viene lanciato dal kernel finita
  27 la fase di avvio e che quindi non è figlio di nessuno.
  28
  29 Tutto ciò significa che, come per i file su disco, i processi sono organizzati
  30 gerarchicamente dalla relazione fra genitori e figli; alla base dell'albero in
  31 questo caso c'è init che è progenitore di ogni altro processo.
  32
  33
  34 \section{Gli identificatori dei processi}
  35 \label{sec:proc_id}
  36
  37 Ogni processo viene identificato dal sistema da un numero identificativo
  38 unico, il \textit{process id} o \textit{pid}. Questo viene assegnato in forma
  39 progressiva ogni volta che un nuovo processo viene creato, fino ad un limite
  40 massimo (in genere essendo detto numero memorizzato in un intero a 16 bit si
  41 arriva a 32767) oltre il quale si riparte dal numero più basso disponibile
  42 (FIXME: verificare, non sono sicuro).  Per questo motivo processo il processo
  43 di avvio (init) ha sempre il pid uguale a uno.
  44
  45 Ogni processo è identificato univocamente dal sistema per il suo
  46 pid; quest'ultimo è un apposito tipo di dato, il \texttt{pid\_t} che in
  47 genere è un intero con segno (nel caso di Linux e delle glibc il tipo usato è
  48 \texttt{int}.
  49
  50 Tutti i processi inoltre portano traccia del pid del genitore, chiamato in
  51 genere \textit{ppid} (da \textit{Parente Process Id}). Questi identificativi
  52 possono essere ottenuti da un programma usando le funzioni:
  53 \begin{itemize}
  54   \item \texttt{pid\_t getpid(void)} restituisce il pid del processo corrente.
  55
  56   \item \texttt{pid\_t getppid(void)} restituisce il pid del padre del processo
  57     corrente.
  58
  59 \end{itemize}
  60 (per l'accesso a queste funzioni e ai relativi tipi di dati occorre includere
  61 gli header files \texttt{unistd.h} e \texttt{sys/types.h}).
  62
  63
  64
  65 \section{Il controllo dei processi}
  66 \label{sec:proc_control}
  67
  68 Esamineremo in questa sezione le varie funzioni per il controllo dei processi:
  69 la lore creazione, la terminazione, l'esecuzione di altri programmi. Prima di
  70 trattare in dettaglio le singole funzioni, faremo un'introduzione generale ai
  71 contetti che stanno alla base della gestione dei processi in unix.
  72
  73 \subsection{Una panoramica}
  74 \label{sec:proc_control_overview}
  75
  76 I processi vengono creati dalla funzione \texttt{fork}; in genere questa è una
  77 system call, ma linux però usa un'altra nomenclatura, e la funzione fork è
  78 basata a sua volta sulla system call \texttt{clone}, che viene usata anche per
  79 generare i \textit{thread}.  Il processo figlio creato dalla \textit{fork} è
  80 una copia identica del processo processo padre, solo che ha un suo pid
  81 proprio.
  82
  83 Se si vuole che il processo padre si fermi fino alla conclusione del processo
  84 figlio questo deve essere specificato subito dopo la fork chiamando la
  85 funzione \texttt{wait} o la funzione \texttt{waitpid}, che restituiscono anche
  86 una informazione abbastanza limitata (il codice di uscita) sulle cause della
  87 terminazione del processo.
  88
  89 Quando un processo ha concluso il suo compito o ha incontrato un errore non
  90 risolvibile esso può essere terminato con la funzione \texttt{exit} (la
  91 questione è più complessa ma ci torneremo più avanti). La vita del processo
  92 però termina solo quando viene chiamata la quando la sua conclusione viene
  93 ricevuta dal processo padre, a quel punto tutte le risorse allocate nel
  94 sistema ad esso associate vengono rilasciate.
  95
  96 Avere due processi che eseguono esattamente lo stesso codice non è molto
  97 utile, mormalmente si genera un secondo processo per affidagli l'esecuzione di
  98 un compito specifico (ad esempio gestire una connessione dopo che questa è
  99 stata stabilita), o fargli eseguire (come fa la shell) un altro programma. Per
 100 questo si usa la seconda funzione fondamentale per programmazione coi processi
 101 che è la \texttt{exec}.
 102
 103 Il programma che un processo sta eseguendo si chiama immagine del processo
 104 (\textit{process image}), le funzioni della famiglia \textit{exec} permettono
 105 di caricare un'altro programma da disco sostituendo quest'ultimo alla process
 106 image corrente, questo fa si che la precedente immagine venga completamente
 107 cancellata e quando il nuovo programma esce anche il processo termina, senza
 108 ritornare alla precedente immagine.
 109
 110 Per questo motivo la \texttt{fork} e la \texttt{exec} sono funzioni molto
 111 particolari con caratteristiche uniche rispetto a tutte le altre, infatti la
 112 prima ritorna due volte (nel processo padre e nel figlio) mentre la seconda
 113 non ritorna mai (in quanto con essa viene eseguito un altro programma).
 114
 115
 116 \subsection{La funzione \texttt{fork}}
 117 \label{sec:proc_fork}
 118
 119
 120 Dopo l'esecuzione di una fork sia il processo padre che il processo figlio
 121 continuano ad essere eseguiti normalmente, ed il processo figlio esegue
 122 esattamente lo stesso codice del padre. La sola differenza è che nel processo
 123 padre il valore di ritorno della funzione fork è il pid del processo figlio,
 124 mentre nel figlio è zero; in questo modo il programma può identificare se
 125 viene eseguito dal padre o dal figlio.
 126
 127
 128
 129
 130 \subsection{La funzione \texttt{exit}}
 131 \label{sec:proc_exit}
 132
 133 \subsection{Le funzioni \texttt{wait} e  \texttt{waitpid}}
 134 \label{sec:proc_wait}
 135
 136 \subsection{Le funzioni \texttt{exec}}
 137 \label{sec:proc_exec}
 138
 139
 140
 141
 142
 143
 144 \section{Il controllo di accesso}
 145 \label{sec:process_perms}
 146
 147 Va messo qui tutta la storia su effective, real, saved uid, e pure le cose di
 148 linux come il filesystem uid.
 149
 150