+Questa funzione ha un utilizzo effettivo soltanto quando si usa lo scheduling
+real-time, e serve a far sì che il processo corrente rilasci la CPU, in modo
+da essere rimesso in coda alla lista dei processi con la stessa priorità per
+permettere ad un altro di essere eseguito; se però il processo è l'unico ad
+essere presente sulla coda l'esecuzione non sarà interrotta. In genere usano
+questa funzione i processi con politica \const{SCHED\_FIFO}, per permettere
+l'esecuzione degli altri processi con pari priorità quando la sezione più
+urgente è finita.
+
+La funzione può essere utilizzata anche con processi che usano lo scheduling
+ordinario, ma in questo caso il comportamento non è ben definito, e dipende
+dall'implementazione. Fino al kernel 2.6.23 questo comportava che i processi
+venissero messi in fondo alla coda di quelli attivi, con la possibilità di
+essere rimessi in esecuzione entro breve tempo, con l'introduzione del
+\textit{Completely Fair Scheduler} questo comportamento è cambiato ed un
+processo che chiama la funzione viene inserito nella lista dei processi
+inattivo, con un tempo molto maggiore.\footnote{è comunque possibile
+ ripristinare un comportamento analogo al precedente scrivendo il valore 1
+ nel file \texttt{/proc/sys/kernel/sched\_compat\_yield}.}
+
+
+
+\subsection{Il controllo dello \textit{scheduler} per i sistemi
+ multiprocessore}
+\label{sec:proc_sched_multiprocess}
+
+Infine 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
+scheduler, quando riavvia un processo precedentemente interrotto scegliendo il
+primo processore disponibile, lo faccia eseguire da un processore diverso
+rispetto a quello su cui era stato eseguito in precedenza. Se il processo
+passa da un processore all'altro in questo modo (cosa che avveniva abbastanza
+di frequente con i kernel della seria 2.4.x) si ha l'\textsl{effetto
+ ping-pong}.
+
+Questo tipo di comportamento può generare dei seri problemi di prestazioni;
+infatti tutti i processori moderni utilizzano una memoria interna (la
+\textit{cache}) contenente i dati più usati, che permette di evitare di
+eseguire un accesso (molto più lento) alla memoria principale sulla scheda
+madre. Chiaramente un processo sarà favorito se i suoi dati sono nella cache
+del processore, ma è ovvio che questo può essere vero solo per un processore
+alla volta, perché in presenza di più copie degli stessi dati su più
+processori, non si potrebbe determinare quale di questi ha la versione dei
+dati aggiornata rispetto alla memoria principale.
+
+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.
+
+\itindbeg{CPU~affinity}
+
+Per ovviare a questo tipo di problemi è nato il concetto di \textsl{affinità
+ di processore} (o \textit{CPU affinity}); la possibilità cioè di far sì che
+un processo possa essere assegnato per l'esecuzione sempre allo stesso
+processore. Lo scheduler dei kernel della serie 2.4.x aveva una scarsa
+\textit{CPU affinity}, e \index{effetto~ping-pong} l'effetto ping-pong era
+comune; con il nuovo scheduler dei kernel della 2.6.x questo problema è stato
+risolto ed esso cerca di mantenere il più possibile ciascun processo sullo
+stesso processore.
+
+In certi casi però resta l'esigenza di poter essere sicuri che un processo sia
+sempre eseguito dallo stesso processore,\footnote{quella che viene detta
+ \textit{hard CPU affinity}, in contrasto con quella fornita dallo scheduler,
+ detta \textit{soft CPU affinity}, che di norma indica solo una preferenza,
+ non un requisito assoluto.} e per poter risolvere questo tipo di
+problematiche nei nuovi kernel\footnote{le due system call per la gestione
+ della \textit{CPU affinity} sono state introdotte nel kernel 2.5.8, e le
+ funzioni di libreria nelle \textsl{glibc} 2.3.} è stata introdotta
+l'opportuna infrastruttura ed una nuova system call che permette di impostare
+su quali processori far eseguire un determinato processo attraverso una
+\textsl{maschera di affinità}. La corrispondente funzione di libreria è
+\funcd{sched\_setaffinity} ed il suo prototipo è:
+\begin{prototype}{sched.h}
+ {int sched\_setaffinity (pid\_t pid, unsigned int cpusetsize, const
+ cpu\_set\_t *cpuset)}
+ Imposta la maschera di affinità del processo \param{pid}.
+
+ \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
+ nel qual caso \var{errno} può assumere i valori:
+ \begin{errlist}
+ \item[\errcode{ESRCH}] il processo \param{pid} non esiste.
+ \item[\errcode{EINVAL}] il valore di \param{cpuset} contiene riferimenti a
+ processori non esistenti nel sistema.
+ \item[\errcode{EPERM}] il processo non ha i privilegi sufficienti per
+ eseguire l'operazione.
+ \end{errlist}
+ ed inoltre anche \errval{EFAULT}.}
+\end{prototype}
+
+
+Questa funzione e la corrispondente \func{sched\_setaffinity} hanno una storia
+abbastanza complessa, la system call prevede l'uso di due ulteriori argomenti
+di tipo \texttt{unsigned int len} e \texttt{unsigned long *mask}, che
+corrispondono al fatto che la implementazione effettiva usa una semplice
+maschera binaria. Quando le funzioni vennero incluse nelle \acr{glibc}
+assunsero invece il prototipo appena mostrato. A complicare la cosa si
+aggiunge il fatto che nella versione 2.3.3 delle \acr{glibc} l'argomento
+\param{cpusetsize} è stato eliminato, per poi essere ripristinato nella
+versione 2.3.4.\footnote{pertanto se la vostra pagina di manuale non è
+ aggiornata, o usate quella particolare versione delle \acr{glibc}, potrete
+ trovare indicazioni diverse, il prototipo illustrato è quello riportato
+ nella versione corrente (maggio 2008) delle pagine di manuale e
+ corrispondente alla definizione presente in \file{sched.h}.}
+
+La funzione imposta, con l'uso del valore contenuto all'indirizzo
+\param{cpuset}, l'insieme dei processori sui quali deve essere eseguito il
+processo identificato tramite il valore passato in \param{pid}. Come in
+precedenza il valore nullo di \param{pid} indica il processo corrente. Per
+poter utilizzare questa funzione sono richiesti i privilegi di amministratore
+(è necessaria la capacità \const{CAP\_SYS\_NICE}) altrimenti essa fallirà con
+un errore di \errcode{EPERM}. Una volta impostata una maschera di affinità,
+questa viene ereditata attraverso una \func{fork}, in questo modo diventa
+possibile legare automaticamente un gruppo di processi ad un singolo
+processore.
+
+Nell'uso comune, almeno con i kernel della serie 2.6.x, l'uso di questa
+funzione non è necessario, in quanto è lo scheduler stesso che provvede a
+mantenere al meglio l'affinità di processore. Esistono però esigenze
+particolari, ad esempio quando un processo (o un gruppo di processi) è
+utilizzato per un compito importante (ad esempio per applicazioni real-time o
+la cui risposta è critica) e si vuole la massima velocità, con questa
+interfaccia diventa possibile selezionare gruppi di processori utilizzabili in
+maniera esclusiva. Lo stesso dicasi quando l'accesso a certe risorse (memoria
+o periferiche) può avere un costo diverso a seconda del processore, come
+avviene nelle architetture NUMA (\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.
+
+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
+ 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
+ riguardo.} che permette di identificare un insieme di processori. Il dato è
+una maschera binaria: in generale è un intero a 32 bit in cui ogni bit
+corrisponde ad un processore, ma dato che per architetture particolari il
+numero di bit di un intero può non essere sufficiente, è stata creata questa
+che è una interfaccia generica che permette di usare a basso livello un tipo
+di dato qualunque rendendosi indipendenti dal numero di bit e dalla loro
+disposizione.
+
+Questa interfaccia, oltre alla definizione del tipo di dato apposito, prevede
+anche una serie di macro di preprocessore per la manipolazione dello stesso,
+che consentono di svuotare un insieme, aggiungere o togliere un processore da
+esso o verificare se vi è già presente:
+\begin{functions}
+ \headdecl{sched.h}
+ \funcdecl{void \macro{CPU\_ZERO}(cpu\_set\_t *set)}
+ Inizializza l'insieme (vuoto).
+
+ \funcdecl{void \macro{CPU\_SET}(int cpu, cpu\_set\_t *set)}
+ Inserisce il processore \param{cpu} nell'insieme.
+
+ \funcdecl{void \macro{CPU\_CLR}(int cpu, cpu\_set\_t *set)}
+ Rimuove il processore \param{cpu} nell'insieme.
+
+ \funcdecl{int \macro{CPU\_ISSET}(int cpu, cpu\_set\_t *set)}
+ Controlla se il processore \param{cpu} è nell'insieme.
+\end{functions}
+
+Oltre a queste macro, simili alle analoghe usate per gli insiemi di file
+descriptor (vedi sez.~\ref{sec:file_select}) è definita la costante
+\const{CPU\_SETSIZE} che indica il numero massimo di processori che possono
+far parte dell'insieme, e che costituisce un limite massimo al valore
+dell'argomento \param{cpu}.
+
+In generale la maschera di affinità è preimpostata in modo che un processo
+possa essere eseguito su qualunque processore, se può comunque leggere il
+valore per un processo specifico usando la funzione
+\funcd{sched\_getaffinity}, il suo prototipo è:
+\begin{prototype}{sched.h}
+ {int sched\_getaffinity (pid\_t pid, unsigned int cpusetsize,
+ const cpu\_set\_t *cpuset)}
+ Legge la maschera di affinità del processo \param{pid}.
+
+ \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
+ nel qual caso \var{errno} può assumere i valori:
+ \begin{errlist}
+ \item[\errcode{ESRCH}] il processo \param{pid} non esiste.
+ \item[\errcode{EFAULT}] il valore di \param{cpuset} non è un indirizzo
+ valido.
+ \end{errlist} }
+\end{prototype}
+
+La funzione restituirà all'indirizzo specificato da \param{cpuset} il valore
+della maschera di affinità del processo, così da poterla riutilizzare per una
+successiva reimpostazione. In questo caso non sono necessari privilegi
+particolari.
+
+È chiaro che queste funzioni per la gestione dell'affinità hanno significato
+soltanto su un sistema multiprocessore, esse possono comunque essere
+utilizzate anche in un sistema con un processore singolo, nel qual caso però
+non avranno alcun risultato effettivo.
+
+\itindend{scheduler}
+\itindend{CPU~affinity}
+
+
+\subsection{Le priorità per le operazioni di I/O}
+\label{sec:io_priority}
+
+A lungo l'unica priorità usata per i processi è stata quella relativa
+all'assegnazione dell'uso del processore. Ma il processore non è l'unica
+risorsa che i processi devono contendersi, un'altra, altrettanto importante
+per le prestazioni, è quella dell'accesso a disco. Per questo motivo sono
+stati introdotti diversi \textit{I/O scheduler} in grado di distribuire in
+maniera opportuna questa risorsa ai vari processi. Fino al kernel 2.6.17 era
+possibile soltanto differenziare le politiche generali di gestione, scegliendo
+di usare un diverso \textit{I/O scheduler}; a partire da questa versione, con
+l'introduzione dello scheduler CFQ (\textit{Completely Fair Queuing}) è
+divenuto possibile, qualora si usi questo scheduler, impostare anche delle
+diverse priorità di accesso per i singoli processi.\footnote{al momento
+ (kernel 2.6.31), le priorità di I/O sono disponibili soltanto per questo
+ scheduler.}
+
+La scelta dello scheduler di I/O si può fare in maniera generica a livello di
+avvio del kernel assegnando il nome dello stesso al parametro
+\texttt{elevator}, mentre se ne può indicare uno per l'accesso al singolo
+disco scrivendo nel file \texttt{/sys/block/\textit{dev}/queue/scheduler}
+(dove \texttt{\textit{dev}} è il nome del dispositivo associato al disco); gli
+scheduler disponibili sono mostrati dal contenuto dello stesso file che
+riporta fra parentesi quadre quello attivo, il default in tutti i kernel
+recenti è proprio il \texttt{cfq},\footnote{nome con cui si indica appunto lo
+ scheduler \textit{Completely Fair Queuing}.} che supporta le priorità. Per i
+dettagli sulle caratteristiche specifiche degli altri scheduler, la cui
+discussione attiene a problematiche di ambito sistemistico, si consulti la
+documentazione nella directory \texttt{Documentation/block/} dei sorgenti del
+kernel.
+
+Una volta che si sia impostato lo scheduler CFQ ci sono due specifiche system
+call, specifiche di Linux, che consentono di leggere ed impostare le priorità
+di I/O.\footnote{se usate in corrispondenza ad uno scheduler diverso il loro
+ 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
+\funcd{ioprio\_set}; i rispettivi prototipi sono:
+\begin{functions}
+ \headdecl{linux/ioprio.h}
+ \funcdecl{int ioprio\_get(int which, int who)}
+ \funcdecl{int ioprio\_set(int which, int who, int ioprio)}
+
+ Rileva o imposta la priorità di I/O di un processo.
+
+ \bodydesc{Le funzioni ritornano rispettivamente un intero positivo
+ (indicante la priorità) o 0 in caso di successo e $-1$ in caso di errore,
+ nel qual caso \var{errno} può assumere i valori:
+ \begin{errlist}
+ \item[\errcode{ESRCH}] non esiste il processo indicato.
+ \item[\errcode{EINVAL}] i valori di \param{which} e \param{who} non sono
+ validi.
+ \item[\errcode{EPERM}] non si hanno i privilegi per eseguire
+ l'impostazione (solo per \func{ioprio\_set}).
+ \end{errlist} }
+\end{functions}
+
+Le funzioni leggono o impostano la priorità di I/O sulla base dell'indicazione
+dei due argomenti \param{which} e \param{who} che hanno lo stesso significato
+già visto per gli omonimi argomenti di \func{getpriority} e
+\func{setpriority}. Anche in questo caso si deve specificare il valore
+di \param{which} tramite le opportune costanti riportate in
+tab.~\ref{tab:ioprio_args} che consentono di indicare un singolo processo, i
+processi di un \textit{process group} (tratteremo questo argomento in
+sez.~\ref{sec:sess_proc_group}) o tutti o processi di un utente.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|c|c|l|}
+ \hline
+ \param{which} & \param{who} & \textbf{Significato} \\
+ \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\_USER} & \type{uid\_t} & utente\\
+ \hline
+ \end{tabular}
+ \caption{Legenda del valore dell'argomento \param{which} e del tipo
+ dell'argomento \param{who} delle funzioni \func{ioprio\_get} e
+ \func{ioprio\_set} per le tre possibili scelte.}
+ \label{tab:ioprio_args}
+\end{table}
+
+In caso di successo \func{ioprio\_get} restituisce un intero positivo che
+esprime il valore della priorità di I/O, questo valore è una maschera binaria
+composta da due parti, una che esprime la \textsl{classe} di scheduling di I/O
+del processo, l'altra che esprime, quando la classe di scheduling lo prevede,
+la priorità del processo all'interno della classe stessa. Questo stesso
+formato viene utilizzato per indicare il valore della priorità da impostare
+con l'argomento \param{ioprio} di \func{ioprio\_set}.
+
+Per la gestione dei valori che esprimono le priorità di I/O sono state
+definite delle opportune macro di preprocessore, riportate in
+tab.~\ref{tab:IOsched_class_macro}. I valori delle priorità si ottengono o si
+impostano usando queste macro. Le prime due si usano con il valore restituito
+da \func{ioprio\_get} e per ottenere rispettivamente la classe di
+scheduling\footnote{restituita dalla macro con i valori di
+ tab.~\ref{tab:IOsched_class}.} e l'eventuale valore della priorità. La terza
+macro viene invece usata per creare un valore di priorità da usare come
+argomento di \func{ioprio\_set} per eseguire una impostazione.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Macro} & \textbf{Significato}\\
+ \hline
+ \hline
+ \macro{IOPRIO\_PRIO\_CLASS}\texttt{(\textit{value})}
+ & dato il valore di una priorità come
+ restituito da \func{ioprio\_get} estrae il
+ valore della classe.\\
+ \macro{IOPRIO\_PRIO\_DATA}\texttt{(\textit{value})}
+ & dato il valore di una priorità come
+ restituito da \func{ioprio\_get} estrae il
+ valore della priorità.\\
+ \macro{IOPRIO\_PRIO\_VALUE}\texttt{(\textit{class},\textit{prio})}
+ & dato un valore di priorità ed una classe
+ ottiene il valore numerico da passare a
+ \func{ioprio\_set}.\\
+ \hline
+ \end{tabular}
+ \caption{Le macro per la gestione dei valori numerici .}
+ \label{tab:IOsched_class_macro}
+\end{table}
+
+Le classi di scheduling previste dallo scheduler CFQ sono tre, e ricalcano tre
+diverse modalità di distribuzione delle risorse analoghe a quelle già adottate
+anche nel funzionamento dello scheduler del processore. Ciascuna di esse è
+identificata tramite una opportuna costante, secondo quanto riportato in
+tab.~\ref{tab:IOsched_class}.
+
+La classe di priorità più bassa è \const{IOPRIO\_CLASS\_IDLE}; i processi in
+questa classe riescono ad accedere a disco soltanto quando nessun altro
+processo richiede l'accesso. Occorre pertanto usarla con molta attenzione,
+perché un processo in questa classe può venire completamente bloccato quando
+ci sono altri processi in una qualunque delle altre due classi che stanno
+accedendo al disco. Quando si usa questa classe non ha senso indicare un
+valore di priorità, dato che in questo caso non esiste nessuna gerarchia e la
+priorità è identica, la minima possibile, per tutti i processi.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|l|}
+ \hline
+ \textbf{Classe} & \textbf{Significato} \\
+ \hline
+ \hline
+ \const{IOPRIO\_CLASS\_RT} & Scheduling di I/O \textit{real time}.\\
+ \const{IOPRIO\_CLASS\_BE} & Scheduling di I/O ordinario.\\
+ \const{IOPRIO\_CLASS\_IDLE}& Scheduling di I/O di priorità minima.\\
+ \hline
+ \end{tabular}
+ \caption{Costanti che identificano le classi di scheduling di I/O.}
+ \label{tab:IOsched_class}
+\end{table}
+
+La seconda classe di priorità di I/O è \const{IOPRIO\_CLASS\_BE} (il nome sta
+per \textit{best-effort}) che è quella usata ordinariamente da tutti
+processi. In questo caso esistono priorità diverse che consentono di
+assegnazione di una maggiore banda passante nell'accesso a disco ad un
+processo rispetto agli altri, con meccanismo simile a quello dei valori di
+\textit{nice} in cui si evita che un processo a priorità più alta possa
+bloccare indefinitamente quelli a priorità più bassa. In questo caso però le
+diverse priorità sono soltanto otto, indicate da un valore numerico fra 0 e 7
+e come per \textit{nice} anche in questo caso un valore più basso indica una
+priorità maggiore.
+
+
+Infine la classe di priorità di I/O \textit{real-time}
+\const{IOPRIO\_CLASS\_RT} ricalca le omonime priorità di processore: un
+processo in questa classe ha sempre la precedenza nell'accesso a disco
+rispetto a tutti i processi delle altre classi e di un processo nella stessa
+classe ma con priorità inferiore, ed è pertanto in grado di bloccare
+completamente tutti gli altri. Anche in questo caso ci sono 8 priorità diverse
+con un valore numerico fra 0 e 7, con una priorità più elevata per valori più
+bassi.
+
+In generale nel funzionamento ordinario la priorità di I/O di un processo
+viene impostata in maniera automatica nella classe \const{IOPRIO\_CLASS\_BE}
+con un valore ottenuto a partire dal corrispondente valore di \textit{nice}
+tramite la formula: $\mathtt{\mathit{prio}}=(\mathtt{\mathit{nice}}+20)/5$. Un
+utente ordinario può modificare con \func{ioprio\_set} soltanto le priorità
+dei processi che gli appartengono,\footnote{per la modifica delle priorità di
+ 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 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}, 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/
+
+%TODO trattare le funzionalità per il NUMA
+% 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 relativamente complesse, che
+spesso presuppongono la conoscenza di altri argomenti trattati più avanti
+nella guida, si può saltare questa lezione ad una prima lettura, tornando su
+di essa in un secondo tempo.
+
+\subsection{La system call \func{clone}}
+\label{sec:process_clone}
+
+Da fare
+
+\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 \type{(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
+ \const{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 \const{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 \const{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
+ \const{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 \const{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
+ \const{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
+
+\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,