\end{figure}
Come accennato in sez.~\ref{sec:intro_unix_struct} è lo
-\textit{scheduler}\index{\textit{scheduler}} che decide quale processo mettere
-in esecuzione; esso viene eseguito ad ogni system call ed ad ogni
+\textit{scheduler}\itindex{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{\textit{scheduler}}
+Ogni volta che viene eseguito, lo \textit{scheduler}\itindex{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.
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 \index{\textit{pathname}}\textit{pathname} univoco,
-che non potrà essere replicato da un altro processo che usi la stessa
-funzione.
+funzione \func{tempnam} (si veda sez.~\ref{sec:file_temp_file}) usa il
+\acr{pid} per generare un \itindex{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{\textit{copy~on~write}}; questa tecnica
+del \textit{copy on write}\itindex{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ù
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{\textit{scheduler}} di Ingo Molnar che esegue sempre per
- primo il figlio; per mantenere la portabilità è opportuno non fare comunque
+ scheduler\itindex{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
istruzioni del codice fra padre e figli, né sull'ordine in cui questi potranno
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{\textit{race~condition}}
-(vedi sez.~\ref{sec:proc_race_cond}).
+rischio di incorrere nelle cosiddette \textit{race
+ condition}\itindex{race~condition} (vedi sez.~\ref{sec:proc_race_cond}).
Si noti inoltre che essendo i segmenti di memoria utilizzati dai singoli
processi completamente separati, le modifiche delle variabili nei processi
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{\textit{close-on-exec}} impostati (vedi
+ \textit{close-on-exec}\itindex{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{\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.
+Dato che Linux supporta il \textit{copy on write}\itindex{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}
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
+ processi del gruppo di \textit{foreground} e il terminale di controllo viene
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
completamente conclusa.
Possiamo utilizzare il nostro programma di prova per analizzare anche questa
-condizione: lanciamo il comando \cmd{forktest} in background, indicando al
-processo padre di aspettare 10 secondi prima di uscire; in questo caso, usando
-\cmd{ps} sullo stesso terminale (prima dello scadere dei 10 secondi)
-otterremo:
+condizione: lanciamo il comando \cmd{forktest} in \textit{background} (vedi
+sez.~\ref{sec:sess_job_control}), indicando al processo padre di aspettare 10
+secondi prima di uscire; in questo caso, usando \cmd{ps} sullo stesso
+terminale (prima dello scadere dei 10 secondi) otterremo:
\footnotesize
\begin{verbatim}
valutata solo se \val{WIFSIGNALED} ha restituito
un valore non nullo.\\
\macro{WCOREDUMP(s)} & Vera se il processo terminato ha generato un
- file di \textit{core dump}. Può essere valutata
- solo se \val{WIFSIGNALED} ha restituito un valore
- non nullo.\footnotemark \\
+ file di \itindex{core~dump}\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}. \\
presente come estensione sia in Linux che in altri Unix.}
Entrambe le funzioni di attesa restituiscono lo stato di terminazione del
-processo tramite il puntatore \param{status} (se non interessa memorizzare lo
-stato si può passare un puntatore nullo). Il valore restituito da entrambe le
-funzioni dipende dall'implementazione, e tradizionalmente alcuni bit (in
-genere 8) sono riservati per memorizzare lo stato di uscita, e altri per
-indicare il segnale che ha causato la terminazione (in caso di conclusione
-anomala), uno per indicare se è stato generato un core file, ecc.\footnote{le
- definizioni esatte si possono trovare in \file{<bits/waitstatus.h>} ma
- questo file non deve mai essere usato direttamente, esso viene incluso
- attraverso \file{<sys/wait.h>}.}
+processo tramite il puntatore \param{status} (se non interessa memorizzare
+lo stato si può passare un puntatore nullo). Il valore restituito da
+entrambe le funzioni dipende dall'implementazione, e tradizionalmente alcuni
+bit (in genere 8) sono riservati per memorizzare lo stato di uscita, e altri
+per indicare il segnale che ha causato la terminazione (in caso di
+conclusione anomala), uno per indicare se è stato generato un
+\itindex{core~dump}\textit{core dump}, ecc.\footnote{le definizioni esatte
+ si possono trovare in \file{<bits/waitstatus.h>} ma questo file non deve
+ mai essere usato direttamente, esso viene incluso attraverso
+ \file{<sys/wait.h>}.}
Lo standard POSIX.1 definisce una serie di macro di preprocessore da usare per
analizzare lo stato di uscita. Esse sono definite sempre in
Le altre quattro funzioni si limitano invece a cercare di eseguire il file
indicato dall'argomento \param{path}, che viene interpretato come il
-\index{\textit{pathname}}\textit{pathname} del programma.
+\itindex{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{\textit{close-on-exec}} (vedi anche
+\textit{close-on-exec}\itindex{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{\textit{close-on-exec}} sulle directory che apre,
-in maniera trasparente all'utente.
+l'impostazione del flag di \textit{close-on-exec}\itindex{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_perms}
In questa sezione esamineremo le problematiche relative al controllo di
-accesso dal punto di vista del processi; vedremo quali sono gli identificatori
+accesso dal punto di vista dei processi; vedremo quali sono gli identificatori
usati, come questi possono essere modificati nella creazione e nel lancio di
nuovi processi, le varie funzioni per la loro manipolazione diretta e tutte le
problematiche connesse ad una gestione accorta dei privilegi.
Come accennato in sez.~\ref{sec:intro_multiuser} il modello base\footnote{in
realtà già esistono estensioni di questo modello base, che lo rendono più
- flessibile e controllabile, come le \textit{capabilities}, le ACL per i file
- o il \textit{Mandatory Access Control} di SELinux; inoltre basandosi sul
- lavoro effettuato con SELinux, a partire dal kernel 2.5.x, è iniziato lo
- sviluppo di una infrastruttura di sicurezza, il \textit{Linux Security
- Modules}, o LSM, in grado di fornire diversi agganci a livello del kernel
- per modularizzare tutti i possibili controlli di accesso.} di sicurezza di
-un sistema unix-like è fondato sui concetti di utente e gruppo, e sulla
+ flessibile e controllabile, come le
+ \itindex{capability}\textit{capabilities}, le ACL per i file o il
+ \textit{Mandatory Access Control} di SELinux; inoltre basandosi sul lavoro
+ effettuato con SELinux, a partire dal kernel 2.5.x, è iniziato lo sviluppo
+ di una infrastruttura di sicurezza, il \textit{Linux Security Modules}, o
+ LSM, in grado di fornire diversi agganci a livello del kernel per
+ modularizzare tutti i possibili controlli di accesso.} di sicurezza di un
+sistema unix-like è fondato sui concetti di utente e gruppo, e sulla
separazione fra l'amministratore (\textsl{root}, detto spesso anche
\textit{superuser}) che non è sottoposto a restrizioni, ed il resto degli
utenti, per i quali invece vengono effettuati i vari controlli di accesso.
Dato che tutte le operazioni del sistema vengono compiute dai processi, è
evidente che per poter implementare un controllo sulle operazioni occorre
anche poter identificare chi è che ha lanciato un certo programma, e pertanto
-anche a ciascun processo dovrà essere associato ad un utente e ad un gruppo.
+anche a ciascun processo dovrà essere associato un utente e un gruppo.
Un semplice controllo di una corrispondenza fra identificativi non garantisce
però sufficiente flessibilità per tutti quei casi in cui è necessario poter
Al secondo gruppo appartengono lo \textsl{user-ID effettivo} ed il
\textsl{group-ID effettivo} (a cui si aggiungono gli eventuali \textsl{group-ID
supplementari} dei gruppi dei quali l'utente fa parte). Questi sono invece
-gli identificatori usati nella verifiche dei permessi del processo e per il
+gli identificatori usati nelle verifiche dei permessi del processo e per il
controllo di accesso ai file (argomento affrontato in dettaglio in
sez.~\ref{sec:file_perm_overview}).
Anche queste funzioni sono un'estensione specifica di Linux, e non richiedono
nessun privilegio. I valori sono restituiti negli argomenti, che vanno
specificati come puntatori (è un altro esempio di
-\index{\textit{value~result~argument}}\textit{value result argument}). Si noti
-che queste funzioni sono le uniche in grado di leggere gli identificatori del
+\itindex{value~result~argument}\textit{value result argument}). Si noti che
+queste funzioni sono le uniche in grado di leggere gli identificatori del
gruppo \textit{saved}.
scrivere codice portabile.
-%\subsection{La gestione delle capabilities}
-%\label{sec:proc_capabilities}
-
+\subsection{La gestione delle capabilities}
+\label{sec:proc_capabilities}
+Da fare
\section{La gestione della priorità di esecuzione}
\label{sec:proc_priority}
In questa sezione tratteremo più approfonditamente i meccanismi con il quale
-lo \textit{scheduler}\index{\textit{scheduler}} assegna la CPU ai vari
+lo \textit{scheduler}\itindex{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}}
\label{sec:proc_sched}
+\itindbeg{scheduler}
La scelta di un meccanismo che sia in grado di distribuire in maniera efficace
il tempo di CPU per l'esecuzione dei processi è sempre una questione delicata,
ed oggetto di numerose ricerche; in generale essa dipende in maniera
cui non esiste un meccanismo che sia valido per tutti gli usi.
La caratteristica specifica di un sistema multitasking come Linux è quella del
-cosiddetto \textit{prehemptive multitasking}: questo significa che al
-contrario di altri sistemi (che usano invece il cosiddetto \textit{cooperative
+cosiddetto \itindex{prehemptive~multitasking}\textit{prehemptive
+ multitasking}: questo significa che al contrario di altri sistemi (che usano
+invece il cosiddetto \itindex{cooperative~multitasking}\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{\textit{scheduler}}, il cui
-scopo è quello di distribuire al meglio il tempo di CPU fra i vari processi.
+apposita del kernel, lo \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
nell'esecuzione.
Il meccanismo usato da Linux è piuttosto semplice,\footnote{in realtà nella
- serie 2.6.x lo \textit{scheduler} è stato riscritto da zero e può usare
- diversi algoritmi, selezionabili sia in fase di compilazione, che, nelle
- versioni più recenti, all'avvio (addirittura è stato ideato un sistema
- modulare che permette di cambiare lo scheduler al volo, che comunque non è
- incluso nel kernel ufficiale).} ad ogni processo è assegnata una
-\textit{time-slice}, cioè un intervallo di tempo (letteralmente una fetta) per
-il quale esso deve essere eseguito. Il valore della \textit{time-slice} è
-controllato dalla cosiddetta \textit{nice} (o \textit{niceness}) del processo.
-Essa è contenuta nel campo \var{nice} di \struct{task\_struct}; tutti i
-processi vengono creati con lo stesso valore, ed essa specifica il valore
-della durata iniziale della \textit{time-slice} 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{\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
- parità del valore di \var{counter} viene favorito chi ha una priorità più
- elevata.} chi ha il peso più alto verrà posto in esecuzione, ed il
-precedente processo sarà spostato in fondo alla coda. Dato che ad ogni
-interruzione del timer il valore di \var{counter} del processo corrente viene
-diminuito, questo assicura che anche i processi con priorità più bassa
-verranno messi in esecuzione.
+ serie 2.6.x lo scheduler è stato riscritto da zero e può usare diversi
+ algoritmi, selezionabili sia in fase di compilazione, che, nelle versioni
+ più recenti, all'avvio (addirittura è stato ideato un sistema modulare che
+ permette di cambiare lo scheduler al volo, che comunque non è incluso nel
+ kernel ufficiale).} ad ogni processo è assegnata una \textit{time-slice},
+cioè un intervallo di tempo (letteralmente una fetta) per il quale esso deve
+essere eseguito. Il valore della \textit{time-slice} è controllato dalla
+cosiddetta \textit{nice} (o \textit{niceness}) del processo. Essa è contenuta
+nel campo \var{nice} di \struct{task\_struct}; tutti i processi vengono creati
+con lo stesso valore, ed essa specifica il valore della durata iniziale della
+\textit{time-slice} 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 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 parità del valore di
+ \var{counter} viene favorito chi ha una priorità più elevata.} chi ha il
+peso più alto verrà posto in esecuzione, ed il precedente processo sarà
+spostato in fondo alla coda. Dato che ad ogni interruzione del timer il
+valore di \var{counter} del processo corrente viene diminuito, questo assicura
+che anche i processi con priorità più bassa verranno messi in esecuzione.
La priorità di un processo è così controllata attraverso il valore di
\var{nice}, che stabilisce la durata della \textit{time-slice}; per il
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{\textit{page~fault}} si possono avere ritardi non previsti.
+\textit{page fault}\itindex{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
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{\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:
+Quando c'è un processo con priorità assoluta lo 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 è
+scelta; 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 (con \func{sched\_yield}), si
funzioni che permettono di controllare in maniera più dettagliata la scelta di
quale processore utilizzare per eseguire un certo programma. Uno dei problemi
che si pongono nei sistemi multiprocessore è infatti quello
-dell'\textsl{effetto ping-pong}.\index{\textsl{effetto ping-pong}} Può
-accadere cioè che lo scheduler, quando riavvia un processo precedentemente
-interrotto, scegliendo il primo processore disponibile lo faccia eseguire da
-un processore diverso rispetto a quello su cui era stato eseguito in
-precedenza. Se il processo passa da un processore all'altro in questo modo
-(cosa che avveniva abbastanza di frequente con i kernel della seria 2.4.x) si
-ha l'\textsl{effetto ping-pong}.
+dell'\textsl{effetto ping-pong}.\index{effetto~ping-pong} Può accadere cioè
+che lo scheduler, quando riavvia un processo precedentemente interrotto,
+scegliendo il primo processore disponibile lo faccia eseguire da un processore
+diverso rispetto a quello su cui era stato eseguito in precedenza. Se il
+processo passa da un processore all'altro in questo modo (cosa che avveniva
+abbastanza di frequente con i kernel della seria 2.4.x) si ha
+l'\textsl{effetto ping-pong}.
Questo tipo di comportamento può generare dei seri problemi di prestazioni;
infatti tutti i processori moderni utilizzano una memoria interna (la
diventa serio quando si verifica l'\textsl{effetto ping-pong}, in tal caso
infatti un processo \textsl{rimbalza} continuamente da un processore all'altro
e si ha una continua invalidazione della cache, che non diventa mai
-disponibile.
+disponibile.
+\itindbeg{CPU~affinity}
Per ovviare a questo tipo di problemi è nato il concetto di \textsl{affinità
- di processore} (o \index{\textit{CPU~affinity}}\textit{CPU affinity}); la
+ di processore} (o \textit{CPU affinity}); la
possibilità cioè di far sì che un processo possa essere assegnato per
l'esecuzione sempre allo stesso processore. Lo scheduler dei kernel della
-serie 2.4.x aveva una scarsa \textit{CPU affinity}, e l'effetto ping-pong era
-comune; con il nuovo scheduler dei kernel della 2.6.x questo problema è stato
-risolto ed esso cerca di mantenere il più possibile ciascun processo sullo
-stesso processore.
+serie 2.4.x aveva una scarsa \textit{CPU affinity}, e
+\index{effetto~ping-pong} l'effetto ping-pong era comune; con il nuovo
+scheduler dei kernel della 2.6.x questo problema è stato risolto ed esso cerca
+di mantenere il più possibile ciascun processo sullo stesso processore.
In certi casi però resta l'esigenza di poter essere sicuri che un processo sia
sempre eseguito dallo stesso processore,\footnote{quella che viene detta
soltanto su un sistema multiprocessore, esse possono comunque essere
utilizzate anche in un sistema con un processore singolo, nel qual caso però
non avranno alcun risultato effettivo.
+\itindend{scheduler}
+\itindend{CPU~affinity}
+
\section{Problematiche di programmazione multitasking}
In un ambiente multitasking il concetto è essenziale, dato che un processo può
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{\textit{race~condition}} (vedi
-sez.~\ref{sec:proc_race_cond}) derivanti da operazioni interrotte in una fase
-in cui non erano ancora state completate.
+accorti nei confronti delle possibili \textit{race
+ condition}\itindex{race~condition} (vedi sez.~\ref{sec:proc_race_cond})
+derivanti da operazioni interrotte in una fase in cui non erano ancora state
+completate.
Nel caso dell'interazione fra processi la situazione è molto più semplice, ed
occorre preoccuparsi della atomicità delle operazioni solo quando si ha a che
\subsection{Le \textit{race condition} ed i \textit{deadlock}}
\label{sec:proc_race_cond}
-\index{\textit{race~condition}|(}
+\itindbeg{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
opportunamente protette da meccanismi di sincronizzazione (torneremo su queste
problematiche di questo tipo in cap.~\ref{cha:IPC}).
-\index{\textit{deadlock}|(}
+\itindbeg{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
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}|)}
+\itindend{race~condition}
+\itindend{deadlock}
\subsection{Le funzioni rientranti}