caratteristiche di Unix (che esamineremo in dettaglio più avanti) è che
qualunque processo può a sua volta generarne altri, detti processi figli
(\textit{child process}). Ogni processo è identificato presso il sistema da un
-numero unico, il cosiddetto \textit{process identifier} o, più brevemente,
-\acr{pid}.
+numero univoco, il cosiddetto \textit{process identifier} o, più brevemente,
+\acr{pid}, assengnato in forma progressiva (vedi \secref{sec:proc_pid}) quando
+il processo viene creato.
Una seconda caratteristica di un sistema Unix è che la generazione di un
processo è un'operazione separata rispetto al lancio di un programma. In
una system call, Linux però usa un'altra nomenclatura, e la funzione
\func{fork} è basata a sua volta sulla system call \func{\_\_clone}, che viene
usata anche per generare i \textit{thread}. Il processo figlio creato dalla
-\func{fork} è una copia identica del processo processo padre, ma ha nuovo
+\func{fork} è una copia identica del processo processo padre, ma ha un nuovo
\acr{pid} e viene eseguito in maniera indipendente (le differenze fra padre e
figlio sono affrontate in dettaglio in \secref{sec:proc_fork}).
\textit{process image}), le funzioni della famiglia \func{exec} permettono di
caricare un'altro programma da disco sostituendo quest'ultimo all'immagine
corrente; questo fa sì che l'immagine precedente venga completamente
-cancellata. Questo significa che quando il nuovo programma esce, anche il
+cancellata. Questo significa che quando il nuovo programma termina, anche il
processo termina, e non si può tornare alla precedente immagine.
Per questo motivo la \func{fork} e la \func{exec} sono funzioni molto
\label{sec:proc_pid}
Come accennato nell'introduzione, ogni processo viene identificato dal sistema
-da un numero identificativo unico, il \textit{process id} o \acr{pid};
+da un numero identificativo univoco, il \textit{process id} o \acr{pid};
quest'ultimo è un tipo di dato standard, il \type{pid\_t} che in genere è un
intero con segno (nel caso di Linux e delle \acr{glibc} il tipo usato è
\ctyp{int}).
-Il \acr{pid} viene assegnato in forma progressiva ogni volta che un nuovo
-processo viene creato, fino ad un limite che, essendo il \acr{pid} un numero
-positivo memorizzato in un intero a 16 bit, arriva ad un massimo di 32767.
-Oltre questo valore l'assegnazione riparte dal numero più basso disponibile a
-partire da un minimo di 300,\footnote{questi valori, fino al kernel 2.4.x,
- sono definiti dalla macro \macro{PID\_MAX} in \file{threads.h} e
- direttamente in \file{fork.c}, con il kernel 2.5.x e la nuova interfaccia
+Il \acr{pid} viene assegnato in forma progressiva\footnote{in genere viene
+ assegnato il numero successivo a quello usato per l'ultimo processo creato,
+ a meno che questo numero non sia già utilizzato per un altro \acr{pid},
+ \acr{pgid} o \acr{sid} (vedi \secref{sec:sess_proc_group}).} ogni volta che
+un nuovo processo viene creato, fino ad un limite che, essendo il \acr{pid} un
+numero positivo memorizzato in un intero a 16 bit, arriva ad un massimo di
+32768. Oltre questo valore l'assegnazione riparte dal numero più basso
+disponibile a partire da un minimo di 300,\footnote{questi valori, fino al
+ kernel 2.4.x, sono definiti dalla macro \macro{PID\_MAX} in \file{threads.h}
+ e direttamente in \file{fork.c}, con il kernel 2.5.x e la nuova interfaccia
per i thread creata da Ingo Molnar anche il meccanismo di allocazione dei
\acr{pid} è stato modificato.} che serve a riservare i \acr{pid} più bassi
ai processi eseguiti dal direttamente dal kernel. Per questo motivo, come
\end{functions}
Dopo il successo dell'esecuzione di una \func{fork} sia il processo padre che
-il processo figlio continuano ad essere eseguiti normalmente all'istruzione
-seguente la \func{fork}; il processo figlio è però una copia del padre, e
-riceve una copia dei segmenti di testo, stack e dati (vedi
+il processo figlio continuano ad essere eseguiti normalmente a partire
+dall'istruzione seccessiva alla \func{fork}; il processo figlio è però una
+copia del padre, e riceve una copia dei segmenti di testo, stack e dati (vedi
\secref{sec:proc_mem_layout}), ed esegue esattamente lo stesso codice del
padre. Si tenga presente però che la memoria è copiata, non condivisa,
pertanto padre e figlio vedono variabili diverse.
-Per quanto riguarda la gestione della memoria in generale il segmento di
-testo, che è identico, è 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.
+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.
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
L'uso di \func{fork} avviene secondo due modalità principali; la prima è
quella in cui all'interno di un programma si creano processi figli cui viene
affidata l'esecuzione di una certa sezione di codice, mentre il processo padre
-ne esegue un'altra. È il caso tipico dei server (il modello
-\textit{client-server} è illustrato in \secref{sec:net_cliserv}) di rete in
-cui il padre riceve ed accetta le richieste da parte dei client, per ciascuna
-delle quali pone in esecuzione un figlio che è incaricato di fornire il
-servizio.
+ne esegue un'altra. È il caso tipico dei programmi server (il modello
+\textit{client-server} è illustrato in \secref{sec:net_cliserv}) in cui il
+padre riceve ed accetta le richieste da parte dei programmi client, per
+ciascuna delle quali pone in esecuzione un figlio che è incaricato di fornire
+il servizio.
La seconda modalità è quella in cui il processo vuole eseguire un altro
programma; questo è ad esempio il caso della shell. In questo caso il processo
-crea un figlio la cui unica operazione è quella fare una \func{exec} (di cui
-parleremo in \secref{sec:proc_exec}) subito dopo la \func{fork}.
+crea un figlio la cui unica operazione è quella di fare una \func{exec} (di
+cui parleremo in \secref{sec:proc_exec}) subito dopo la \func{fork}.
Alcuni sistemi operativi (il VMS ad esempio) combinano le operazioni di questa
seconda modalità (una \func{fork} seguita da una \func{exec}) in un'unica
relativamente facile intervenire sulle le modalità di esecuzione del nuovo
programma.
-In \figref{fig:proc_fork_code} si è riportato il corpo del codice del
-programma di esempio \cmd{forktest}, che ci permette di illustrare molte
-caratteristiche dell'uso della funzione \func{fork}. Il programma permette di
-creare un numero di figli specificato da linea di comando, e prende anche
-alcune opzioni per indicare degli eventuali tempi di attesa in secondi
-(eseguiti tramite la funzione \func{sleep}) per il padre ed il figlio (con
-\cmd{forktest -h} si ottiene la 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}
+In \figref{fig:proc_fork_code} è riportato il corpo del codice del programma
+di esempio \cmd{forktest}, che permette di illustrare molte caratteristiche
+dell'uso della funzione \func{fork}. Il programma crea un numero di figli
+specificato da linea di comando, e prende anche alcune opzioni per indicare
+degli eventuali tempi di attesa in secondi (eseguiti tramite la funzione
+\func{sleep}) per il padre ed il figlio (con \cmd{forktest -h} si ottiene la
+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}}.
Decifrato il numero di figli da creare, il ciclo principale del programma
processo figlio termina. Se un figlio è già terminato la funzione ritorna
immediatamente.
-Al ritorno lo stato di terminazione del processo viene salvato nella
+Al ritorno, lo stato di terminazione del processo viene salvato nella
variabile puntata da \var{status} e tutte le informazioni relative al
processo (vedi \secref{sec:proc_termination}) vengono rilasciate. Nel
caso un processo abbia più figli il valore di ritorno permette di
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
-processo, con \func{exec} si avvia un nuovo programma, con \func{exit} e
-\func{wait} si effettua e verifica la conclusione dei programmi. Tutte le
-altre funzioni sono ausiliarie e servono la lettura e l'impostazione dei vari
-parametri connessi ai processi.
+processo, con \func{exec} si lancia un nuovo programma, con \func{exit} e
+\func{wait} si effettua e verifica la conclusione dei processi. Tutte le
+altre funzioni sono ausiliarie e servono per la lettura e l'impostazione dei
+vari parametri connessi ai processi.
imposta questi identificatori ai valori corrispondenti all'utente che entra
nel sistema.
-Al secondo gruppo appartengono l'\textsl{userid effettivo} e l'\textsl{groupid
- effettivo} (a cui si aggiungono gli eventuali \textsl{groupid supplementari}
-dei gruppi dei quali l'utente fa parte). Questi sono invece gli
-identificatori usati nella verifiche dei permessi del processo e per il
+Al secondo gruppo appartengono lo \textsl{userid effettivo} ed il
+\textsl{groupid effettivo} (a cui si aggiungono gli eventuali \textsl{groupid
+ supplementari} dei gruppi dei quali l'utente fa parte). Questi sono invece
+gli identificatori usati nella verifiche dei permessi del processo e per il
controllo di accesso ai file (argomento affrontato in dettaglio in
\secref{sec:file_perm_overview}).
qualunque. Specificando un argomento di valore -1 l'identificatore
corrispondente verrà lasciato inalterato.
-Con queste funzione si possono scambiare fra loro gli userid reale e
+Con queste funzioni si possono scambiare fra loro gli userid reale e
effettivo, e pertanto è possibile implementare un comportamento simile a
quello visto in precedenza per \func{setgid}, cedendo i privilegi con un primo
scambio, e recuperandoli, eseguito il lavoro non privilegiato, con un secondo
aspettare la conclusione di altri che non hanno questa necessità.
Il concetto di priorità assoluta dice che quando due processi si contendono
-l'esecuzione, vince sempre quello con la priorità assoluta più alta, anche
-quando l'altro è in esecuzione (grazie al \textit{prehemptive scheduling}).
+l'esecuzione, vince sempre quello con la priorità assoluta più alta.
Ovviamente questo avviene solo per i processi che sono pronti per essere
eseguiti (cioè nello stato \textit{runnable}). La priorità assoluta viene in
genere indicata con un numero intero, ed un valore più alto comporta una
\var{nice}, che stabilisce la durata della \textit{time-slice}; per il
meccanismo appena descritto infatti un valore più lungo infatti assicura una
maggiore attribuzione di CPU. L'origine del nome di questo parametro sta nel
-fatto che in genere esso viene generalmente usato per diminuire la priorità di
-un processo, come misura di cortesia nei confronti degli altri.
-I processi infatti vengono creati dal sistema con lo stesso valore di
-\var{nice} (nullo) e nessuno è privilegiato rispetto agli altri; il valore può
-essere modificato solo attraverso la funzione \func{nice}, il cui prototipo è:
+fatto che generalmente questo viene usato per diminuire la priorità di un
+processo, come misura di cortesia nei confronti degli altri. I processi
+infatti vengono creati dal sistema con lo stesso valore di \var{nice} (nullo)
+e nessuno è privilegiato rispetto agli altri; il valore può essere modificato
+solo attraverso la funzione \func{nice}, il cui prototipo è:
\begin{prototype}{unistd.h}
{int nice(int inc)}
Aumenta il valore di \var{nice} per il processo corrente.
nel qual caso \var{errno} viene impostata opportunamente.}
\end{prototype}
-La funzione fa si che il processo rilasci la CPU, in modo da essere rimesso in
+La funzione fa sì che il processo rilasci la CPU, in modo da essere rimesso in
coda alla lista dei processi da eseguire, e permettere l'esecuzione di un
altro processo; se però il processo è l'unico ad essere presente sulla coda
l'esecuzione non sarà interrotta. In genere usano questa funzione i processi
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.
+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} è
quello in cui un flag di ``occupazione'' viene rilasciato da un evento
asincrono (come un segnale o un altro processo) fra il momento in cui lo si è
projects / gapil.git / blobdiff