+% standard IEEE per le operazioni in virgola mobile definisce varie eccezioni
+% aritmetiche e richiede che esse siano notificate.
+% TODO trovare altre info su SIGFPE e trattare la notifica delle eccezioni
+
+\item[\const{SIGILL}] Il nome deriva da \textit{illegal instruction},
+ significa che il programma sta cercando di eseguire una istruzione
+ privilegiata o inesistente, in generale del codice illecito. Poiché il
+ compilatore del C genera del codice valido si ottiene questo segnale se il
+ file eseguibile è corrotto o si stanno cercando di eseguire dei dati.
+ Quest'ultimo caso può accadere quando si passa un puntatore sbagliato al
+ posto di un puntatore a funzione, o si eccede la scrittura di un vettore di
+ una variabile locale, andando a corrompere lo \itindex{stack}
+ \textit{stack}. Lo stesso segnale viene generato in caso di overflow dello
+ \itindex{stack} \textit{stack} o di problemi nell'esecuzione di un gestore.
+ Se il gestore ritorna il comportamento del processo è indefinito.
+\item[\const{SIGSEGV}] Il nome deriva da \itindex{segment~violation}
+ \textit{segment violation}, e significa che il programma sta cercando di
+ leggere o scrivere in una zona di memoria protetta al di fuori di quella che
+ gli è stata riservata dal sistema. In genere è il meccanismo della
+ protezione della memoria che si accorge dell'errore ed il kernel genera il
+ segnale. Se il gestore ritorna il comportamento del processo è indefinito.
+
+ È tipico ottenere questo segnale dereferenziando un puntatore nullo o non
+ inizializzato leggendo al di là della fine di un vettore.
+\item[\const{SIGBUS}] Il nome deriva da \textit{bus error}. Come
+ \const{SIGSEGV} questo è un segnale che viene generato di solito quando si
+ dereferenzia un puntatore non inizializzato, la differenza è che
+ \const{SIGSEGV} indica un accesso non permesso su un indirizzo esistente
+ (tipo fuori dallo heap o dallo \itindex{stack} \textit{stack}), mentre
+ \const{SIGBUS} indica l'accesso ad un indirizzo non valido, come nel caso di
+ un puntatore non allineato.
+\item[\const{SIGABRT}] Il nome deriva da \textit{abort}. Il segnale indica che
+ il programma stesso ha rilevato un errore che viene riportato chiamando la
+ funzione \func{abort} che genera questo segnale.
+\item[\const{SIGTRAP}] È il segnale generato da un'istruzione di breakpoint o
+ dall'attivazione del tracciamento per il processo. È usato dai programmi per
+ il debugging e un programma normale non dovrebbe ricevere questo segnale.
+\item[\const{SIGSYS}] Sta ad indicare che si è eseguita una istruzione che
+ richiede l'esecuzione di una system call, ma si è fornito un codice
+ sbagliato per quest'ultima.
+\end{basedescript}
+
+
+\subsection{I segnali di terminazione}
+\label{sec:sig_termination}
+
+Questo tipo di segnali sono usati per terminare un processo; hanno vari nomi a
+causa del differente uso che se ne può fare, ed i programmi possono
+trattarli in maniera differente.
+
+La ragione per cui può essere necessario trattare questi segnali è che il
+programma può dover eseguire una serie di azioni di pulizia prima di
+terminare, come salvare informazioni sullo stato in cui si trova, cancellare
+file temporanei, o ripristinare delle condizioni alterate durante il
+funzionamento (come il modo del terminale o le impostazioni di una qualche
+periferica).
+
+L'azione predefinita di questi segnali è di terminare il processo, questi
+segnali sono:
+\begin{basedescript}{\desclabelwidth{2.0cm}}
+\item[\const{SIGTERM}] Il nome sta per \textit{terminate}. È un segnale
+ generico usato per causare la conclusione di un programma. Al contrario di
+ \const{SIGKILL} può essere intercettato, ignorato, bloccato. In genere lo si
+ usa per chiedere in maniera ``\textsl{educata}'' ad un processo di
+ concludersi.
+
+\item[\const{SIGINT}] Il nome sta per \textit{interrupt}. È il segnale di
+ interruzione per il programma. È quello che viene generato di default dal
+ comando \cmd{kill} o dall'invio sul terminale del carattere di controllo
+ INTR (interrupt, generato dalla sequenza \cmd{C-c}).
+
+\item[\const{SIGQUIT}] È analogo a \const{SIGINT} con la differenza che è
+ controllato da un altro carattere di controllo, QUIT, corrispondente alla
+ sequenza \texttt{C-\bslash}. A differenza del precedente l'azione
+ predefinita, oltre alla terminazione del processo, comporta anche la
+ creazione di un \itindex{core~dump} \textit{core dump}.
+
+ In genere lo si può pensare come corrispondente ad una condizione di errore
+ del programma rilevata dall'utente. Per questo motivo non è opportuno fare
+ eseguire al gestore di questo segnale le operazioni di pulizia normalmente
+ previste (tipo la cancellazione di file temporanei), dato che in certi casi
+ esse possono eliminare informazioni utili nell'esame dei \itindex{core~dump}
+ \textit{core dump}.
+
+
+\item[\const{SIGKILL}] Il nome è utilizzato per terminare in maniera immediata
+ qualunque programma. Questo segnale non può essere né intercettato, né
+ ignorato, né bloccato, per cui causa comunque la terminazione del processo.
+ In genere esso viene generato solo per richiesta esplicita dell'utente dal
+ comando (o tramite la funzione) \cmd{kill}. Dato che non lo si può
+ intercettare è sempre meglio usarlo come ultima risorsa quando metodi meno
+ brutali, come \const{SIGTERM} o \cmd{C-c} non funzionano.
+
+ Se un processo non risponde a nessun altro segnale \const{SIGKILL} ne causa
+ sempre la terminazione (in effetti il fallimento della terminazione di un
+ processo da parte di \const{SIGKILL} costituirebbe un malfunzionamento del
+ kernel). Talvolta è il sistema stesso che può generare questo segnale quando
+ per condizioni particolari il processo non può più essere eseguito neanche
+ per eseguire un gestore.
+
+\item[\const{SIGHUP}] Il nome sta per \textit{hang-up}. Segnala che il
+ terminale dell'utente si è disconnesso (ad esempio perché si è interrotta la
+ rete). Viene usato anche per riportare la terminazione del processo di
+ controllo di un terminale a tutti i processi della sessione, in modo che
+ essi possano disconnettersi dal relativo terminale.
+
+ Viene inoltre usato in genere per segnalare ai demoni (che non hanno un
+ terminale di controllo) la necessità di reinizializzarsi e rileggere il/i
+ file di configurazione.
+\end{basedescript}
+
+
+\subsection{I segnali di allarme}
+\label{sec:sig_alarm}
+
+Questi segnali sono generati dalla scadenza di un timer (vedi
+sez.~\ref{sec:sig_alarm_abort}). Il loro comportamento predefinito è quello di
+causare la terminazione del programma, ma con questi segnali la scelta
+predefinita è irrilevante, in quanto il loro uso presuppone sempre la
+necessità di un gestore. Questi segnali sono:
+\begin{basedescript}{\desclabelwidth{2.0cm}}
+\item[\const{SIGALRM}] Il nome sta per \textit{alarm}. Segnale la scadenza di
+ un timer misurato sul tempo reale o sull'orologio di sistema. È normalmente
+ usato dalla funzione \func{alarm}.
+
+\item[\const{SIVGTALRM}] Il nome sta per \textit{virtual alarm}. È analogo al
+ precedente ma segnala la scadenza di un timer sul tempo di CPU usato dal
+ processo.
+
+\item[\const{SIGPROF}] Il nome sta per \textit{profiling}. Indica la scadenza
+ di un timer che misura sia il tempo di CPU speso direttamente dal processo
+ che quello che il sistema ha speso per conto di quest'ultimo. In genere
+ viene usato dagli strumenti che servono a fare la profilazione dell'utilizzo
+ del tempo di CPU da parte del processo.
+\end{basedescript}
+
+
+\subsection{I segnali di I/O asincrono}
+\label{sec:sig_asyncio}
+
+Questi segnali operano in congiunzione con le funzioni di I/O asincrono. Per
+questo occorre comunque usare \func{fcntl} per abilitare un file descriptor a
+generare questi segnali. L'azione predefinita è di essere ignorati. Questi
+segnali sono:
+\begin{basedescript}{\desclabelwidth{2.0cm}}
+\item[\const{SIGIO}] Questo segnale viene inviato quando un file descriptor è
+ pronto per eseguire dell'input/output. In molti sistemi solo i
+ socket e i terminali possono generare questo segnale, in Linux
+ questo può essere usato anche per i file, posto che la \func{fcntl} abbia
+ avuto successo.
+
+\item[\const{SIGURG}] Questo segnale è inviato quando arrivano dei dati
+ urgenti o \itindex{out-of-band} \textit{out-of-band} su di un
+ socket; per maggiori dettagli al proposito si veda
+ sez.~\ref{sec:TCP_urgent_data}.
+
+\item[\const{SIGPOLL}] Questo segnale è equivalente a \const{SIGIO}, è
+ definito solo per compatibilità con i sistemi System V.
+\end{basedescript}
+
+
+\subsection{I segnali per il controllo di sessione}
+\label{sec:sig_job_control}
+
+Questi sono i segnali usati dal controllo delle sessioni e dei processi, il
+loro uso è specializzato e viene trattato in maniera specifica nelle sezioni
+in cui si trattano gli argomenti relativi. Questi segnali sono:
+\begin{basedescript}{\desclabelwidth{2.0cm}}
+\item[\const{SIGCHLD}] Questo è il segnale mandato al processo padre quando un
+ figlio termina o viene fermato. L'azione predefinita è di ignorare il
+ segnale, la sua gestione è trattata in sez.~\ref{sec:proc_wait}.
+
+\item[\const{SIGCLD}] Per Linux questo è solo un segnale identico al
+ precedente, il nome è obsoleto e andrebbe evitato.
+
+\item[\const{SIGCONT}] Il nome sta per \textit{continue}. Il segnale viene
+ usato per fare ripartire un programma precedentemente fermato da
+ \const{SIGSTOP}. Questo segnale ha un comportamento speciale, e fa sempre
+ ripartire il processo prima della sua consegna. Il comportamento predefinito
+ è di fare solo questo; il segnale non può essere bloccato. Si può anche
+ installare un gestore, ma il segnale provoca comunque il riavvio del
+ processo.
+
+ La maggior pare dei programmi non hanno necessità di intercettare il
+ segnale, in quanto esso è completamente trasparente rispetto all'esecuzione
+ che riparte senza che il programma noti niente. Si possono installare dei
+ gestori per far si che un programma produca una qualche azione speciale
+ se viene fermato e riavviato, come per esempio riscrivere un prompt, o
+ inviare un avviso.
+\item[\const{SIGSTOP}] Il segnale ferma un processo (lo porta cioè in uno
+ stato di sleep, vedi sez.~\ref{sec:proc_sched}); il segnale non può essere né
+ intercettato, né ignorato, né bloccato.
+
+\item[\const{SIGTSTP}] Il nome sta per \textit{interactive stop}. Il segnale
+ ferma il processo interattivamente, ed è generato dal carattere SUSP
+ (prodotto dalla combinazione \cmd{C-z}), ed al contrario di
+ \const{SIGSTOP} può essere intercettato e ignorato. In genere un programma
+ installa un gestore per questo segnale quando vuole lasciare il sistema
+ o il terminale in uno stato definito prima di fermarsi; se per esempio un
+ programma ha disabilitato l'eco sul terminale può installare un gestore
+ per riabilitarlo prima di fermarsi.
+
+\item[\const{SIGTTIN}] Un processo non può leggere dal terminale se esegue una
+ sessione di lavoro in \textit{background}. Quando un processo in background
+ tenta di leggere da un terminale viene inviato questo segnale a tutti i
+ processi della sessione di lavoro. L'azione predefinita è di fermare il
+ processo. L'argomento è trattato in
+ sez.~\ref{sec:sess_job_control_overview}.
+
+\item[\const{SIGTTOU}] Segnale analogo al precedente \const{SIGTTIN}, ma
+ generato quando si tenta di scrivere o modificare uno dei modi del
+ terminale. L'azione predefinita è di fermare il processo, l'argomento è
+ trattato in sez.~\ref{sec:sess_job_control_overview}.
+\end{basedescript}
+
+
+\subsection{I segnali di operazioni errate}
+\label{sec:sig_oper_error}
+
+Questi segnali sono usati per riportare al programma errori generati da
+operazioni da lui eseguite; non indicano errori del programma quanto errori
+che impediscono il completamento dell'esecuzione dovute all'interazione con il
+resto del sistema. L'azione predefinita di questi segnali è di terminare il
+processo, questi segnali sono:
+\begin{basedescript}{\desclabelwidth{2.0cm}}
+\item[\const{SIGPIPE}] Sta per \textit{Broken pipe}. Se si usano delle pipe,
+ (o delle FIFO o dei socket) è necessario, prima che un processo inizi a
+ scrivere su una di esse, che un altro l'abbia aperta in lettura (si veda
+ sez.~\ref{sec:ipc_pipes}). Se il processo in lettura non è partito o è
+ terminato inavvertitamente alla scrittura sulla pipe il kernel genera questo
+ segnale. Se il segnale è bloccato, intercettato o ignorato la chiamata che
+ lo ha causato fallisce, restituendo l'errore \errcode{EPIPE}.
+\item[\const{SIGLOST}] Sta per \textit{Resource lost}. Tradizionalmente è il
+ segnale che viene generato quando si perde un advisory lock su un file su
+ NFS perché il server NFS è stato riavviato. Il progetto GNU lo utilizza per
+ indicare ad un client il crollo inaspettato di un server. In Linux è
+ definito come sinonimo di \const{SIGIO}.\footnote{ed è segnalato come BUG
+ nella pagina di manuale.}
+\item[\const{SIGXCPU}] Sta per \textit{CPU time limit exceeded}. Questo
+ segnale è generato quando un processo eccede il limite impostato per il
+ tempo di CPU disponibile, vedi sez.~\ref{sec:sys_resource_limit}.
+\item[\const{SIGXFSZ}] Sta per \textit{File size limit exceeded}. Questo
+ segnale è generato quando un processo tenta di estendere un file oltre le
+ dimensioni specificate dal limite impostato per le dimensioni massime di un
+ file, vedi sez.~\ref{sec:sys_resource_limit}.
+\end{basedescript}
+
+
+\subsection{Ulteriori segnali}
+\label{sec:sig_misc_sig}
+
+Raccogliamo qui infine una serie di segnali che hanno scopi differenti non
+classificabili in maniera omogenea. Questi segnali sono:
+\begin{basedescript}{\desclabelwidth{2.0cm}}
+\item[\const{SIGUSR1}] Insieme a \const{SIGUSR2} è un segnale a disposizione
+ dell'utente che lo può usare per quello che vuole. Viene generato solo
+ attraverso l'invocazione della funzione \func{kill}. Entrambi i segnali
+ possono essere utili per implementare una comunicazione elementare fra
+ processi diversi, o per eseguire a richiesta una operazione utilizzando un
+ gestore. L'azione predefinita è di terminare il processo.
+\item[\const{SIGUSR2}] È il secondo segnale a disposizione degli utenti. Vedi
+ quanto appena detto per \const{SIGUSR1}.
+\item[\const{SIGWINCH}] Il nome sta per \textit{window (size) change} e viene
+ generato in molti sistemi (GNU/Linux compreso) quando le dimensioni (in
+ righe e colonne) di un terminale vengono cambiate. Viene usato da alcuni
+ programmi testuali per riformattare l'uscita su schermo quando si cambia
+ dimensione a quest'ultimo. L'azione predefinita è di essere ignorato.
+\item[\const{SIGINFO}] Il segnale indica una richiesta di informazioni. È
+ usato con il controllo di sessione, causa la stampa di informazioni da parte
+ del processo leader del gruppo associato al terminale di controllo, gli
+ altri processi lo ignorano.
+\end{basedescript}
+
+
+\subsection{Le funzioni \func{strsignal} e \func{psignal}}
+\label{sec:sig_strsignal}
+
+Per la descrizione dei segnali il sistema mette a disposizione due funzioni
+che stampano un messaggio di descrizione dato il numero. In genere si usano
+quando si vuole notificare all'utente il segnale ricevuto (nel caso di
+terminazione di un processo figlio o di un gestore che gestisce più segnali);
+la prima funzione, \funcd{strsignal}, è una estensione GNU, accessibile avendo
+definito \macro{\_GNU\_SOURCE}, ed è analoga alla funzione \func{strerror} (si
+veda sez.~\ref{sec:sys_strerror}) per gli errori:
+\begin{prototype}{string.h}{char *strsignal(int signum)}
+ Ritorna il puntatore ad una stringa che contiene la descrizione del segnale
+ \param{signum}.
+\end{prototype}
+\noindent dato che la stringa è allocata staticamente non se ne deve
+modificare il contenuto, che resta valido solo fino alla successiva chiamata
+di \func{strsignal}. Nel caso si debba mantenere traccia del messaggio sarà
+necessario copiarlo.
+
+La seconda funzione, \funcd{psignal}, deriva da BSD ed è analoga alla funzione
+\func{perror} descritta sempre in sez.~\ref{sec:sys_strerror}; il suo prototipo
+è:
+\begin{prototype}{signal.h}{void psignal(int sig, const char *s)}
+ Stampa sullo standard error un messaggio costituito dalla stringa \param{s},
+ seguita da due punti ed una descrizione del segnale indicato da \param{sig}.
+\end{prototype}
+
+Una modalità alternativa per utilizzare le descrizioni restituite da
+\func{strsignal} e \func{psignal} è quello di usare la variabile
+\var{sys\_siglist}, che è definita in \file{signal.h} e può essere acceduta
+con la dichiarazione:
+\includecodesnip{listati/siglist.c}
+
+L'array \var{sys\_siglist} contiene i puntatori alle stringhe di descrizione,
+indicizzate per numero di segnale, per cui una chiamata del tipo di \code{char
+ *decr = strsignal(SIGINT)} può essere sostituita dall'equivalente \code{char
+ *decr = sys\_siglist[SIGINT]}.
+
+
+
+\section{La gestione di base dei segnali}
+\label{sec:sig_management}
+
+I segnali sono il primo e più classico esempio di eventi asincroni, cioè di
+eventi che possono accadere in un qualunque momento durante l'esecuzione di un
+programma. Per questa loro caratteristica la loro gestione non può essere
+effettuata all'interno del normale flusso di esecuzione dello stesso, ma è
+delegata appunto agli eventuali gestori che si sono installati.
+
+In questa sezione vedremo come si effettua la gestione dei segnali, a partire
+dalla loro interazione con le system call, passando per le varie funzioni che
+permettono di installare i gestori e controllare le reazioni di un processo
+alla loro occorrenza.
+
+
+\subsection{Il comportamento generale del sistema}
+\label{sec:sig_gen_beha}
+
+Abbiamo già trattato in sez.~\ref{sec:sig_intro} le modalità con cui il sistema
+gestisce l'interazione fra segnali e processi, ci resta da esaminare però il
+comportamento delle system call; in particolare due di esse, \func{fork} ed
+\func{exec}, dovranno essere prese esplicitamente in considerazione, data la
+loro stretta relazione con la creazione di nuovi processi.
+
+Come accennato in sez.~\ref{sec:proc_fork} quando viene creato un nuovo
+processo esso eredita dal padre sia le azioni che sono state impostate per i
+singoli segnali, che la maschera dei segnali bloccati (vedi
+sez.~\ref{sec:sig_sigmask}). Invece tutti i segnali pendenti e gli allarmi
+vengono cancellati; essi infatti devono essere recapitati solo al padre, al
+figlio dovranno arrivare solo i segnali dovuti alle sue azioni.
+
+Quando si mette in esecuzione un nuovo programma con \func{exec} (si ricordi
+quanto detto in sez.~\ref{sec:proc_exec}) tutti i segnali per i quali è stato
+installato un gestore vengono reimpostati a \const{SIG\_DFL}. Non ha più
+senso infatti fare riferimento a funzioni definite nel programma originario,
+che non sono presenti nello spazio di indirizzi del nuovo programma.
+
+Si noti che questo vale solo per le azioni per le quali è stato installato un
+gestore; viene mantenuto invece ogni eventuale impostazione dell'azione a
+\const{SIG\_IGN}. Questo permette ad esempio alla shell di impostare ad
+\const{SIG\_IGN} le risposte per \const{SIGINT} e \const{SIGQUIT} per i
+programmi eseguiti in background, che altrimenti sarebbero interrotti da una
+successiva pressione di \texttt{C-c} o \texttt{C-y}.
+
+Per quanto riguarda il comportamento di tutte le altre system call si danno
+sostanzialmente due casi, a seconda che esse siano \index{system~call~lente}
+\textsl{lente} (\textit{slow}) o \textsl{veloci} (\textit{fast}). La gran
+parte di esse appartiene a quest'ultima categoria, che non è influenzata
+dall'arrivo di un segnale. Esse sono dette \textsl{veloci} in quanto la loro
+esecuzione è sostanzialmente immediata; la risposta al segnale viene sempre
+data dopo che la system call è stata completata, in quanto attendere per
+eseguire un gestore non comporta nessun inconveniente.
+
+In alcuni casi però alcune system call (che per questo motivo vengono chiamate
+\textsl{lente}) possono bloccarsi indefinitamente. In questo caso non si può
+attendere la conclusione della system call, perché questo renderebbe
+impossibile una risposta pronta al segnale, per cui il gestore viene
+eseguito prima che la system call sia ritornata. Un elenco dei casi in cui si
+presenta questa situazione è il seguente:
+\begin{itemize*}
+\item la lettura da file che possono bloccarsi in attesa di dati non ancora
+ presenti (come per certi \index{file!di~dispositivo} file di dispositivo, i
+ socket o le pipe);
+\item la scrittura sugli stessi file, nel caso in cui dati non possano essere
+ accettati immediatamente (di nuovo comune per i socket);
+\item l'apertura di un file di dispositivo che richiede operazioni non
+ immediate per una risposta (ad esempio l'apertura di un nastro che deve
+ essere riavvolto);
+\item le operazioni eseguite con \func{ioctl} che non è detto possano essere
+ eseguite immediatamente;
+\item le funzioni di intercomunicazione che si bloccano in attesa di risposte
+ da altri processi;
+\item la funzione \func{pause} (usata appunto per attendere l'arrivo di un
+ segnale);
+\item la funzione \func{wait} (se nessun processo figlio è ancora terminato).
+\end{itemize*}
+
+In questo caso si pone il problema di cosa fare una volta che il gestore sia
+ritornato. La scelta originaria dei primi Unix era quella di far ritornare
+anche la system call restituendo l'errore di \errcode{EINTR}. Questa è a
+tutt'oggi una scelta corrente, ma comporta che i programmi che usano dei
+gestori controllino lo stato di uscita delle funzioni che eseguono una system
+call lenta per ripeterne la chiamata qualora l'errore fosse questo.
+
+Dimenticarsi di richiamare una system call interrotta da un segnale è un
+errore comune, tanto che le \acr{glibc} provvedono una macro
+\code{TEMP\_FAILURE\_RETRY(expr)} che esegue l'operazione automaticamente,
+ripetendo l'esecuzione dell'espressione \var{expr} fintanto che il risultato
+non è diverso dall'uscita con un errore \errcode{EINTR}.
+
+La soluzione è comunque poco elegante e BSD ha scelto un approccio molto
+diverso, che è quello di fare ripartire automaticamente una system call
+interrotta invece di farla fallire. In questo caso ovviamente non c'è bisogno
+di preoccuparsi di controllare il codice di errore; si perde però la
+possibilità di eseguire azioni specifiche all'occorrenza di questa particolare
+condizione.
+
+Linux e le \acr{glibc} consentono di utilizzare entrambi gli approcci,
+attraverso una opportuna opzione di \func{sigaction} (vedi
+sez.~\ref{sec:sig_sigaction}). È da chiarire comunque che nel caso di
+interruzione nel mezzo di un trasferimento parziale di dati, le system call
+ritornano sempre indicando i byte trasferiti.
+
+
+\subsection{La funzione \func{signal}}
+\label{sec:sig_signal}
+
+L'interfaccia più semplice per la gestione dei segnali è costituita dalla
+funzione \funcd{signal} che è definita fin dallo standard ANSI C.
+Quest'ultimo però non considera sistemi multitasking, per cui la definizione è
+tanto vaga da essere del tutto inutile in un sistema Unix; è questo il motivo
+per cui ogni implementazione successiva ne ha modificato e ridefinito il
+comportamento, pur mantenendone immutato il prototipo\footnote{in realtà in
+ alcune vecchie implementazioni (SVr4 e 4.3+BSD in particolare) vengono usati
+ alcuni argomenti aggiuntivi per definire il comportamento della funzione,
+ vedremo in sez.~\ref{sec:sig_sigaction} che questo è possibile usando la
+ funzione \func{sigaction}.} che è:
+\begin{prototype}{signal.h}
+ {sighandler\_t signal(int signum, sighandler\_t handler)}
+
+ Installa la funzione di gestione \param{handler} (il gestore) per il
+ segnale \param{signum}.
+
+ \bodydesc{La funzione ritorna il precedente gestore in caso di successo
+ o \const{SIG\_ERR} in caso di errore.}
+\end{prototype}
+
+In questa definizione si è usato un tipo di dato, \type{sighandler\_t}, che è
+una estensione GNU, definita dalle \acr{glibc}, che permette di riscrivere il
+prototipo di \func{signal} nella forma appena vista, molto più leggibile di
+quanto non sia la versione originaria, che di norma è definita come:
+\includecodesnip{listati/signal.c}
+questa infatti, per la poca chiarezza della sintassi del C quando si vanno a
+trattare puntatori a funzioni, è molto meno comprensibile. Da un confronto
+con il precedente prototipo si può dedurre la definizione di
+\type{sighandler\_t} che è:
+\includecodesnip{listati/sighandler_t.c}
+e cioè un puntatore ad una funzione \ctyp{void} (cioè senza valore di ritorno)
+e che prende un argomento di tipo \ctyp{int}.\footnote{si devono usare le
+ parentesi intorno al nome della funzione per via delle precedenze degli
+ operatori del C, senza di esse si sarebbe definita una funzione che ritorna
+ un puntatore a \ctyp{void} e non un puntatore ad una funzione \ctyp{void}.}
+La funzione \func{signal} quindi restituisce e prende come secondo argomento
+un puntatore a una funzione di questo tipo, che è appunto la funzione che
+verrà usata come gestore del segnale.
+
+Il numero di segnale passato nell'argomento \param{signum} può essere indicato
+direttamente con una delle costanti definite in sez.~\ref{sec:sig_standard}.
+L'argomento \param{handler} che indica il gestore invece, oltre all'indirizzo
+della funzione da chiamare all'occorrenza del segnale, può assumere anche i
+due valori costanti \const{SIG\_IGN} e \const{SIG\_DFL}; il primo indica che
+il segnale deve essere ignorato,\footnote{si ricordi però che i due segnali
+ \const{SIGKILL} e \const{SIGSTOP} non possono essere né ignorati né
+ intercettati; l'uso di \const{SIG\_IGN} per questi segnali non ha alcun
+ effetto.} mentre il secondo ripristina l'azione predefinita.\footnote{e
+ serve a tornare al comportamento di default quando non si intende più
+ gestire direttamente un segnale.}
+
+La funzione restituisce l'indirizzo dell'azione precedente, che può essere
+salvato per poterlo ripristinare (con un'altra chiamata a \func{signal}) in un
+secondo tempo. Si ricordi che se si imposta come azione \const{SIG\_IGN} (o si
+imposta un \const{SIG\_DFL} per un segnale la cui azione predefinita è di
+essere ignorato), tutti i segnali pendenti saranno scartati, e non verranno
+mai notificati.
+
+L'uso di \func{signal} è soggetto a problemi di compatibilità, dato che essa
+si comporta in maniera diversa per sistemi derivati da BSD o da System V. In
+questi ultimi infatti la funzione è conforme al comportamento originale dei
+primi Unix in cui il gestore viene disinstallato alla sua chiamata, secondo la
+semantica inaffidabile; anche Linux seguiva questa convenzione con le vecchie
+librerie del C come le \acr{libc4} e le \acr{libc5}.\footnote{nelle
+ \acr{libc5} esiste però la possibilità di includere \file{bsd/signal.h} al
+ posto di \file{signal.h}, nel qual caso la funzione \func{signal} viene
+ ridefinita per seguire la semantica affidabile usata da BSD.}
+
+Al contrario BSD segue la semantica affidabile, non disinstallando il gestore
+e bloccando il segnale durante l'esecuzione dello stesso. Con l'utilizzo delle
+\acr{glibc} dalla versione 2 anche Linux è passato a questo comportamento. Il
+comportamento della versione originale della funzione, il cui uso è deprecato
+per i motivi visti in sez.~\ref{sec:sig_semantics}, può essere ottenuto
+chiamando \func{sysv\_signal}, una volta che si sia definita la macro
+\macro{\_XOPEN\_SOURCE}. In generale, per evitare questi problemi, l'uso di
+\func{signal}, che tra l'altro ha un comportamento indefinito in caso di
+processo \itindex{thread} multi-\textit{thread}, è da evitare; tutti i nuovi
+programmi dovrebbero usare \func{sigaction}.
+
+È da tenere presente che, seguendo lo standard POSIX, il comportamento di un
+processo che ignora i segnali \const{SIGFPE}, \const{SIGILL}, o
+\const{SIGSEGV} (qualora questi non originino da una chiamata ad una
+\func{kill} o ad una \func{raise}) è indefinito. Un gestore che ritorna da
+questi segnali può dare luogo ad un ciclo infinito.
+
+
+\subsection{Le funzioni \func{kill} e \func{raise}}
+\label{sec:sig_kill_raise}
+
+Come precedentemente accennato in sez.~\ref{sec:sig_types}, un segnale può
+anche essere generato direttamente nell'esecuzione di un programma, attraverso
+la chiamata ad una opportuna system call. Le funzioni che si utilizzano di
+solito per inviare un segnale generico ad un processo sono due: \func{raise} e
+\func{kill}.
+
+La prima funzione è \funcd{raise}, che è definita dallo standard ANSI C, e
+serve per inviare un segnale al processo corrente,\footnote{non prevedendo la
+ presenza di un sistema multiutente lo standard ANSI C non poteva che
+ definire una funzione che invia il segnale al programma in esecuzione. Nel
+ caso di Linux questa viene implementata come funzione di compatibilità.} il
+suo prototipo è:
+\begin{prototype}{signal.h}{int raise(int sig)}
+ Invia il segnale \param{sig} al processo corrente.
+
+ \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
+ errore, il solo errore restituito è \errval{EINVAL} qualora si sia
+ specificato un numero di segnale invalido.}
+\end{prototype}
+
+Il valore di \param{sig} specifica il segnale che si vuole inviare e può
+essere specificato con una delle macro definite in
+sez.~\ref{sec:sig_classification}. In genere questa funzione viene usata per
+riprodurre il comportamento predefinito di un segnale che sia stato
+intercettato. In questo caso, una volta eseguite le operazioni volute, il
+gestore dovrà prima reinstallare l'azione predefinita, per poi attivarla
+chiamando \func{raise}.
+
+Mentre \func{raise} è una funzione di libreria, quando si vuole inviare un
+segnale generico ad un processo occorre utilizzare la apposita system call,
+questa può essere chiamata attraverso la funzione \funcd{kill}, il cui
+prototipo è:
+\begin{functions}
+ \headdecl{sys/types.h}
+ \headdecl{signal.h}
+ \funcdecl{int kill(pid\_t pid, int sig)} Invia il segnale \param{sig} al
+ processo specificato con \param{pid}.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
+ errore nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] il segnale specificato non esiste.
+ \item[\errcode{ESRCH}] il processo selezionato non esiste.
+ \item[\errcode{EPERM}] non si hanno privilegi sufficienti ad inviare il
+ segnale.
+ \end{errlist}}
+\end{functions}
+
+Lo standard POSIX prevede che il valore 0 per \param{sig} sia usato per
+specificare il segnale nullo. Se la funzione viene chiamata con questo valore
+non viene inviato nessun segnale, ma viene eseguito il controllo degli errori,
+in tal caso si otterrà un errore \errcode{EPERM} se non si hanno i permessi
+necessari ed un errore \errcode{ESRCH} se il processo specificato non esiste.
+Si tenga conto però che il sistema ricicla i \acr{pid} (come accennato in
+sez.~\ref{sec:proc_pid}) per cui l'esistenza di un processo non significa che
+esso sia realmente quello a cui si intendeva mandare il segnale.
+
+Il valore dell'argomento \param{pid} specifica il processo (o i processi) di
+destinazione a cui il segnale deve essere inviato e può assumere i valori
+riportati in tab.~\ref{tab:sig_kill_values}.
+
+Si noti pertanto che la funzione \code{raise(sig)} può essere definita in
+termini di \func{kill}, ed è sostanzialmente equivalente ad una
+\code{kill(getpid(), sig)}. Siccome \func{raise}, che è definita nello
+standard ISO C, non esiste in alcune vecchie versioni di Unix, in generale
+l'uso di \func{kill} finisce per essere più portabile.
+
+Una seconda funzione che può essere definita in termini di \func{kill} è
+\funcd{killpg}, che è sostanzialmente equivalente a
+\code{kill(-pidgrp, signal)}; il suo prototipo è:
+\begin{prototype}{signal.h}{int killpg(pid\_t pidgrp, int signal)}
+
+ Invia il segnale \param{signal} al \itindex{process~group} \textit{process
+ group} \param{pidgrp}.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
+ errore, gli errori sono gli stessi di \func{kill}.}
+\end{prototype}
+\noindent e permette di inviare un segnale a tutto un \itindex{process~group}
+\textit{process group} (vedi sez.~\ref{sec:sess_proc_group}).
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|r|l|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ $>0$ & Il segnale è mandato al processo con il \acr{pid} indicato.\\
+ 0 & Il segnale è mandato ad ogni processo del \itindex{process~group}
+ \textit{process group} del chiamante.\\
+ $-1$ & Il segnale è mandato ad ogni processo (eccetto \cmd{init}).\\
+ $<-1$ & Il segnale è mandato ad ogni processo del \textit{process group}
+ \itindex{process~group} $|\code{pid}|$.\\
+ \hline
+ \end{tabular}
+ \caption{Valori dell'argomento \param{pid} per la funzione
+ \func{kill}.}
+ \label{tab:sig_kill_values}
+\end{table}
+
+Solo l'amministratore può inviare un segnale ad un processo qualunque, in
+tutti gli altri casi l'user-ID reale o l'user-ID effettivo del processo
+chiamante devono corrispondere all'user-ID reale o all'user-ID salvato della
+destinazione. Fa eccezione il caso in cui il segnale inviato sia
+\const{SIGCONT}, nel quale occorre che entrambi i processi appartengano alla
+stessa sessione. Inoltre, dato il ruolo fondamentale che riveste nel sistema
+(si ricordi quanto visto in sez.~\ref{sec:sig_termination}), non è possibile
+inviare al processo 1 (cioè a \cmd{init}) segnali per i quali esso non abbia
+un gestore installato.
+
+Infine, seguendo le specifiche POSIX 1003.1-2001, l'uso della chiamata
+\code{kill(-1, sig)} comporta che il segnale sia inviato (con la solita
+eccezione di \cmd{init}) a tutti i processi per i quali i permessi lo
+consentano. Lo standard permette comunque alle varie implementazioni di
+escludere alcuni processi specifici: nel caso in questione Linux non invia il
+segnale al processo che ha effettuato la chiamata.
+
+
+\subsection{Le funzioni \func{alarm}, \func{abort} ed i \textit{timer}}
+\label{sec:sig_alarm_abort}
+
+Un caso particolare di segnali generati a richiesta è quello che riguarda i
+vari segnali di temporizzazione e \const{SIGABRT}, per ciascuno di questi
+segnali sono previste funzioni specifiche che ne effettuino l'invio. La più
+comune delle funzioni usate per la temporizzazione è \funcd{alarm} il cui
+prototipo è:
+\begin{prototype}{unistd.h}{unsigned int alarm(unsigned int seconds)}
+ Predispone l'invio di \const{SIGALRM} dopo \param{seconds} secondi.
+
+ \bodydesc{La funzione restituisce il numero di secondi rimanenti ad un
+ precedente allarme, o zero se non c'erano allarmi pendenti.}
+\end{prototype}
+
+La funzione fornisce un meccanismo che consente ad un processo di predisporre
+un'interruzione nel futuro, (ad esempio per effettuare una qualche operazione
+dopo un certo periodo di tempo), programmando l'emissione di un segnale (nel
+caso in questione \const{SIGALRM}) dopo il numero di secondi specificato da
+\param{seconds}.
+
+Se si specifica per \param{seconds} un valore nullo non verrà inviato nessun
+segnale; siccome alla chiamata viene cancellato ogni precedente allarme,
+questo può essere usato per cancellare una programmazione precedente.
+
+La funzione inoltre ritorna il numero di secondi rimanenti all'invio
+dell'allarme programmato in precedenza. In questo modo è possibile controllare
+se non si è cancellato un precedente allarme e predisporre eventuali misure
+che permettano di gestire il caso in cui servono più interruzioni.
+
+In sez.~\ref{sec:sys_unix_time} abbiamo visto che ad ogni processo sono
+associati tre tempi diversi: il \textit{clock time}, l'\textit{user time} ed
+il \textit{system time}. Per poterli calcolare il kernel mantiene per ciascun
+processo tre diversi timer:
+\begin{itemize*}
+\item un \textit{real-time timer} che calcola il tempo reale trascorso (che
+ corrisponde al \textit{clock time}). La scadenza di questo timer provoca
+ l'emissione di \const{SIGALRM};
+\item un \textit{virtual timer} che calcola il tempo di processore usato dal
+ processo in user space (che corrisponde all'\textit{user time}). La scadenza
+ di questo timer provoca l'emissione di \const{SIGVTALRM};
+\item un \textit{profiling timer} che calcola la somma dei tempi di processore
+ utilizzati direttamente dal processo in user space, e dal kernel nelle
+ system call ad esso relative (che corrisponde a quello che in
+ sez.~\ref{sec:sys_unix_time} abbiamo chiamato \textit{CPU time}). La scadenza
+ di questo timer provoca l'emissione di \const{SIGPROF}.
+\end{itemize*}
+
+Il timer usato da \func{alarm} è il \textit{clock time}, e corrisponde cioè al
+tempo reale. La funzione come abbiamo visto è molto semplice, ma proprio per
+questo presenta numerosi limiti: non consente di usare gli altri timer, non
+può specificare intervalli di tempo con precisione maggiore del secondo e
+genera il segnale una sola volta.
+
+Per ovviare a questi limiti Linux deriva da BSD la funzione \funcd{setitimer}
+che permette di usare un timer qualunque e l'invio di segnali periodici, al
+costo però di una maggiore complessità d'uso e di una minore portabilità. Il
+suo prototipo è:
+\begin{prototype}{sys/time.h}{int setitimer(int which, const struct
+ itimerval *value, struct itimerval *ovalue)}
+
+ Predispone l'invio di un segnale di allarme alla scadenza dell'intervallo
+ \param{value} sul timer specificato da \param{which}.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
+ errore, nel qual caso \var{errno} assumerà uno dei valori \errval{EINVAL} o
+ \errval{EFAULT}.}
+\end{prototype}
+
+Il valore di \param{which} permette di specificare quale dei tre timer
+illustrati in precedenza usare; i possibili valori sono riportati in
+tab.~\ref{tab:sig_setitimer_values}.
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|l|}
+ \hline
+ \textbf{Valore} & \textbf{Timer} \\
+ \hline
+ \hline
+ \const{ITIMER\_REAL} & \textit{real-time timer}\\
+ \const{ITIMER\_VIRTUAL} & \textit{virtual timer}\\
+ \const{ITIMER\_PROF} & \textit{profiling timer}\\
+ \hline
+ \end{tabular}
+ \caption{Valori dell'argomento \param{which} per la funzione
+ \func{setitimer}.}
+ \label{tab:sig_setitimer_values}
+\end{table}
+
+Il valore della struttura specificata \param{value} viene usato per impostare
+il timer, se il puntatore \param{ovalue} non è nullo il precedente valore
+viene salvato qui. I valori dei timer devono essere indicati attraverso una
+struttura \struct{itimerval}, definita in fig.~\ref{fig:file_stat_struct}.
+
+La struttura è composta da due membri, il primo, \var{it\_interval} definisce
+il periodo del timer; il secondo, \var{it\_value} il tempo mancante alla
+scadenza. Entrambi esprimono i tempi tramite una struttura \struct{timeval} che
+permette una precisione fino al microsecondo.
+
+Ciascun timer decrementa il valore di \var{it\_value} fino a zero, poi invia
+il segnale e reimposta \var{it\_value} al valore di \var{it\_interval}, in
+questo modo il ciclo verrà ripetuto; se invece il valore di \var{it\_interval}
+è nullo il timer si ferma.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/itimerval.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{itimerval}, che definisce i valori dei timer
+ di sistema.}
+ \label{fig:sig_itimerval}
+\end{figure}
+
+L'uso di \func{setitimer} consente dunque un controllo completo di tutte le
+caratteristiche dei timer, ed in effetti la stessa \func{alarm}, benché
+definita direttamente nello standard POSIX.1, può a sua volta essere espressa
+in termini di \func{setitimer}, come evidenziato dal manuale delle \acr{glibc}
+\cite{glibc} che ne riporta la definizione mostrata in
+fig.~\ref{fig:sig_alarm_def}.\footnote{questo comporta anche che non è il caso
+ di mescolare chiamate ad \func{abort} e a \func{setitimer}.}
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/alarm_def.c}
+ \end{minipage}
+ \normalsize
+ \caption{Definizione di \func{alarm} in termini di \func{setitimer}.}
+ \label{fig:sig_alarm_def}
+\end{figure}
+
+Si deve comunque tenere presente che fino al kernel 2.6.16 la precisione di
+queste funzioni era limitata dalla frequenza del timer di sistema,\footnote{il
+ valore della constante \texttt{HZ}, di cui abbiamo già parlato in
+ sez.~\ref{sec:proc_hierarchy}.} in quanto le temporizzazioni erano calcolate
+in numero di interruzioni del timer (i cosiddetti ''\textit{jiffies}''), ed era
+assicurato soltanto che il segnale non sarebbe stato mai generato prima della
+scadenza programmata (l'arrotondamento cioè era effettuato per
+eccesso).\footnote{questo in realtà non è del tutto vero a causa di un bug,
+ presente fino al kernel 2.6.12, che in certe circostanze causava l'emissione
+ del segnale con un arrotondamento per difetto.} L'uso del contatore dei
+\textit{jiffies}, un intero a 32 bit, comportava inoltre l'impossibilità di
+specificare tempi molto lunghi.\footnote{superiori al valore della costante
+ \const{MAX\_SEC\_IN\_JIFFIES}, pari, nel caso di default di un valore di
+ \const{HZ} di 250, a circa 99 giorni e mezzo.} Con il cambiamento della
+rappresentazione effettuato nel kernel 2.6.16 questo problema è scomparso e
+con l'introduzione dei timer ad alta risoluzione (vedi
+sez.~\ref{sec:sig_timer_adv}) nel kernel 2.6.21 la precisione è diventata
+quella fornita dall'hardware disponibile.
+
+Una seconda causa di potenziali ritardi è che il segnale viene generato alla
+scadenza del timer, ma poi deve essere consegnato al processo; se quest'ultimo
+è attivo (questo è sempre vero per \const{ITIMER\_VIRT}) la consegna è
+immediata, altrimenti può esserci un ulteriore ritardo che può variare a
+seconda del carico del sistema.
+
+Questo ha una conseguenza che può indurre ad errori molto subdoli, si tenga
+conto poi che in caso di sistema molto carico, si può avere il caso patologico
+in cui un timer scade prima che il segnale di una precedente scadenza sia
+stato consegnato; in questo caso, per il comportamento dei segnali descritto
+in sez.~\ref{sec:sig_sigchld}, un solo segnale sarà consegnato.
+
+Dato che sia \func{alarm} che \func{setitimer} non consentono di leggere il
+valore corrente di un timer senza modificarlo, è possibile usare la funzione
+\funcd{getitimer}, il cui prototipo è:
+\begin{prototype}{sys/time.h}{int getitimer(int which, struct
+ itimerval *value)}
+
+ Legge in \param{value} il valore del timer specificato da \param{which}.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
+ errore e restituisce gli stessi errori di \func{getitimer}.}
+\end{prototype}
+\noindent i cui argomenti hanno lo stesso significato e formato di quelli di
+\func{setitimer}.
+
+
+L'ultima funzione che permette l'invio diretto di un segnale è \funcd{abort},
+che, come accennato in sez.~\ref{sec:proc_termination}, permette di abortire
+l'esecuzione di un programma tramite l'invio di \const{SIGABRT}. Il suo
+prototipo è:
+\begin{prototype}{stdlib.h}{void abort(void)}
+
+ Abortisce il processo corrente.
+
+ \bodydesc{La funzione non ritorna, il processo è terminato inviando il
+ segnale di \const{SIGABRT}.}
+\end{prototype}
+
+La differenza fra questa funzione e l'uso di \func{raise} è che anche se il
+segnale è bloccato o ignorato, la funzione ha effetto lo stesso. Il segnale
+può però essere intercettato per effettuare eventuali operazioni di chiusura
+prima della terminazione del processo.
+
+Lo standard ANSI C richiede inoltre che anche se il gestore ritorna, la
+funzione non ritorni comunque. Lo standard POSIX.1 va oltre e richiede che se
+il processo non viene terminato direttamente dal gestore sia la stessa
+\func{abort} a farlo al ritorno dello stesso. Inoltre, sempre seguendo lo
+standard POSIX, prima della terminazione tutti i file aperti e gli stream
+saranno chiusi ed i buffer scaricati su disco. Non verranno invece eseguite le
+eventuali funzioni registrate con \func{atexit} e \func{on\_exit}.
+
+
+\subsection{Le funzioni di pausa e attesa}
+\label{sec:sig_pause_sleep}
+
+Sono parecchie le occasioni in cui si può avere necessità di sospendere
+temporaneamente l'esecuzione di un processo. Nei sistemi più elementari in
+genere questo veniva fatto con un opportuno loop di attesa, ma in un sistema
+multitasking un loop di attesa è solo un inutile spreco di CPU, per questo ci
+sono apposite funzioni che permettono di mettere un processo in stato di
+attesa.\footnote{si tratta in sostanza di funzioni che permettono di portare
+ esplicitamente il processo in stato di \textit{sleep}, vedi
+ sez.~\ref{sec:proc_sched}.}
+
+Il metodo tradizionale per fare attendere ad un processo fino all'arrivo di un
+segnale è quello di usare la funzione \funcd{pause}, il cui prototipo è:
+\begin{prototype}{unistd.h}{int pause(void)}
+
+ Pone il processo in stato di sleep fino al ritorno di un gestore.
+
+ \bodydesc{La funzione ritorna solo dopo che un segnale è stato ricevuto ed
+ il relativo gestore è ritornato, nel qual caso restituisce $-1$ e
+ \var{errno} assumerà il valore \errval{EINTR}.}
+\end{prototype}
+
+La funzione segnala sempre una condizione di errore (il successo sarebbe
+quello di aspettare indefinitamente). In genere si usa questa funzione quando
+si vuole mettere un processo in attesa di un qualche evento specifico che non
+è sotto il suo diretto controllo (ad esempio la si può usare per interrompere
+l'esecuzione del processo fino all'arrivo di un segnale inviato da un altro
+processo).
+
+Quando invece si vuole fare attendere un processo per un intervallo di tempo
+già noto nello standard POSIX.1 viene definita la funzione \funcd{sleep}, il
+cui prototipo è:
+\begin{prototype}{unistd.h}{unsigned int sleep(unsigned int seconds)}
+
+ Pone il processo in stato di sleep per \param{seconds} secondi.
+
+ \bodydesc{La funzione restituisce zero se l'attesa viene completata, o il
+ numero di secondi restanti se viene interrotta da un segnale.}
+\end{prototype}
+
+La funzione attende per il tempo specificato, a meno di non essere interrotta
+da un segnale. In questo caso non è una buona idea ripetere la chiamata per il
+tempo rimanente, in quanto la riattivazione del processo può avvenire in un
+qualunque momento, ma il valore restituito sarà sempre arrotondato al secondo,
+con la conseguenza che, se la successione dei segnali è particolarmente
+sfortunata e le differenze si accumulano, si potranno avere ritardi anche di
+parecchi secondi. In genere la scelta più sicura è quella di stabilire un
+termine per l'attesa, e ricalcolare tutte le volte il numero di secondi da
+aspettare.
+
+In alcune implementazioni inoltre l'uso di \func{sleep} può avere conflitti
+con quello di \const{SIGALRM}, dato che la funzione può essere realizzata con
+l'uso di \func{pause} e \func{alarm} (in maniera analoga all'esempio che
+vedremo in sez.~\ref{sec:sig_example}). In tal caso mescolare chiamata di
+\func{alarm} e \func{sleep} o modificare l'azione di \const{SIGALRM}, può
+causare risultati indefiniti. Nel caso delle \acr{glibc} è stata usata una
+implementazione completamente indipendente e questi problemi non ci sono.
+
+La granularità di \func{sleep} permette di specificare attese soltanto in
+secondi, per questo sia sotto BSD4.3 che in SUSv2 è stata definita la funzione
+\funcd{usleep} (dove la \texttt{u} è intesa come sostituzione di $\mu$); i due
+standard hanno delle definizioni diverse, ma le \acr{glibc}
+seguono\footnote{secondo la pagina di manuale almeno dalla versione 2.2.2.}
+seguono quella di SUSv2 che prevede il seguente prototipo:
+\begin{prototype}{unistd.h}{int usleep(unsigned long usec)}
+
+ Pone il processo in stato di sleep per \param{usec} microsecondi.
+
+ \bodydesc{La funzione restituisce zero se l'attesa viene completata, o $-1$
+ in caso di errore, nel qual caso \var{errno} assumerà il valore
+ \errval{EINTR}.}
+
+\end{prototype}
+
+Anche questa funzione, a seconda delle implementazioni, può presentare
+problemi nell'interazione con \func{alarm} e \const{SIGALRM}. È pertanto
+deprecata in favore della funzione \funcd{nanosleep}, definita dallo standard
+POSIX1.b, il cui prototipo è:
+\begin{prototype}{unistd.h}{int nanosleep(const struct timespec *req, struct
+ timespec *rem)}
+
+ Pone il processo in stato di sleep per il tempo specificato da \param{req}.
+ In caso di interruzione restituisce il tempo restante in \param{rem}.
+
+ \bodydesc{La funzione restituisce zero se l'attesa viene completata, o $-1$
+ in caso di errore, nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] si è specificato un numero di secondi negativo o un
+ numero di nanosecondi maggiore di 999.999.999.
+ \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale.
+ \end{errlist}}
+\end{prototype}
+
+Lo standard richiede che la funzione sia implementata in maniera del tutto
+indipendente da \func{alarm}\footnote{nel caso di Linux questo è fatto
+ utilizzando direttamente il timer del kernel.} e sia utilizzabile senza
+interferenze con l'uso di \const{SIGALRM}. La funzione prende come argomenti
+delle strutture di tipo \struct{timespec}, la cui definizione è riportata in
+fig.~\ref{fig:sys_timespec_struct}, che permette di specificare un tempo con
+una precisione fino al nanosecondo.
+
+La funzione risolve anche il problema di proseguire l'attesa dopo
+l'interruzione dovuta ad un segnale; infatti in tal caso in \param{rem} viene
+restituito il tempo rimanente rispetto a quanto richiesto
+inizialmente,\footnote{con l'eccezione, valida solo nei kernel della serie
+ 2.4, in cui, per i processi riavviati dopo essere stati fermati da un
+ segnale, il tempo passato in stato \texttt{T} non viene considerato nel
+ calcolo della rimanenza.} e basta richiamare la funzione per completare
+l'attesa.\footnote{anche qui però occorre tenere presente che i tempi sono
+ arrotondati, per cui la precisione, per quanto migliore di quella ottenibile
+ con \func{sleep}, è relativa e in caso di molte interruzioni si può avere
+ una deriva, per questo esiste la funzione \func{clock\_nanosleep} (vedi
+ sez.~\ref{sec:sig_timer_adv}) che permette di specificare un tempo assoluto
+ anziché un tempo relativo.}
+
+Chiaramente, anche se il tempo può essere specificato con risoluzioni fino al
+nanosecondo, la precisione di \func{nanosleep} è determinata dalla risoluzione
+temporale del timer di sistema. Perciò la funzione attenderà comunque il tempo
+specificato, ma prima che il processo possa tornare ad essere eseguito
+occorrerà almeno attendere la successiva interruzione del timer di sistema,
+cioè un tempo che a seconda dei casi può arrivare fino a 1/\const{HZ}, (sempre
+che il sistema sia scarico ed il processa venga immediatamente rimesso in
+esecuzione); per questo motivo il valore restituito in \param{rem} è sempre
+arrotondato al multiplo successivo di 1/\const{HZ}.
+
+Con i kernel della serie 2.4 in realtà era possibile ottenere anche pause più
+precise del centesimo di secondo usando politiche di \itindex{scheduler}
+scheduling \textit{real-time} come \const{SCHED\_FIFO} o \const{SCHED\_RR}; in
+tal caso infatti il calcolo sul numero di interruzioni del timer veniva
+evitato utilizzando direttamente un ciclo di attesa con cui si raggiungevano
+pause fino ai 2~ms con precisioni del $\mu$s. Questa estensione è stata
+rimossa con i kernel della serie 2.6, che consentono una risoluzione più alta
+del timer di sistema; inoltre a partire dal kernel 2.6.21, \func{nanosleep}
+può avvalersi del supporto dei timer ad alta risoluzione, ottenendo la massima
+precisione disponibile sull'hardware della propria macchina.
+
+
+\subsection{Un esempio elementare}
+\label{sec:sig_sigchld}
+
+Un semplice esempio per illustrare il funzionamento di un gestore di segnale è
+quello della gestione di \const{SIGCHLD}. Abbiamo visto in
+sez.~\ref{sec:proc_termination} che una delle azioni eseguite dal kernel alla
+conclusione di un processo è quella di inviare questo segnale al
+padre.\footnote{in realtà in SVr4 eredita la semantica di System V, in cui il
+ segnale si chiama \const{SIGCLD} e viene trattato in maniera speciale; in
+ System V infatti se si imposta esplicitamente l'azione a \const{SIG\_IGN} il
+ segnale non viene generato ed il sistema non genera \index{zombie} zombie
+ (lo stato di terminazione viene scartato senza dover chiamare una
+ \func{wait}). L'azione predefinita è sempre quella di ignorare il segnale,
+ ma non attiva questo comportamento. Linux, come BSD e POSIX, non supporta
+ questa semantica ed usa il nome di \const{SIGCLD} come sinonimo di
+ \const{SIGCHLD}.} In generale dunque, quando non interessa elaborare lo
+stato di uscita di un processo, si può completare la gestione della
+terminazione installando un gestore per \const{SIGCHLD} il cui unico compito
+sia quello di chiamare \func{waitpid} per completare la procedura di
+terminazione in modo da evitare la formazione di \index{zombie} zombie.
+
+In fig.~\ref{fig:sig_sigchld_handl} è mostrato il codice contenente una
+implementazione generica di una funzione di gestione per \const{SIGCHLD}, (che
+si trova nei sorgenti allegati nel file \file{SigHand.c}); se ripetiamo i test
+di sez.~\ref{sec:proc_termination}, invocando \cmd{forktest} con l'opzione
+\cmd{-s} (che si limita ad effettuare l'installazione di questa funzione come
+gestore di \const{SIGCHLD}) potremo verificare che non si ha più la creazione
+di \index{zombie} zombie.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/hand_sigchild.c}
+ \end{minipage}
+ \normalsize
+ \caption{Codice di una funzione generica di gestione per il segnale
+ \texttt{SIGCHLD}.}
+ \label{fig:sig_sigchld_handl}
+\end{figure}
+
+Il codice del gestore è di lettura immediata; come buona norma di
+programmazione (si ricordi quanto accennato sez.~\ref{sec:sys_errno}) si
+comincia (\texttt{\small 6--7}) con il salvare lo stato corrente di
+\var{errno}, in modo da poterlo ripristinare prima del ritorno del gestore
+(\texttt{\small 16--17}). In questo modo si preserva il valore della variabile
+visto dal corso di esecuzione principale del processo, che altrimenti sarebbe
+sovrascritto dal valore restituito nella successiva chiamata di \func{waitpid}.
+
+Il compito principale del gestore è quello di ricevere lo stato di
+terminazione del processo, cosa che viene eseguita nel ciclo in
+(\texttt{\small 9--15}). Il ciclo è necessario a causa di una caratteristica
+fondamentale della gestione dei segnali: abbiamo già accennato come fra la
+generazione di un segnale e l'esecuzione del gestore possa passare un certo
+lasso di tempo e niente ci assicura che il gestore venga eseguito prima della
+generazione di ulteriori segnali dello stesso tipo. In questo caso normalmente
+i segnali successivi vengono ``\textsl{fusi}'' col primo ed al processo ne
+viene recapitato soltanto uno.
+
+Questo può essere un caso comune proprio con \const{SIGCHLD}, qualora capiti
+che molti processi figli terminino in rapida successione. Esso inoltre si
+presenta tutte le volte che un segnale viene bloccato: per quanti siano i
+segnali emessi durante il periodo di blocco, una volta che quest'ultimo sarà
+rimosso verrà recapitato un solo segnale.
+
+Allora, nel caso della terminazione dei processi figli, se si chiamasse
+\func{waitpid} una sola volta, essa leggerebbe lo stato di terminazione per un
+solo processo, anche se i processi terminati sono più di uno, e gli altri
+resterebbero in stato di \index{zombie} zombie per un tempo indefinito.
+
+Per questo occorre ripetere la chiamata di \func{waitpid} fino a che essa non
+ritorni un valore nullo, segno che non resta nessun processo di cui si debba
+ancora ricevere lo stato di terminazione (si veda sez.~\ref{sec:proc_wait} per
+la sintassi della funzione). Si noti anche come la funzione venga invocata con
+il parametro \const{WNOHANG} che permette di evitare il suo blocco quando
+tutti gli stati di terminazione sono stati ricevuti.
+
+
+
+\section{La gestione avanzata dei segnali}
+\label{sec:sig_adv_control}
+
+Le funzioni esaminate finora fanno riferimento alle modalità più elementari
+della gestione dei segnali; non si sono pertanto ancora prese in
+considerazione le tematiche più complesse, collegate alle varie
+\itindex{race~condition} \textit{race condition} che i segnali possono
+generare e alla natura asincrona degli stessi.
+
+Affronteremo queste problematiche in questa sezione, partendo da un esempio
+che le evidenzi, per poi prendere in esame le varie funzioni che permettono di
+risolvere i problemi più complessi connessi alla programmazione con i segnali,
+fino a trattare le caratteristiche generali della gestione dei medesimi nella
+casistica ordinaria.
+
+
+\subsection{Alcune problematiche aperte}
+\label{sec:sig_example}
+
+Come accennato in sez.~\ref{sec:sig_pause_sleep} è possibile implementare
+\func{sleep} a partire dall'uso di \func{pause} e \func{alarm}. A prima vista
+questo può sembrare di implementazione immediata; ad esempio una semplice
+versione di \func{sleep} potrebbe essere quella illustrata in
+fig.~\ref{fig:sig_sleep_wrong}.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/sleep_danger.c}
+ \end{minipage}
+ \normalsize
+ \caption{Una implementazione pericolosa di \func{sleep}.}
+ \label{fig:sig_sleep_wrong}
+\end{figure}
+
+Dato che è nostra intenzione utilizzare \const{SIGALRM} il primo passo della
+nostra implementazione sarà quello di installare il relativo gestore salvando
+il precedente (\texttt{\small 14-17}). Si effettuerà poi una chiamata ad
+\func{alarm} per specificare il tempo d'attesa per l'invio del segnale a cui
+segue la chiamata a \func{pause} per fermare il programma (\texttt{\small
+ 18-20}) fino alla sua ricezione. Al ritorno di \func{pause}, causato dal
+ritorno del gestore (\texttt{\small 1-9}), si ripristina il gestore originario
+(\texttt{\small 21-22}) restituendo l'eventuale tempo rimanente
+(\texttt{\small 23-24}) che potrà essere diverso da zero qualora
+l'interruzione di \func{pause} venisse causata da un altro segnale.
+
+Questo codice però, a parte il non gestire il caso in cui si è avuta una
+precedente chiamata a \func{alarm} (che si è tralasciato per brevità),
+presenta una pericolosa \itindex{race~condition} \textit{race condition}.
+Infatti, se il processo viene interrotto fra la chiamata di \func{alarm} e
+\func{pause}, può capitare (ad esempio se il sistema è molto carico) che il
+tempo di attesa scada prima dell'esecuzione di quest'ultima, cosicché essa
+sarebbe eseguita dopo l'arrivo di \const{SIGALRM}. In questo caso ci si
+troverebbe di fronte ad un \itindex{deadlock} deadlock, in quanto \func{pause}
+non verrebbe mai più interrotta (se non in caso di un altro segnale).
+
+Questo problema può essere risolto (ed è la modalità con cui veniva fatto in
+SVr2) usando la funzione \func{longjmp} (vedi sez.~\ref{sec:proc_longjmp}) per
+uscire dal gestore; in questo modo, con una condizione sullo stato di
+uscita di quest'ultima, si può evitare la chiamata a \func{pause}, usando un
+codice del tipo di quello riportato in fig.~\ref{fig:sig_sleep_incomplete}.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/sleep_defect.c}
+ \end{minipage}
+ \normalsize
+ \caption{Una implementazione ancora malfunzionante di \func{sleep}.}
+ \label{fig:sig_sleep_incomplete}
+\end{figure}
+
+In questo caso il gestore (\texttt{\small 18-27}) non ritorna come in
+fig.~\ref{fig:sig_sleep_wrong}, ma usa \func{longjmp} (\texttt{\small 25}) per
+rientrare nel corpo principale del programma; dato che in questo caso il
+valore di uscita di \func{setjmp} è 1, grazie alla condizione in
+(\texttt{\small 9-12}) si evita comunque che \func{pause} sia chiamata a
+vuoto.
+
+Ma anche questa implementazione comporta dei problemi; in questo caso infatti
+non viene gestita correttamente l'interazione con gli altri segnali; se
+infatti il segnale di allarme interrompe un altro gestore, l'esecuzione non
+riprenderà nel gestore in questione, ma nel ciclo principale, interrompendone
+inopportunamente l'esecuzione. Lo stesso tipo di problemi si presenterebbero
+se si volesse usare \func{alarm} per stabilire un timeout su una qualunque
+system call bloccante.
+
+Un secondo esempio è quello in cui si usa il segnale per notificare una
+qualche forma di evento; in genere quello che si fa in questo caso è impostare
+nel gestore un opportuno flag da controllare nel corpo principale del
+programma (con un codice del tipo di quello riportato in
+fig.~\ref{fig:sig_event_wrong}). La logica è quella di far impostare al
+gestore (\texttt{\small 14-19}) una variabile globale preventivamente
+inizializzata nel programma principale, il quale potrà determinare,
+osservandone il contenuto, l'occorrenza o meno del segnale, e prendere le
+relative azioni conseguenti (\texttt{\small 6-11}).
+
+\begin{figure}[!htb]
+ \footnotesize\centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/sig_alarm.c}
+ \end{minipage}
+ \normalsize
+ \caption{Un esempio non funzionante del codice per il controllo di un
+ evento generato da un segnale.}
+ \label{fig:sig_event_wrong}
+\end{figure}
+
+Questo è il tipico esempio di caso, già citato in
+sez.~\ref{sec:proc_race_cond}, in cui si genera una \itindex{race~condition}
+\textit{race condition}; infatti, in una situazione in cui un segnale è già
+arrivato (e \var{flag} è già ad 1) se un altro segnale arriva immediatamente
+dopo l'esecuzione del controllo (\texttt{\small 6}) ma prima della
+cancellazione del flag (\texttt{\small 7}), la sua occorrenza sarà perduta.
+
+Questi esempi ci mostrano che per una gestione effettiva dei segnali occorrono
+delle funzioni più sofisticate di quelle finora illustrate, queste hanno la
+loro origine nella semplice interfaccia dei primi sistemi Unix, ma con esse
+non è possibile gestire in maniera adeguata di tutti i possibili aspetti con
+cui un processo deve reagire alla ricezione di un segnale.
+
+
+
+\subsection{Gli \textsl{insiemi di segnali} o \textit{signal set}}
+\label{sec:sig_sigset}
+
+\itindbeg{signal~set}
+
+Come evidenziato nel paragrafo precedente, le funzioni di gestione dei segnali
+originarie, nate con la semantica inaffidabile, hanno dei limiti non
+superabili; in particolare non è prevista nessuna funzione che permetta di
+gestire il blocco dei segnali o di verificare lo stato dei segnali pendenti.
+Per questo motivo lo standard POSIX.1, insieme alla nuova semantica dei
+segnali ha introdotto una interfaccia di gestione completamente nuova, che
+permette di ottenere un controllo molto più dettagliato. In particolare lo
+standard ha introdotto un nuovo tipo di dato \type{sigset\_t}, che permette di
+rappresentare un \textsl{insieme di segnali} (un \textit{signal set}, come
+viene usualmente chiamato), tale tipo di dato viene usato per gestire il
+blocco dei segnali.
+
+In genere un \textsl{insieme di segnali} è rappresentato da un intero di
+dimensione opportuna, di solito pari al numero di bit dell'architettura della
+macchina,\footnote{nel caso dei PC questo comporta un massimo di 32 segnali
+ distinti: dato che in Linux questi sono sufficienti non c'è necessità di
+ nessuna struttura più complicata.} ciascun bit del quale è associato ad uno
+specifico segnale; in questo modo è di solito possibile implementare le
+operazioni direttamente con istruzioni elementari del processore. Lo standard
+POSIX.1 definisce cinque funzioni per la manipolazione degli insiemi di
+segnali: \funcd{sigemptyset}, \funcd{sigfillset}, \funcd{sigaddset},
+\funcd{sigdelset} e \funcd{sigismember}, i cui prototipi sono:
+\begin{functions}
+ \headdecl{signal.h}
+
+ \funcdecl{int sigemptyset(sigset\_t *set)} Inizializza un insieme di segnali
+ vuoto (in cui non c'è nessun segnale).
+
+ \funcdecl{int sigfillset(sigset\_t *set)} Inizializza un insieme di segnali
+ pieno (in cui ci sono tutti i segnali).
+
+ \funcdecl{int sigaddset(sigset\_t *set, int signum)} Aggiunge il segnale
+ \param{signum} all'insieme di segnali \param{set}.
+
+ \funcdecl{int sigdelset(sigset\_t *set, int signum)} Toglie il segnale
+ \param{signum} dall'insieme di segnali \param{set}.
+
+ \funcdecl{int sigismember(const sigset\_t *set, int signum)} Controlla se il
+ segnale \param{signum} è nell'insieme di segnali \param{set}.
+
+ \bodydesc{Le prime quattro funzioni ritornano 0 in caso di successo, mentre
+ \func{sigismember} ritorna 1 se \param{signum} è in \param{set} e 0
+ altrimenti. In caso di errore tutte ritornano $-1$, con \var{errno}
+ impostata a \errval{EINVAL} (il solo errore possibile è che \param{signum}
+ non sia un segnale valido).}
+\end{functions}
+
+Dato che in generale non si può fare conto sulle caratteristiche di una
+implementazione (non è detto che si disponga di un numero di bit sufficienti
+per mettere tutti i segnali in un intero, o in \type{sigset\_t} possono essere
+immagazzinate ulteriori informazioni) tutte le operazioni devono essere
+comunque eseguite attraverso queste funzioni.
+
+In genere si usa un insieme di segnali per specificare quali segnali si vuole
+bloccare, o per riottenere dalle varie funzioni di gestione la maschera dei
+segnali attivi (vedi sez.~\ref{sec:sig_sigmask}). Essi possono essere definiti
+in due diverse maniere, aggiungendo i segnali voluti ad un insieme vuoto
+ottenuto con \func{sigemptyset} o togliendo quelli che non servono da un
+insieme completo ottenuto con \func{sigfillset}. Infine \func{sigismember}
+permette di verificare la presenza di uno specifico segnale in un
+insieme.
+
+\itindend{signal~set}
+
+
+\subsection{La funzione \func{sigaction}}
+\label{sec:sig_sigaction}
+
+Abbiamo già accennato in sez.~\ref{sec:sig_signal} i problemi di compatibilità
+relativi all'uso di \func{signal}. Per ovviare a tutto questo lo standard
+POSIX.1 ha ridefinito completamente l'interfaccia per la gestione dei segnali,
+rendendola molto più flessibile e robusta, anche se leggermente più complessa.
+
+La funzione principale dell'interfaccia POSIX.1 per i segnali è
+\funcd{sigaction}. Essa ha sostanzialmente lo stesso uso di \func{signal},
+permette cioè di specificare le modalità con cui un segnale può essere gestito
+da un processo. Il suo prototipo è:
+\begin{prototype}{signal.h}{int sigaction(int signum, const struct sigaction
+ *act, struct sigaction *oldact)}
+
+ Installa una nuova azione per il segnale \param{signum}.
+
+ \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] si è specificato un numero di segnale invalido o si è
+ cercato di installare il gestore per \const{SIGKILL} o
+ \const{SIGSTOP}.
+ \item[\errcode{EFAULT}] si sono specificati indirizzi non validi.
+ \end{errlist}}
+\end{prototype}
+
+La funzione serve ad installare una nuova \textsl{azione} per il segnale
+\param{signum}; si parla di \textsl{azione} e non di \textsl{gestore}
+come nel caso di \func{signal}, in quanto la funzione consente di specificare
+le varie caratteristiche della risposta al segnale, non solo la funzione che
+verrà eseguita alla sua occorrenza. Per questo lo standard raccomanda di
+usare sempre questa funzione al posto di \func{signal} (che in genere viene
+definita tramite essa), in quanto permette un controllo completo su tutti gli
+aspetti della gestione di un segnale, sia pure al prezzo di una maggiore
+complessità d'uso.
+
+Se il puntatore \param{act} non è nullo, la funzione installa la nuova azione
+da esso specificata, se \param{oldact} non è nullo il valore dell'azione
+corrente viene restituito indietro. Questo permette (specificando \param{act}
+nullo e \param{oldact} non nullo) di superare uno dei limiti di \func{signal},
+che non consente di ottenere l'azione corrente senza installarne una nuova.
+
+Entrambi i puntatori fanno riferimento alla struttura \struct{sigaction},
+tramite la quale si specificano tutte le caratteristiche dell'azione associata
+ad un segnale. Anch'essa è descritta dallo standard POSIX.1 ed in Linux è
+definita secondo quanto riportato in fig.~\ref{fig:sig_sigaction}. Il campo
+\var{sa\_restorer}, non previsto dallo standard, è obsoleto e non deve essere
+più usato.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/sigaction.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{sigaction}.}
+ \label{fig:sig_sigaction}
+\end{figure}
+
+Il campo \var{sa\_mask} serve ad indicare l'insieme dei segnali che devono
+essere bloccati durante l'esecuzione del gestore, ad essi viene comunque
+sempre aggiunto il segnale che ne ha causato la chiamata, a meno che non si
+sia specificato con \var{sa\_flag} un comportamento diverso. Quando il
+gestore ritorna comunque la maschera dei segnali bloccati (vedi
+sez.~\ref{sec:sig_sigmask}) viene ripristinata al valore precedente
+l'invocazione.
+
+L'uso di questo campo permette ad esempio di risolvere il problema residuo
+dell'implementazione di \code{sleep} mostrata in
+fig.~\ref{fig:sig_sleep_incomplete}. In quel caso infatti se il segnale di
+allarme avesse interrotto un altro gestore questo non sarebbe stato eseguito
+correttamente; la cosa poteva essere prevenuta installando gli altri gestori
+usando \var{sa\_mask} per bloccare \const{SIGALRM} durante la loro esecuzione.
+Il valore di \var{sa\_flag} permette di specificare vari aspetti del
+comportamento di \func{sigaction}, e della reazione del processo ai vari
+segnali; i valori possibili ed il relativo significato sono riportati in
+tab.~\ref{tab:sig_sa_flag}.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \const{SA\_NOCLDSTOP}& Se il segnale è \const{SIGCHLD} allora non deve
+ essere notificato quando il processo figlio viene
+ fermato da uno dei segnali \const{SIGSTOP},
+ \const{SIGTSTP}, \const{SIGTTIN} o
+ \const{SIGTTOU}.\\
+ \const{SA\_RESETHAND}& Ristabilisce l'azione per il segnale al valore
+ predefinito una volta che il gestore è stato
+ lanciato, riproduce cioè il comportamento della
+ semantica inaffidabile.\\
+ \const{SA\_ONESHOT} & Nome obsoleto, sinonimo non standard di
+ \const{SA\_RESETHAND}; da evitare.\\
+ \const{SA\_ONSTACK} & Stabilisce l'uso di uno \itindex{stack}
+ \textit{stack} alternativo per l'esecuzione del
+ gestore (vedi
+ sez.~\ref{sec:sig_specific_features}).\\
+ \const{SA\_RESTART} & Riavvia automaticamente le \textit{slow system
+ call} quando vengono interrotte dal suddetto
+ segnale; riproduce cioè il comportamento standard
+ di BSD.\index{system~call~lente}\\
+ \const{SA\_NODEFER} & Evita che il segnale corrente sia bloccato durante
+ l'esecuzione del gestore.\\
+ \const{SA\_NOMASK} & Nome obsoleto, sinonimo non standard di
+ \const{SA\_NODEFER}.\\
+ \const{SA\_SIGINFO} & Deve essere specificato quando si vuole usare un
+ gestore in forma estesa usando
+ \var{sa\_sigaction} al posto di
+ \var{sa\_handler}.\\
+ \const{SA\_NOCLDWAIT}& Se il segnale è \const{SIGCHLD} allora i processi
+ figli non diventano \textit{zombie} quando
+ terminano.\footnotemark \\
+ \hline
+ \end{tabular}
+ \caption{Valori del campo \var{sa\_flag} della struttura \struct{sigaction}.}
+ \label{tab:sig_sa_flag}
+\end{table}
+
+\footnotetext{questa funzionalità è stata introdotta nel kernel 2.6 e va a
+ modificare il comportamento di \func{waitpid}.}
+
+Come si può notare in fig.~\ref{fig:sig_sigaction} \func{sigaction} permette
+di utilizzare due forme diverse di gestore,\footnote{la possibilità è prevista
+ dallo standard POSIX.1b, ed è stata aggiunta nei kernel della serie 2.1.x
+ con l'introduzione dei segnali real-time (vedi
+ sez.~\ref{sec:sig_real_time}); in precedenza era possibile ottenere alcune
+ informazioni addizionali usando \var{sa\_handler} con un secondo parametro
+ addizionale di tipo \var{sigcontext}, che adesso è deprecato.} da
+specificare, a seconda dell'uso o meno del flag \const{SA\_SIGINFO},
+rispettivamente attraverso i campi \var{sa\_sigaction} o
+\var{sa\_handler},\footnote{i due campi devono essere usati in maniera
+ alternativa, in certe implementazioni questi campi vengono addirittura
+ definiti come \ctyp{union}.} Quest'ultima è quella classica usata anche con
+\func{signal}, mentre la prima permette di usare un gestore più complesso, in
+grado di ricevere informazioni più dettagliate dal sistema, attraverso la
+struttura \struct{siginfo\_t}, riportata in fig.~\ref{fig:sig_siginfo_t}.
+
+Installando un gestore di tipo \var{sa\_sigaction} diventa allora possibile
+accedere alle informazioni restituite attraverso il puntatore a questa
+struttura. Tutti i segnali impostano i campi \var{si\_signo}, che riporta il
+numero del segnale ricevuto, \var{si\_errno}, che riporta, quando diverso da
+zero, il codice dell'errore associato al segnale, e \var{si\_code}, che viene
+usato dal kernel per specificare maggiori dettagli riguardo l'evento che ha
+causato l'emissione del segnale.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/siginfo_t.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{siginfo\_t}.}
+ \label{fig:sig_siginfo_t}
+\end{figure}
+
+In generale \var{si\_code} contiene, per i segnali generici, per quelli
+real-time e per tutti quelli inviati tramite da un processo con \func{kill} o
+affini, le informazioni circa l'origine del segnale stesso, ad esempio se
+generato dal kernel, da un timer, da \func{kill}, ecc. Il valore viene sempre
+espresso come una costante,\footnote{le definizioni di tutti i valori
+ possibili si trovano in \file{bits/siginfo.h}.} ed i valori possibili in
+questo caso sono riportati in tab.~\ref{tab:sig_si_code_generic}.
+
+Nel caso di alcuni segnali però il valore di \var{si\_code} viene usato per
+fornire una informazione specifica relativa alle motivazioni della ricezione
+dello stesso; ad esempio i vari segnali di errore (\const{SIGILL},
+\const{SIGFPE}, \const{SIGSEGV} e \const{SIGBUS}) lo usano per fornire
+maggiori dettagli riguardo l'errore, come il tipo di errore aritmetico, di
+istruzione illecita o di violazione di memoria; mentre alcuni segnali di
+controllo (\const{SIGCHLD}, \const{SIGTRAP} e \const{SIGPOLL}) forniscono
+altre informazioni specifiche.
+
+\begin{table}[!htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \const{SI\_USER} & generato da \func{kill} o \func{raise}.\\
+ \const{SI\_KERNEL} & inviato dal kernel.\\
+ \const{SI\_QUEUE} & inviato con \func{sigqueue} (vedi
+ sez.~\ref{sec:sig_real_time}).\\
+ \const{SI\_TIMER} & scadenza di un POSIX timer
+ (vedi sez.~\ref{sec:sig_timer_adv}).\\
+ \const{SI\_MESGQ} & inviato al cambiamento di stato di una coda di
+ messaggi POSIX (vedi
+ sez.~\ref{sec:ipc_posix_mq}).\footnotemark\\
+ \const{SI\_ASYNCIO}& una operazione di I/O asincrono (vedi
+ sez.~\ref{sec:file_asyncronous_access}) è stata
+ completata.\\
+ \const{SI\_SIGIO} & segnale di \const{SIGIO} da una coda (vedi
+ sez.~\ref{sec:file_asyncronous_operation}).\\
+ \const{SI\_TKILL} & inviato da \func{tkill} o \func{tgkill} (vedi
+ sez.~\ref{cha:threads_xxx}).\footnotemark\\
+ \hline
+ \end{tabular}
+ \caption{Valori del campo \var{si\_code} della struttura \struct{sigaction}
+ per i segnali generici.}
+ \label{tab:sig_si_code_generic}
+\end{table}
+
+\footnotetext[24]{introdotto con il kernel 2.6.6.}
+\footnotetext{introdotto con il kernel 2.4.19.}
+
+In questo caso il valore del campo \var{si\_code} deve essere verificato nei
+confronti delle diverse costanti previste per ciascuno di detti
+segnali;\footnote{dato che si tratta di una costante, e non di una maschera
+ binaria, i valori numerici vengono riutilizzati e ciascuno di essi avrà un
+ significato diverso a seconda del segnale a cui è associato.} l'elenco
+dettagliato dei nomi di queste costanti è riportato nelle diverse sezioni di
+tab.~\ref{tab:sig_si_code_special} che sono state ordinate nella sequenza in
+cui si sono appena citati i rispettivi segnali.\footnote{il prefisso del nome
+ indica comunque in maniera diretta il segnale a cui le costanti fanno
+ riferimento.}
+
+\begin{table}[!htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \const{ILL\_ILLOPC} & codice di operazione illegale.\\
+ \const{ILL\_ILLOPN} & operando illegale.\\
+ \const{ILL\_ILLADR} & modo di indirizzamento illegale.\\
+ \const{ILL\_ILLTRP} & trappola di processore illegale.\\
+ \const{ILL\_PRVOPC} & codice di operazione privilegiato.\\
+ \const{ILL\_PRVREG} & registro privilegiato.\\
+ \const{ILL\_COPROC} & errore del coprocessore.\\
+ \const{ILL\_BADSTK} & errore nello stack interno.\\
+ \hline
+ \const{FPE\_INTDIV} & divisione per zero intera.\\
+ \const{FPE\_INTOVF} & overflow intero.\\
+ \const{FPE\_FLTDIV} & divisione per zero in virgola mobile.\\
+ \const{FPE\_FLTOVF} & overflow in virgola mobile.\\
+ \const{FPE\_FLTUND} & underflow in virgola mobile.\\
+ \const{FPE\_FLTRES} & risultato in virgola mobile non esatto.\\
+ \const{FPE\_FLTINV} & operazione in virgola mobile non valida.\\
+ \const{FPE\_FLTSUB} & mantissa? fuori intervallo.\\
+ \hline
+ \const{SEGV\_MAPERR} & indirizzo non mappato.\\
+ \const{SEGV\_ACCERR} & permessi non validi per l'indirizzo.\\
+ \hline
+ \const{BUS\_ADRALN} & allineamento dell'indirizzo non valido.\\
+ \const{BUS\_ADRERR} & indirizzo fisico inesistente.\\
+ \const{BUS\_OBJERR} & errore hardware sull'indirizzo.\\
+ \hline
+ \const{TRAP\_BRKPT} & breakpoint sul processo.\\
+ \const{TRAP\_TRACE} & trappola di tracciamento del processo.\\
+ \hline
+ \const{CLD\_EXITED} & il figlio è uscito.\\
+ \const{CLD\_KILLED} & il figlio è stato terminato.\\
+ \const{CLD\_DUMPED} & il figlio è terminato in modo anormale.\\
+ \const{CLD\_TRAPPED} & un figlio tracciato ha raggiunto una trappola.\\
+ \const{CLD\_STOPPED} & il figlio è stato fermato.\\
+ \const{CLD\_CONTINUED}& il figlio è ripartito.\\
+ \hline
+ \const{POLL\_IN} & disponibili dati in ingresso.\\
+ \const{POLL\_OUT} & spazio disponibile sul buffer di uscita.\\
+ \const{POLL\_MSG} & disponibili messaggi in ingresso.\\
+ \const{POLL\_ERR} & errore di I/O.\\
+ \const{POLL\_PRI} & disponibili dati di alta priorità in ingresso.\\
+ \const{POLL\_HUP} & il dispositivo è stato disconnesso.\\
+ \hline
+ \end{tabular}
+ \caption{Valori del campo \var{si\_code} della struttura \struct{sigaction}
+ impostati rispettivamente dai segnali \const{SIGILL}, \const{SIGFPE},
+ \const{SIGSEGV}, \const{SIGBUS}, \const{SIGCHLD}, \const{SIGTRAP} e
+ \const{SIGPOLL}/\const{SIGIO}.}
+ \label{tab:sig_si_code_special}
+\end{table}
+
+Il resto della struttura \struct{siginfo\_t} è definito come \ctyp{union} ed i
+valori eventualmente presenti dipendono dal segnale, così \const{SIGCHLD} ed i
+segnali real-time (vedi sez.~\ref{sec:sig_real_time}) inviati tramite
+\func{kill} avvalorano \var{si\_pid} e \var{si\_uid} coi valori corrispondenti
+al processo che ha emesso il segnale, \const{SIGCHLD} avvalora anche i campi
+\const{si\_status}, \const{si\_utime} e \const{si\_stime} che indicano
+rispettivamente lo stato di uscita, l'\textit{user time} e il \textit{system
+ time} (vedi sez.~\ref{sec:sys_cpu_times}) usati dal processo;
+\const{SIGILL}, \const{SIGFPE}, \const{SIGSEGV} e \const{SIGBUS} avvalorano
+\var{si\_addr} con l'indirizzo in cui è avvenuto l'errore, \const{SIGIO} (vedi
+sez.~\ref{sec:file_asyncronous_io}) avvalora \var{si\_fd} con il numero del
+file descriptor e \var{si\_band} per i \itindex{out-of-band} dati urgenti
+(vedi sez.~\ref{sec:TCP_urgent_data}) su un socket.
+
+Benché sia possibile usare nello stesso programma sia \func{sigaction} che
+\func{signal} occorre molta attenzione, in quanto le due funzioni possono
+interagire in maniera anomala. Infatti l'azione specificata con
+\struct{sigaction} contiene un maggior numero di informazioni rispetto al
+semplice indirizzo del gestore restituito da \func{signal}. Per questo motivo
+se si usa quest'ultima per installare un gestore sostituendone uno
+precedentemente installato con \func{sigaction}, non sarà possibile effettuare
+un ripristino corretto dello stesso.
+
+Per questo è sempre opportuno usare \func{sigaction}, che è in grado di
+ripristinare correttamente un gestore precedente, anche se questo è stato
+installato con \func{signal}. In generale poi non è il caso di usare il valore
+di ritorno di \func{signal} come campo \var{sa\_handler}, o viceversa, dato
+che in certi sistemi questi possono essere diversi. In definitiva dunque, a
+meno che non si sia vincolati all'aderenza stretta allo standard ISO C, è
+sempre il caso di evitare l'uso di \func{signal} a favore di \func{sigaction}.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15.6cm}
+ \includecodesample{listati/Signal.c}
+ \end{minipage}
+ \normalsize
+ \caption{La funzione \func{Signal}, equivalente a \func{signal}, definita
+ attraverso \func{sigaction}.}
+ \label{fig:sig_Signal_code}
+\end{figure}
+
+Per questo motivo si è provveduto, per mantenere un'interfaccia semplificata
+che abbia le stesse caratteristiche di \func{signal}, a definire attraverso
+\func{sigaction} una funzione equivalente \func{Signal}, il cui codice è
+riportato in fig.~\ref{fig:sig_Signal_code} (il codice completo si trova nel
+file \file{SigHand.c} nei sorgenti allegati). Si noti come, essendo la
+funzione estremamente semplice, essa è definita come
+\direct{inline};\footnote{la direttiva \direct{inline} viene usata per dire al
+ compilatore di trattare la funzione cui essa fa riferimento in maniera
+ speciale inserendo il codice direttamente nel testo del programma. Anche se
+ i compilatori più moderni sono in grado di effettuare da soli queste
+ manipolazioni (impostando le opportune ottimizzazioni) questa è una tecnica
+ usata per migliorare le prestazioni per le funzioni piccole ed usate di
+ frequente (in particolare nel kernel, dove in certi casi le ottimizzazioni
+ dal compilatore, tarate per l'uso in user space, non sono sempre adatte). In
+ tal caso infatti le istruzioni per creare un nuovo frame nello
+ \itindex{stack} \textit{stack} per chiamare la funzione costituirebbero una
+ parte rilevante del codice, appesantendo inutilmente il programma.
+ Originariamente questo comportamento veniva ottenuto con delle macro, ma
+ queste hanno tutta una serie di problemi di sintassi nel passaggio degli
+ argomenti (si veda ad esempio \cite{PratC}) che in questo modo possono
+ essere evitati.} per semplificare ulteriormente la definizione si è poi
+definito un apposito tipo \texttt{SigFunc}.
+
+
+
+\subsection{La gestione della \textsl{maschera dei segnali} o
+ \textit{signal mask}}
+\label{sec:sig_sigmask}
+
+\itindbeg{signal~mask}
+Come spiegato in sez.~\ref{sec:sig_semantics} tutti i moderni sistemi unix-like
+permettono di bloccare temporaneamente (o di eliminare completamente,
+impostando \const{SIG\_IGN} come azione) la consegna dei segnali ad un
+processo. Questo è fatto specificando la cosiddetta \textsl{maschera dei
+ segnali} (o \textit{signal mask}) del processo\footnote{nel caso di Linux
+ essa è mantenuta dal campo \var{blocked} della \struct{task\_struct} del
+ processo.} cioè l'insieme dei segnali la cui consegna è bloccata. Abbiamo
+accennato in sez.~\ref{sec:proc_fork} che la \textit{signal mask} viene
+ereditata dal padre alla creazione di un processo figlio, e abbiamo visto al
+paragrafo precedente che essa può essere modificata, durante l'esecuzione di
+un gestore, attraverso l'uso dal campo \var{sa\_mask} di \struct{sigaction}.
+
+Uno dei problemi evidenziatisi con l'esempio di fig.~\ref{fig:sig_event_wrong}
+è che in molti casi è necessario proteggere delle sezioni di codice (nel caso
+in questione la sezione fra il controllo e la eventuale cancellazione del flag
+che testimoniava l'avvenuta occorrenza del segnale) in modo da essere sicuri
+che essi siano eseguite senza interruzioni.
+
+Le operazioni più semplici, come l'assegnazione o il controllo di una
+variabile (per essere sicuri si può usare il tipo \type{sig\_atomic\_t}) di
+norma sono atomiche; quando si devono eseguire operazioni più complesse si può
+invece usare la funzione \funcd{sigprocmask} che permette di bloccare uno o
+più segnali; il suo prototipo è:
+\begin{prototype}{signal.h}
+{int sigprocmask(int how, const sigset\_t *set, sigset\_t *oldset)}
+
+ Cambia la \textsl{maschera dei segnali} del processo corrente.
+
+ \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] si è specificato un numero di segnale invalido.
+ \item[\errcode{EFAULT}] si sono specificati indirizzi non validi.
+ \end{errlist}}
+\end{prototype}
+
+La funzione usa l'insieme di segnali dato all'indirizzo \param{set} per
+modificare la maschera dei segnali del processo corrente. La modifica viene
+effettuata a seconda del valore dell'argomento \param{how}, secondo le modalità
+specificate in tab.~\ref{tab:sig_procmask_how}. Qualora si specifichi un valore
+non nullo per \param{oldset} la maschera dei segnali corrente viene salvata a
+quell'indirizzo.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \const{SIG\_BLOCK} & L'insieme dei segnali bloccati è l'unione fra
+ quello specificato e quello corrente.\\
+ \const{SIG\_UNBLOCK} & I segnali specificati in \param{set} sono rimossi
+ dalla maschera dei segnali, specificare la
+ cancellazione di un segnale non bloccato è legale.\\
+ \const{SIG\_SETMASK} & La maschera dei segnali è impostata al valore
+ specificato da \param{set}.\\
+ \hline
+ \end{tabular}
+ \caption{Valori e significato dell'argomento \param{how} della funzione
+ \func{sigprocmask}.}
+ \label{tab:sig_procmask_how}
+\end{table}
+
+In questo modo diventa possibile proteggere delle sezioni di codice bloccando
+l'insieme di segnali voluto per poi riabilitarli alla fine della
+\index{sezione~critica} sezione critica. La funzione permette di risolvere
+problemi come quelli mostrati in fig.~\ref{fig:sig_event_wrong}, proteggendo
+la sezione fra il controllo del flag e la sua cancellazione.
+
+La funzione può essere usata anche all'interno di un gestore, ad esempio
+per riabilitare la consegna del segnale che l'ha invocato, in questo caso però
+occorre ricordare che qualunque modifica alla maschera dei segnali viene
+perduta alla conclusione del terminatore.
+
+Benché con l'uso di \func{sigprocmask} si possano risolvere la maggior parte
+dei casi di \itindex{race~condition} \textit{race condition} restano aperte
+alcune possibilità legate all'uso di \func{pause}; il caso è simile a quello
+del problema illustrato nell'esempio di fig.~\ref{fig:sig_sleep_incomplete}, e
+cioè la possibilità che il processo riceva il segnale che si intende usare per
+uscire dallo stato di attesa invocato con \func{pause} immediatamente prima
+dell'esecuzione di quest'ultima. Per poter effettuare atomicamente la modifica
+della maschera dei segnali (di solito attivandone uno specifico) insieme alla
+sospensione del processo lo standard POSIX ha previsto la funzione
+\funcd{sigsuspend}, il cui prototipo è:
+\begin{prototype}{signal.h}
+{int sigsuspend(const sigset\_t *mask)}
+
+ Imposta la \textit{signal mask} specificata, mettendo in attesa il processo.
+
+ \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] si è specificato un numero di segnale invalido.
+ \item[\errcode{EFAULT}] si sono specificati indirizzi non validi.
+ \end{errlist}}
+\end{prototype}
+
+Come esempio dell'uso di queste funzioni proviamo a riscrivere un'altra volta
+l'esempio di implementazione di \code{sleep}. Abbiamo accennato in
+sez.~\ref{sec:sig_sigaction} come con \func{sigaction} sia possibile bloccare
+\const{SIGALRM} nell'installazione dei gestori degli altri segnali, per poter
+usare l'implementazione vista in fig.~\ref{fig:sig_sleep_incomplete} senza
+interferenze. Questo però comporta una precauzione ulteriore al semplice uso
+della funzione, vediamo allora come usando la nuova interfaccia è possibile
+ottenere un'implementazione, riportata in fig.~\ref{fig:sig_sleep_ok} che non
+presenta neanche questa necessità.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15.6cm}
+ \includecodesample{listati/sleep.c}
+ \end{minipage}
+ \normalsize
+ \caption{Una implementazione completa di \func{sleep}.}
+ \label{fig:sig_sleep_ok}
+\end{figure}
+
+Per evitare i problemi di interferenza con gli altri segnali in questo caso
+non si è usato l'approccio di fig.~\ref{fig:sig_sleep_incomplete} evitando
+l'uso di \func{longjmp}. Come in precedenza il gestore (\texttt{\small 27-30})
+non esegue nessuna operazione, limitandosi a ritornare per interrompere il
+programma messo in attesa.
+
+La prima parte della funzione (\texttt{\small 6-10}) provvede ad installare
+l'opportuno gestore per \const{SIGALRM}, salvando quello originario, che
+sarà ripristinato alla conclusione della stessa (\texttt{\small 23}); il passo
+successivo è quello di bloccare \const{SIGALRM} (\texttt{\small 11-14}) per
+evitare che esso possa essere ricevuto dal processo fra l'esecuzione di
+\func{alarm} (\texttt{\small 16}) e la sospensione dello stesso. Nel fare
+questo si salva la maschera corrente dei segnali, che sarà ripristinata alla
+fine (\texttt{\small 22}), e al contempo si prepara la maschera dei segnali
+\var{sleep\_mask} per riattivare \const{SIGALRM} all'esecuzione di
+\func{sigsuspend}.
+
+In questo modo non sono più possibili \itindex{race~condition} \textit{race
+ condition} dato che \const{SIGALRM} viene disabilitato con
+\func{sigprocmask} fino alla chiamata di \func{sigsuspend}. Questo metodo è
+assolutamente generale e può essere applicato a qualunque altra situazione in
+cui si deve attendere per un segnale, i passi sono sempre i seguenti:
+\begin{enumerate*}
+\item leggere la maschera dei segnali corrente e bloccare il segnale voluto
+ con \func{sigprocmask};
+\item mandare il processo in attesa con \func{sigsuspend} abilitando la
+ ricezione del segnale voluto;
+\item ripristinare la maschera dei segnali originaria.
+\end{enumerate*}
+Per quanto possa sembrare strano bloccare la ricezione di un segnale per poi
+riabilitarla immediatamente dopo, in questo modo si evita il
+\itindex{deadlock} deadlock dovuto all'arrivo del segnale prima
+dell'esecuzione di \func{sigsuspend}.
+
+\itindend{signal~mask}
+
+
+\subsection{Ulteriori funzioni di gestione}
+\label{sec:sig_specific_features}
+
+In questo ultimo paragrafo esamineremo le rimanenti funzioni di gestione dei
+segnali non descritte finora, relative agli aspetti meno utilizzati e più
+``\textsl{esoterici}'' della interfaccia.
+
+La prima di queste funzioni è \funcd{sigpending}, anch'essa introdotta dallo
+standard POSIX.1; il suo prototipo è:
+\begin{prototype}{signal.h}
+{int sigpending(sigset\_t *set)}
+
+Scrive in \param{set} l'insieme dei segnali pendenti.
+
+ \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
+ errore.}
+\end{prototype}
+
+La funzione permette di ricavare quali sono i segnali pendenti per il processo
+in corso, cioè i segnali che sono stati inviati dal kernel ma non sono stati
+ancora ricevuti dal processo in quanto bloccati. Non esiste una funzione
+equivalente nella vecchia interfaccia, ma essa è tutto sommato poco utile,
+dato che essa può solo assicurare che un segnale è stato inviato, dato che
+escluderne l'avvenuto invio al momento della chiamata non significa nulla
+rispetto a quanto potrebbe essere in un qualunque momento successivo.
+
+Una delle caratteristiche di BSD, disponibile anche in Linux, è la possibilità
+di usare uno \itindex{stack} \textit{stack} alternativo per i segnali; è cioè
+possibile fare usare al sistema un altro \itindex{stack} \textit{stack}
+(invece di quello relativo al processo, vedi sez.~\ref{sec:proc_mem_layout})
+solo durante l'esecuzione di un gestore. L'uso di uno \textit{stack}
+alternativo è del tutto trasparente ai gestori, occorre però seguire una certa
+procedura:
+\begin{enumerate*}
+\item allocare un'area di memoria di dimensione sufficiente da usare come
+ \textit{stack} alternativo;
+\item usare la funzione \func{sigaltstack} per rendere noto al sistema
+ l'esistenza e la locazione dello \textit{stack} alternativo;
+\item quando si installa un gestore occorre usare \func{sigaction}
+ specificando il flag \const{SA\_ONSTACK} (vedi tab.~\ref{tab:sig_sa_flag})
+ per dire al sistema di usare lo \textit{stack} alternativo durante
+ l'esecuzione del gestore.
+\end{enumerate*}
+
+In genere il primo passo viene effettuato allocando un'opportuna area di
+memoria con \code{malloc}; in \file{signal.h} sono definite due costanti,
+\const{SIGSTKSZ} e \const{MINSIGSTKSZ}, che possono essere utilizzate per
+allocare una quantità di spazio opportuna, in modo da evitare overflow. La
+prima delle due è la dimensione canonica per uno \itindex{stack}
+\textit{stack} di segnali e di norma è sufficiente per tutti gli usi normali.
+
+La seconda è lo spazio che occorre al sistema per essere in grado di lanciare
+il gestore e la dimensione di uno \textit{stack} alternativo deve essere
+sempre maggiore di questo valore. Quando si conosce esattamente quanto è lo
+spazio necessario al gestore gli si può aggiungere questo valore per allocare
+uno \itindex{stack} \textit{stack} di dimensione sufficiente.
+
+Come accennato, per poter essere usato, lo \itindex{stack} \textit{stack} per
+i segnali deve essere indicato al sistema attraverso la funzione
+\funcd{sigaltstack}; il suo prototipo è:
+\begin{prototype}{signal.h}
+{int sigaltstack(const stack\_t *ss, stack\_t *oss)}
+
+Installa un nuovo \textit{stack} per i segnali.
+
+ \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori:
+
+ \begin{errlist}
+ \item[\errcode{ENOMEM}] la dimensione specificata per il nuovo
+ \textit{stack} è minore di \const{MINSIGSTKSZ}.
+ \item[\errcode{EPERM}] uno degli indirizzi non è valido.
+ \item[\errcode{EFAULT}] si è cercato di cambiare lo \textit{stack}
+ alternativo mentre questo è attivo (cioè il processo è in esecuzione su di
+ esso).
+ \item[\errcode{EINVAL}] \param{ss} non è nullo e \var{ss\_flags} contiene un
+ valore diverso da zero che non è \const{SS\_DISABLE}.
+ \end{errlist}}
+\end{prototype}
+
+La funzione prende come argomenti puntatori ad una struttura di tipo
+\var{stack\_t}, definita in fig.~\ref{fig:sig_stack_t}. I due valori
+\param{ss} e \param{oss}, se non nulli, indicano rispettivamente il nuovo
+\itindex{stack} \textit{stack} da installare e quello corrente (che viene
+restituito dalla funzione per un successivo ripristino).
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/stack_t.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{stack\_t}.}
+ \label{fig:sig_stack_t}
+\end{figure}
+
+Il campo \var{ss\_sp} di \struct{stack\_t} indica l'indirizzo base dello
+\itindex{stack} \textit{stack}, mentre \var{ss\_size} ne indica la dimensione;
+il campo \var{ss\_flags} invece indica lo stato dello \textit{stack}.
+Nell'indicare un nuovo \textit{stack} occorre inizializzare \var{ss\_sp} e
+\var{ss\_size} rispettivamente al puntatore e alla dimensione della memoria
+allocata, mentre \var{ss\_flags} deve essere nullo. Se invece si vuole
+disabilitare uno \textit{stack} occorre indicare \const{SS\_DISABLE} come
+valore di \var{ss\_flags} e gli altri valori saranno ignorati.
+
+Se \param{oss} non è nullo verrà restituito dalla funzione indirizzo e
+dimensione dello \itindex{stack} \textit{stack} corrente nei relativi campi,
+mentre \var{ss\_flags} potrà assumere il valore \const{SS\_ONSTACK} se il
+processo è in esecuzione sullo \textit{stack} alternativo (nel qual caso non è
+possibile cambiarlo) e \const{SS\_DISABLE} se questo non è abilitato.
+
+In genere si installa uno \itindex{stack} \textit{stack} alternativo per i
+segnali quando si teme di avere problemi di esaurimento dello \textit{stack}
+standard o di superamento di un limite (vedi
+sez.~\ref{sec:sys_resource_limit}) imposto con chiamate del tipo
+\code{setrlimit(RLIMIT\_STACK, \&rlim)}. In tal caso infatti si avrebbe un
+segnale di \const{SIGSEGV}, che potrebbe essere gestito soltanto avendo
+abilitato uno \itindex{stack} \textit{stack} alternativo.
+
+Si tenga presente che le funzioni chiamate durante l'esecuzione sullo
+\textit{stack} alternativo continueranno ad usare quest'ultimo, che, al
+contrario di quanto avviene per lo \itindex{stack} \textit{stack} ordinario
+dei processi, non si accresce automaticamente (ed infatti eccederne le
+dimensioni può portare a conseguenze imprevedibili). Si ricordi infine che
+una chiamata ad una funzione della famiglia \func{exec} cancella ogni
+\textit{stack} alternativo.
+
+Abbiamo visto in fig.~\ref{fig:sig_sleep_incomplete} come si possa usare
+\func{longjmp} per uscire da un gestore rientrando direttamente nel corpo
+del programma; sappiamo però che nell'esecuzione di un gestore il segnale
+che l'ha invocato viene bloccato, e abbiamo detto che possiamo ulteriormente
+modificarlo con \func{sigprocmask}.
+
+Resta quindi il problema di cosa succede alla maschera dei segnali quando si
+esce da un gestore usando questa funzione. Il comportamento dipende
+dall'implementazione; in particolare la semantica usata da BSD prevede che sia
+ripristinata la maschera dei segnali precedente l'invocazione, come per un
+normale ritorno, mentre quella usata da System V no.
+
+Lo standard POSIX.1 non specifica questo comportamento per \func{setjmp} e
+\func{longjmp}, ed il comportamento delle \acr{glibc} dipende da quale delle
+caratteristiche si sono abilitate con le macro viste in
+sez.~\ref{sec:intro_gcc_glibc_std}.
+
+Lo standard POSIX però prevede anche la presenza di altre due funzioni
+\funcd{sigsetjmp} e \funcd{siglongjmp}, che permettono di decidere quale dei
+due comportamenti il programma deve assumere; i loro prototipi sono:
+\begin{functions}
+ \headdecl{setjmp.h}
+
+ \funcdecl{int sigsetjmp(sigjmp\_buf env, int savesigs)} Salva il contesto
+ dello \textit{stack} per un \index{salto~non-locale} salto non-locale.
+
+ \funcdecl{void siglongjmp(sigjmp\_buf env, int val)} Esegue un salto
+ non-locale su un precedente contesto.
+
+ \bodydesc{Le due funzioni sono identiche alle analoghe \func{setjmp} e
+ \func{longjmp} di sez.~\ref{sec:proc_longjmp}, ma consentono di specificare
+ il comportamento sul ripristino o meno della maschera dei segnali.}
+\end{functions}
+
+Le due funzioni prendono come primo argomento la variabile su cui viene
+salvato il contesto dello \itindex{stack} \textit{stack} per permettere il
+\index{salto~non-locale} salto non-locale; nel caso specifico essa è di tipo
+\type{sigjmp\_buf}, e non \type{jmp\_buf} come per le analoghe di
+sez.~\ref{sec:proc_longjmp} in quanto in questo caso viene salvata anche la
+maschera dei segnali.
+
+Nel caso di \func{sigsetjmp}, se si specifica un valore di \param{savesigs}
+diverso da zero la maschera dei valori sarà salvata in \param{env} e
+ripristinata in un successivo \func{siglongjmp}; quest'ultima funzione, a
+parte l'uso di \type{sigjmp\_buf} per \param{env}, è assolutamente identica a
+\func{longjmp}.
+
+
+\subsection{Criteri di programmazione per i gestori dei segnali}
+\label{sec:sig_signal_handler}
+
+Abbiamo finora parlato dei gestori dei segnali come funzioni chiamate in
+corrispondenza della consegna di un segnale. In realtà un gestore non può
+essere una funzione qualunque, in quanto esso può essere eseguito in
+corrispondenza all'interruzione in un punto qualunque del programma principale,
+ed ad esempio può essere problematico chiamare all'interno di un gestore di
+segnali la stessa funzione che dal segnale è stata interrotta.
+
+\index{funzioni!sicure|(}
+
+Il concetto è comunque più generale e porta ad una distinzione fra quelle che
+che POSIX chiama \textsl{funzioni insicure} (\textit{unsafe function}) e
+\textsl{funzioni sicure} (\textit{safe function}); quando un segnale
+interrompe una funzione insicura ed il gestore chiama al suo interno una
+funzione insicura il sistema può dare luogo ad un comportamento indefinito.
+
+Tutto questo significa che un gestore di segnale deve essere programmato con
+molta cura per evitare questa evenienza, pertanto è non è possibile chiamare
+al suo interno una funzione qualunque, e si può ricorrere soltanto all'uso di
+funzioni sicure.
+
+L'elenco delle funzioni sicure varia a secondo dello standard a cui si fa
+riferimento, secondo quanto riportato dallo standard POSIX 1003.1 nella
+revisione del 2003, le ``\textit{signal safe function}'' che possono essere
+chiamate anche all'interno di un gestore di segnali sono quelle della lista
+riportata in fig.~\ref{fig:sig_safe_functions}.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \func{\_exit}, \func{abort}, \func{accept}, \func{access},
+ \func{aio\_error} \func{aio\_return}, \func{aio\_suspend}, \func{alarm},
+ \func{bind}, \func{cfgetispeed}, \func{cfgetospeed}, \func{cfsetispeed},
+ \func{cfsetospeed}, \func{chdir}, \func{chmod}, \func{chown},
+ \func{clock\_gettime}, \func{close}, \func{connect}, \func{creat},
+ \func{dup}, \func{dup2}, \func{execle}, \func{execve}, \func{fchmod},
+ \func{fchown}, \func{fcntl}, \func{fdatasync}, \func{fork},
+ \func{fpathconf}, \func{fstat}, \func{fsync}, \func{ftruncate},
+ \func{getegid}, \func{geteuid}, \func{getgid}, \func{getgroups},
+ \func{getpeername}, \func{getpgrp}, \func{getpid}, \func{getppid},
+ \func{getsockname}, \func{getsockopt}, \func{getuid}, \func{kill},
+ \func{link}, \func{listen}, \func{lseek}, \func{lstat}, \func{mkdir},
+ \func{mkfifo}, \func{open}, \func{pathconf}, \func{pause}, \func{pipe},
+ \func{poll}, \func{posix\_trace\_event}, \func{pselect}, \func{raise},
+ \func{read}, \func{readlink}, \func{recv}, \func{recvfrom},
+ \func{recvmsg}, \func{rename}, \func{rmdir}, \func{select},
+ \func{sem\_post}, \func{send}, \func{sendmsg}, \func{sendto},
+ \func{setgid}, \func{setpgid}, \func{setsid}, \func{setsockopt},
+ \func{setuid}, \func{shutdown}, \func{sigaction}, \func{sigaddset},
+ \func{sigdelset}, \func{sigemptyset}, \func{sigfillset},
+ \func{sigismember}, \func{signal}, \func{sigpause}, \func{sigpending},
+ \func{sigprocmask}, \func{sigqueue}, \func{sigset}, \func{sigsuspend},
+ \func{sleep}, \func{socket}, \func{socketpair}, \func{stat},
+ \func{symlink}, \func{sysconf}, \func{tcdrain}, \func{tcflow},
+ \func{tcflush}, \func{tcgetattr}, \func{tcgetgrp}, \func{tcsendbreak},
+ \func{tcsetattr}, \func{tcsetpgrp}, \func{time}, \func{timer\_getoverrun},
+ \func{timer\_gettime}, \func{timer\_settime}, \func{times}, \func{umask},
+ \func{uname}, \func{unlink}, \func{utime}, \func{wait}, \func{waitpid},
+ \func{write}.
+ \end{minipage}
+ \normalsize
+ \caption{Elenco delle funzioni sicure secondo lo standard POSIX
+ 1003.1-2003.}
+ \label{fig:sig_safe_functions}
+\end{figure}
+
+\index{funzioni!sicure|)}
+
+Per questo motivo è opportuno mantenere al minimo indispensabile le operazioni
+effettuate all'interno di un gestore di segnali, qualora si debbano compiere
+operazioni complesse è sempre preferibile utilizzare la tecnica in cui si usa
+il gestore per impostare il valore di una qualche variabile globale, e poi si
+eseguono le operazioni complesse nel programma verificando (con tutti gli
+accorgimenti visti in precedenza) il valore di questa variabile tutte le volte
+che si è rilevata una interruzione dovuta ad un segnale.
+
+
+\section{Funzionalità avanzate}
+\label{sec:sig_advanced_signal}
+
+
+Tratteremo in questa ultima sezione alcune funzionalità avanzate relativa ai
+segnali ed in generale ai meccanismi di notifica, a partire dalla funzioni
+introdotte per la gestione dei cosiddetti ``\textsl{segnali real-time}'', alla
+gestione avanzata delle temporizzazioni e le nuove interfacce per la gestione
+di segnali ed eventi attraverso l'uso di file descriptor.
+
+\subsection{I segnali real-time}
+\label{sec:sig_real_time}
+
+Lo standard POSIX.1b, nel definire una serie di nuove interfacce per i servizi
+\textit{real-time}, ha introdotto una estensione del modello classico dei
+segnali che presenta dei significativi miglioramenti,\footnote{questa
+ estensione è stata introdotta in Linux a partire dal kernel 2.1.43, e dalle
+ \acr{glibc} 2.1.} in particolare sono stati superati tre limiti fondamentali
+dei segnali classici:
+\begin{basedescript}{\desclabelwidth{1cm}\desclabelstyle{\nextlinelabel}}
+\item[I segnali non sono accumulati]
+ se più segnali vengono generati prima dell'esecuzione di un gestore
+ questo sarà eseguito una sola volta, ed il processo non sarà in grado di
+ accorgersi di quante volte l'evento che ha generato il segnale è accaduto;
+\item[I segnali non trasportano informazione]
+ i segnali classici non prevedono altra informazione sull'evento
+ che li ha generati se non il fatto che sono stati emessi (tutta
+ l'informazione che il kernel associa ad un segnale è il suo numero);
+\item[I segnali non hanno un ordine di consegna]
+ l'ordine in cui diversi segnali vengono consegnati è casuale e non
+ prevedibile. Non è possibile stabilire una priorità per cui la reazione a
+ certi segnali ha la precedenza rispetto ad altri.
+\end{basedescript}
+
+Per poter superare queste limitazioni lo standard POSIX.1b ha introdotto delle
+nuove caratteristiche, che sono state associate ad una nuova classe di
+segnali, che vengono chiamati \textsl{segnali real-time}, in particolare le
+funzionalità aggiunte sono:
+
+\begin{enumerate}
+\item i segnali sono inseriti in una coda che permette di consegnare istanze
+ multiple dello stesso segnale qualora esso venga inviato più volte prima
+ dell'esecuzione del gestore; si assicura così che il processo riceva un
+ segnale per ogni occorrenza dell'evento che lo genera.
+\item è stata introdotta una priorità nella consegna dei segnali: i segnali
+ vengono consegnati in ordine a seconda del loro valore, partendo da quelli
+ con un numero minore, che pertanto hanno una priorità maggiore.
+\item è stata introdotta la possibilità di restituire dei dati al gestore,
+ attraverso l'uso di un apposito campo \var{si\_value} nella struttura
+ \struct{siginfo\_t}, accessibile tramite gestori di tipo
+ \var{sa\_sigaction}.
+\end{enumerate}
+
+Tutte queste nuove funzionalità eccetto l'ultima, che, come illustrato in
+sez.~\ref{sec:sig_sigaction}, è disponibile anche con i segnali ordinari, si
+applicano solo ai nuovi segnali \textit{real-time}; questi ultimi sono
+accessibili in un intervallo di valori specificati dalle due costanti
+\const{SIGRTMIN} e \const{SIGRTMAX},\footnote{in Linux di solito (cioè sulla
+ piattaforma i386) il primo valore è 33, ed il secondo \code{\_NSIG-1}, che
+ di norma è 64, per un totale di 32 segnali disponibili, contro gli almeno 8
+ richiesti da POSIX.1b.} che specificano il numero minimo e massimo associato
+ad un segnale real-time.
+
+% TODO rivedere secondo man 7 signal con le informazioni aggiornate sul numero
+% di segnali real-time disponibili
+
+I segnali con un numero più basso hanno una priorità maggiore e vengono
+consegnati per primi, inoltre i segnali \textit{real-time} non possono
+interrompere l'esecuzione di un gestore di un segnale a priorità più alta; la
+loro azione predefinita è quella di terminare il programma. I segnali
+ordinari hanno tutti la stessa priorità, che è più alta di quella di qualunque
+segnale \textit{real-time}.\footnote{lo standard non definisce niente al
+ riguardo ma Linux, come molte altre implementazioni, adotta questa
+ politica.}
+
+
+Si tenga presente che questi nuovi segnali non sono associati a nessun evento
+specifico, a meno di non utilizzarli in meccanismi di notifica come quelli per
+l'I/O asincrono (vedi sez.~\ref{sec:file_asyncronous_io}) o per le code di
+messaggi POSIX (vedi sez.~\ref{sec:ipc_posix_mq}); pertanto devono essere
+inviati esplicitamente.
+
+Inoltre, per poter usufruire della capacità di restituire dei dati, i relativi
+gestori devono essere installati con \func{sigaction}, specificando per
+\var{sa\_flags} la modalità \const{SA\_SIGINFO} che permette di utilizzare la
+forma estesa \var{sa\_sigaction} (vedi sez.~\ref{sec:sig_sigaction}). In
+questo modo tutti i segnali real-time possono restituire al gestore una serie
+di informazioni aggiuntive attraverso l'argomento \struct{siginfo\_t}, la cui
+definizione è stata già vista in fig.~\ref{fig:sig_siginfo_t}, nella
+trattazione dei gestori in forma estesa.
+
+In particolare i campi utilizzati dai segnali real-time sono \var{si\_pid} e
+\var{si\_uid} in cui vengono memorizzati rispettivamente il \acr{pid} e
+l'user-ID effettivo del processo che ha inviato il segnale, mentre per la
+restituzione dei dati viene usato il campo \var{si\_value}.
+
+Questo è una \ctyp{union} di tipo \struct{sigval\_t} (la sua definizione è in
+fig.~\ref{fig:sig_sigval}) in cui può essere memorizzato o un valore numerico,
+se usata nella forma \var{sival\_int}, o un indirizzo, se usata nella forma
+\var{sival\_ptr}. L'unione viene usata dai segnali real-time e da vari
+meccanismi di notifica\footnote{un campo di tipo \struct{sigval\_t} è presente
+ anche nella struttura \struct{sigevent} (definita in
+ fig.~\ref{fig:file_sigevent}) che viene usata dai meccanismi di notifica
+ come quelli per l'I/O asincrono (vedi sez.~\ref{sec:file_asyncronous_io}) o
+ le code di messaggi POSIX (vedi sez.~\ref{sec:ipc_posix_mq}).} per
+restituire dati al gestore del segnale; in alcune definizioni essa viene
+identificata anche come \code{union sigval}.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/sigval_t.h}
+ \end{minipage}
+ \normalsize
+ \caption{La unione \structd{sigval\_t}.}
+ \label{fig:sig_sigval}
+\end{figure}
+
+A causa delle loro caratteristiche, la funzione \func{kill} non è adatta ad
+inviare segnali \textit{real-time}, poiché non è in grado di fornire alcun
+valore per \struct{sigval\_t}; per questo motivo lo standard ha previsto una
+nuova funzione, \funcd{sigqueue}, il cui prototipo è:
+\begin{prototype}{signal.h}
+ {int sigqueue(pid\_t pid, int signo, const sigval\_t value)}
+
+ Invia il segnale \param{signo} al processo \param{pid}, restituendo al
+ gestore il valore \param{value}.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EAGAIN}] la coda è esaurita, ci sono già
+ \const{SIGQUEUE\_MAX} segnali in attesa si consegna.
+ \item[\errcode{EPERM}] non si hanno privilegi appropriati per inviare il
+ segnale al processo specificato.
+ \item[\errcode{ESRCH}] il processo \param{pid} non esiste.
+ \item[\errcode{EINVAL}] si è specificato un valore non valido per
+ \param{signo}.
+ \end{errlist}
+ ed inoltre \errval{ENOMEM}.}
+\end{prototype}
+
+Il comportamento della funzione è analogo a quello di \func{kill}, ed i
+privilegi occorrenti ad inviare il segnale ad un determinato processo sono gli
+stessi; un valore nullo di \param{signo} permette di verificare le condizioni
+di errore senza inviare nessun segnale.
+
+Se il segnale è bloccato la funzione ritorna immediatamente, se si è
+installato un gestore con \const{SA\_SIGINFO} e ci sono risorse disponibili,
+(vale a dire che c'è posto\footnote{la profondità della coda è indicata dalla
+ costante \const{SIGQUEUE\_MAX}, una della tante costanti di sistema definite
+ dallo standard POSIX che non abbiamo riportato esplicitamente in
+ sez.~\ref{sec:sys_limits}; il suo valore minimo secondo lo standard,
+ \const{\_POSIX\_SIGQUEUE\_MAX}, è pari a 32. Nel caso di Linux questo è uno
+ dei parametri del kernel impostabili sia con \func{sysctl}, che scrivendolo
+ direttamente in \procfile{/proc/sys/kernel/rtsig-max}, il valore predefinito
+ è di 1024.} nella coda dei segnali real-time) esso viene inserito e diventa
+pendente; una volta consegnato riporterà nel campo \var{si\_code} di
+\struct{siginfo\_t} il valore \const{SI\_QUEUE} e il campo \var{si\_value}
+riceverà quanto inviato con \param{value}. Se invece si è installato un
+gestore nella forma classica il segnale sarà generato, ma tutte le
+caratteristiche tipiche dei segnali real-time (priorità e coda) saranno perse.
+
+Lo standard POSIX.1b definisce inoltre delle nuove funzioni che permettono di
+gestire l'attesa di segnali specifici su una coda, esse servono in particolar
+modo nel caso dei \itindex{thread} \textit{thread}, in cui si possono usare i
+segnali real-time come meccanismi di comunicazione elementare; la prima di
+queste funzioni è \funcd{sigwait}, il cui prototipo è:
+\begin{prototype}{signal.h}
+ {int sigwait(const sigset\_t *set, int *sig)}
+
+ Attende che uno dei segnali specificati in \param{set} sia pendente.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINTR}] la funzione è stata interrotta.
+ \item[\errcode{EINVAL}] si è specificato un valore non valido per
+ \param{set}.
+ \end{errlist}
+ ed inoltre \errval{EFAULT}.}
+\end{prototype}
+
+La funzione estrae dall'insieme dei segnali pendenti uno qualunque dei segnali
+specificati da \param{set}, il cui valore viene restituito in \param{sig}. Se
+sono pendenti più segnali, viene estratto quello a priorità più alta (cioè con
+il numero più basso). Se, nel caso di segnali real-time, c'è più di un segnale
+pendente, ne verrà estratto solo uno. Una volta estratto il segnale non verrà
+più consegnato, e se era in una coda il suo posto sarà liberato. Se non c'è
+nessun segnale pendente il processo viene bloccato fintanto che non ne arriva
+uno.
+
+Per un funzionamento corretto la funzione richiede che alla sua chiamata i
+segnali di \param{set} siano bloccati. In caso contrario si avrebbe un
+conflitto con gli eventuali gestori: pertanto non si deve utilizzare per
+lo stesso segnale questa funzione e \func{sigaction}. Se questo non avviene il
+comportamento del sistema è indeterminato: il segnale può sia essere
+consegnato che essere ricevuto da \func{sigwait}, il tutto in maniera non
+prevedibile.
+
+Lo standard POSIX.1b definisce altre due funzioni, anch'esse usate
+prevalentemente con i \itindex{thread} \textit{thread}; \funcd{sigwaitinfo} e
+\funcd{sigtimedwait}, i relativi prototipi sono:
+\begin{functions}
+ \headdecl{signal.h}
+
+ \funcdecl{int sigwaitinfo(const sigset\_t *set, siginfo\_t *info)}
+
+ Analoga a \func{sigwait}, ma riceve anche le informazioni associate al
+ segnale in \param{info}.
+
+ \funcdecl{int sigtimedwait(const sigset\_t *set, siginfo\_t *value, const
+ struct timespec *info)}
+
+ Analoga a \func{sigwaitinfo}, con un la possibilità di specificare un
+ timeout in \param{timeout}.
+
+
+ \bodydesc{Le funzioni restituiscono 0 in caso di successo e $-1$ in caso di
+ errore, nel qual caso \var{errno} assumerà uno dei valori già visti per
+ \func{sigwait}, ai quali si aggiunge, per \func{sigtimedwait}:
+ \begin{errlist}
+ \item[\errcode{EAGAIN}] si è superato il timeout senza che un segnale atteso
+ fosse emesso.
+ \end{errlist}
+}
+\end{functions}
+
+Entrambe le funzioni sono estensioni di \func{sigwait}. La prima permette di
+ricevere, oltre al numero del segnale, anche le informazioni ad esso associate
+tramite \param{info}; in particolare viene restituito il numero del segnale
+nel campo \var{si\_signo}, la sua causa in \var{si\_code}, e se il segnale è
+stato immesso sulla coda con \func{sigqueue}, il valore di ritorno ad esso
+associato viene riportato in \var{si\_value}, che altrimenti è indefinito.
+
+La seconda è identica alla prima ma in più permette di specificare un timeout,
+scaduto il quale ritornerà con un errore. Se si specifica un puntatore nullo
+il comportamento sarà identico a \func{sigwaitinfo}, se si specifica un tempo
+di timeout nullo, e non ci sono segnali pendenti la funzione ritornerà
+immediatamente; in questo modo si può eliminare un segnale dalla coda senza
+dover essere bloccati qualora esso non sia presente.
+
+\itindbeg{thread}
+
+L'uso di queste funzioni è principalmente associato alla gestione dei segnali
+con i \textit{thread}. In genere esse vengono chiamate dal \textit{thread}
+incaricato della gestione, che al ritorno della funzione esegue il codice che
+usualmente sarebbe messo nel gestore, per poi ripetere la chiamata per
+mettersi in attesa del segnale successivo. Questo ovviamente comporta che non
+devono essere installati gestori, che solo il \textit{thread} di gestione deve
+usare \func{sigwait} e che, per evitare che venga eseguita l'azione
+predefinita, i segnali gestiti in questa maniera devono essere mascherati per
+tutti i \textit{thread}, compreso quello dedicato alla gestione, che potrebbe
+riceverlo fra due chiamate successive.
+
+\itindend{thread}
+
+
+\subsection{La gestione avanzata delle temporizzazioni}
+\label{sec:sig_timer_adv}
+
+% TODO trattare i Posix timer, e le fuzioni:
+% clock_getres clock_gettime clock_settime (vedi man page)
+% timer_getoverrun, timer_gettime, timer_settime, timer_create, timer_delete
+
+
+\subsection{Le interfacce per la notifica attraverso i file descriptor}
+\label{sec:sig_signalfd_eventfd}
+
+
+% TODO trattare qui eventfd signalfd e timerfd introdotte con il 2.6.22
+% timerfd è stata tolta nel 2.6.23 e rifatta per bene nel 2.6.25
+% vedi: http://lwn.net/Articles/233462/
+% http://lwn.net/Articles/245533/
+% http://lwn.net/Articles/267331/
+
+
+
+
+% LocalWords: kernel POSIX timer shell control ctrl kill raise signal handler
+% LocalWords: reliable unreliable fig race condition sez struct process table
+% LocalWords: delivered pending scheduler sigpending l'I suspend SIGKILL wait
+% LocalWords: SIGSTOP sigaction waitpid dump stack debugger nell'header NSIG
+% LocalWords: tab BSD SUSv SIGHUP PL Hangup SIGINT Interrupt SIGQUIT Quit AEF
+% LocalWords: SIGILL SIGABRT abort SIGFPE SIGSEGV SIGPIPE SIGALRM alarm SIGUSR
+% LocalWords: SIGTERM SIGCHLD SIGCONT SIGTSTP SIGTTIN SIGTTOU SIGBUS bad SL of
+% LocalWords: memory access SIGPOLL Pollable event Sys SIGIO SIGPROF profiling
+% LocalWords: SIGSYS SVID SIGTRAP breakpoint SIGURG urgent socket Virtual IOT
+% LocalWords: clock SIGXCPU SIGXFSZ SIGIOT trap SIGEMT SIGSTKFLT SIGCLD SIGPWR
+% LocalWords: SIGINFO SIGLOST lock NFS SIGWINCH Sun SIGUNUSED fault point heap
+% LocalWords: exception l'overflow illegal instruction overflow segment error
+% LocalWords: violation system call interrupt INTR hang SIGVTALRM virtual SUSP
+% LocalWords: profilazione fcntl descriptor sleep interactive Broken FIFO lost
+% LocalWords: EPIPE Resource advisory client limit exceeded size window change
+% LocalWords: strsignal psignal SOURCE strerror string char int signum perror
+% LocalWords: void sig const sys siglist L'array decr fork exec DFL IGN ioctl
+% LocalWords: EINTR glibc TEMP FAILURE RETRY expr multitasking SVr sighandler
+% LocalWords: ERR libc bsd sysv XOPEN EINVAL pid errno ESRCH EPERM getpid init
+% LocalWords: killpg pidgrp group unistd unsigned seconds all' setitimer which
+% LocalWords: itimerval value ovalue EFAULT ITIMER it interval timeval ms VIRT
+% LocalWords: getitimer stdlib stream atexit exit usleep long usec nanosleep
+% LocalWords: timespec req rem HZ scheduling SCHED RR SigHand forktest WNOHANG
+% LocalWords: deadlock longjmp setjmp sigset sigemptyset sigfillset sigaddset
+% LocalWords: sigdelset sigismember act oldact restorer mask NOCLDSTOP ONESHOT
+% LocalWords: RESETHAND RESTART NOMASK NODEFER ONSTACK sigcontext union signo
+% LocalWords: siginfo bits uid addr fd inline like blocked atomic sigprocmask
+% LocalWords: how oldset BLOCK UNBLOCK SETMASK sigsuspend sigaltstack malloc
+% LocalWords: SIGSTKSZ MINSIGSTKSZ ss oss ENOMEM flags DISABLE sp setrlimit LB
+% LocalWords: RLIMIT rlim sigsetjmp siglongjmp sigjmp buf env savesigs jmp ptr
+% LocalWords: SIGRTMIN SIGRTMAX sigval sigevent sigqueue EAGAIN sysctl safe
+% LocalWords: QUEUE thread sigwait sigwaitinfo sigtimedwait info DEF SLB bind
+% LocalWords: function accept return cfgetispeed cfgetospeed cfsetispeed chdir
+% LocalWords: cfsetospeed chmod chown gettime close connect creat dup execle
+% LocalWords: execve fchmod fchown fdatasync fpathconf fstat fsync ftruncate
+% LocalWords: getegid geteuid getgid getgroups getpeername getpgrp getppid sem
+% LocalWords: getsockname getsockopt getuid listen lseek lstat mkdir mkfifo
+% LocalWords: pathconf poll posix pselect read readlink recv recvfrom recvmsg
+% LocalWords: rename rmdir select send sendmsg sendto setgid setpgid setsid
+% LocalWords: setsockopt setuid shutdown sigpause socketpair stat symlink page
+% LocalWords: sysconf tcdrain tcflow tcflush tcgetattr tcgetgrp tcsendbreak
+% LocalWords: tcsetattr tcsetpgrp getoverrun times umask uname unlink utime
+% LocalWords: write sival SIVGTALRM NOCLDWAIT MESGQ ASYNCIO TKILL tkill tgkill
+% LocalWords: ILL ILLOPC ILLOPN ILLADR ILLTRP PRVOPC PRVREG COPROC BADSTK FPE
+% LocalWords: INTDIV INTOVF FLTDIV FLTOVF FLTUND underflow FLTRES FLTINV SEGV
+% LocalWords: FLTSUB MAPERR ACCERR ADRALN ADRERR OBJERR BRKPT CLD EXITED MSG
+% LocalWords: KILLED DUMPED TRAPPED STOPPED CONTINUED PRI HUP SigFunc jiffies
+% LocalWords: SEC
+