(che in seguito incontreremo a più riprese), è mostrato in
fig.~\ref{fig:proc_task_struct}.
-\begin{figure}[htb]
- \centering
- \includegraphics[width=12cm]{img/task_struct}
+\begin{figure}[!htb]
+ \centering \includegraphics[width=14cm]{img/task_struct}
\caption{Schema semplificato dell'architettura delle strutture usate dal
kernel nella gestione dei processi.}
\label{fig:proc_task_struct}
La funzione \funcd{fork} è la funzione fondamentale della gestione dei
processi: come si è detto tradizionalmente l'unico modo di creare un nuovo
processo era attraverso l'uso di questa funzione,\footnote{in realtà oggi la
- system call usata più comunemente da Linux per creare nuovi processi è
- \func{clone} (vedi \ref{sec:process_clone}) , anche perché a partire dalle
- \acr{glibc} 2.3.3 non viene più usata la system call originale, ma la stessa
+ \textit{system call} usata da Linux per creare nuovi processi è \func{clone}
+ (vedi \ref{sec:process_clone}), anche perché a partire dalle \acr{glibc}
+ 2.3.3 non viene più usata la \textit{system call} originale, ma la stessa
\func{fork} viene implementata tramite \func{clone}, cosa che consente una
migliore interazione coi \textit{thread}.} essa quindi riveste un ruolo
centrale tutte le volte che si devono scrivere programmi che usano il
\func{getppid}, vedi sez.~\ref{sec:proc_pid}) per cui si usa il valore nullo,
che non è il \acr{pid} di nessun processo.
-\begin{figure}[!htb]
+\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/ForkTest.c}
\end{minipage}
\normalsize
sez.~\ref{sec:sig_notification}), che non vengono ereditate dal figlio;
\item le mappature di memoria marcate come \const{MADV\_DONTFORK} (vedi
sez.~\ref{sec:file_memory_map}) che non vengono ereditate dal figlio;
-\item l'impostazione con \func{prctl} (vedi sez.~\ref{sec:prctl_xxx}) che
+\item l'impostazione con \func{prctl} (vedi sez.~\ref{sec:process_prctl}) che
notifica al figlio la terminazione del padre viene cancellata;
-\item il segnale di terminazione del figlio è sempre \const{SIGCHLD} anche
+\item il segnale di terminazione del figlio è sempre \signal{SIGCHLD} anche
qualora nel padre fosse stato modificato (vedi sez.~\ref{sec:process_clone}).
\end{itemize*}
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 system call \func{clone} (che
-tratteremo in dettaglio in sez.~\ref{sec:process_clone}) è deprecato; per
+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.
chiamare la funzione \func{abort} per invocare una chiusura anomala, o essere
terminato da un segnale (torneremo sui segnali in cap.~\ref{cha:signals}). In
realtà anche la prima modalità si riconduce alla seconda, dato che
-\func{abort} si limita a generare il segnale \const{SIGABRT}.
+\func{abort} si limita a generare il segnale \signal{SIGABRT}.
Qualunque sia la modalità di conclusione di un processo, il kernel esegue
comunque una serie di operazioni: chiude tutti i file aperti, rilascia la
\item viene memorizzato lo stato di terminazione del processo;
\item ad ogni processo figlio viene assegnato un nuovo padre (in genere
\cmd{init});
-\item viene inviato il segnale \const{SIGCHLD} al processo padre (vedi
+\item viene inviato il segnale \signal{SIGCHLD} al processo padre (vedi
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
+ è quello della sessione viene mandato un segnale di \signal{SIGHUP} a tutti i
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
- inviati in successione i segnali \const{SIGHUP} e \const{SIGCONT}
+ inviati in successione i segnali \signal{SIGHUP} e \signal{SIGCONT}
(vedi ancora sez.~\ref{sec:sess_ctrl_term}).
\end{itemize*}
adottarli e provvedere a concluderne la terminazione.
-\subsection{La funzione \func{waitpid} e le funzioni di ricezione degli stati
- di uscita}
+\subsection{Le funzioni di attesa e ricezione degli stati di uscita}
\label{sec:proc_wait}
Uno degli usi più comuni delle capacità multitasking di un sistema unix-like
processi figli. Si è già sottolineato al paragrafo precedente come in questo
caso diventi necessario gestire esplicitamente la conclusione dei figli onde
evitare di riempire di \index{zombie} \textit{zombie} la tabella dei processi;
-le funzioni deputate a questo compito sono principalmente due, \funcd{wait} e
-\func{waitpid}. La prima, il cui prototipo è:
+le funzioni deputate a questo compito sono principalmente due, la prima è
+\funcd{wait} ed il suo prototipo è:
\begin{functions}
\headdecl{sys/types.h}
\headdecl{sys/wait.h}
\end{errlist}}
\end{functions}
\noindent
-è presente fin dalle prime versioni di Unix; la funzione ritorna non appena un
-processo figlio termina. Se un figlio è già terminato la funzione ritorna
-immediatamente, se più di un figlio è terminato occorre chiamare la funzione
-più volte se si vuole recuperare lo stato di terminazione di tutti quanti.
+
+Questa funzione è presente fin dalle prime versioni di Unix; essa ritorna non
+appena un qualunque processo figlio termina. Se un figlio è già terminato
+prima della chiamata la funzione ritorna immediatamente, se più di un figlio è
+già terminato occorre continuare chiamare la funzione più volte se si vuole
+recuperare lo stato di terminazione di tutti quanti.
Al ritorno della funzione lo stato di terminazione del figlio viene salvato
nella variabile puntata da \param{status} e tutte le risorse del kernel
-relative al processo (vedi sez.~\ref{sec:proc_termination}) vengono rilasciate.
-Nel caso un processo abbia più figli il valore di ritorno (il \acr{pid} del
-figlio) permette di identificare qual è quello che è uscito.
+relative al processo (vedi sez.~\ref{sec:proc_termination}) vengono
+rilasciate. Nel caso un processo abbia più figli il valore di ritorno della
+funzione sarà impostato al \acr{pid} del processo di cui si è ricevuto lo
+stato di terminazione, cosa che permette di identificare qual è il figlio che
+è terminato.
Questa funzione ha il difetto di essere poco flessibile, in quanto ritorna
all'uscita di un qualunque processo figlio. Nelle occasioni in cui è
provvedere a ripetere la chiamata alla funzione nel caso il processo cercato
sia ancora attivo.
-Per questo motivo lo standard POSIX.1 ha introdotto la funzione
-\funcd{waitpid} che effettua lo stesso servizio, ma dispone di una serie di
-funzionalità più ampie, legate anche al controllo di sessione (si veda
+Per questo motivo lo standard POSIX.1 ha introdotto una seconda funzione che
+effettua lo stesso servizio, ma dispone di una serie di funzionalità più
+ampie, legate anche al controllo di sessione (si veda
sez.~\ref{sec:sess_job_control}). Dato che è possibile ottenere lo stesso
comportamento di \func{wait}\footnote{in effetti il codice
\code{wait(\&status)} è del tutto equivalente a \code{waitpid(WAIT\_ANY,
- \&status, 0)}.} si consiglia di utilizzare sempre questa funzione, il cui
-prototipo è:
+ \&status, 0)}.} si consiglia di utilizzare sempre questa nuova funzione,
+\funcd{waitpid}, il cui prototipo è:
\begin{functions}
\headdecl{sys/types.h}
\headdecl{sys/wait.h}
parte in tab.~\ref{tab:proc_waitpid_options} che possono essere combinati fra
loro con un OR aritmetico. Nella seconda parte della stessa tabella si sono
riportati anche alcuni valori non standard specifici di Linux, che consentono
-un controllo più dettagliato per i processi creati con la system call generica
-\func{clone} (vedi sez.~\ref{sec:process_clone}) usati principalmente per la
-gestione della terminazione dei \itindex{thread} \textit{thread} (vedi
+un controllo più dettagliato per i processi creati con la \textit{system call}
+generica \func{clone} (vedi sez.~\ref{sec:process_clone}) usati principalmente
+per la gestione della terminazione dei \itindex{thread} \textit{thread} (vedi
sez.~\ref{sec:thread_xxx}).
\begin{table}[!htb]
\const{WCONTINUED}& Ritorna anche quando un processo figlio che era stato
fermato ha ripreso l'esecuzione.\footnotemark \\
\hline
- \const{\_\_WCLONE}& Attende solo per i figli creati con \func{clone},
- vale a dire processi che non emettono nessun segnale
- o emettono un segnale diverso da \const{SIGCHL} alla
+ \const{\_\_WCLONE}& Attende solo per i figli creati con \func{clone}
+ (vedi sez.~\ref{sec:process_clone}), vale a dire
+ processi che non emettono nessun segnale
+ o emettono un segnale diverso da \signal{SIGCHLD} alla
terminazione. \\
\const{\_\_WALL} & Attende per qualunque processo figlio. \\
\const{\_\_WNOTHREAD}& Non attende per i figli di altri \textit{thread}
realtà viene notificato soltanto il caso in cui il processo è stato fermato
da un segnale di stop (vedi sez.~\ref{sec:sess_ctrl_term}), e non quello in
cui lo stato \textit{stopped} è dovuto all'uso di \func{ptrace} (vedi
- sez.~\ref{sec:xxx_ptrace}).} (vedi tab.~\ref{tab:proc_proc_states}), mentre
-con \const{WCONTINUED} la funzione ritorna quando un processo in stato
+ sez.~\ref{sec:process_ptrace}).} (vedi tab.~\ref{tab:proc_proc_states}),
+mentre con \const{WCONTINUED} la funzione ritorna quando un processo in stato
\textit{stopped} riprende l'esecuzione per la ricezione del segnale
-\const{SIGCONT} (l'uso di questi segnali per il controllo di sessione è
-dettagliato in sez.~\ref{sec:sess_ctrl_term}).
+\signal{SIGCONT} (l'uso di questi segnali per il controllo di sessione è
+dettagliato in sez.~\ref{sec:sess_ctrl_term}).
La terminazione di un processo figlio (così come gli altri eventi osservabili
con \func{waitpid}) è chiaramente un evento asincrono rispetto all'esecuzione
di un programma e può avvenire in un qualunque momento. Per questo motivo,
come accennato nella sezione precedente, una delle azioni prese dal kernel
alla conclusione di un processo è quella di mandare un segnale di
-\const{SIGCHLD} al padre. L'azione predefinita (si veda
+\signal{SIGCHLD} al padre. L'azione predefinita (si veda
sez.~\ref{sec:sig_base}) per questo segnale è di essere ignorato, ma la sua
generazione costituisce il meccanismo di comunicazione asincrona con cui il
kernel avverte il processo padre che uno dei suoi figli è terminato.
al kernel 2.6, quest'ultimo infatti si è adeguato alle prescrizioni dello
standard POSIX.1-2001,\footnote{una revisione del 2001 dello standard POSIX.1
che ha aggiunto dei requisiti e delle nuove funzioni, come \func{waitid}.}
-e come da esso richiesto se \const{SIGCHLD} viene ignorato, o se si imposta il
+e come da esso richiesto se \signal{SIGCHLD} viene ignorato, o se si imposta il
flag di \const{SA\_NOCLDSTOP} nella ricezione dello stesso (si veda
sez.~\ref{sec:sig_sigaction}) i processi figli che terminano non diventano
\textit{zombie} e sia \func{wait} che \func{waitpid} si bloccano fintanto che
errore di \errcode{ENOCHLD}.\footnote{questo è anche il motivo per cui le
opzioni \const{WUNTRACED} e \const{WCONTINUED} sono utilizzabili soltanto
qualora non si sia impostato il flag di \const{SA\_NOCLDSTOP} per il segnale
- \const{SIGCHLD}.}
+ \signal{SIGCHLD}.}
Con i kernel della serie 2.4 e tutti i kernel delle serie precedenti entrambe
le funzioni di attesa ignorano questa prescrizione\footnote{lo standard POSIX.1
originale infatti lascia indefinito il comportamento di queste funzioni
- quando \const{SIGCHLD} viene ignorato.} e si comportano sempre nello stesso
-modo, indipendentemente dal fatto \const{SIGCHLD} sia ignorato o meno:
+ quando \signal{SIGCHLD} viene ignorato.} e si comportano sempre nello stesso
+modo, indipendentemente dal fatto \signal{SIGCHLD} sia ignorato o meno:
attendono la terminazione di un processo figlio e ritornano il relativo
\acr{pid} e lo stato di terminazione nell'argomento \param{status}.
nullo. \\
\macro{WIFCONTINUED(s)}& Vera se il processo che ha causato il ritorno è
stato riavviato da un
- \const{SIGCONT}.\footnotemark \\
+ \signal{SIGCONT}.\footnotemark \\
\hline
\end{tabular}
\caption{Descrizione delle varie macro di preprocessore utilizzabili per
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 \const{SIGCHLD} con i segnali in sez.~\ref{sec:sig_example}). In
+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 la chiamata a \func{waitpid} non si bloccherà.
\item[\var{si\_pid}] con il \acr{pid} del figlio.
\item[\var{si\_uid}] con l'user-ID reale (vedi sez.~\ref{sec:proc_perms}) del
figlio.
-\item[\var{si\_signo}] con \const{SIGCHLD}.
+\item[\var{si\_signo}] con \signal{SIGCHLD}.
\item[\var{si\_status}] con lo stato di uscita del figlio o con il segnale che
lo ha terminato, fermato o riavviato.
\item[\var{si\_code}] con uno fra \const{CLD\_EXITED}, \const{CLD\_KILLED},
indicato dall'argomento \param{path}, che viene interpretato come il
\itindex{pathname} \textit{pathname} del programma.
-\begin{figure}[htb]
- \centering
- \includegraphics[width=12cm]{img/exec_rel}
+\begin{figure}[!htb]
+ \centering \includegraphics[width=12cm]{img/exec_rel}
\caption{La interrelazione fra le sei funzioni della famiglia \func{exec}.}
\label{fig:proc_exec_relat}
\end{figure}
mantengono la stessa impostazione pure nel nuovo programma, ma tutti gli altri
segnali, ed in particolare quelli per i quali è stato installato un gestore
vengono impostati alla loro azione predefinita (vedi
-sez.~\ref{sec:sig_gen_beha}). Un caso speciale è il segnale \const{SIGCHLD}
+sez.~\ref{sec:sig_gen_beha}). Un caso speciale è il segnale \signal{SIGCHLD}
che, quando impostato a \const{SIG\_IGN}, potrebbe anche essere reimpostato a
\const{SIG\_DFL}, anche se questo con Linux non avviene.\footnote{lo standard
POSIX.1-2001 prevede che questo comportamento sia deciso dalla singola
sez.~\ref{sec:thread_xxx}) sono cancellati e tutti gli oggetti ad essi
relativi (vedi sez.~\ref{sec:thread_xxx}) rimossi;
\item viene impostato il flag \const{PR\_SET\_DUMPABLE} di \func{prctl} (vedi
- sez.~\ref{sec:prctl_xxx}) a meno che il programma da eseguire non sia
+ 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});
\item il flag \const{PR\_SET\_KEEPCAPS} di \func{prctl} (vedi
- sez.~\ref{sec:prctl_xxx}) viene cancellato;
+ sez.~\ref{sec:process_prctl}) viene cancellato;
\item il nome del processo viene impostato al nome del file contenente il
programma messo in esecuzione;
-\item il segnale di terminazione viene reimpostato a \const{SIGCHLD};
+\item il segnale di terminazione viene reimpostato a \signal{SIGCHLD};
\item l'ambiente viene reinizializzato impostando le variabili attinenti alla
localizzazione al valore di default POSIX.
\end{itemize*}
genere per I/O), e non può essere
interrotto in nessuna circostanza.\\
\textbf{Stopped} & \texttt{T} & Il processo è stato fermato con un
- \const{SIGSTOP}, o è tracciato.\\
+ \signal{SIGSTOP}, o è tracciato.\\
\textbf{Zombie}\index{zombie} & \texttt{Z} & Il processo è terminato ma il
suo stato di terminazione non è ancora
stato letto dal padre.\\
2.6.25, sostanzialmente identico
all'\textbf{Uninterrutible Sleep} con la
sola differenza che il processo può
- terminato con \const{SIGKILL} (usato per
+ terminato con \signal{SIGKILL} (usato per
lo più per NFS).\\
\hline
\end{tabular}
debba essere assegnato all'interno di un intervallo fra un massimo ed un
minimo che nel caso di Linux sono rispettivamente 1 e 99.
-\begin{figure}[!bht]
+\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15cm}
+ \begin{minipage}[c]{\textwidth}
\includestruct{listati/sched_param.c}
\end{minipage}
\normalsize
di processore.
Per facilitare l'uso dell'argomento \param{cpuset} le \acr{glibc} hanno
-introdotto un apposito dato di tipo, \ctyp{cpu\_set\_t},\footnote{questa è una
+introdotto un apposito dato di tipo, \type{cpu\_set\_t},\footnote{questa è una
estensione specifica delle \acr{glibc}, da attivare definendo la macro
\macro{\_GNU\_SOURCE}, non esiste infatti una standardizzazione per
questo tipo di interfaccia e POSIX al momento non prevede nulla al
utilizzo non avrà alcun effetto.} Dato che non esiste una interfaccia
diretta nelle \acr{glibc} per queste due funzioni occorrerà invocarle tramite
la funzione \func{syscall} (come illustrato in
-sez.~\ref{sec:intro_syscall}). Le due funzioni sono \funcd{ioprio\_get} ed
+sez.~\ref{sec:proc_syscall}). Le due funzioni sono \funcd{ioprio\_get} ed
\funcd{ioprio\_set}; i rispettivi prototipi sono:
\begin{functions}
\headdecl{linux/ioprio.h}
altri processi occorrono privilegi amministrativi, ed in particolare la
capacità \const{CAP\_SYS\_NICE} (vedi sez.~\ref{sec:proc_capabilities}).}
cioè quelli il cui user-ID reale corrisponde all'user-ID reale o effettivo del
-chiamante. Data la possibilità di ottenere un blocco totale dello stesso, solo
+chiamante. Data la possibilità di ottenere un blocco totale del sistema, solo
l'amministratore\footnote{o un processo con la capacità
\const{CAP\_SYS\_ADMIN} (vedi sez.~\ref{sec:proc_capabilities}).} può
impostare un processo ad una priorità di I/O nella classe
-\const{IOPRIO\_CLASS\_RT} o \const{IOPRIO\_CLASS\_IDLE}.
+\const{IOPRIO\_CLASS\_RT}, lo stesso privilegio era richiesto anche per la
+classe \const{IOPRIO\_CLASS\_IDLE} fino al kernel 2.6.24, ma dato che in
+questo caso non ci sono effetti sugli altri processi questo limite è stato
+rimosso a partire dal kernel 2.6.25.
%TODO verificare http://lwn.net/Articles/355987/
% vedi man numa e le pagine di manuale relative
% vedere anche dove metterle...
+
+\section{Funzioni di gestione avanzata}
+\label{sec:proc_advanced_control}
+
+Nelle precedenti sezioni si sono trattate la gran parte delle funzioni che
+attengono alla gestione ordinaria dei processi e delle loro proprietà più
+comuni. Tratteremo qui alcune \textit{system call} dedicate alla gestione di
+funzionalità dei processi molto specifiche ed avanzate, il cui uso è in genere
+piuttosto ridotto. Trattandosi di problematiche abbastanza complesse, che
+spesso presuppongono la conoscenza di altri argomenti trattati nel seguito
+della guida, si può saltare questa sezione in una prima lettura, tornando su
+di essa in un secondo tempo.
+
+\subsection{La system call \func{clone}}
+\label{sec:process_clone}
+
+La funzione tradizionale con cui creare un nuovo processo in un sistema
+Unix-like, come illustrato in sez.~\ref{sec:proc_fork}, è \func{fork}, ma con
+l'introduzione del supporto del kernel per i \textit{thread} (vedi
+cap.~\ref{cha:threads}), si è avuta la necessità di una interfaccia che
+consentisse un maggiore controllo sulla modalità con cui vengono creati nuovi
+processi, che poi è stata utilizzata anche per fornire supporto per le
+tecnologie di virtualizzazione dei processi (i cosiddetti \textit{container}).
+
+Per questo l'interfaccia per la creazione di un nuovo processo è stata
+delegata ad una nuova \textit{system call}, \func{sys\_clone}, che consente di
+reimplementare anche la tradizionale \func{fork}. In realtà in questo caso più
+che di nuovi processi si può parlare della creazioni di nuovi
+``\textit{task}'' del kernel che possono assumere la veste sia di un processo
+classico come quelli trattati finora, che di un \textit{thread}, come quelli
+che vedremo in sez.~\ref{sec:linux_thread}, in cui la memoria viene condivisa
+fra il processo chiamante ed il nuovo processo creato. Per evitare confusione
+fra \textit{thread} e processi ordinari, abbiamo deciso di usare la
+nomenclatura \textit{task} per indicare la unità di esecuzione generica messa
+a disposizione del kernel che \texttt{sys\_clone} permette di creare.
+
+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 PID, l'albero dei
+file, dei \textit{mount point}, della 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
+nuovo \textit{task}, il secondo, \param{child\_stack}, imposta l'indirizzo
+dello \itindex{stack} \textit{stack} per il nuovo \textit{task}, e deve essere
+indicato quando si intende creare un \textit{thread}. L'esecuzione del
+programma creato da \func{sys\_clone} riprende, come per \func{fork}, da
+dopo l'esecuzione della stessa.
+
+La necessità di avere uno \itindex{stack} \textit{stack} alternativo c'è solo
+quando si intende creare un \textit{thread}, in tal caso infatti il nuovo
+\textit{task} vede esattamente la stessa memoria del \textit{task}
+``\textsl{padre}'',\footnote{in questo caso per padre si intende semplicemente
+ il \textit{task} che ha eseguito \func{sys\_clone} rispetto al \textit{task}
+ da essa creato, senza nessuna delle implicazioni che il concetto ha per i
+ processi.} e nella sua esecuzione alla prima chiamata di una funzione
+andrebbe a scrivere sullo \textit{stack} usato anche dal padre (si ricordi
+quanto visto in sez.~\ref{sec:proc_mem_layout} riguardo all'uso dello
+\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. 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.
+
+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
+vedremo a breve, consente anche di passare per \param{child\_stack} il valore
+\val{NULL}, che non imposta un nuovo \textit{stack}. Se infatti si crea un
+processo, questo ottiene un suo nuovo spazio degli indirizzi,\footnote{è
+ sottinteso cioè che non si stia usando il flag \const{CLONE\_VM}.} 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.
+
+Dato che l'uso principale della nuova \textit{system call} è quello relativo
+alla creazione dei \textit{thread}, le \acr{glibc} definiscono una funzione di
+libreria con una sintassi diversa, orientata a questo scopo, e la
+\textit{system call} resta accessibile solo se invocata esplicitamente come
+visto in sez.~\ref{sec:proc_syscall}.\footnote{ed inoltre per questa
+ \textit{system call} non è disponibile la chiamata veloce con
+ \texttt{vsyscall}.} La funzione di libreria si chiama semplicemente
+\funcd{clone} ed il suo prototipo è:
+\begin{functions}
+ \headdecl{sys/sched.h}
+
+ \funcdecl{int clone(int (*fn)(void *), void *child\_stack, int
+ flags, void *arg, ... \\
+ /* pid\_t *ptid, struct user\_desc *tls, pid\_t *ctid */)}
+
+ Crea un nuovo processo o \textit{thread} eseguendo la funzione \param{fn}.
+
+ \bodydesc{La funzione ritorna al chiamante il \textit{Thread ID} assegnato
+ al nuovo processo in caso di successo e $-1$ in caso di errore, nel qual
+ caso \var{errno} può assumere i valori:
+ \begin{errlist}
+ \item[\errcode{EAGAIN}] sono già in esecuzione troppi processi.
+ \item[\errcode{EINVAL}] si è usata una combinazione non valida di flag o
+ un valore nullo per \param{child\_stack}.
+ \item[\errcode{ENOMEM}] non c'è memoria sufficiente per creare una nuova
+ \struct{task\_struct} o per copiare le parti del contesto del chiamante
+ necessarie al nuovo \textit{task}.
+ \item[\errcode{EPERM}] non si hanno i privilegi di amministratore
+ richiesti dai flag indicati.
+ \end{errlist}
+ }
+\end{functions}
+
+La funzione prende come primo argomento il puntatore alla funzione che verrà
+messa in esecuzione nel nuovo processo, che può avere un unico argomento di
+tipo puntatore a \ctyp{void}, il cui valore viene passato dal terzo
+argomento \param{arg}; per quanto il precedente prototipo possa intimidire
+nella sua espressione, in realtà l'uso è molto semplice basterà definire una
+qualunque funzione \param{fn} del tipo indicato, e \code{fn(arg)} sarà
+eseguita in un nuovo processo.
+
+Il nuovo processo resterà in esecuzione fintanto che la funzione \param{fn}
+non ritorna, o esegue \func{exit} o viene terminata da un segnale. Il valore
+di ritorno della funzione (o quello specificato con \func{exit}) verrà
+utilizzato come stato di uscita della funzione.
+
+I tre argomenti \param{ptid}, \param{tls} e \param{ctid} sono opzionali e sono
+presenti solo a partire dal kernel 2.6.
+
+Il comportamento di \func{clone}, che si riflette sulle caratteristiche del
+nuovo processo da essa creato, è controllato dall'argomento \param{flags},
+
+\begin{basedescript}{\desclabelstyle{\pushlabel}}
+
+\item[\const{CLONE\_CHILD\_CLEARTID}]
+\item[\const{CLONE\_CHILD\_SETTID}]
+\item[\const{CLONE\_FILES}]
+\item[\const{CLONE\_FS}]
+\item[\const{CLONE\_IO}]
+\item[\const{CLONE\_NEWIPC}]
+\item[\const{CLONE\_NEWNET}]
+\item[\const{CLONE\_NEWNS}]
+\item[\const{CLONE\_NEWPID}]
+\item[\const{CLONE\_NEWUTS}]
+\item[\const{CLONE\_PARENT}]
+\item[\const{CLONE\_PARENT\_SETTID}]
+\item[\const{CLONE\_PID}]
+\item[\const{CLONE\_PTRACE}]
+\item[\const{CLONE\_SETTLS}]
+\item[\const{CLONE\_SIGHAND}]
+\item[\const{CLONE\_STOPPED}]
+\item[\const{CLONE\_SYSVSEM}]
+\item[\const{CLONE\_THREAD}]
+\item[\const{CLONE\_UNTRACED}]
+\item[\const{CLONE\_VFORK}]
+\item[\const{CLONE\_VM}]
+\end{basedescript}
+
+
+\subsection{La funzione \func{prctl}}
+\label{sec:process_prctl}
+
+Benché la gestione ordinaria possa essere effettuata attraverso le funzioni
+che abbiamo già esaminato nelle sezioni precedenti, esistono una serie di
+proprietà e caratteristiche particolari dei processi non coperte da esse, per
+la cui gestione è stata predisposta una apposita \textit{system call} che
+fornisce una interfaccia generica per tutte le operazioni specialistiche. La
+funzione è \funcd{prctl} ed il suo prototipo è:\footnote{la funzione non è
+ standardizzata ed è specifica di Linux, anche se ne esiste una analoga in
+ IRIX; è stata introdotta con il kernel 2.1.57.}
+\begin{functions}
+ \headdecl{sys/prctl.h}
+
+ \funcdecl{int prctl(int option, unsigned long arg2, unsigned long arg3,
+ unsigned long arg4, unsigned long arg5)}
+
+ Esegue una operazione speciale sul processo corrente.
+
+ \bodydesc{La funzione ritorna 0 o un valore positivo dipendente
+ dall'operazione in caso di successo e $-1$ in caso di errore, nel qual
+ caso \var{errno} assumerà valori diversi a seconda del tipo di operazione
+ richiesta (in genere \errval{EINVAL} o \errval{EPERM}). }
+\end{functions}
+
+La funzione ritorna un valore nullo o positivo in caso di successo e $-1$ in
+caso di errore; il significato degli argomenti della funzione successivi al
+primo, il valore di ritorno in caso di successo, il tipo di errore restituito
+in \var{errno} dipendono dall'operazione eseguita, indicata tramite il primo
+argomento, \param{option}. Questo è un valore intero che identifica
+l'operazione, e deve essere specificato con l'uso di una delle costanti
+predefinite del seguente elenco, che illustra quelle disponibili al momento:
+
+\begin{basedescript}{\desclabelstyle{\pushlabel}}
+\item[\const{PR\_CAPBSET\_READ}] Controlla la disponibilità di una delle
+ \textit{capabilities} (vedi sez.~\ref{sec:proc_capabilities}). La funzione
+ ritorna 1 se la capacità specificata nell'argomento \param{arg2} (con una
+ delle costanti di tab.~\ref{tab:proc_capabilities}) è presente nel
+ \textit{capabilities bounding set} del processo e zero altrimenti,
+ se \param{arg2} non è un valore valido si avrà un errore di \errval{EINVAL}.
+ Introdotta a partire dal kernel 2.6.25.
+\item[\const{PR\_CAPBSET\_DROP}] Rimuove permanentemente una delle
+ \textit{capabilities} (vedi sez.~\ref{sec:proc_capabilities}) dal processo e
+ da tutti i suoi discendenti. La funzione cancella la capacità specificata
+ nell'argomento \param{arg2} con una delle costanti di
+ tab.~\ref{tab:proc_capabilities} dal \textit{capabilities bounding set} del
+ processo. L'operazione richiede i privilegi di amministratore (la capacità
+ \const{CAP\_SETPCAP}), altrimenti la chiamata fallirà con un errore di
+ \errval{EPERM}; se il valore di \param{arg2} non è valido o se il supporto
+ per le \textit{file capabilities} non è stato compilato nel kernel la
+ chiamata fallirà con un errore di \errval{EINVAL}. Introdotta a partire dal
+ kernel 2.6.25.
+\item[\const{PR\_SET\_DUMPABLE}] Imposta il flag che determina se la
+ terminazione di un processo a causa di un segnale per il quale è prevista la
+ generazione di un file di \itindex{core~dump} \textit{core dump} (vedi
+ sez.~\ref{sec:sig_standard}) lo genera effettivamente. In genere questo flag
+ viene attivato automaticamente, ma per evitare problemi di sicurezza (la
+ generazione di un file da parte di processi privilegiati può essere usata
+ per sovrascriverne altri) viene cancellato quando si mette in esecuzione un
+ programma con i bit \acr{suid} e \acr{sgid} attivi (vedi
+ sez.~\ref{sec:file_special_perm}) o con l'uso delle funzioni per la modifica
+ degli \textit{user-ID} dei processi (vedi
+ sez.~\ref{sec:proc_setuid}). L'operazione è stata introdotta a partire dal
+ kernel 2.3.20, fino al kernel 2.6.12 e per i kernel successivi al 2.6.17 era
+ possibile usare solo un valore 0 di \param{arg2} per disattivare il flag ed
+ un valore 1 per attivarlo, nei kernel dal 2.6.13 al 2.6.17 è stato
+ supportato anche il valore 2, che causava la generazione di un
+ \itindex{core~dump} \textit{core dump} leggibile solo
+ dall'amministratore.\footnote{la funzionalità è stata rimossa per motivi di
+ sicurezza, in quanto consentiva ad un utente normale di creare un file di
+ \textit{core dump} appartenente all'amministratore in directory dove
+ l'utente avrebbe avuto permessi di accesso.}
+\item[\const{PR\_GET\_DUMPABLE}] Ottiene come valore di ritorno della funzione
+ lo stato corrente del flag che controlla la effettiva generazione dei
+ \itindex{core~dump} \textit{core dump}. Introdotta a partire dal kernel
+ 2.3.20.
+\item[\const{PR\_SET\_ENDIAN}] Imposta la \textit{endianess} del processo
+ chiamante secondo il valore fornito in \param{arg2}. I valori possibili sono
+ sono: \const{PR\_ENDIAN\_BIG} (\textit{big endian}),
+ \const{PR\_ENDIAN\_LITTLE} (\textit{little endian}), e
+ \const{PR\_ENDIAN\_PPC\_LITTLE} (lo pseudo \textit{little endian} del
+ PowerPC). Introdotta a partire dal kernel 2.6.18, solo per architettura
+ PowerPC.
+\item[\const{PR\_GET\_ENDIAN}] Ottiene il valore della \textit{endianess} del
+ processo chiamante, salvato sulla variabile puntata da \param{arg2} che deve
+ essere passata come di tipo \ctyp{(int *)}. Introdotta a partire dal kernel
+ 2.6.18, solo su PowerPC.
+\item[\const{PR\_SET\_FPEMU}] Imposta i bit di controllo per l'emulazione
+ della virgola mobile su architettura ia64, secondo il valore
+ di \param{arg2}, si deve passare \const{PR\_FPEMU\_NOPRINT} per emulare in
+ maniera trasparente l'accesso alle operazioni in virgola mobile, o
+ \const{PR\_FPEMU\_SIGFPE} per non emularle ed inviare il segnale
+ \signal{SIGFPE} (vedi sez.~\ref{sec:sig_prog_error}). Introdotta a partire
+ dal kernel 2.4.18, solo su ia64.
+\item[\const{PR\_GET\_FPEMU}] Ottiene il valore dei flag di controllo
+ dell'emulazione della virgola mobile, salvato all'indirizzo puntato
+ da \param{arg2}, che deve essere di tipo \code{(int *)}. Introdotta a
+ partire dal kernel 2.4.18, solo su ia64.
+\item[\const{PR\_SET\_FPEXC}] Imposta la modalità delle eccezioni in virgola
+ mobile (\textit{floating-point exception mode}) al valore di \param{arg2}.
+ I valori possibili sono: \const{PR\_FP\_EXC\_SW\_ENABLE} per usare FPEXC per
+ le eccezioni, \const{PR\_FP\_EXC\_DIV} per la divisione per zero in virgola
+ mobile, \const{PR\_FP\_EXC\_OVF} per gli overflow, \const{PR\_FP\_EXC\_UND}
+ per gli underflow, \const{PR\_FP\_EXC\_RES} per risultati non esatti,
+ \const{PR\_FP\_EXC\_INV} per operazioni invalide,
+ \const{PR\_FP\_EXC\_DISABLED} per disabilitare le eccezioni,
+ \const{PR\_FP\_EXC\_NONRECOV} per utilizzare la modalità di eccezione
+ asincrona non recuperabile, \const{PR\_FP\_EXC\_ASYNC} per utilizzare la
+ modalità di eccezione asincrona recuperabile, \const{PR\_FP\_EXC\_PRECISE}
+ per la modalità precisa di eccezione.\footnote{trattasi di gestione
+ specialistica della gestione delle eccezioni dei calcoli in virgola mobile
+ che, i cui dettagli al momento vanno al di là dello scopo di questo
+ testo.} Introdotta a partire dal kernel 2.4.21, solo su PowerPC.
+\item[\const{PR\_GET\_FPEXC}] Ottiene il valore della modalità delle eccezioni
+ delle operazioni in virgola mobile, salvata all'indirizzo
+ puntato \param{arg2}, che deve essere di tipo \code{(int *)}. Introdotta a
+ partire dal kernel 2.4.21, solo su PowerPC.
+\item[\const{PR\_SET\_KEEPCAPS}] Consente di controllare quali
+ \textit{capabilities} vengono cancellate quando si esegue un cambiamento di
+ \textit{user-ID} del processo (per i dettagli si veda
+ sez.~\ref{sec:proc_capabilities}, in particolare quanto illustrato a
+ pag.~\pageref{sec:capability-uid-transition}). Un valore nullo (il default)
+ 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.
+\item[\const{PR\_GET\_KEEPCAPS}] Ottiene come valore di ritorno della funzione
+ il valore del flag di controllo impostato con
+ \const{PR\_SET\_KEEPCAPS}. Introdotta a partire dal kernel 2.2.18.
+\item[\const{PR\_SET\_NAME}] Imposta il nome del processo chiamante alla
+ stringa puntata da \param{arg2}, che deve essere di tipo \code{(char *)}. Il
+ nome può essere lungo al massimo 16 caratteri, e la stringa deve essere
+ terminata da NUL se più corta. Introdotta a partire dal kernel 2.6.9.
+\item[\const{PR\_GET\_NAME}] Ottiene il nome del processo chiamante nella
+ stringa puntata da \param{arg2}, che deve essere di tipo \code{(char *)}; si
+ devono allocare per questo almeno 16 byte, e il nome sarà terminato da NUL
+ se più corto. Introdotta a partire dal kernel 2.6.9.
+\item[\const{PR\_SET\_PDEATHSIG}] Consente di richiedere l'emissione di un
+ segnale, che sarà ricevuto dal processo chiamante, in occorrenza della
+ terminazione del proprio processo padre; in sostanza consente di invertire
+ il ruolo di \signal{SIGCHLD}. Il valore di \param{arg2} deve indicare il
+ numero del segnale, o 0 per disabilitare l'emissione. Il valore viene
+ automaticamente cancellato per un processo figlio creato con \func{fork}.
+ Introdotta a partire dal kernel 2.1.57.
+\item[\const{PR\_GET\_PDEATHSIG}] Ottiene il valore dell'eventuale segnale
+ emesso alla terminazione del padre, salvato all'indirizzo
+ puntato \param{arg2}, che deve essere di tipo \code{(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 \textit{secure computing mode} il
+ processo potrà utilizzare soltanto un insieme estremamente limitato di
+ \textit{system call}: \func{read}, \func{write}, \func{\_exit} e
+ \func{sigreturn}, ogni altra \textit{system call} porterà all'emissione di
+ un \func{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 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}.
+\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 \textit{secure computing mode}
+ comporterebbe l'emissione di \texttt{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
+ 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.
+\item[\const{PR\_SET\_TIMING}] Imposta il metodo di temporizzazione del
+ processo da indicare con il valore di \param{arg2}, con
+ \const{PR\_TIMING\_STATISTICAL} si usa il metodo statistico tradizionale,
+ con \const{PR\_TIMING\_TIMESTAMP} il più accurato basato su dei
+ \textit{timestamp}, quest'ultimo però non è ancora implementato ed il suo
+ uso comporta la restituzione di un errore di \errval{EINVAL}. Introdotta a
+ partire dal kernel 2.6.0-test4.
+\item[\const{PR\_GET\_TIMING}] Ottiene come valore di ritorno della funzione
+ il metodo di temporizzazione del processo attualmente in uso. Introdotta a
+ partire dal kernel 2.6.0-test4.
+\item[\const{PR\_SET\_TSC}] Imposta il flag che indica se il processo
+ chiamante può leggere il registro di processore contenente il contatore dei
+ \textit{timestamp} (TSC, o \textit{Time Stamp Counter}) da indicare con il
+ valore di \param{arg2}. Si deve specificare \const{PR\_TSC\_ENABLE} per
+ 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 \textit{secure computing mode}. 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
+ puntato \param{arg2}, che deve essere di tipo \code{(int *)}. Introdotta a
+ partire dal kernel 2.6.26, solo su x86.
+% articoli sul TSC e relativi problemi: http://lwn.net/Articles/209101/,
+% http://blog.cr0.org/2009/05/time-stamp-counter-disabling-oddities.html,
+% http://en.wikipedia.org/wiki/Time_Stamp_Counter
+\item[\const{PR\_SET\_UNALIGN}] Imposta la modalità di controllo per l'accesso
+ a indirizzi di memoria non allineati, che in varie architetture risultano
+ illegali, da indicare con il valore di \param{arg2}. Si deve specificare il
+ valore \const{PR\_UNALIGN\_NOPRINT} per ignorare gli accessi non allineati,
+ ed il valore \const{PR\_UNALIGN\_SIGBUS} per generare un segnale di
+ \signal{SIGBUS} (vedi sez.~\ref{sec:sig_prog_error}) in caso di accesso non
+ allineato. Introdotta con diverse versioni su diverse architetture.
+\item[\const{PR\_GET\_UNALIGN}] Ottiene il valore della modalità di controllo
+ per l'accesso a indirizzi di memoria non allineati, salvato all'indirizzo
+ puntato \param{arg2}, che deve essere di tipo \code{(int *)}. Introdotta con
+ diverse versioni su diverse architetture.
+\item[\const{PR\_MCE\_KILL}] Imposta la politica di gestione degli errori
+ dovuti a corruzione della memoria per problemi hardware. Questo tipo di
+ errori vengono riportati dall'hardware di controllo della RAM e vengono
+ gestiti dal kernel,\footnote{la funzionalità è disponibile solo sulle
+ piattaforme più avanzate che hanno il supporto hardware per questo tipo di
+ controlli.} ma devono essere opportunamente riportati ai processi che
+ usano quella parte di RAM che presenta errori; nel caso specifico questo
+ avviene attraverso l'emissione di un segnale di \signal{SIGBUS} (vedi
+ sez.~\ref{sec:sig_prog_error}).\footnote{in particolare viene anche
+ impostato il valore di \var{si\_code} in \struct{siginfo\_t} a
+ \const{BUS\_MCEERR\_AO}; per il significato di tutto questo si faccia
+ riferimento alla trattazione di sez.~\ref{sec:sig_sigaction}.}
+
+ Il comportamento di default prevede che per tutti i processi si applichi la
+ politica generale di sistema definita nel file
+ \procfile{/proc/sys/vm/memory\_failure\_early\_kill}, ma specificando
+ per \param{arg2} il valore \const{PR\_MCE\_KILL\_SET} è possibile impostare
+ con il contenuto di \param{arg3} una politica specifica del processo
+ chiamante. Si può tornare alla politica di default del sistema utilizzando
+ invece per \param{arg2} il valore \const{PR\_MCE\_KILL\_CLEAR}. In tutti i
+ casi, per compatibilità con eventuali estensioni future, tutti i valori
+ degli argomenti non utilizzati devono essere esplicitamente posti a zero,
+ pena il fallimento della chiamata con un errore di \errval{EINVAL}.
+
+ In caso di impostazione di una politica specifica del processo con
+ \const{PR\_MCE\_KILL\_SET} i valori di \param{arg3} possono essere soltanto
+ due, che corrispondono anche al valore che si trova nell'impostazione
+ generale di sistema di \texttt{memory\_failure\_early\_kill}, con
+ \const{PR\_MCE\_KILL\_EARLY} si richiede l'emissione immediata di
+ \signal{SIGBUS} non appena viene rilevato un errore, mentre con
+ \const{PR\_MCE\_KILL\_LATE} il segnale verrà inviato solo quando il processo
+ tenterà un accesso alla memoria corrotta. Questi due valori corrispondono
+ rispettivamente ai valori 1 e 0 di
+ \texttt{memory\_failure\_early\_kill}.\footnote{in sostanza nel primo caso
+ viene immediatamente inviato il segnale a tutti i processi che hanno la
+ memoria corrotta mappata all'interno del loro spazio degli indirizzi, nel
+ secondo caso prima la pagina di memoria viene tolta dallo spazio degli
+ indirizzi di ciascun processo, mentre il segnale viene inviato solo quei
+ processi che tentano di accedervi.} Si può usare per \param{arg3} anche un
+ terzo valore, \const{PR\_MCE\_KILL\_DEFAULT}, che corrisponde a impostare
+ per il processo la politica di default.\footnote{si presume la politica di
+ default corrente, in modo da non essere influenzati da un eventuale
+ successivo cambiamento della stessa.} Introdotta a partire dal kernel
+ 2.6.32.
+\item[\const{PR\_MCE\_KILL\_GET}] Ottiene come valore di ritorno della
+ funzione la politica di gestione degli errori dovuti a corruzione della
+ 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.
+\label{sec:prctl_operation}
+\end{basedescript}
+
+
+
+
+\subsection{La funzione \func{ptrace}}
+\label{sec:process_ptrace}
+
+Da fare
+
+% TODO: trattare PTRACE_SEIZE, aggiunta con il kernel 3.1
+
+
+\subsection{L'accesso alle porte di I/O}
+\label{sec:process_io_port}
+
+%
+% TODO l'I/O sulle porte di I/O
+% consultare le manpage di ioperm, iopl e outb
+
+Da fare
+
+% TODO: funzioni varie sparse citate da qualche parte e da trattare forse in
+% una sezione a parte: sigreturn,
+
+
\section{Problematiche di programmazione multitasking}
\label{sec:proc_multi_prog}
opportunamente protette da meccanismi di sincronizzazione (torneremo su queste
problematiche di questo tipo in cap.~\ref{cha:IPC}).
-\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
-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.
-
+\itindbeg{deadlock} Un caso particolare di \textit{race condition} sono poi i
+cosiddetti \textit{deadlock} (traducibile in \textsl{condizioni di stallo}),
+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} è quello in cui un flag di
un'altra invocazione non fa altro che allocarne un'altra copia. Una funzione
può non essere rientrante quando opera su memoria che non è nello
\itindex{stack} \textit{stack}. Ad esempio una funzione non è mai rientrante
-se usa una variabile globale o statica.
+se usa una \index{variabili!globali} variabile globale o
+\index{variabili!statiche} statica.
Nel caso invece la funzione operi su un oggetto allocato dinamicamente, la
cosa viene a dipendere da come avvengono le operazioni: se l'oggetto è creato
parte del programmatore.
In genere le funzioni di libreria non sono rientranti, molte di esse ad
-esempio utilizzano variabili statiche, le \acr{glibc} però mettono a
-disposizione due macro di compilatore,\footnote{si ricordi quanto illustrato
- in sez.~\ref{sec:intro_gcc_glibc_std}.} \macro{\_REENTRANT} e
-\macro{\_THREAD\_SAFE}, la cui definizione attiva le versioni rientranti di
-varie funzioni di libreria, che sono identificate aggiungendo il suffisso
-\code{\_r} al nome della versione normale.
+esempio utilizzano \index{variabili!statiche} variabili statiche, le
+\acr{glibc} però mettono a disposizione due macro di compilatore,\footnote{si
+ ricordi quanto illustrato in sez.~\ref{sec:intro_gcc_glibc_std}.}
+\macro{\_REENTRANT} e \macro{\_THREAD\_SAFE}, la cui definizione attiva le
+versioni rientranti di varie funzioni di libreria, che sono identificate
+aggiungendo il suffisso \code{\_r} al nome della versione normale.
\index{funzioni!rientranti|)}
% LocalWords: CONTINUED sources forking Spawned successfully executing exiting
% LocalWords: next cat for COMMAND pts bash defunct TRAPPED DUMPED Killable PR
% LocalWords: SIGKILL static RLIMIT preemption PREEMPT VOLUNTARY IDLE RTPRIO
-% LocalWords: Completely Fair compat Uniform CFQ Queuing elevator dev cfq RT
-% LocalWords: Documentation block syscall ioprio IPRIO CLASS class best effort
-% LocalWords: refresh semop dnotify MADV DONTFORK prctl WCLONE SIGCHL WALL
-% LocalWords: WNOTHREAD DUMPABLE KEEPCAPS
+% LocalWords: completely fair compat uniform CFQ queuing elevator dev cfq RT
+% LocalWords: documentation block syscall ioprio IPRIO CLASS class best effort
+% LocalWords: refresh semop dnotify MADV DONTFORK prctl WCLONE WALL big
+% LocalWords: WNOTHREAD DUMPABLE KEEPCAPS IRIX CAPBSET endianess endian flags
+% LocalWords: little PPC PowerPC FPEMU NOPRINT SIGFPE FPEXC point FP SW malloc
+% LocalWords: exception EXC ENABLE OVF overflow UND underflow RES INV DISABLED
+% LocalWords: NONRECOV ASYNC KEEP securebits NAME NUL PDEATHSIG SECCOMP VM
+% LocalWords: secure computing sigreturn TIMING STATISTICAL TSC MCE conditions
+% LocalWords: timestamp Stamp SIGSEGV UNALIGN SIGBUS MCEERR AO failure early
%%% Local Variables:
%%% mode: latex
projects / gapil.git / blobdiff