%% 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 "Un preambolo",
\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
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}
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
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
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
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
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
+ \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
\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.}
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
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
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
\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}}
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
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
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.
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
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.
-\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ò
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}
projects / gapil.git / blobdiff