caratteristiche fondanti di Unix, che esamineremo in dettaglio più avanti, è
che qualunque processo può a sua volta generarne altri. Ogni processo è
identificato presso il sistema da un numero univoco, il cosiddetto
-\itindex{Process~ID~(PID)} \textit{Process ID} o, più brevemente, \ids{PID},
-assegnato in forma progressiva (vedi sez.~\ref{sec:proc_pid}) quando il
-processo viene creato.
+\textit{Process ID} o, più brevemente, \ids{PID}, assegnato in forma
+progressiva (vedi sez.~\ref{sec:proc_pid}) quando il processo viene creato.
Una seconda caratteristica di un sistema unix-like è che la generazione di un
processo è un'operazione separata rispetto al lancio di un programma. In
\ids{PID} successivi ad uno, sono in realtà processi interni al kernel e che
non rientrano in questa classificazione.}
+\itindbeg{process~table}
+
Il kernel mantiene una tabella dei processi attivi, la cosiddetta
-\itindex{process~table} \textit{process table}. Per ciascun processo viene
-mantenuta una voce in questa tabella, costituita da una struttura
-\kstruct{task\_struct}, che contiene tutte le informazioni rilevanti per quel
-processo. Tutte le strutture usate a questo scopo sono dichiarate
-nell'\textit{header file} \file{linux/sched.h}, ed uno schema semplificato,
-che riporta la struttura delle principali informazioni contenute nella
-\struct{task\_struct} (che in seguito incontreremo a più riprese), è mostrato
-in fig.~\ref{fig:proc_task_struct}.
+\textit{process table}. Per ciascun processo viene mantenuta una voce in
+questa tabella, costituita da una struttura \kstruct{task\_struct}, che
+contiene tutte le informazioni rilevanti per quel processo. Tutte le strutture
+usate a questo scopo sono dichiarate nell'\textit{header file}
+\file{linux/sched.h}, ed uno schema semplificato, che riporta la struttura
+delle principali informazioni contenute nella \struct{task\_struct} (che in
+seguito incontreremo a più riprese), è mostrato in
+fig.~\ref{fig:proc_task_struct}.
\begin{figure}[!htb]
\centering \includegraphics[width=14cm]{img/task_struct}
\label{fig:proc_task_struct}
\end{figure}
+\itindend{process~table}
+
% TODO la task_struct è cambiata per qualche dettaglio vedi anche
% http://www.ibm.com/developerworks/linux/library/l-linux-process-management/
% TODO completare la parte su quando viene chiamato lo scheduler.
\subsection{Gli identificatori dei processi}
\label{sec:proc_pid}
+\itindbeg{Process~ID~(PID)}
+
Come accennato nella sezione precedente ogni processo viene identificato dal
sistema da un numero identificativo univoco, il \textit{process ID} o
\ids{PID}. Questo è un tipo di dato standard, \type{pid\_t} che in genere è un
riparte dal numero più basso disponibile a partire da un minimo di
300,\footnote{questi valori, fino al kernel 2.4.x, erano definiti dalla macro
\const{PID\_MAX} nei file \file{threads.h} e \file{fork.c} dei sorgenti del
- kernel, con il 2.6.x e la nuova interfaccia per i \itindex{thread}
- \textit{thread} anche il meccanismo di allocazione dei \ids{PID} è stato
- modificato ed il valore massimo è impostabile attraverso il file
- \sysctlfile{kernel/pid\_max} e di default vale 32768.} che serve a
-riservare i \ids{PID} più bassi ai processi eseguiti direttamente dal kernel.
-Per questo motivo, come visto in sez.~\ref{sec:proc_hierarchy}, il processo di
-avvio (\cmd{init}) ha sempre il \ids{PID} uguale a uno.
+ kernel, con il 2.6.x e la nuova interfaccia per i \textit{thread} anche il
+ meccanismo di allocazione dei \ids{PID} è stato modificato ed il valore
+ massimo è impostabile attraverso il file \sysctlfile{kernel/pid\_max} e di
+ default vale 32768.} che serve a riservare i \ids{PID} più bassi ai processi
+eseguiti direttamente dal kernel. Per questo motivo, come visto in
+sez.~\ref{sec:proc_hierarchy}, il processo di avvio (\cmd{init}) ha sempre il
+\ids{PID} uguale a uno.
+
+\itindbeg{Parent~Process~ID~(PPID)}
Tutti i processi inoltre memorizzano anche il \ids{PID} del genitore da cui
sono stati creati, questo viene chiamato in genere \ids{PPID} (da
-\itindex{Parent~Process~ID~(PPID)} \textit{Parent Process ID}). Questi due
-identificativi possono essere ottenuti usando le due funzioni di sistema
-\funcd{getpid} e \funcd{getppid}, i cui prototipi sono:
+\textit{Parent Process ID}). Questi due identificativi possono essere
+ottenuti usando le due funzioni di sistema \funcd{getpid} e \funcd{getppid}, i
+cui prototipi sono:
\begin{funcproto}{
\fhead{sys/types.h}
l'argomento è complesso e sarà affrontato in dettaglio in
sez.~\ref{sec:proc_perms}.
+\itindend{Process~ID~(PID)}
+\itindend{Parent~Process~ID~(PPID)}
\subsection{La funzione \func{fork} e le funzioni di creazione dei processi}
\label{sec:proc_fork}
condivisa, pertanto padre e figlio vedranno variabili diverse e le eventuali
modifiche saranno totalmente indipendenti.
-Per quanto riguarda la gestione della memoria, in generale il
-\index{segmento!testo} segmento di testo, che è identico per i due processi, è
-condiviso e tenuto in sola lettura per il padre e per i figli. Per gli altri
-segmenti Linux utilizza la tecnica del \itindex{copy~on~write} \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.
+\itindbeg{copy~on~write}
+
+Per quanto riguarda la gestione della memoria, in generale il segmento di
+testo, che è identico per i due processi, è condiviso e tenuto in sola lettura
+per il padre e per i figli. Per gli altri segmenti Linux utilizza la tecnica
+del \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.
+
+\itindend{copy~on~write}
La differenza che si ha nei due processi è che nel processo padre il valore di
ritorno della funzione \func{fork} è il \ids{PID} del processo figlio, mentre
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 \itindex{race~condition} \textit{race
- condition} (vedi sez.~\ref{sec:proc_race_cond}).
+rischio di incorrere nelle cosiddette \textit{race condition} (vedi
+sez.~\ref{sec:proc_race_cond}).
In realtà con l'introduzione dei kernel della serie 2.6 lo \textit{scheduler}
è stato modificato per eseguire sempre per primo il figlio.\footnote{i
risultati precedenti infatti sono stati ottenuti usando un kernel della
serie 2.4.} Questa è una ottimizzazione adottata per evitare che il padre,
effettuando per primo una operazione di scrittura in memoria, attivasse il
-meccanismo del \itindex{copy~on~write} \textit{copy on write}, operazione
-inutile qualora il figlio venga creato solo per eseguire una \func{exec} su
-altro programma che scarta completamente lo spazio degli indirizzi e rende
-superflua la copia della memoria modificata dal padre. Eseguendo sempre per
-primo il figlio la \func{exec} verrebbe effettuata subito, con la certezza di
-utilizzare \itindex{copy~on~write} \textit{copy on write} solo quando
-necessario.
+meccanismo del \textit{copy on write}, operazione inutile qualora il figlio
+venga creato solo per eseguire una \func{exec} su altro programma che scarta
+completamente lo spazio degli indirizzi e rende superflua la copia della
+memoria modificata dal padre. Eseguendo sempre per primo il figlio la
+\func{exec} verrebbe effettuata subito, con la certezza di utilizzare
+\textit{copy on write} solo quando necessario.
Con il kernel 2.6.32 però il comportamento è stato nuovamente cambiato,
stavolta facendo eseguire per primo sempre il padre. Si è realizzato infatti
duplicare nei processi figli tutti i \textit{file descriptor} (vedi
sez.~\ref{sec:file_fd}) dei file aperti nel processo padre (allo stesso modo
in cui lo fa la funzione \func{dup}, trattata in sez.~\ref{sec:file_dup}), il
-che comporta che padre e figli condividono le stesse voci della
-\itindex{file~table} \textit{file table} (tratteremo in dettaglio questi
-termini in sez.~\ref{sec:file_shared_access}) fra cui c'è anche la posizione
-corrente nel file.
+che comporta che padre e figli condividono le stesse voci della \textit{file
+ table} (tratteremo in dettaglio questi termini in sez.~\ref{sec:file_fd} e
+sez.~\ref{sec:file_shared_access}) fra cui c'è anche la posizione corrente nel
+file.
In questo modo se un processo scrive su un file aggiornerà la posizione
-corrente sulla \itindex{file~table} \textit{file table}, e tutti gli altri
-processi, che vedono la stessa \itindex{file~table} \textit{file table},
-vedranno il nuovo valore. In questo modo si evita, in casi come quello appena
-mostrato in cui diversi processi scrivono sullo stesso file, che l'output
-successivo di un processo vada a sovrapporsi a quello dei precedenti: l'output
-potrà risultare mescolato, ma non ci saranno parti perdute per via di una
-sovrascrittura.
+corrente sulla \textit{file table}, e tutti gli altri processi, che vedono la
+stessa \textit{file table}, vedranno il nuovo valore. In questo modo si evita,
+in casi come quello appena mostrato in cui diversi processi scrivono sullo
+stesso file, che l'output successivo di un processo vada a sovrapporsi a
+quello dei precedenti: l'output potrà risultare mescolato, ma non ci saranno
+parti perdute per via di una sovrascrittura.
Questo tipo di comportamento è essenziale in tutti quei casi in cui il padre
crea un figlio e attende la sua conclusione per proseguire, ed entrambi
reale}, il \textsl{group-ID reale}, l'\textsl{user-ID effettivo}, il
\textsl{group-ID effettivo} ed i \textsl{group-ID supplementari} (vedi
sez.~\ref{sec:proc_access_id});
-\item gli identificatori per il controllo di sessione: il
- \itindex{process~group} \textit{process group-ID} e il \textit{session id}
- ed il terminale di controllo (vedi sez.~\ref{sec:sess_proc_group});
+\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});
\item la directory di lavoro (vedi sez.~\ref{sec:file_work_dir}) e la
directory radice (vedi sez.~\ref{sec:file_chroot});
\item la maschera dei permessi di creazione dei file (vedi
\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 \itindex{copy~on~write} \textit{copy on write} la
-perdita di prestazioni è assolutamente trascurabile, e l'uso di questa
-funzione, che resta un caso speciale della \textit{system call} \func{clone}
-(che tratteremo in dettaglio in sez.~\ref{sec:process_clone}) è deprecato; per
-questo eviteremo di trattarla ulteriormente.
+Dato che Linux supporta il \textit{copy on write} la perdita di prestazioni è
+assolutamente trascurabile, e l'uso di questa funzione, che resta un caso
+speciale della \textit{system call} \func{clone} (che tratteremo in dettaglio
+in sez.~\ref{sec:process_clone}) è deprecato; per questo eviteremo di
+trattarla ulteriormente.
\subsection{La conclusione di un processo}
Oltre queste operazioni è però necessario poter disporre di un meccanismo
ulteriore che consenta di sapere come la terminazione è avvenuta: dato che in
un sistema unix-like tutto viene gestito attraverso i processi, il meccanismo
-scelto consiste nel riportare lo \itindex{termination~status} \textsl{stato di
- terminazione} (il cosiddetto \textit{termination status}) al processo padre.
+scelto consiste nel riportare lo \textsl{stato di terminazione} (il cosiddetto
+\textit{termination status}) al processo padre.
Nel caso di conclusione normale, abbiamo visto in
sez.~\ref{sec:proc_conclusion} che lo stato di uscita del processo viene
dal processo (vedi sez.~\ref{sec:sys_unix_time}) e lo stato di terminazione,
mentre la memoria in uso ed i file aperti vengono rilasciati immediatamente.
+\itindbeg{zombie}
+
I processi che sono terminati, ma il cui stato di terminazione non è stato
-ancora ricevuto dal padre sono chiamati \itindex{zombie} \textit{zombie}, essi
-restano presenti nella tabella dei processi ed in genere possono essere
-identificati dall'output di \cmd{ps} per la presenza di una \texttt{Z} nella
-colonna che ne indica lo stato (vedi tab.~\ref{tab:proc_proc_states}). Quando
-il padre effettuerà la lettura dello stato di terminazione anche questa
-informazione, non più necessaria, verrà scartata ed il processo potrà
-considerarsi completamente concluso.
+ancora ricevuto dal padre sono chiamati \textit{zombie}, essi restano presenti
+nella tabella dei processi ed in genere possono essere identificati
+dall'output di \cmd{ps} per la presenza di una \texttt{Z} nella colonna che ne
+indica lo stato (vedi tab.~\ref{tab:proc_proc_states}). Quando il padre
+effettuerà la lettura dello stato di terminazione anche questa informazione,
+non più necessaria, verrà scartata ed il processo potrà considerarsi
+completamente concluso.
Possiamo utilizzare il nostro programma di prova per analizzare anche questa
condizione: lanciamo il comando \cmd{forktest} in \textit{background} (vedi
%$
e come si vede, dato che non si è fatto nulla per riceverne lo stato di
terminazione, i tre processi figli sono ancora presenti pur essendosi
-conclusi, con lo stato di \itindex{zombie} \textit{zombie} e l'indicazione che
-sono terminati (la scritta \texttt{defunct}).
-
-La possibilità di avere degli \itindex{zombie} \textit{zombie} deve essere
-tenuta sempre presente quando si scrive un programma che deve essere mantenuto
-in esecuzione a lungo e creare molti processi figli. In questo caso si deve
-sempre avere cura di far leggere al programma l'eventuale stato di uscita di
-tutti i figli. Una modalità comune di farlo è attraverso l'utilizzo di un
-apposito \textit{signal handler} che chiami la funzione \func{wait}, (vedi
+conclusi, con lo stato di \textit{zombie} e l'indicazione che sono terminati
+(la scritta \texttt{defunct}).
+
+La possibilità di avere degli \textit{zombie} deve essere tenuta sempre
+presente quando si scrive un programma che deve essere mantenuto in esecuzione
+a lungo e creare molti processi figli. In questo caso si deve sempre avere
+cura di far leggere al programma l'eventuale stato di uscita di tutti i
+figli. Una modalità comune di farlo è attraverso l'utilizzo di un apposito
+\textit{signal handler} che chiami la funzione \func{wait}, (vedi
sez.~\ref{sec:proc_wait}), ne esamineremo in dettaglio un esempio
(fig.~\ref{fig:sig_sigchld_handl}) in sez.~\ref{sec:sig_sigchld}.
La lettura degli stati di uscita è necessaria perché anche se gli
-\itindex{zombie} \textit{zombie} non consumano risorse di memoria o
-processore, occupano comunque una voce nella tabella dei processi e se li si
-lasciano accumulare a lungo quest'ultima potrebbe esaurirsi, con la
-conseguente impossibilità di lanciare nuovi processi.
+\textit{zombie} non consumano risorse di memoria o processore, occupano
+comunque una voce nella tabella dei processi e se li si lasciano accumulare a
+lungo quest'ultima potrebbe esaurirsi, con la conseguente impossibilità di
+lanciare nuovi processi.
Si noti tuttavia che quando un processo adottato da \cmd{init} termina, non
-diviene mai uno \itindex{zombie} \textit{zombie}. Questo perché una delle
-funzioni di \cmd{init} è appunto quella di chiamare la funzione \func{wait}
-per i processi a cui fa da padre, completandone la terminazione. Questo è
-quanto avviene anche quando, come nel caso del precedente esempio con
-\cmd{forktest}, il padre termina con dei figli in stato di \itindex{zombie}
-\textit{zombie}. Questi scompaiono quando, alla terminazione del padre dopo i
-secondi programmati, tutti figli che avevamo generato, e che erano diventati
-\itindex{zombie} \textit{zombie}, vengono adottati da \cmd{init}, il quale
-provvede a completarne la terminazione.
-
-Si tenga presente infine che siccome gli \itindex{zombie} \textit{zombie} sono
-processi già terminati, non c'è modo di eliminarli con il comando \cmd{kill} o
-inviandogli un qualunque segnale di terminazione (l'argomento è trattato in
+diviene mai uno \textit{zombie}. Questo perché una delle funzioni di
+\cmd{init} è appunto quella di chiamare la funzione \func{wait} per i processi
+a cui fa da padre, completandone la terminazione. Questo è quanto avviene
+anche quando, come nel caso del precedente esempio con \cmd{forktest}, il
+padre termina con dei figli in stato di \textit{zombie}. Questi scompaiono
+quando, alla terminazione del padre dopo i secondi programmati, tutti figli
+che avevamo generato, e che erano diventati \textit{zombie}, vengono adottati
+da \cmd{init}, il quale provvede a completarne la terminazione.
+
+Si tenga presente infine che siccome gli \textit{zombie} sono processi già
+terminati, non c'è modo di eliminarli con il comando \cmd{kill} o inviandogli
+un qualunque segnale di terminazione (l'argomento è trattato in
sez.~\ref{sec:sig_termination}). Qualora ci si trovi in questa situazione
l'unica possibilità di cancellarli dalla tabella dei processi è quella di
terminare il processo che li ha generati e che non sta facendo il suo lavoro,
in modo che \cmd{init} possa adottarli e concluderne correttamente la
-terminazione.
+terminazione.
Si tenga anche presente che la presenza di \textit{zombie} nella tabella dei
processi non è sempre indice di un qualche malfunzionamento, in una macchina
con molto carico infatti può esservi una presenza temporanea dovuta al fatto
che il processo padre ancora non ha avuto il tempo di gestirli.
+\itindend{zombie}
+
+
\subsection{Le funzioni di attesa e ricezione degli stati di uscita}
\label{sec:proc_wait}
Si è già sottolineato al paragrafo precedente come in questo caso diventi
necessario gestire esplicitamente la conclusione dei figli onde evitare di
-riempire di \itindex{zombie} \textit{zombie} la tabella dei
-processi. Tratteremo in questa sezione le funzioni di sistema deputate a
-questo compito; la prima è \funcd{wait} ed il suo prototipo è:
+riempire di \textit{zombie} la tabella dei processi. Tratteremo in questa
+sezione le funzioni di sistema deputate a questo compito; la prima è
+\funcd{wait} ed il suo prototipo è:
\begin{funcproto}{
\fhead{sys/types.h}
\ids{PID} del processo di cui si è ricevuto lo stato di terminazione, cosa che
permette di identificare qual è il figlio che è terminato.
-\itindend{termination~status}
+\itindend{termination~status}
Questa funzione ha il difetto di essere poco flessibile, in quanto ritorna
all'uscita di un qualunque processo figlio. Nelle occasioni in cui è
\textbf{Valore} & \textbf{Costante} &\textbf{Significato}\\
\hline
\hline
- $<-1$& -- & Attende per un figlio il cui
- \itindex{process~group} \textit{process group}
- (vedi sez.~\ref{sec:sess_proc_group}) è uguale
- al valore assoluto di \param{pid}.\\
+ $<-1$& -- & Attende per un figlio il cui \textit{process
+ group} (vedi sez.~\ref{sec:sess_proc_group}) è
+ uguale al valore assoluto di \param{pid}.\\
$-1$&\const{WAIT\_ANY} & Attende per un figlio qualsiasi, usata in
questa maniera senza specificare nessuna opzione
è equivalente a \func{wait}.\\
- $ 0$&\const{WAIT\_MYPGRP}&Attende per un figlio il cui
- \itindex{process~group} \textit{process group}
- (vedi sez.~\ref{sec:sess_proc_group}) è
+ $ 0$&\const{WAIT\_MYPGRP}&Attende per un figlio il cui \textit{process
+ group} (vedi sez.~\ref{sec:sess_proc_group}) è
uguale a quello del processo chiamante.\\
$>0$& -- & Attende per un figlio il cui \ids{PID} è uguale
al valore di \param{pid}.\\
Linux, che consentono un controllo più dettagliato per i processi creati con
la \textit{system call} generica \func{clone} (vedi
sez.~\ref{sec:process_clone}) e che vengono usati principalmente per la
-gestione della terminazione dei \itindex{thread} \textit{thread} (vedi
+gestione della terminazione dei \textit{thread} (vedi
sez.~\ref{sec:thread_xxx}).
\begin{table}[!htb]
In generale in un programma non si vuole essere forzati ad attendere la
conclusione di un processo figlio per proseguire l'esecuzione, specie se tutto
questo serve solo per leggerne lo stato di chiusura (ed evitare eventualmente
-la presenza di \itindex{zombie} \textit{zombie}). Per questo la modalità più
-comune di chiamare queste funzioni è quella di utilizzarle all'interno di un
+la presenza di \textit{zombie}). Per questo la modalità più comune di
+chiamare queste funzioni è quella di utilizzarle all'interno di un
\textit{signal handler} (vedremo un esempio di come gestire \signal{SIGCHLD}
con i segnali in sez.~\ref{sec:sig_example}). In questo caso infatti, dato che
il segnale è generato dalla terminazione di un figlio, avremo la certezza che
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{EPERM}] il file ha i bit \itindex{suid~bit} \acr{suid} o
- \itindex{sgid~bit} \acr{sgid} e l'utente non è root, ed il processo viene
- tracciato, oppure il filesystem è montato con l'opzione \cmd{nosuid}.
+ \item[\errcode{EPERM}] il file ha i bit \acr{suid} o \acr{sgid} e l'utente
+ non è root, ed il processo viene tracciato, oppure il filesystem è montato
+ con l'opzione \cmd{nosuid}.
\item[\errcode{ETXTBSY}] l'eseguibile è aperto in scrittura da uno o più
processi.
\item[\errcode{E2BIG}] la lista degli argomenti è troppo grande.
\item il valori di \textit{nice}, le priorità real-time e le affinità di
processore (vedi sez.~\ref{sec:proc_sched_stand};
sez.~\ref{sec:proc_real_time} e sez.~\ref{sec:proc_sched_multiprocess});
-\item il \textit{session ID} (\acr{sid}) ed il \itindex{process~group}
- \textit{process group ID} (\acr{pgid}), vedi sez.~\ref{sec:sess_proc_group};
+\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});
\item i limiti sulle risorse (vedi sez.~\ref{sec:sys_resource_limit});
relativi (vedi sez.~\ref{sec:thread_xxx}) rimossi;
\item viene impostato il flag \const{PR\_SET\_DUMPABLE} di \func{prctl} (vedi
sez.~\ref{sec:process_prctl}) a meno che il programma da eseguire non sia
- \itindex{suid~bit} \acr{suid} o \itindex{sgid~bit} \acr{sgid} (vedi
- sez.~\ref{sec:proc_access_id});
+ \acr{suid} o \acr{sgid} (vedi sez.~\ref{sec:proc_access_id} e
+ sez.~\ref{sec:file_special_perm});
\item il flag \const{PR\_SET\_KEEPCAPS} di \func{prctl} (vedi
sez.~\ref{sec:process_prctl}) viene cancellato;
\item il nome del processo viene impostato al nome del file contenente il
\itindend{close-on-exec}
-
Il comportamento della funzione in relazione agli identificatori relativi al
controllo di accesso verrà trattato in dettaglio in sez.~\ref{sec:proc_perms},
qui è sufficiente anticipare (si faccia riferimento a
stessi, mentre l'\textsl{user-ID salvato} ed il \textsl{group-ID salvato}
vengono impostati rispettivamente all'\textsl{user-ID effettivo} ed il
\textsl{group-ID effettivo}. Questi ultimi normalmente non vengono modificati,
-a meno che il file di cui viene chiesta l'esecuzione non abbia o il
-\itindex{suid~bit} \acr{suid} bit o lo \itindex{sgid~bit} \acr{sgid} bit
-impostato, in questo caso l'\textsl{user-ID effettivo} ed il \textsl{group-ID
- effettivo} vengono impostati rispettivamente all'utente o al gruppo cui il
-file appartiene.
+a meno che il file di cui viene chiesta l'esecuzione non abbia o il \acr{suid}
+bit o lo \acr{sgid} bit impostato (vedi sez.~\ref{sec:file_special_perm}), in
+questo caso l'\textsl{user-ID effettivo} ed il \textsl{group-ID effettivo}
+vengono impostati rispettivamente all'utente o al gruppo cui il file
+appartiene.
Se il file da eseguire è in formato \emph{a.out} e necessita di librerie
condivise, viene lanciato il \textit{linker} dinamico \cmd{/lib/ld.so} prima
accesso.
Abbiamo già accennato come il sistema associ ad ogni utente e gruppo due
-identificatori univoci, lo \itindex{User~ID~(PID)} \textsl{User-ID}
-(abbreviato in \ids{UID}) ed il \itindex{Group~ID~(PID)} \textsl{Group-ID}
+identificatori univoci, lo \itindex{User~ID~(UID)} \textsl{User-ID}
+(abbreviato in \ids{UID}) ed il \itindex{Group~ID~(GID)} \textsl{Group-ID}
(abbreviato in \ids{GID}). Questi servono al kernel per identificare uno
specifico utente o un gruppo di utenti, per poi poter controllare che essi
siano autorizzati a compiere le operazioni richieste. Ad esempio in
Questi identificatori normalmente sono identici ai corrispondenti del gruppo
\textit{real} tranne nel caso in cui, come accennato in
sez.~\ref{sec:proc_exec}, il programma che si è posto in esecuzione abbia i
-bit \itindex{suid~bit} \acr{suid} o \itindex{sgid~bit} \acr{sgid} impostati
-(il significato di questi bit è affrontato in dettaglio in
-sez.~\ref{sec:file_special_perm}). In questo caso essi saranno impostati
-all'utente e al gruppo proprietari del file. Questo consente, per programmi in
-cui ci sia questa necessità, di dare a qualunque utente i privilegi o i
-permessi di un altro, compreso l'amministratore.
+bit \acr{suid} o \acr{sgid} impostati (il significato di questi bit è
+affrontato in dettaglio in sez.~\ref{sec:file_special_perm}). In questo caso
+essi saranno impostati all'utente e al gruppo proprietari del file. Questo
+consente, per programmi in cui ci sia questa necessità, di dare a qualunque
+utente i privilegi o i permessi di un altro, compreso l'amministratore.
Come nel caso del \ids{PID} e del \ids{PPID}, anche tutti questi
identificatori possono essere ottenuti da un programma attraverso altrettante
processo padre, e vengono impostati dalla funzione \func{exec} all'avvio del
processo, come copie dell'\ids{UID} \textsl{effettivo} e del \ids{GID}
\textsl{effettivo} dopo che questi sono stati impostati tenendo conto di
-eventuali \itindex{suid~bit} \acr{suid} o \itindex{sgid~bit} \acr{sgid}. Essi
-quindi consentono di tenere traccia di quale fossero utente e gruppo effettivi
-all'inizio dell'esecuzione di un nuovo programma.
+eventuali permessi \acr{suid} o \acr{sgid} (su cui torneremo in
+sez.~\ref{sec:file_special_perm}). Essi quindi consentono di tenere traccia
+di quale fossero utente e gruppo effettivi all'inizio dell'esecuzione di un
+nuovo programma.
L'\ids{UID} \textsl{di filesystem} e il \ids{GID} \textsl{di filesystem} sono
un'estensione introdotta in Linux per rendere più sicuro l'uso di NFS
altri casi viene segnalato un errore con \errcode{EPERM}.
Come accennato l'uso principale di queste funzioni è quello di poter
-consentire ad un programma con i bit \itindex{suid~bit} \acr{suid} o
-\itindex{sgid~bit} \acr{sgid} impostati (vedi
+consentire ad un programma con i bit \acr{suid} o \acr{sgid} impostati (vedi
sez.~\ref{sec:file_special_perm}) di riportare l'\ids{UID} effettivo a quello
dell'utente che ha lanciato il programma, effettuare il lavoro che non
necessita di privilegi aggiuntivi, ed eventualmente tornare indietro.
interrotto in nessuna circostanza.\\
\textit{stopped} & \texttt{T} & Il processo è stato fermato con un
\signal{SIGSTOP}, o è tracciato.\\
- \textit{zombie}\itindex{zombie}& \texttt{Z} & Il processo è terminato ma il
+ \textit{zombie} & \texttt{Z} & Il processo è terminato ma il
suo stato di terminazione non è ancora
stato letto dal padre.\\
\textit{killable}& \texttt{D} & Un nuovo stato introdotto con il kernel
\hline
\hline
\const{PRIO\_PROCESS} & \type{pid\_t} & processo \\
- \const{PRIO\_PRGR} & \type{pid\_t} & \itindex{process~group}
- \textit{process group}\\
+ \const{PRIO\_PRGR} & \type{pid\_t} & \textit{process group} (vedi
+ sez.~\ref{sec:sess_proc_group})\\
\const{PRIO\_USER} & \type{uid\_t} & utente \\
\hline
\end{tabular}
multiprocessore}
\label{sec:proc_sched_multiprocess}
+\index{effetto~ping-pong|(}
+
Con il supporto dei sistemi multiprocessore sono state introdotte delle
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 del cosiddetto
-\index{effetto~ping-pong} \textsl{effetto ping-pong}. Può accadere cioè che lo
-\textit{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}.
+\textsl{effetto ping-pong}. Può accadere cioè che lo \textit{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'effetto ping-pong.
Questo tipo di comportamento può generare dei seri problemi di prestazioni;
infatti tutti i processori moderni utilizzano una memoria interna (la
Questo comporta che quando un processore inserisce un dato nella sua cache,
tutti gli altri processori che hanno lo stesso dato devono invalidarlo, e
questa operazione è molto costosa in termini di prestazioni. Il problema
-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.
+diventa serio quando si verifica l'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.
\itindbeg{CPU~affinity}
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 \textit{scheduler} dei kernel della serie 2.4.x aveva una
-scarsa \textit{CPU affinity}, e \index{effetto~ping-pong} l'effetto ping-pong
-era comune; con il nuovo \textit{scheduler} dei kernel della 2.6.x questo
-problema è stato risolto ed esso cerca di mantenere il più possibile ciascun
-processo sullo stesso processore.
+scarsa \textit{CPU affinity}, e l'effetto ping-pong era comune; con il nuovo
+\textit{scheduler} dei kernel della 2.6.x questo problema è stato risolto ed
+esso cerca di mantenere il più possibile ciascun processo sullo stesso
+processore.
+
+\index{effetto~ping-pong|)}
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
(\textit{Non-Uniform Memory Access}).
Infine se un gruppo di processi accede alle stesse risorse condivise (ad
-esempio una applicazione con più \itindex{thread} \textit{thread}) può avere
-senso usare lo stesso processore in modo da sfruttare meglio l'uso della sua
-cache; questo ovviamente riduce i benefici di un sistema multiprocessore
-nell'esecuzione contemporanea dei \itindex{thread} \textit{thread}, ma in
-certi casi (quando i \itindex{thread} \textit{thread} sono inerentemente
-serializzati nell'accesso ad una risorsa) possono esserci sufficienti vantaggi
-nell'evitare la perdita della cache da rendere conveniente l'uso dell'affinità
-di processore.
+esempio una applicazione con più \textit{thread}) può avere senso usare lo
+stesso processore in modo da sfruttare meglio l'uso della sua cache; questo
+ovviamente riduce i benefici di un sistema multiprocessore nell'esecuzione
+contemporanea dei \textit{thread}, ma in certi casi (quando i \textit{thread}
+sono inerentemente serializzati nell'accesso ad una risorsa) possono esserci
+sufficienti vantaggi nell'evitare la perdita della cache da rendere
+conveniente l'uso dell'affinità di processore.
Dato che il numero di processori può variare a seconda delle architetture, per
semplificare l'uso dell'argomento \param{mask} la \acr{glibc} ha introdotto un
restituisce un intero da usare come valore logico (zero se la CPU non è
presente, diverso da zero se è presente).
+\itindbeg{side~effects}
Si tenga presente che trattandosi di macro l'argomento \param{cpu} può essere
valutato più volte. Questo significa ad esempio che non si può usare al suo
posto una funzione o un'altra macro, altrimenti queste verrebbero eseguite più
volte, l'argomento cioè non deve avere \textsl{effetti collaterali} (in gergo
-\itindex{side~effects} \textit{side effects}).\footnote{nel linguaggio C si
+ \textit{side effects}).\footnote{nel linguaggio C si
parla appunto di \textit{side effects} quando si usano istruzioni la cui
valutazione comporta effetti al di fuori dell'istruzione stessa, come il
caso indicato in cui si passa una funzione ad una macro che usa l'argomento
al suo interno più volte, o si scrivono espressioni come \code{a=a++} in cui
non è chiaro se prima avvenga l'incremento e poi l'assegnazione, ed il cui
risultato dipende dall'implementazione del compilatore.}
+\itindend{side~effects}
+
Le CPU sono numerate da zero (che indica la prima disponibile) fino ad
un numero massimo che dipende dalla architettura hardware. La costante
\hline
\hline
\const{IPRIO\_WHO\_PROCESS} & \type{pid\_t} & processo\\
- \const{IPRIO\_WHO\_PRGR} & \type{pid\_t} & \itindex{process~group}
- \textit{process group}\\
+ \const{IPRIO\_WHO\_PRGR} & \type{pid\_t} & \textit{process group}\\
\const{IPRIO\_WHO\_USER} & \type{uid\_t} & utente\\
\hline
\end{tabular}
per \param{arg2} comporta che vengano cancellate, il valore 1 che vengano
mantenute, questo valore viene sempre cancellato attraverso una \func{exec}.
L'uso di questo flag è stato sostituito, a partire dal kernel 2.6.26, dal
- flag \const{SECURE\_KEEP\_CAPS} dei \itindex{securebits} \textit{securebits}
- (vedi l'uso di \const{PR\_SET\_SECUREBITS} più avanti). Introdotta a partire
- dal kernel 2.2.18.
+ flag \const{SECURE\_KEEP\_CAPS} dei \textit{securebits} (vedi
+ sez.~\ref{sec:proc_capabilities} e l'uso di \const{PR\_SET\_SECUREBITS} più
+ avanti). Introdotta a partire dal kernel 2.2.18.
\item[\const{PR\_GET\_KEEPCAPS}] Ottiene come valore di ritorno della funzione
il valore del flag di controllo delle \textit{capabilities} impostato con
puntato \param{arg2}, che deve essere di tipo ``\ctyp{int *}''. Introdotta a
partire dal kernel 2.3.15.
-\item[\const{PR\_SET\_SECCOMP}] Imposta il cosiddetto
- \itindex{secure~computing~mode} \textit{secure computing mode} per il
- processo corrente. Prevede come unica possibilità che \param{arg2} sia
- impostato ad 1. Una volta abilitato il \itindex{secure~computing~mode}
- \textit{secure computing mode} il processo potrà utilizzare soltanto un
- insieme estremamente limitato di \textit{system call}: \func{read},
- \func{write}, \func{\_exit} e \funcm{sigreturn}. Ogni altra \textit{system
- call} porterà all'emissione di un \signal{SIGKILL} (vedi
- sez.~\ref{sec:sig_termination}). Il \textit{secure computing mode} è stato
- ideato per fornire un supporto per l'esecuzione di codice esterno non fidato
- e non verificabile a scopo di calcolo;\footnote{lo scopo è quello di poter
- vendere la capacità di calcolo della proprio macchina ad un qualche
- servizio di calcolo distribuito senza comprometterne la sicurezza
- eseguendo codice non sotto il proprio controllo.} in genere i dati vengono
- letti o scritti grazie ad un socket o una \textit{pipe}, e per evitare
- problemi di sicurezza non sono possibili altre operazioni se non quelle
- citate. Introdotta a partire dal kernel 2.6.23, disponibile solo se si è
- abilitato il supporto nel kernel con \texttt{CONFIG\_SECCOMP}.
+\itindbeg{secure~computing~mode}
+\item[\const{PR\_SET\_SECCOMP}] Imposta il cosiddetto \textit{secure computing
+ mode} per il processo corrente. Prevede come unica possibilità
+ che \param{arg2} sia impostato ad 1. Una volta abilitato il \textit{secure
+ computing mode} il processo potrà utilizzare soltanto un insieme
+ estremamente limitato di \textit{system call}: \func{read}, \func{write},
+ \func{\_exit} e \funcm{sigreturn}. Ogni altra \textit{system call} porterà
+ all'emissione di un \signal{SIGKILL} (vedi sez.~\ref{sec:sig_termination}).
+ Il \textit{secure computing mode} è stato ideato per fornire un supporto per
+ l'esecuzione di codice esterno non fidato e non verificabile a scopo di
+ calcolo;\footnote{lo scopo è quello di poter vendere la capacità di calcolo
+ della proprio macchina ad un qualche servizio di calcolo distribuito senza
+ comprometterne la sicurezza eseguendo codice non sotto il proprio
+ controllo.} in genere i dati vengono letti o scritti grazie ad un socket o
+ una \textit{pipe}, e per evitare problemi di sicurezza non sono possibili
+ altre operazioni se non quelle citate. Introdotta a partire dal kernel
+ 2.6.23, disponibile solo se si è abilitato il supporto nel kernel con
+ \texttt{CONFIG\_SECCOMP}.
% TODO a partire dal kernel 3.5 è stato introdotto la possibilità di usare un
% terzo argomento se il secondo è SECCOMP_MODE_FILTER, vedi
\item[\const{PR\_GET\_SECCOMP}] Ottiene come valore di ritorno della funzione
lo stato corrente del \textit{secure computing mode}, al momento attuale la
funzione è totalmente inutile in quanto l'unico valore ottenibile è 0, dato
- che la chiamata di questa funzione in \itindex{secure~computing~mode}
- \textit{secure computing mode} comporterebbe l'emissione di
- \signal{SIGKILL}, è stata comunque definita per eventuali estensioni future.
- Introdotta a partire dal kernel 2.6.23.
-
-\item[\const{PR\_SET\_SECUREBITS}] Imposta i \itindex{securebits}
- \textit{securebits} per il processo chiamante al valore indicato
- da \param{arg2}; per i dettagli sul significato dei \textit{securebits} si
- veda sez.~\ref{sec:proc_capabilities}, ed in particolare i valori di
+ che la chiamata di questa funzione in \textit{secure computing mode}
+ comporterebbe l'emissione di \signal{SIGKILL}, è stata comunque definita per
+ eventuali estensioni future. Introdotta a partire dal kernel 2.6.23.
+\itindend{secure~computing~mode}
+
+\item[\const{PR\_SET\_SECUREBITS}] Imposta i \textit{securebits} per il
+ processo chiamante al valore indicato da \param{arg2}; per i dettagli sul
+ significato dei \textit{securebits} si veda
+ sez.~\ref{sec:proc_capabilities}, ed in particolare i valori di
tab.~\ref{tab:securebits_values} e la relativa trattazione. L'operazione
richiede i privilegi di amministratore (la capacità \const{CAP\_SETPCAP}),
altrimenti la chiamata fallirà con un errore di \errval{EPERM}. Introdotta a
partire dal kernel 2.6.26.
\item[\const{PR\_GET\_SECUREBITS}] Ottiene come valore di ritorno della
- funzione l'impostazione corrente per i \itindex{securebits}
- \textit{securebits}. Introdotta a partire dal kernel 2.6.26.
+ funzione l'impostazione corrente per i \textit{securebits}. Introdotta a
+ partire dal kernel 2.6.26.
\item[\const{PR\_SET\_TIMING}] Imposta il metodo di temporizzazione del
processo da indicare con il valore di \param{arg2}, attualmente i valori
abilitare la lettura o \const{PR\_TSC\_SIGSEGV} per disabilitarla con la
generazione di un segnale di \signal{SIGSEGV} (vedi
sez.~\ref{sec:sig_prog_error}). La lettura viene automaticamente
- disabilitata se si attiva il \itindex{secure~computing~mode} \textit{secure
- computing mode}. Introdotta a partire dal kernel 2.6.26, solo su x86.
+ disabilitata se si attiva il \textit{secure computing mode} (vedi
+ \const{PR\_SET\_SECCOMP} più avanti). Introdotta a partire dal kernel
+ 2.6.26, solo su x86.
\item[\const{PR\_GET\_TSC}] Ottiene il valore del flag che controlla la
lettura del contattore dei \textit{timestamp}, salvato all'indirizzo
memoria. Tutti gli argomenti non utilizzati (al momento tutti) devono essere
nulli pena la ricezione di un errore di \errval{EINVAL}. Introdotta a
partire dal kernel 2.6.32.
-\itindbeg{child reaper}
+\itindbeg{child~reaper}
\item[\const{PR\_SET\_CHILD\_SUBREAPER}] Se \param{arg2} è diverso da zero
imposta l'attributo di \textit{child reaper} per il processo, se nullo lo
cancella. Lo stato di \textit{child reaper} è una funzionalità, introdotta
come di tipo \code{int *}). Il valore viene letto come valore logico, se
diverso da 0 lo stato di \textit{child reaper} è attivo altrimenti è
disattivo. Introdotta a partire dal kernel 3.4.
-\itindend{child reaper}
+\itindend{child~reaper}
% TODO documentare PR_SET_SECCOMP introdotto a partire dal kernel 3.5. Vedi:
Oltre a questo la funzione consente, ad uso delle nuove funzionalità di
virtualizzazione dei processi, di creare nuovi \textit{namespace} per una
serie di proprietà generali dei processi (come l'elenco dei \ids{PID},
-l'albero dei file, i \itindex{mount~point} \textit{mount point}, la rete,
-ecc.), che consentono di creare gruppi di processi che vivono in una sorta di
-spazio separato dagli altri, che costituisce poi quello che viene chiamato un
-\textit{container}.
+l'albero dei file, i \textit{mount point}, la rete, ecc.), che consentono di
+creare gruppi di processi che vivono in una sorta di spazio separato dagli
+altri, che costituisce poi quello che viene chiamato un \textit{container}.
La \textit{system call} richiede soltanto due argomenti: il
primo, \param{flags}, consente di controllare le modalità di creazione del
\textit{stack}).
Per evitare di doversi garantire contro la evidente possibilità di
-\itindex{race~condition} \textit{race condition} che questa situazione
-comporta (vedi sez.~\ref{sec:proc_race_cond} per una spiegazione della
-problematica) è necessario che il chiamante allochi preventivamente un'area di
-memoria. In genere lo si fa con una \func{malloc} che allochi un buffer che
-la funzione imposterà come \textit{stack} del nuovo processo, avendo
-ovviamente cura di non utilizzarlo direttamente nel processo chiamante.
+\textit{race condition} che questa situazione comporta (vedi
+sez.~\ref{sec:proc_race_cond} per una spiegazione della problematica) è
+necessario che il chiamante allochi preventivamente un'area di memoria. In
+genere lo si fa con una \func{malloc} che allochi un buffer che la funzione
+imposterà come \textit{stack} del nuovo processo, avendo ovviamente cura di
+non utilizzarlo direttamente nel processo chiamante.
In questo modo i due \textit{task} avranno degli \textit{stack} indipendenti e
-non si dovranno affrontare problematiche di \itindex{race~condition}
-\textit{race condition}. Si tenga presente inoltre che in molte architetture
-di processore lo \textit{stack} cresce verso il basso, pertanto in tal caso
-non si dovrà specificare per \param{child\_stack} il puntatore restituito da
-\func{malloc}, ma un puntatore alla fine del buffer da essa allocato.
+non si dovranno affrontare problematiche di \textit{race condition}. Si tenga
+presente inoltre che in molte architetture di processore lo \textit{stack}
+cresce verso il basso, pertanto in tal caso non si dovrà specificare
+per \param{child\_stack} il puntatore restituito da \func{malloc}, ma un
+puntatore alla fine del buffer da essa allocato.
Dato che tutto ciò è necessario solo per i \textit{thread} che condividono la
memoria, la \textit{system call}, a differenza della funzione di libreria che
\val{NULL}, che non imposta un nuovo \textit{stack}. Se infatti si crea un
processo, questo ottiene un suo nuovo spazio degli indirizzi (è sottinteso
cioè che non si stia usando il flag \const{CLONE\_VM} che vedremo a breve) ed
-in questo caso si applica la semantica del \itindex{copy~on~write}
-\textit{copy on write} illustrata in sez.~\ref{sec:proc_fork}, per cui le
-pagine dello \textit{stack} verranno automaticamente copiate come le altre e
-il nuovo processo avrà un suo \textit{stack} totalmente indipendente da quello
-del padre.
+in questo caso si applica la semantica del \textit{copy on write} illustrata
+in sez.~\ref{sec:proc_fork}, per cui le pagine dello \textit{stack} verranno
+automaticamente copiate come le altre e il nuovo processo avrà un suo
+\textit{stack} totalmente indipendente da quello del padre.
Dato che l'uso principale della nuova \textit{system call} è quello relativo
alla creazione dei \textit{thread}, la \acr{glibc} definisce una funzione di
figlio all'indirizzo dato dall'argomento \param{ctid}. Questo flag viene
utilizzato dalla librerie di gestione dei \textit{thread}.
\item[\const{CLONE\_FILES}] se impostato il nuovo processo condividerà con il
- padre la \itindex{file~descriptor~table} \textit{file descriptor table}
- (vedi sez.~\ref{sec:file_fd}), questo significa che ogni \textit{file
- descriptor} aperto da un processo verrà visto anche dall'altro e che ogni
- chiusura o cambiamento dei \textit{file descriptor flag} di un \textit{file
- descriptor} verrà per entrambi.
+ padre la \textit{file descriptor table} (vedi sez.~\ref{sec:file_fd}),
+ questo significa che ogni \textit{file descriptor} aperto da un processo
+ verrà visto anche dall'altro e che ogni chiusura o cambiamento dei
+ \textit{file descriptor flag} di un \textit{file descriptor} verrà per
+ entrambi.
Se non viene impostato il processo figlio eredita una copia della
- \itindex{file~descriptor~table} \textit{file descriptor table} del padre e
- vale la semantica classica della gestione dei \textit{file descriptor}, che
- costituisce il comportamento ordinario di un sistema unix-like e che
- illustreremo in dettaglio in sez.~\ref{sec:file_shared_access}.
+ \textit{file descriptor table} del padre e vale la semantica classica della
+ gestione dei \textit{file descriptor}, che costituisce il comportamento
+ ordinario di un sistema unix-like e che illustreremo in dettaglio in
+ sez.~\ref{sec:file_shared_access}.
\item[\const{CLONE\_FS}] se questo flag viene impostato il nuovo processo
condividerà con il padre le informazioni relative all'albero dei file, ed in
\textit{umask} (sez.~\ref{sec:file_perm_management}). Una modifica di una
qualunque di queste caratteristiche in un processo, avrà effetto anche
sull'altro. Se assente il nuovo processo riceverà una copia delle precedenti
- informazioni, che saranno così indipendenti per i due processi.
+ informazioni, che saranno così indipendenti per i due processi, come avviene
+ nel comportamento ordinario di un sistema unix-like.
\item[\const{CLONE\_IO}]
\item[\const{CLONE\_NEWIPC}]
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 \itindex{race~condition} \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} (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
Qualora invece si usino i \textit{thread}, in cui lo spazio degli indirizzi è
condiviso, il problema è sempre presente, perché qualunque \textit{thread} può
interromperne un altro in qualunque momento e l'atomicità di qualunque
-operazione è messa in discussione, per cui l'assenza di eventuali
-\itindex{race~condition} \textit{race condition} deve essere sempre verificata
-nei minimi dettagli.
+operazione è messa in discussione, per cui l'assenza di eventuali \textit{race
+ condition} (vedi sez.~\ref{sec:proc_race_cond}) deve essere sempre
+verificata nei minimi dettagli.
In questo caso il sistema provvede un tipo di dato, il \type{sig\_atomic\_t},
il cui accesso è assicurato essere atomico. In pratica comunque si può
projects / gapil.git / blobdiff