X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=prochand.tex;h=6fa1b86e6ce36e344cfa2a900900de26ff170c07;hp=69da2ce7199b032d725e6ca47e045a4d92bdf92c;hb=428bc5cd4e05a99bbcb57be6946eb4b1fa9dfca9;hpb=2354bea32f841874996df139e72aab07b29ba12e diff --git a/prochand.tex b/prochand.tex index 69da2ce..6fa1b86 100644 --- a/prochand.tex +++ b/prochand.tex @@ -1,9 +1,9 @@ %% prochand.tex %% -%% Copyright (C) 2000-2004 Simone Piccardi. Permission is granted to +%% Copyright (C) 2000-2005 Simone Piccardi. Permission is granted to %% copy, distribute and/or modify this document under the terms of the GNU Free %% Documentation License, Version 1.1 or any later version published by the -%% Free Software Foundation; with the Invariant Sections being "Prefazione", +%% Free Software Foundation; with the Invariant Sections being "Un preambolo", %% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the %% license is included in the section entitled "GNU Free Documentation %% License". @@ -116,7 +116,7 @@ Dato che tutti i processi attivi nel sistema sono comunque generati da \cmd{init} o da uno dei suoi figli\footnote{in realtà questo non è del tutto vero, in Linux ci sono alcuni processi speciali che pur comparendo come figli di \cmd{init}, o con \acr{pid} successivi, sono in realtà generati - direttamente dal kernel, (come \cmd{keventd}, \cmd{kswapd}, etc.).} si + direttamente dal kernel, (come \cmd{keventd}, \cmd{kswapd}, ecc.).} si possono classificare i processi con la relazione padre/figlio in un'organizzazione gerarchica ad albero, in maniera analoga a come i file sono organizzati in un albero di directory (si veda @@ -144,8 +144,8 @@ fig.~\ref{fig:proc_task_struct}. \end{figure} Come accennato in sez.~\ref{sec:intro_unix_struct} è lo -\textit{scheduler}\index{scheduler} che decide quale processo mettere in -esecuzione; esso viene eseguito ad ogni system call ed ad ogni +\textit{scheduler}\index{\textit{scheduler}} che decide quale processo mettere +in esecuzione; esso viene eseguito ad ogni system call ed ad ogni interrupt,\footnote{più in una serie di altre occasioni. NDT completare questa parte.} (ma può essere anche attivato esplicitamente). Il timer di sistema provvede comunque a che esso sia invocato periodicamente, generando un @@ -157,10 +157,10 @@ Hertz.\footnote{Il valore usuale di questa costante sez.~\ref{sec:sys_unix_time}).} %Si ha cioè un interrupt dal timer ogni centesimo di secondo. -Ogni volta che viene eseguito, lo \textit{scheduler}\index{scheduler} effettua -il calcolo delle priorità dei vari processi attivi (torneremo su questo in -sez.~\ref{sec:proc_priority}) e stabilisce quale di essi debba essere posto in -esecuzione fino alla successiva invocazione. +Ogni volta che viene eseguito, lo \textit{scheduler}\index{\textit{scheduler}} +effettua il calcolo delle priorità dei vari processi attivi (torneremo su +questo in sez.~\ref{sec:proc_priority}) e stabilisce quale di essi debba +essere posto in esecuzione fino alla successiva invocazione. \subsection{Una panoramica sulle funzioni fondamentali} @@ -268,8 +268,9 @@ Il fatto che il \acr{pid} sia un numero univoco per il sistema lo rende un candidato per generare ulteriori indicatori associati al processo di cui diventa possibile garantire l'unicità: ad esempio in alcune implementazioni la funzione \func{tmpname} (si veda sez.~\ref{sec:file_temp_file}) usa il -\acr{pid} per generare un pathname univoco, che non potrà essere replicato da -un altro processo che usi la stessa funzione. +\acr{pid} per generare un \index{\textit{pathname}}\textit{pathname} univoco, +che non potrà essere replicato da un altro processo che usi la stessa +funzione. Tutti i processi figli dello stesso processo padre sono detti \textit{sibling}, questa è una delle relazioni usate nel \textsl{controllo di @@ -325,14 +326,14 @@ pertanto padre e figlio vedono variabili diverse. Per quanto riguarda la gestione della memoria, in generale il segmento di testo, che è identico per i due processi, è condiviso e tenuto in read-only per il padre e per i figli. Per gli altri segmenti Linux utilizza la tecnica -del \textit{copy on write}\index{copy on write}; questa tecnica comporta che -una pagina di memoria viene effettivamente copiata per il nuovo processo solo -quando ci viene effettuata sopra una scrittura (e si ha quindi una reale -differenza fra padre e figlio). In questo modo si rende molto più efficiente -il meccanismo della creazione di un nuovo processo, non essendo più necessaria -la copia di tutto lo spazio degli indirizzi virtuali del padre, ma solo delle -pagine di memoria che sono state modificate, e solo al momento della modifica -stessa. +del \textit{copy on write}\index{\textit{copy~on~write}}; questa tecnica +comporta che una pagina di memoria viene effettivamente copiata per il nuovo +processo solo quando ci viene effettuata sopra una scrittura (e si ha quindi +una reale differenza fra padre e figlio). In questo modo si rende molto più +efficiente il meccanismo della creazione di un nuovo processo, non essendo più +necessaria la copia di tutto lo spazio degli indirizzi virtuali del padre, ma +solo delle pagine di memoria che sono state modificate, e solo al momento +della modifica stessa. La differenza che si ha nei due processi è che nel processo padre il valore di ritorno della funzione \func{fork} è il \acr{pid} del processo figlio, mentre @@ -399,8 +400,8 @@ degli eventuali tempi di attesa in secondi (eseguiti tramite la funzione descrizione delle opzioni); il codice completo, compresa la parte che gestisce le opzioni a riga di comando, è disponibile nel file \file{ForkTest.c}, distribuito insieme agli altri sorgenti degli esempi su -\href{http://gapil.firenze.linux.it/gapil_source.tgz} -{\texttt{http://gapil.firenze.linux.it/gapil\_source.tgz}}. +\href{http://gapil.truelite.it/gapil_source.tgz} +{\textsf{http://gapil.truelite.it/gapil\_source.tgz}}. Decifrato il numero di figli da creare, il ciclo principale del programma (\texttt{\small 24--40}) esegue in successione la creazione dei processi figli @@ -441,8 +442,8 @@ Go to next child Esaminiamo questo risultato: una prima conclusione che si può trarre è che non si può dire quale processo fra il padre ed il figlio venga eseguito per primo\footnote{a partire dal kernel 2.5.2-pre10 è stato introdotto il nuovo - scheduler\index{scheduler} di Ingo Molnar che esegue sempre per primo il - figlio; per mantenere la portabilità è opportuno non fare comunque + scheduler\index{\textit{scheduler}} di Ingo Molnar che esegue sempre per + primo il figlio; per mantenere la portabilità è opportuno non fare comunque affidamento su questo comportamento.} dopo la chiamata a \func{fork}; dall'esempio si può notare infatti come nei primi due cicli sia stato eseguito per primo il padre (con la stampa del \acr{pid} del nuovo processo) per poi @@ -464,7 +465,7 @@ istruzioni del codice fra padre e figli, n essere messi in esecuzione. Se è necessaria una qualche forma di precedenza occorrerà provvedere ad espliciti meccanismi di sincronizzazione, pena il rischio di incorrere nelle cosiddette -\textit{race condition}\index{race condition} +\textit{race condition}\index{\textit{race~condition}} (vedi sez.~\ref{sec:proc_race_cond}). Si noti inoltre che essendo i segmenti di memoria utilizzati dai singoli @@ -585,35 +586,35 @@ propriet comune dopo l'esecuzione di una \func{fork} è la seguente: \begin{itemize*} \item i file aperti e gli eventuali flag di - \textit{close-on-exec}\index{close-on-exec} impostati (vedi - sez.~\ref{sec:proc_exec} e sez.~\ref{sec:file_fcntl}). + \textit{close-on-exec}\index{\textit{close-on-exec}} impostati (vedi + sez.~\ref{sec:proc_exec} e sez.~\ref{sec:file_fcntl}); \item gli identificatori per il controllo di accesso: l'\textsl{user-ID reale}, il \textsl{group-ID reale}, l'\textsl{user-ID effettivo}, il \textsl{group-ID effettivo} ed i \textit{group-ID supplementari} (vedi - sez.~\ref{sec:proc_access_id}). + sez.~\ref{sec:proc_access_id}); \item gli identificatori per il controllo di sessione: il \textit{process group-ID} e il \textit{session id} ed il terminale di controllo (vedi - sez.~\ref{sec:sess_proc_group}). + sez.~\ref{sec:sess_proc_group}); \item la directory di lavoro e la directory radice (vedi - sez.~\ref{sec:file_work_dir} e sez.~\ref{sec:file_chroot}). -\item la maschera dei permessi di creazione (vedi sez.~\ref{sec:file_umask}). + sez.~\ref{sec:file_work_dir} e sez.~\ref{sec:file_chroot}); +\item la maschera dei permessi di creazione (vedi sez.~\ref{sec:file_umask}); \item la maschera dei segnali bloccati (vedi sez.~\ref{sec:sig_sigmask}) e le - azioni installate (vedi sez.~\ref{sec:sig_gen_beha}). + azioni installate (vedi sez.~\ref{sec:sig_gen_beha}); \item i segmenti di memoria condivisa agganciati al processo (vedi - sez.~\ref{sec:ipc_sysv_shm}). -\item i limiti sulle risorse (vedi sez.~\ref{sec:sys_resource_limit}). + sez.~\ref{sec:ipc_sysv_shm}); +\item i limiti sulle risorse (vedi sez.~\ref{sec:sys_resource_limit}); \item le variabili di ambiente (vedi sez.~\ref{sec:proc_environ}). \end{itemize*} -le differenze fra padre e figlio dopo la \func{fork} invece sono: +Le differenze fra padre e figlio dopo la \func{fork} invece sono: \begin{itemize*} -\item il valore di ritorno di \func{fork}. -\item il \acr{pid} (\textit{process id}). +\item il valore di ritorno di \func{fork}; +\item il \acr{pid} (\textit{process id}); \item il \acr{ppid} (\textit{parent process id}), quello del figlio viene - impostato al \acr{pid} del padre. + impostato al \acr{pid} del padre; \item i valori dei tempi di esecuzione della struttura \struct{tms} (vedi - sez.~\ref{sec:sys_cpu_times}) che nel figlio sono posti a zero. + sez.~\ref{sec:sys_cpu_times}) che nel figlio sono posti a zero; \item i \textit{lock} sui file (vedi sez.~\ref{sec:file_locking}), che non - vengono ereditati dal figlio. + vengono ereditati dal figlio; \item gli allarmi ed i segnali pendenti (vedi sez.~\ref{sec:sig_gen_beha}), che per il figlio vengono cancellati. \end{itemize*} @@ -636,13 +637,14 @@ padre, che costituiva un inutile appesantimento in tutti quei casi in cui la \func{fork} veniva fatta solo per poi eseguire una \func{exec}. La funzione venne introdotta in BSD per migliorare le prestazioni. -Dato che Linux supporta il \textit{copy on write}\index{copy on write} la -perdita di prestazioni è assolutamente trascurabile, e l'uso di questa -funzione (che resta un caso speciale della system call \func{\_\_clone}), è -deprecato; per questo eviteremo di trattarla ulteriormente. +Dato che Linux supporta il \textit{copy on + write}\index{\textit{copy~on~write}} la perdita di prestazioni è +assolutamente trascurabile, e l'uso di questa funzione (che resta un caso +speciale della system call \func{\_\_clone}) è deprecato; per questo eviteremo +di trattarla ulteriormente. -\subsection{La conclusione di un processo.} +\subsection{La conclusione di un processo} \label{sec:proc_termination} In sez.~\ref{sec:proc_conclusion} abbiamo già affrontato le modalità con cui @@ -669,16 +671,16 @@ comunque una serie di operazioni: chiude tutti i file aperti, rilascia la memoria che stava usando, e così via; l'elenco completo delle operazioni eseguite alla chiusura di un processo è il seguente: \begin{itemize*} -\item tutti i file descriptor sono chiusi. -\item viene memorizzato lo stato di terminazione del processo. +\item tutti i file descriptor sono chiusi; +\item viene memorizzato lo stato di terminazione del processo; \item ad ogni processo figlio viene assegnato un nuovo padre (in genere - \cmd{init}). + \cmd{init}); \item viene inviato il segnale \const{SIGCHLD} al processo padre (vedi - sez.~\ref{sec:sig_sigchld}). + sez.~\ref{sec:sig_sigchld}); \item se il processo è un leader di sessione ed il suo terminale di controllo è quello della sessione viene mandato un segnale di \const{SIGHUP} a tutti i processi del gruppo di foreground e il terminale di controllo viene - disconnesso (vedi sez.~\ref{sec:sess_ctrl_term}). + disconnesso (vedi sez.~\ref{sec:sess_ctrl_term}); \item se la conclusione di un processo rende orfano un \textit{process group} ciascun membro del gruppo viene bloccato, e poi gli vengono inviati in successione i segnali \const{SIGHUP} e \const{SIGCONT} @@ -850,7 +852,7 @@ Al ritorno della funzione lo stato di terminazione del figlio viene salvato nella variabile puntata da \param{status} e tutte le risorse del kernel relative al processo (vedi sez.~\ref{sec:proc_termination}) vengono rilasciate. Nel caso un processo abbia più figli il valore di ritorno (il \acr{pid} del -figlio) permette di identificare qual'è quello che è uscito. +figlio) permette di identificare qual è quello che è uscito. Questa funzione ha il difetto di essere poco flessibile, in quanto ritorna all'uscita di un qualunque processo figlio. Nelle occasioni in cui è @@ -957,26 +959,32 @@ generato dalla terminazione di un figlio, avremo la certezza che la chiamata a \hline \hline \macro{WIFEXITED(s)} & Condizione vera (valore non nullo) per un processo - figlio che sia terminato normalmente. \\ + figlio che sia terminato normalmente. \\ \macro{WEXITSTATUS(s)} & Restituisce gli otto bit meno significativi dello - stato di uscita del processo (passato attraverso \func{\_exit}, \func{exit} - o come valore di ritorno di \func{main}). Può essere valutata solo se - \val{WIFEXITED} ha restituito un valore non nullo.\\ + stato di uscita del processo (passato attraverso + \func{\_exit}, \func{exit} o come valore di + ritorno di \func{main}). Può essere valutata solo + se \val{WIFEXITED} ha restituito un valore non + nullo.\\ \macro{WIFSIGNALED(s)} & Vera se il processo figlio è terminato - in maniera anomala a causa di un segnale che non è stato catturato (vedi - sez.~\ref{sec:sig_notification}).\\ - \macro{WTERMSIG(s)} & restituisce il numero del segnale che ha causato - la terminazione anomala del processo. Può essere valutata solo se - \val{WIFSIGNALED} ha restituito un valore non nullo.\\ + in maniera anomala a causa di un segnale che non + è stato catturato (vedi + sez.~\ref{sec:sig_notification}).\\ + \macro{WTERMSIG(s)} & Restituisce il numero del segnale che ha causato + la terminazione anomala del processo. Può essere + valutata solo se \val{WIFSIGNALED} ha restituito + un valore non nullo.\\ \macro{WCOREDUMP(s)} & Vera se il processo terminato ha generato un - file si \textit{core dump}. Può essere valutata solo se - \val{WIFSIGNALED} ha restituito un valore non nullo.\footnotemark \\ + file di \textit{core dump}. Può essere valutata + solo se \val{WIFSIGNALED} ha restituito un valore + non nullo.\footnotemark \\ \macro{WIFSTOPPED(s)} & Vera se il processo che ha causato il ritorno di - \func{waitpid} è bloccato. L'uso è possibile solo avendo specificato - l'opzione \const{WUNTRACED}. \\ - \macro{WSTOPSIG(s)} & restituisce il numero del segnale che ha bloccato - il processo, Può essere valutata solo se \val{WIFSTOPPED} ha - restituito un valore non nullo. \\ + \func{waitpid} è bloccato. L'uso è possibile solo + avendo specificato l'opzione \const{WUNTRACED}. \\ + \macro{WSTOPSIG(s)} & Restituisce il numero del segnale che ha bloccato + il processo. Può essere valutata solo se + \val{WIFSTOPPED} ha restituito un valore non + nullo. \\ \hline \end{tabular} \caption{Descrizione delle varie macro di preprocessore utilizzabili per @@ -1015,7 +1023,7 @@ usando le apposite funzioni trattate in sez.~\ref{sec:sig_strsignal}. Linux, seguendo un'estensione di BSD, supporta altre due funzioni per la lettura dello stato di terminazione di un processo, analoghe alle precedenti -ma che prevedono un ulteriore parametro attraverso il quale il kernel può +ma che prevedono un ulteriore argomento attraverso il quale il kernel può restituire al padre informazioni sulle risorse usate dal processo terminato e dai vari figli. Le due funzioni sono \funcd{wait3} e \funcd{wait4}, che diventano accessibili definendo la macro \macro{\_USE\_BSD}; i loro prototipi @@ -1024,10 +1032,10 @@ sono: \headdecl{sys/times.h} \headdecl{sys/types.h} \headdecl{sys/wait.h} \headdecl{sys/resource.h} - \funcdecl{pid\_t wait4(pid\_t pid, int * status, int options, struct rusage - * rusage)} - È identica a \func{waitpid} sia per comportamento che per i valori dei - parametri, ma restituisce in \param{rusage} un sommario delle risorse usate + \funcdecl{pid\_t wait4(pid\_t pid, int *status, int options, struct rusage + *rusage)} + È identica a \func{waitpid} sia per comportamento che per i valori degli + argomenti, ma restituisce in \param{rusage} un sommario delle risorse usate dal processo. \funcdecl{pid\_t wait3(int *status, int options, struct rusage *rusage)} @@ -1073,14 +1081,14 @@ famiglia di funzioni) che possono essere usate per questo compito, in realt riconosciuto come tale, o compilato per un'altra architettura. \item[\errcode{ENOENT}] il file o una delle librerie dinamiche o l'interprete necessari per eseguirlo non esistono. - \item[\errcode{ETXTBSY}] L'eseguibile è aperto in scrittura da uno o più + \item[\errcode{ETXTBSY}] l'eseguibile è aperto in scrittura da uno o più processi. - \item[\errcode{EINVAL}] L'eseguibile ELF ha più di un segmento + \item[\errcode{EINVAL}] l'eseguibile ELF ha più di un segmento \const{PF\_INTERP}, cioè chiede di essere eseguito da più di un interprete. - \item[\errcode{ELIBBAD}] Un interprete ELF non è in un formato + \item[\errcode{ELIBBAD}] un interprete ELF non è in un formato riconoscibile. - \item[\errcode{E2BIG}] La lista degli argomenti è troppo grande. + \item[\errcode{E2BIG}] la lista degli argomenti è troppo grande. \end{errlist} ed inoltre anche \errval{EFAULT}, \errval{ENOMEM}, \errval{EIO}, \errval{ENAMETOOLONG}, \errval{ELOOP}, \errval{ENOTDIR}, \errval{ENFILE}, @@ -1095,8 +1103,8 @@ argomenti e dell'ambiente possono essere acceduti dal nuovo programma quando la sua funzione \func{main} è dichiarata nella forma \code{main(int argc, char *argv[], char *envp[])}. -Le altre funzioni della famiglia servono per fornire all'utente una serie -possibile di diverse interfacce per la creazione di un nuovo processo. I loro +Le altre funzioni della famiglia servono per fornire all'utente una serie di +possibili diverse interfacce per la creazione di un nuovo processo. I loro prototipi sono: \begin{functions} \headdecl{unistd.h} @@ -1108,7 +1116,7 @@ prototipi sono: \funcdecl{int execvp(const char *file, char *const argv[])} Sostituiscono l'immagine corrente del processo con quella indicata nel primo -argomento. I parametri successivi consentono di specificare gli argomenti a +argomento. Gli argomenti successivi consentono di specificare gli argomenti a linea di comando e l'ambiente ricevuti dal nuovo processo. \bodydesc{Queste funzioni ritornano solo in caso di errore, restituendo -1; @@ -1118,8 +1126,8 @@ linea di comando e l'ambiente ricevuti dal nuovo processo. Per capire meglio le differenze fra le funzioni della famiglia si può fare riferimento allo specchietto riportato in tab.~\ref{tab:proc_exec_scheme}. La -prima differenza riguarda le modalità di passaggio dei parametri che poi -andranno a costituire gli argomenti a linea di comando (cioè i valori di +prima differenza riguarda le modalità di passaggio dei valori che poi andranno +a costituire gli argomenti a linea di comando (cioè i valori di \param{argv} e \param{argc} visti dalla funzione \func{main} del programma chiamato). @@ -1151,8 +1159,8 @@ per indicare il nome del file che contiene il programma che verr argomenti a lista &$\bullet$&$\bullet$&$\bullet$&&& \\ argomenti a vettore &&&&$\bullet$&$\bullet$&$\bullet$\\ \hline - filename completo &&$\bullet$&&&$\bullet$& \\ - ricerca su \var{PATH}&$\bullet$&&$\bullet$&$\bullet$&&$\bullet$ \\ + filename completo &$\bullet$&&$\bullet$&$\bullet$&&$\bullet$\\ + ricerca su \var{PATH} &&$\bullet$&&&$\bullet$& \\ \hline ambiente a vettore &&&$\bullet$&&&$\bullet$ \\ uso di \var{environ} &$\bullet$&$\bullet$&&$\bullet$&$\bullet$& \\ @@ -1166,10 +1174,10 @@ per indicare il nome del file che contiene il programma che verr La seconda differenza fra le funzioni riguarda le modalità con cui si specifica il programma che si vuole eseguire. Con lo mnemonico \code{p} si indicano le due funzioni che replicano il comportamento della shell nello -specificare il comando da eseguire; quando il parametro \param{file} non -contiene una ``\file{/}'' esso viene considerato come un nome di programma, e -viene eseguita automaticamente una ricerca fra i file presenti nella lista di -directory specificate dalla variabile di ambiente \var{PATH}. Il file che +specificare il comando da eseguire; quando l'argomento \param{file} non +contiene una ``\texttt{/}'' esso viene considerato come un nome di programma, +e viene eseguita automaticamente una ricerca fra i file presenti nella lista +di directory specificate dalla variabile di ambiente \var{PATH}. Il file che viene posto in esecuzione è il primo che viene trovato. Se si ha un errore relativo a permessi di accesso insufficienti (cioè l'esecuzione della sottostante \func{execve} ritorna un \errcode{EACCES}), la ricerca viene @@ -1179,7 +1187,7 @@ non viene trovato nessun altro file viene finalmente restituito Le altre quattro funzioni si limitano invece a cercare di eseguire il file indicato dall'argomento \param{path}, che viene interpretato come il -\textit{pathname} del programma. +\index{\textit{pathname}}\textit{pathname} del programma. \begin{figure}[htb] \centering @@ -1189,32 +1197,33 @@ indicato dall'argomento \param{path}, che viene interpretato come il \end{figure} La terza differenza è come viene passata la lista delle variabili di ambiente. -Con lo mnemonico \code{e} vengono indicate quelle funzioni che necessitano di -un vettore di parametri \var{envp[]} analogo a quello usato per gli argomenti -a riga di comando (terminato quindi da un \val{NULL}), le altre usano il -valore della variabile \var{environ} (vedi sez.~\ref{sec:proc_environ}) del -processo di partenza per costruire l'ambiente. +Con lo mnemonico \texttt{e} vengono indicate quelle funzioni che necessitano +di un vettore di parametri \var{envp[]} analogo a quello usato per gli +argomenti a riga di comando (terminato quindi da un \val{NULL}), le altre +usano il valore della variabile \var{environ} (vedi +sez.~\ref{sec:proc_environ}) del processo di partenza per costruire +l'ambiente. Oltre a mantenere lo stesso \acr{pid}, il nuovo programma fatto partire da \func{exec} assume anche una serie di altre proprietà del processo chiamante; la lista completa è la seguente: \begin{itemize*} \item il \textit{process id} (\acr{pid}) ed il \textit{parent process id} - (\acr{ppid}). + (\acr{ppid}); \item l'\textsl{user-ID reale}, il \textit{group-ID reale} ed i - \textsl{group-ID supplementari} (vedi sez.~\ref{sec:proc_access_id}). + \textsl{group-ID supplementari} (vedi sez.~\ref{sec:proc_access_id}); \item il \textit{session id} (\acr{sid}) ed il \textit{process group-ID} - (\acr{pgid}), vedi sez.~\ref{sec:sess_proc_group}. -\item il terminale di controllo (vedi sez.~\ref{sec:sess_ctrl_term}). -\item il tempo restante ad un allarme (vedi sez.~\ref{sec:sig_alarm_abort}). + (\acr{pgid}), vedi sez.~\ref{sec:sess_proc_group}; +\item il terminale di controllo (vedi sez.~\ref{sec:sess_ctrl_term}); +\item il tempo restante ad un allarme (vedi sez.~\ref{sec:sig_alarm_abort}); \item la directory radice e la directory di lavoro corrente (vedi - sez.~\ref{sec:file_work_dir}). + sez.~\ref{sec:file_work_dir}); \item la maschera di creazione dei file (\var{umask}, vedi sez.~\ref{sec:file_umask}) ed i \textit{lock} sui file (vedi - sez.~\ref{sec:file_locking}). + sez.~\ref{sec:file_locking}); \item i segnali sospesi (\textit{pending}) e la maschera dei segnali (si veda - sez.~\ref{sec:sig_sigmask}). -\item i limiti sulle risorse (vedi sez.~\ref{sec:sys_resource_limit}). + sez.~\ref{sec:sig_sigmask}); +\item i limiti sulle risorse (vedi sez.~\ref{sec:sys_resource_limit}); \item i valori delle variabili \var{tms\_utime}, \var{tms\_stime}, \var{tms\_cutime}, \var{tms\_ustime} (vedi sez.~\ref{sec:sys_cpu_times}). \end{itemize*} @@ -1227,7 +1236,7 @@ speciale sez.~\ref{sec:sig_gen_beha}). La gestione dei file aperti dipende dal valore che ha il flag di -\textit{close-on-exec}\index{close-on-exec} (vedi anche +\textit{close-on-exec}\index{\textit{close-on-exec}} (vedi anche sez.~\ref{sec:file_fcntl}) per ciascun file descriptor. I file per cui è impostato vengono chiusi, tutti gli altri file restano aperti. Questo significa che il comportamento predefinito è che i file restano aperti @@ -1237,8 +1246,9 @@ che imposti il suddetto flag. Per le directory, lo standard POSIX.1 richiede che esse vengano chiuse attraverso una \func{exec}, in genere questo è fatto dalla funzione \func{opendir} (vedi sez.~\ref{sec:file_dir_read}) che effettua da sola -l'impostazione del flag di \textit{close-on-exec}\index{close-on-exec} sulle -directory che apre, in maniera trasparente all'utente. +l'impostazione del flag di +\textit{close-on-exec}\index{\textit{close-on-exec}} sulle directory che apre, +in maniera trasparente all'utente. Abbiamo detto che l'\textsl{user-ID reale} ed il \textsl{group-ID reale} restano gli stessi all'esecuzione di \func{exec}; lo stesso vale per @@ -1250,17 +1260,17 @@ bit impostato, in questo caso l'\textsl{user-ID effettivo} ed il gruppo cui il file appartiene (per i dettagli vedi sez.~\ref{sec:proc_perms}). Se il file da eseguire è in formato \emph{a.out} e necessita di librerie -condivise, viene lanciato il \textit{linker} dinamico \cmd{ld.so} prima del -programma per caricare le librerie necessarie ed effettuare il link +condivise, viene lanciato il \textit{linker} dinamico \cmd{/lib/ld.so} prima +del programma per caricare le librerie necessarie ed effettuare il link dell'eseguibile. Se il programma è in formato ELF per caricare le librerie dinamiche viene usato l'interprete indicato nel segmento \const{PT\_INTERP}, in genere questo è \file{/lib/ld-linux.so.1} per programmi linkati con le \acr{libc5}, e \file{/lib/ld-linux.so.2} per programmi linkati con le -\acr{glibc}. Infine nel caso il file sia uno script esso deve iniziare con -una linea nella forma \cmd{\#!/path/to/interpreter} dove l'interprete indicato -deve esse un programma valido (binario, non un altro script) che verrà -chiamato come se si fosse eseguito il comando \cmd{interpreter [argomenti] - filename}. +\acr{glibc}. Infine nel caso il file sia uno script esso deve iniziare con una +linea nella forma \cmd{\#!/path/to/interpreter [argomenti]} dove l'interprete +indicato deve essere un programma valido (binario, non un altro script) che +verrà chiamato come se si fosse eseguito il comando \cmd{interpreter + [argomenti] filename}. Con la famiglia delle \func{exec} si chiude il novero delle funzioni su cui è basata la gestione dei processi in Unix: con \func{fork} si crea un nuovo @@ -1661,7 +1671,7 @@ Le due funzioni sono identiche, quanto detto per la prima riguardo gli user-ID si applica alla seconda per i group-ID. I processi non privilegiati possono cambiare uno qualunque degli user-ID solo ad un valore corrispondente o all'user-ID reale, o a quello effettivo o a quello salvato, l'amministratore -può specificare i valori che vuole; un valore di -1 per un qualunque parametro +può specificare i valori che vuole; un valore di -1 per un qualunque argomento lascia inalterato l'identificatore corrispondente. Per queste funzioni esistono anche due controparti che permettono di leggere @@ -1865,10 +1875,10 @@ scrivere codice portabile. \label{sec:proc_priority} In questa sezione tratteremo più approfonditamente i meccanismi con il quale -lo \textit{scheduler}\index{scheduler} assegna la CPU ai vari processi attivi. -In particolare prenderemo in esame i vari meccanismi con cui viene gestita -l'assegnazione del tempo di CPU, ed illustreremo le varie funzioni di -gestione. +lo \textit{scheduler}\index{\textit{scheduler}} assegna la CPU ai vari +processi attivi. In particolare prenderemo in esame i vari meccanismi con cui +viene gestita l'assegnazione del tempo di CPU, ed illustreremo le varie +funzioni di gestione. \subsection{I meccanismi di \textit{scheduling}} @@ -1886,8 +1896,8 @@ contrario di altri sistemi (che usano invece il cosiddetto \textit{cooperative multitasking}) non sono i singoli processi, ma il kernel stesso a decidere quando la CPU deve essere passata ad un altro processo. Come accennato in sez.~\ref{sec:proc_hierarchy} questa scelta viene eseguita da una sezione -apposita del kernel, lo \textit{scheduler}\index{scheduler}, il cui scopo è -quello di distribuire al meglio il tempo di CPU fra i vari processi. +apposita del kernel, lo \textit{scheduler}\index{\textit{scheduler}}, il cui +scopo è quello di distribuire al meglio il tempo di CPU fra i vari processi. La cosa è resa ancora più complicata dal fatto che con le architetture multi-processore si deve anche scegliere quale sia la CPU più opportuna da @@ -2018,8 +2028,8 @@ che viene assegnato ad un altro campo della struttura (\var{counter}) quando il processo viene eseguito per la prima volta e diminuito progressivamente ad ogni interruzione del timer. -Durante la sua esecuzione lo scheduler\index{scheduler} scandisce la coda dei -processi in stato \textit{runnable} associando, in base al valore di +Durante la sua esecuzione lo scheduler\index{\textit{scheduler}} scandisce la +coda dei processi in stato \textit{runnable} associando, in base al valore di \var{counter}, un peso ad ogni processo in attesa di esecuzione,\footnote{il calcolo del peso in realtà è un po' più complicato, ad esempio nei sistemi multiprocessore viene favorito un processo eseguito sulla stessa CPU, e a @@ -2157,8 +2167,8 @@ processo qualsiasi sia la sua priorit Adeos gestiti dalle code del nano-kernel), in modo da poterli controllare direttamente qualora ci sia la necessità di avere un processo con priorità più elevata di un \textit{interrupt handler}.} mentre con l'incorrere in un -page fault\index{page fault} si possono avere ritardi non previsti. Se -l'ultimo problema può essere aggirato attraverso l'uso delle funzioni di +page fault\index{\textit{page~fault}} si possono avere ritardi non previsti. +Se l'ultimo problema può essere aggirato attraverso l'uso delle funzioni di controllo della memoria virtuale (vedi sez.~\ref{sec:proc_mem_lock}), il primo non è superabile e può comportare ritardi non prevedibili riguardo ai tempi di esecuzione di qualunque processo. @@ -2172,13 +2182,14 @@ si lavora con processi che usano priorit cui si sia assegnata la massima priorità assoluta, in modo da poter essere comunque in grado di rientrare nel sistema. -Quando c'è un processo con priorità assoluta lo scheduler\index{scheduler} lo -metterà in esecuzione prima di ogni processo normale. In caso di più processi -sarà eseguito per primo quello con priorità assoluta più alta. Quando ci sono -più processi con la stessa priorità assoluta questi vengono tenuti in una coda -e tocca al kernel decidere quale deve essere eseguito. -Il meccanismo con cui vengono gestiti questi processi dipende dalla politica -di scheduling che si è scelto; lo standard ne prevede due: +Quando c'è un processo con priorità assoluta lo +scheduler\index{\textit{scheduler}} lo metterà in esecuzione prima di ogni +processo normale. In caso di più processi sarà eseguito per primo quello con +priorità assoluta più alta. Quando ci sono più processi con la stessa priorità +assoluta questi vengono tenuti in una coda e tocca al kernel decidere quale +deve essere eseguito. Il meccanismo con cui vengono gestiti questi processi +dipende dalla politica di scheduling che si è scelto; lo standard ne prevede +due: \begin{basedescript}{\desclabelwidth{1.2cm}\desclabelstyle{\nextlinelabel}} \item[\textit{FIFO}] \textit{First In First Out}. Il processo viene eseguito fintanto che non cede volontariamente la CPU, si blocca, finisce o viene @@ -2253,8 +2264,9 @@ zero Lo standard POSIX.1b prevede comunque che i due valori della massima e minima priorità statica possano essere ottenuti, per ciascuna delle politiche di -scheduling realtime, tramite le due funzioni \funcd{sched\_get\_priority\_max} -e \funcd{sched\_get\_priority\_min}, i cui prototipi sono: +scheduling \textit{real-time}, tramite le due funzioni +\funcd{sched\_get\_priority\_max} e \funcd{sched\_get\_priority\_min}, i cui +prototipi sono: \begin{functions} \headdecl{sched.h} @@ -2404,7 +2416,7 @@ In un ambiente multitasking il concetto essere interrotto in qualunque momento dal kernel che mette in esecuzione un altro processo o dalla ricezione di un segnale; occorre pertanto essere accorti nei confronti delle possibili -\textit{race condition}\index{race condition} (vedi +\textit{race condition}\index{\textit{race~condition}} (vedi sez.~\ref{sec:proc_race_cond}) derivanti da operazioni interrotte in una fase in cui non erano ancora state completate. @@ -2438,17 +2450,17 @@ condiviso, onde evitare problemi con le ottimizzazioni del codice. -\subsection{Le \textit{race condition}\index{race condition} e i - \textit{deadlock}\index{deadlock}} +\subsection{Le \textit{race condition} ed i \textit{deadlock}} \label{sec:proc_race_cond} -Si definiscono \textit{race condition}\index{race condition} tutte quelle -situazioni in cui processi diversi operano su una risorsa comune, ed in cui il -risultato viene a dipendere dall'ordine in cui essi effettuano le loro -operazioni. Il caso tipico è quello di un'operazione che viene eseguita da un -processo in più passi, e può essere compromessa dall'intervento di un altro -processo che accede alla stessa risorsa quando ancora non tutti i passi sono -stati completati. +\index{\textit{race~condition}|(} +Si definiscono \textit{race condition} tutte quelle situazioni in cui processi +diversi operano su una risorsa comune, ed in cui il risultato viene a +dipendere dall'ordine in cui essi effettuano le loro operazioni. Il caso +tipico è quello di un'operazione che viene eseguita da un processo in più +passi, e può essere compromessa dall'intervento di un altro processo che +accede alla stessa risorsa quando ancora non tutti i passi sono stati +completati. Dato che in un sistema multitasking ogni processo può essere interrotto in qualunque momento per farne subentrare un altro in esecuzione, niente può @@ -2461,37 +2473,39 @@ funzioner Per questo occorre essere ben consapevoli di queste problematiche, e del fatto che l'unico modo per evitarle è quello di riconoscerle come tali e prendere gli adeguati provvedimenti per far sì che non si verifichino. Casi tipici di -\textit{race condition}\index{race condition} si hanno quando diversi processi -accedono allo stesso file, o nell'accesso a meccanismi di intercomunicazione -come la memoria condivisa. In questi casi, se non si dispone della possibilità -di eseguire atomicamente le operazioni necessarie, occorre che quelle parti di -codice in cui si compiono le operazioni sulle risorse condivise (le cosiddette -\textsl{sezioni critiche}\index{sezioni critiche}) del programma, siano +\textit{race condition} si hanno quando diversi processi accedono allo stesso +file, o nell'accesso a meccanismi di intercomunicazione come la memoria +condivisa. In questi casi, se non si dispone della possibilità di eseguire +atomicamente le operazioni necessarie, occorre che quelle parti di codice in +cui si compiono le operazioni sulle risorse condivise (le cosiddette +\textsl{sezioni critiche}\index{sezioni~critiche}) del programma, siano opportunamente protette da meccanismi di sincronizzazione (torneremo su queste problematiche di questo tipo in cap.~\ref{cha:IPC}). -Un caso particolare di \textit{race condition}\index{race condition} sono poi -i cosiddetti \textit{deadlock}\index{deadlock}, particolarmente gravi in -quanto comportano spesso il blocco completo di un servizio, e non il -fallimento di una singola operazione. Per definizione un -\textit{deadlock}\index{deadlock} è una situazione in cui due o più processi +\index{\textit{deadlock}|(} +Un caso particolare di \textit{race condition} sono poi i cosiddetti +\textit{deadlock}, particolarmente gravi in quanto comportano spesso il blocco +completo di un servizio, e non il fallimento di una singola operazione. Per +definizione un \textit{deadlock} è una situazione in cui due o più processi non sono più in grado di proseguire perché ciascuno aspetta il risultato di una operazione che dovrebbe essere eseguita dall'altro. L'esempio tipico di una situazione che può condurre ad un -\textit{deadlock}\index{deadlock} è quello in cui un flag di +\textit{deadlock} è quello in cui un flag di ``\textsl{occupazione}'' viene rilasciato da un evento asincrono (come un segnale o un altro processo) fra il momento in cui lo si è controllato (trovandolo occupato) e la successiva operazione di attesa per lo sblocco. In questo caso, dato che l'evento di sblocco del flag è avvenuto senza che ce ne accorgessimo proprio fra il controllo e la messa in attesa, quest'ultima -diventerà perpetua (da cui il nome di \textit{deadlock}\index{deadlock}). +diventerà perpetua (da cui il nome di \textit{deadlock}). In tutti questi casi è di fondamentale importanza il concetto di atomicità visto in sez.~\ref{sec:proc_atom_oper}; questi problemi infatti possono essere risolti soltanto assicurandosi, quando essa sia richiesta, che sia possibile eseguire in maniera atomica le operazioni necessarie. +\index{\textit{race~condition}|)} +\index{\textit{deadlock}|)} \subsection{Le funzioni rientranti}