+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[\signald{SIGUSR1}] Insieme a \signal{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[\signald{SIGUSR2}] È il secondo segnale a disposizione degli utenti. Per
+ il suo utilizzo vale esattamente quanto appena detto per \signal{SIGUSR1}.
+\item[\signald{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[\signald{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. Su Linux però viene utilizzato come sinonimo di
+ \signal{SIGPWR} e l'azione predefinita è di terminare il processo.
+\item[\signald{SIGPWR}] Il segnale indica un cambio nello stato di
+ alimentazione di un eventuale gruppo di continuità e viene usato
+ principalmente per segnalare l'assenza ed il ritorno della corrente. Viene
+ usato principalmente con \cmd{init} per attivare o fermare le procedure di
+ spegnimento automatico all'esaurimento delle batterie. L'azione predefinita
+ è di terminare il processo.
+\item[\signald{SIGSTKFLT}] Indica un errore nello stack del coprocessore
+ matematico, è definito solo per le architetture PC, ma è completamente
+ inusato. L'azione predefinita è di terminare il processo.
+\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 specificando il numero del segnale
+con una delle costanti di tab.~\ref{tab:sig_signal_list}. In genere si usano
+quando si vuole notificare all'utente il segnale ricevuto, ad esempio nel caso
+di terminazione di un processo figlio o di un gestore che gestisce più
+segnali.
+
+La prima funzione, \funcd{strsignal}, è una estensione GNU fornita dalla
+\acr{glibc}, ed è accessibile solo avendo definito la macro
+\macro{\_GNU\_SOURCE}, il suo comportamento è analogo a quello della funzione
+\func{strerror} (si veda sez.~\ref{sec:sys_strerror}) usata per notificare gli
+errori:
+
+\begin{funcproto}{
+\fhead{string.h}
+\fdecl{char *strsignal(int signum)}
+\fdesc{Ottiene la descrizione di un segnale.}
+}
+
+{La funzione ritorna puntatore ad una stringa che descrive il segnale, non
+ sono previste condizioni di errore ed \var{errno} non viene modificata.}
+\end{funcproto}
+
+
+La funzione ritorna sempre il puntatore ad una stringa che contiene la
+descrizione del segnale indicato dall'argomento \param{signum}, se questo non
+indica un segnale valido viene restituito il puntatore ad una stringa che
+segnale che il valore indicato non è valido. 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 in sez.~\ref{sec:sys_strerror}, il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{void psignal(int sig, const char *s)}
+\fdesc{Stampa un messaggio di descrizione di un segnale.}
+}
+{La funzione non ritorna nulla e non prevede errori.}
+\end{funcproto}
+
+La funzione stampa sullo \textit{standard error} un messaggio costituito dalla
+stringa passata nell'argomento \param{s}, seguita dal carattere di due punti
+ed una descrizione del segnale indicato dall'argomento \param{sig}.
+
+Una modalità alternativa per utilizzare le descrizioni restituite da
+\func{strsignal} e \func{psignal} è quello di usare la variabile globale
+\var{sys\_siglist}, che è definita in \headfile{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 \textit{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 \textit{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 \constd{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
+\constd{SIG\_IGN}. Questo permette ad esempio alla shell di impostare ad
+\const{SIG\_IGN} le risposte per \signal{SIGINT} e \signal{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 \textit{system call} si
+danno sostanzialmente due casi, a seconda che esse siano \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 \textit{system call} è stata completata, in quanto attendere per eseguire
+un gestore non comporta nessun inconveniente.
+
+\index{system~call~lente|(}
+
+In alcuni casi però alcune \textit{system call} possono bloccarsi
+indefinitamente e per questo motivo vengono chiamate \textsl{lente} o
+\textsl{bloccanti}. In questo caso non si può attendere la conclusione della
+\textit{system call}, perché questo renderebbe impossibile una risposta pronta
+al segnale, per cui il gestore viene eseguito prima che la \textit{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 file di dispositivo, i socket o le \textit{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 l'uso di funzioni di intercomunicazione fra processi (vedi
+ cap.~\ref{cha:IPC}) che si bloccano in attesa di risposte da altri processi;
+\item l'uso della funzione \func{pause} (vedi sez.~\ref{sec:sig_pause_sleep})
+ e le analoghe \func{sigsuspend}, \func{sigtimedwait}, e \func{sigwaitinfo}
+ (vedi sez.~\ref{sec:sig_real_time}), usate appunto per attendere l'arrivo di
+ un segnale;
+\item l'uso delle funzioni associate al \textit{file locking} (vedi
+ sez.~\ref{sec:file_locking})
+\item l'uso della funzione \func{wait} e le analoghe funzioni di attesa 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 \textit{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
+\textit{system call} lenta per ripeterne la chiamata qualora l'errore fosse
+questo.
+
+Dimenticarsi di richiamare una \textit{system call} interrotta da un segnale è
+un errore comune, tanto che la \acr{glibc} provvede 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 \textit{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 la \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 \textit{system
+ call} ritornano sempre indicando i byte trasferiti.
+
+Si tenga presente però che alcune \textit{system call} vengono comunque
+interrotte con un errore di \errcode{EINTR} indipendentemente dal fatto che ne
+possa essere stato richiesto il riavvio automatico, queste funzioni sono:
+
+\begin{itemize*}
+\item le funzioni di attesa di un segnale: \func{pause} (vedi
+ sez.~\ref{sec:sig_pause_sleep}) o \func{sigsuspend}, \func{sigtimedwait}, e
+ \func{sigwaitinfo} (vedi sez.~\ref{sec:sig_real_time}).
+\item le funzioni di attesa dell'\textit{I/O multiplexing} (vedi
+ sez.~\ref{sec:file_multiplexing}) come \func{select}, \func{pselect},
+ \func{poll}, \func{ppoll}, \func{epoll\_wait} e \func{epoll\_pwait}.
+\item le funzioni del System V IPC che prevedono attese: \func{msgrcv},
+ \func{msgsnd} (vedi sez.~\ref{sec:ipc_sysv_mq}), \func{semop} e
+ \func{semtimedop} (vedi sez.~\ref{sec:ipc_sysv_sem}).
+\item le funzioni per la messa in attesa di un processo come \func{usleep},
+ \func{nanosleep} (vedi sez.~\ref{sec:sig_pause_sleep}) e
+ \func{clock\_nanosleep} (vedi sez.~\ref{sec:sig_timer_adv}).
+\item le funzioni che operano sui socket quando è stato impostato un
+ \textit{timeout} sugli stessi con \func{setsockopt} (vedi
+ sez.~\ref{sec:sock_generic_options}) ed in particolare \func{accept},
+ \func{recv}, \func{recvfrom}, \func{recvmsg} per un \textit{timeout} in
+ ricezione e \func{connect}, \func{send}, \func{sendto} e \func{sendmsg} per
+ un \textit{timeout} in trasmissione.
+%\item la funzione \func{io\_getevents} per l'I/O asincrono (vedi sez.??)
+\end{itemize*}
+
+
+\index{system~call~lente|)}
+
+
+\subsection{L'installazione di un gestore}
+\label{sec:sig_signal}
+
+L'interfaccia più semplice per la gestione dei segnali è costituita dalla
+funzione di sistema \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. Per questo motivo
+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{funcproto}{
+\fhead{signal.h}
+\fdecl{sighandler\_t signal(int signum, sighandler\_t handler)}
+\fdesc{Installa un gestore di segnale (\textit{signal handler}).}
+}
+
+{La funzione ritorna il precedente gestore in caso di successo in caso di
+ successo e \constd{SIG\_ERR} per un errore, nel qual caso \var{errno}
+ assumerà il valore:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] il numero di segnale \param{signum} non è valido.
+ \end{errlist}
+}
+\end{funcproto}
+
+In questa definizione per l'argomento \param{handler} che indica il gestore da
+installare si è usato un tipo di dato, \type{sighandler\_t}, che è una
+estensione GNU, definita dalla \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 complessità 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
+\typed{sighandler\_t} che è:
+\includecodesnip{listati/sighandler_t.c}
+e cioè un puntatore ad una funzione \ctyp{void} (cioè senza valore di ritorno)
+che prende un argomento di tipo \ctyp{int}. Si noti come 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. Il secondo ripristina l'azione predefinita, e
+serve a tornare al comportamento di default quando non si intende più gestire
+direttamente un segnale.
+
+Si ricordi però che i due segnali \signal{SIGKILL} e \signal{SIGSTOP} non
+possono essere né ignorati né intercettati e per loro l'uso di \func{signal}
+non ha alcun effetto, qualunque cosa si specifichi nell'argomento
+\param{handler}.
+
+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 \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 la \acr{libc4} e la \acr{libc5}.\footnote{nelle
+ \acr{libc5} esisteva però la possibilità di includere \file{bsd/signal.h} al
+ posto di \headfile{signal.h}, nel qual caso la funzione \func{signal} era
+ 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 della
+\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 \funcm{sysv\_signal}, una volta che si sia definita la macro
+\macro{\_XOPEN\_SOURCE}.
+
+In generale, per evitare questi problemi e per le possibili differenze nella
+semantica fra versioni diverse di kernel, l'uso di \func{signal} è sempre da
+evitare, visto che tra l'altro la funzione ha un comportamento indefinito in
+caso di processi multi-\textit{thread}; l'unico utilizzo sicuro della funzione
+è con \const{SIG\_IGN} e \const{SIG\_DFL}, in tutti gli altri casi si deve
+usare \func{sigaction}.
+
+Infine si deve tenere presente che su Linux, seguendo lo standard POSIX, il
+comportamento di un processo che ignora i segnali \signal{SIGFPE},
+\signal{SIGILL}, o \signal{SIGSEGV}, qualora questi non originino da una
+chiamata ad una \func{kill} o altra funzione affine, è indefinito. Un gestore
+che ritorna da questi segnali può dare luogo ad un ciclo infinito.
+
+
+\subsection{Le funzioni per l'invio di segnali}
+\label{sec:sig_kill_raise}
+
+Come 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 \textit{system call}. Le funzioni che si utilizzano di solito
+per inviare un segnale generico ad un processo sono \func{raise} e
+\func{kill}.
+
+La funzione \funcd{raise}, definita dallo standard ANSI C, 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{funcproto}{
+\fhead{signal.h}
+\fdecl{int raise(int sig)}
+\fdesc{Invia un segnale al processo corrente.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà il valore:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] il segnale \param{sig} non è valido.
+ \end{errlist}
+}
+\end{funcproto}
+
+Il valore di \param{sig} specifica il segnale che si vuole inviare e può
+essere specificato con una delle costanti illustrate in
+tab.~\ref{tab:sig_signal_list}. 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}.
+
+In realtà \func{raise} è una funzione di libreria, che per i processi ordinari
+veniva implementata (nelle versioni più recenti del kernel viene usata
+\func{tgkill} che vedremo in sez.~\ref{sec:thread_signal}) attraverso la
+funzione di sistema \funcd{kill} che è quella che consente effettivamente di
+inviare un segnale generico ad un processo, il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{sys/types.h}
+\fhead{signal.h}
+\fdecl{int kill(pid\_t pid, int sig)}
+\fdesc{Invia un segnale ad uno o più processi.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] il segnale specificato non esiste.
+ \item[\errcode{EPERM}] non si hanno privilegi sufficienti ad inviare il
+ segnale.
+ \item[\errcode{ESRCH}] il processo o il gruppo di processi indicato non
+ esiste.
+ \end{errlist}
+}
+\end{funcproto}
+
+La funzione invia il segnale specificato dall'argomento \param{sig} al
+processo o ai processi specificati con l'argomento \param{pid}. 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 o i processi specificati
+con \param{pid} non esistono.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|r|p{8cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ $>0$ & Il segnale è mandato al processo con \ids{PID} uguale
+ a \param{pid}.\\
+ 0 & Il segnale è mandato ad ogni processo del \textit{process group}
+ (vedi sez.~\ref{sec:sess_proc_group}) del chiamante.\\
+ $-1$ & Il segnale è mandato ad ogni processo (eccetto \cmd{init}).\\
+ $<-1$& Il segnale è mandato ad ogni processo del \textit{process group}
+ con \ids{PGID} uguale a $|\param{pid}|$.\\
+ \hline
+ \end{tabular}
+ \caption{Valori dell'argomento \param{pid} per la funzione
+ \func{kill}.}
+ \label{tab:sig_kill_values}
+\end{table}
+
+A seconda del valore dell'argomento \param{pid} si può inviare il segnale ad
+uno specifico processo, ad un \textit{process group} (vedi
+sez.~\ref{sec:sess_proc_group}) o a tutti i processi, secondo quanto
+illustrato in tab.~\ref{tab:sig_kill_values} che riporta i valori possibili
+per questo argomento. Si tenga conto però che il sistema ricicla i \ids{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 (torneremo su questo in sez.~\ref{sec:sig_pid_fd}).
+
+Indipendentemente dalla funzione specifica che viene usata solo
+l'amministratore può inviare un segnale ad un processo qualunque, in tutti gli
+altri casi l'\ids{UID} reale o l'\ids{UID} effettivo del processo chiamante
+devono corrispondere all'\ids{UID} reale o all'\ids{UID} salvato della
+destinazione.\footnote{questo a partire dal kernel 1.3.78, seguendo lo
+ standard POSIX.1; in precedenza il comportamento era diverso, gli
+ interessati alla storia possono consultare la pagina di manuale della
+ funzione.} Fa eccezione il caso in cui il segnale inviato sia
+\signal{SIGCONT}, nel quale occorre anche che entrambi i processi appartengano
+alla stessa sessione.
+
+Si tenga presente che, per il ruolo fondamentale che riveste nel sistema, 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.
+
+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}, il suo
+prototipo è:
+
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{int killpg(pid\_t pidgrp, int signal)}
+\fdesc{Invia un segnale ad un \textit{process group}.}
+}
+
+{ La funzione ritorna $0$ in caso di successo e $-1$ per un errore, e gli
+ errori sono gli stessi di \func{kill}.
+}
+\end{funcproto}
+
+
+La funzione invia il segnale \param{signal} al \textit{process group} il cui
+\acr{PGID} (vedi sez.~\ref{sec:sess_proc_group}) è indicato
+dall'argomento \param{pidgrp}, che deve essere un intero positivo. Il suo
+utilizzo è sostanzialmente equivalente all'esecuzione di \code{kill(-pidgrp,
+ signal)}.
+
+Oltre alle precedenti funzioni di base, vedremo più avanti che esistono altre
+funzioni per inviare segnali generici, come \func{sigqueue} per i segnali
+\textit{real-time} (vedi sez.~\ref{sec:sig_real_time}) e le specifiche
+funzioni per i \textit{thread} che tratteremo in sez.~\ref{sec:thread_signal}.
+
+Esiste però un'ultima funzione che permette l'invio diretto di un segnale che
+vale la pena di trattare a parte per le sue peculiarità. La funzione in
+questione è \funcd{abort} che, come accennato in
+sez.~\ref{sec:proc_termination}, permette di abortire l'esecuzione di un
+programma tramite l'invio del segnale \signal{SIGABRT}. Il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{stdlib.h}
+\fdecl{void abort(void)}
+\fdesc{Abortisce il processo corrente.}
+}
+
+{La funzione non ritorna, il processo viene terminato.}
+\end{funcproto}
+
+La differenza fra questa funzione e l'uso di \func{raise} o di un'altra
+funzione per l'invio di \signal{SIGABRT} è 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 allarme ed i \textit{timer}}
+\label{sec:sig_alarm_abort}
+
+Un caso particolare di segnali generati a richiesta è quello che riguarda i
+vari segnali usati per la temporizzazione, per ciascuno di essi infatti sono
+previste delle funzioni specifiche che ne effettuino l'invio. La più comune, e
+la più semplice, delle funzioni usate per la temporizzazione è la funzione di
+sistema \funcd{alarm}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{unsigned int alarm(unsigned int seconds)}
+\fdesc{Predispone l'invio di un allarme.}
+}
+
+{La funzione ritorna il numero di secondi rimanenti ad un precedente allarme,
+ o $0$ se non c'erano allarmi pendenti, non sono previste condizioni di
+ errore.}
+\end{funcproto}
+
+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 \signal{SIGALRM}) dopo il numero di secondi specificato
+dall'argomento \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 valore 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 \signal{SIGALRM};
+\item un \textit{virtual timer} che calcola il tempo di processore usato dal
+ processo in \textit{user space} (che corrisponde all'\textit{user time}). La
+ scadenza di questo timer provoca l'emissione di \signal{SIGVTALRM};
+\item un \textit{profiling timer} che calcola la somma dei tempi di processore
+ utilizzati direttamente dal processo in \textit{user space}, e dal kernel
+ nelle \textit{system call} ad esso relative (che corrisponde a quello che in
+ sez.~\ref{sec:sys_unix_time} abbiamo chiamato \textit{processor time}). La
+ scadenza di questo timer provoca l'emissione di \signal{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{funcproto}{
+\fhead{sys/time.h}
+\fdecl{int setitimer(int which, const struct itimerval *value, struct
+ itimerval *ovalue)}
+
+\fdesc{Predispone l'invio di un segnale di allarme.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori \errval{EINVAL} o \errval{EFAULT}
+ nel loro significato generico.}
+\end{funcproto}
+
+
+La funzione predispone l'invio di un segnale di allarme alla scadenza
+dell'intervallo indicato dall'argomento \param{value}. Il valore
+dell'argomento \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
+ \constd{ITIMER\_REAL} & \textit{real-time timer}\\
+ \constd{ITIMER\_VIRTUAL} & \textit{virtual timer}\\
+ \constd{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]{0.8\textwidth}
+ \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 della \acr{glibc}
+\cite{GlibcMan} 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]{0.8\textwidth}
+ \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, determinato
+dal valore della costante \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 nella maggior
+parte dei casi, comportava inoltre l'impossibilità di specificare tempi molto
+lunghi. superiori al valore della costante \constd{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\_VIRTUAL}) 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. Per questo
+oggi l'uso di questa funzione è deprecato a favore degli
+\textit{high-resolution timer} e della cosiddetta \textit{POSIX Timer API},
+che tratteremo in sez.~\ref{sec:sig_timer_adv}.
+
+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{funcproto}{
+\fhead{sys/time.h}
+\fdecl{int getitimer(int which, struct itimerval *value)}
+\fdesc{Legge il valore di un timer.}
+}
+
+{ La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà gli stessi valori di \func{getitimer}. }
+\end{funcproto}
+
+La funzione legge nella struttura \struct{itimerval} puntata da \param{value}
+il valore del timer specificato da \param{which} ed i suoi argomenti hanno lo
+stesso significato e formato di quelli di \func{setitimer}.
+
+
+\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 ciclo di attesa in cui il programma ripete
+una operazione un numero sufficiente di volte per far passare il tempo
+richiesto.
+
+Ma in un sistema multitasking un ciclo di attesa è solo un inutile spreco di
+tempo di processore dato che altri programmi possono essere eseguiti nel
+frattempo, per questo ci sono delle apposite funzioni che permettono di
+mantenere un processo in attesa per il tempo voluto, senza impegnare il
+processore. In pratica si tratta di funzioni che permettono di portare
+esplicitamente il processo nello stato di \textit{sleep} (si ricordi quanto
+illustrato in tab.~\ref{tab:proc_proc_states}) per un certo periodo di tempo.
+
+La prima di queste è la funzione di sistema \funcd{pause}, che viene usata per
+mettere un processo in attesa per un periodo di tempo indefinito, fino
+all'arrivo di un segnale, il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{int pause(void)}
+\fdesc{Pone il processo in pausa fino al ricevimento di un segnale.}
+}
+
+{La funzione ritorna solo dopo che un segnale è stato ricevuto ed il relativo
+ gestore è ritornato, nel qual caso restituisce $-1$ e \var{errno} assume il
+ valore \errval{EINTR}.}
+\end{funcproto}
+
+La funzione ritorna sempre con una condizione di errore, dato che il successo
+sarebbe quello di continuare ad 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 in partenza, lo standard POSIX.1 prevede una funzione di attesa
+specifica, \funcd{sleep}, il cui prototipo è:
+
+\begin{funcproto}{
+
+\fhead{unistd.h}
+\fdecl{unsigned int sleep(unsigned int seconds)}
+\fdesc{Pone il processo in pausa per un tempo in secondi.}
+}
+
+{La funzione ritorna $0$ se l'attesa viene completata o il
+ numero di secondi restanti se viene interrotta da un segnale, non sono
+ previsti codici di errore.}
+\end{funcproto}
+
+La funzione pone il processo in stato di \textit{sleep} per il numero di
+secondi specificato dall'argomento \param{seconds}, a meno di non essere
+interrotta da un segnale. Alla terminazione del periodo di tempo indicato la
+funzione ritorna riportando il processo in stato \textit{runnable} così che
+questo possa riprendere l'esecuzione.
+
+In caso di interruzione della funzione non è una buona idea ripetere la
+chiamata per il tempo rimanente restituito dalla stessa, in quanto la
+riattivazione del processo può avvenire in un qualunque momento, ma il valore
+restituito sarà sempre arrotondato al secondo. Questo può avere la conseguenza
+che se la successione dei segnali è particolarmente sfortunata e le differenze
+si accumulano, si possono avere ritardi anche di parecchi secondi rispetto a
+quanto programmato inizialmente. In genere la scelta più sicura in questo caso
+è quella di stabilire un termine per l'attesa, e ricalcolare tutte le volte il
+numero di secondi che restano da aspettare.
+
+Si tenga presente che alcune implementazioni l'uso di \func{sleep} può avere
+conflitti con quello di \signal{SIGALRM}, dato che la funzione può essere
+realizzata con l'uso di \func{pause} e \func{alarm}, in una maniera analoga a
+quella dell'esempio che vedremo in sez.~\ref{sec:sig_example}. In tal caso
+mescolare chiamate di \func{alarm} e \func{sleep} o modificare l'azione
+associata \signal{SIGALRM}, può portare a dei risultati indefiniti. Nel caso
+della \acr{glibc} è stata usata una implementazione completamente indipendente
+e questi problemi non ci sono, ma un programma portabile non può fare questa
+assunzione.
+
+La granularità di \func{sleep} permette di specificare attese soltanto in
+secondi, per questo sia sotto BSD4.3 che in SUSv2 è stata definita un'altra
+funzione con una precisione teorica del microsecondo. I due standard hanno
+delle definizioni diverse, ma la \acr{glibc} segue (secondo la pagina di
+manuale almeno dalla versione 2.2.2) quella di SUSv2 per cui la
+funzione \funcd{usleep} (dove la \texttt{u} è intesa come sostituzione di
+$\mu$), ha il seguente prototipo:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{int usleep(unsigned long usec)}
+\fdesc{Pone il processo in pausa per un tempo in microsecondi.}
+}
+
+{La funzione ritorna $0$ se l'attesa viene completata e $-1$ per un errore,
+ nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale.
+ \item[\errcode{EINVAL}] si è indicato un valore di \param{usec} maggiore di
+ 1000000.
+ \end{errlist}
+}
+\end{funcproto}
+
+Anche questa funzione, a seconda delle implementazioni, può presentare
+problemi nell'interazione con \func{alarm} e \signal{SIGALRM}, per questo
+motivo, pur essendovi citata, nello standard POSIX.1-2001 viene deprecata in
+favore della nuova funzione di sistema \funcd{nanosleep}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{int nanosleep(const struct timespec *req, struct timespec *rem)}
+\fdesc{Pone il processo in pausa per un intervallo di tempo.}
+}
+
+{La funzione ritorna $0$ se l'attesa viene completata e $-1$ per un errore,
+ nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale.
+ \item[\errcode{EINVAL}] si è specificato un numero di secondi negativo o un
+ numero di nanosecondi maggiore di 999.999.999.
+ \end{errlist}
+}
+\end{funcproto}
+
+La funzione pone il processo in pausa portandolo nello stato di \textit{sleep}
+per il tempo specificato dall'argomento \param{req}, ed in caso di
+interruzione restituisce il tempo restante nell'argomento \param{rem}. Lo
+standard richiede che la funzione sia implementata in maniera del tutto
+indipendente da \func{alarm}, e nel caso di Linux questo è fatto utilizzando
+direttamente il timer del kernel. Lo standard richiede inoltre che la funzione
+sia utilizzabile senza interferenze con l'uso di \signal{SIGALRM}. La funzione
+prende come argomenti delle strutture di tipo \struct{timespec}, la cui
+definizione è riportata in fig.~\ref{fig:sys_timespec_struct}, il che permette
+di specificare un tempo con una precisione teorica 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.
+
+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 \textit{scheduling}
+\textit{real-time} come \const{SCHED\_FIFO} o \const{SCHED\_RR} (vedi
+sez.~\ref{sec:proc_real_time}); 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 \signal{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. 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 \signal{SIGCHLD} il cui unico compito sia quello di chiamare
+\func{waitpid} per completare la procedura di terminazione in modo da evitare
+la formazione di \textit{zombie}.\footnote{si ricordi comunque che dal kernel
+ 2.6 seguendo lo standard POSIX.1-2001 per evitare di dover ricevere gli
+ stati di uscita che non interessano basta impostare come azione predefinita
+ quella di ignorare \signal{SIGCHLD}, nel qual caso viene assunta la
+ semantica di System V, in cui il segnale non viene inviato, il sistema non
+ genera \textit{zombie} e lo stato di terminazione viene scartato senza dover
+ chiamare una \func{wait}.}
+
+In fig.~\ref{fig:sig_sigchld_handl} è mostrato il codice contenente una
+implementazione generica di una funzione di gestione per \signal{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 \signal{SIGCHLD}) potremo verificare che non si ha
+più la creazione di \textit{zombie}.
+
+\begin{figure}[!htbp]
+ \footnotesize \centering
+ \begin{minipage}[c]{\codesamplewidth}
+ \includecodesample{listati/hand_sigchild.c}
+ \end{minipage}
+ \normalsize
+ \caption{Codice di una funzione generica di gestione per il segnale
+ \signal{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 \signal{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 \textit{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 \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]{\codesamplewidth}
+ \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 \signal{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 \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 \signal{SIGALRM}. In questo caso ci si troverebbe di fronte ad un
+\textit{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]{\codesamplewidth}
+ \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 la funzione \func{longjmp}
+(\texttt{\small 25}) per rientrare direttamente nel corpo principale del
+programma. Dato che in questo caso il valore di uscita che verrà restituito da
+\func{setjmp} è 1, grazie alla condizione impostata in (\texttt{\small 9--12})
+si potrà evitare 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 questa implementazione di \func{alarm} per stabilire un
+timeout su una qualunque \textit{system call} bloccante.
+
+Un secondo esempio dei problemi a cui si può andare incontro è quello in cui
+si usa un segnale per notificare una qualche forma di evento. In genere quello
+che si fa in questo caso è impostare all'interno del 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 del programma è quella di impostare nel gestore una variabile
+globale preventivamente inizializzata nel programma principale ad un valore
+diverso (\texttt{\small 14--19}). In questo modo dal corpo principale del
+programma si potrà determinare, osservando il contenuto di detta variabile,
+l'occorrenza o meno del segnale, ed eseguire le conseguenti azioni relative
+(\texttt{\small 6--11}).
+
+\begin{figure}[!htbp]
+ \footnotesize\centering
+ \begin{minipage}[c]{\codesamplewidth}
+ \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 \textit{race
+ condition}. Infatti, in una situazione in cui un segnale è già arrivato (e
+quindi \var{flag} è già stata impostata ad 1 nel gestore) se un altro segnale
+arriva immediatamente dopo l'esecuzione del controllo (\texttt{\small 6}) ma
+prima della cancellazione di \var{flag} fatta subito dopo (\texttt{\small 7}),
+la sua occorrenza sarà perduta.
+
+Questi esempi ci mostrano come per poter eseguire una gestione effettiva dei
+segnali occorrono delle funzioni più sofisticate di quelle finora
+illustrate. La funzione \func{signal} infatti ha la sua origine
+nell'interfaccia alquanto primitiva che venne adottata nei primi sistemi Unix,
+ma con questa funzione è sostanzialmente impossibile 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.
+
+Inizialmente un \textsl{insieme di segnali} veniva rappresentato da un intero
+di dimensione opportuna, di solito pari al numero di bit dell'architettura
+della macchina, ciascun bit del quale era associato ad uno specifico
+segnale. Nel caso di architetture a 32 bit questo comporta un massimo di 32
+segnali distinti e dato che a lungo questi sono stati sufficienti non c'era
+necessità di nessuna struttura più complicata, in questo modo era possibile
+implementare le operazioni direttamente con istruzioni elementari del
+processore.
+
+Oggi questo non è più vero, in particolare con l'introduzione dei segnali
+\textit{real-rime} (che vedremo in sez.~\ref{sec:sig_real_time}). Dato che in
+generale non si può fare conto sulle caratteristiche di una implementazione,
+perché non è detto che si disponga di un numero di bit sufficienti per mettere
+tutti i segnali in un intero, o perché in \type{sigset\_t} possono essere
+immagazzinate ulteriori informazioni, tutte le operazioni devono essere
+effettuate tramite le opportune funzioni di libreria che si curano di
+mascherare i dettagli di basso livello.
+
+Lo standard POSIX.1 definisce cinque funzioni per la manipolazione degli
+insiemi di segnali. Le prime quattro, che consentono di manipolare i contenuti
+di un \textit{signal set}, sono \funcd{sigemptyset}, \funcd{sigfillset},
+\funcd{sigaddset} e \funcd{sigdelset}; i rispettivi prototipi sono:
+
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{int sigemptyset(sigset\_t *set)}
+\fdesc{Inizializza un insieme di segnali vuoto.}
+\fdecl{int sigfillset(sigset\_t *set)}
+\fdesc{Inizializza un insieme di segnali pieno.}
+\fdecl{int sigaddset(sigset\_t *set, int signum)}
+\fdesc{Aggiunge un segnale ad un insieme di segnali.}
+\fdecl{int sigdelset(sigset\_t *set, int signum)}
+\fdesc{Rimuove un segnale da un insieme di segnali.}
+}
+
+{Le funzioni ritornano $0$ in caso di successo, e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà il valore:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] \param{signum} non è un segnale valido.
+ \end{errlist}
+}
+\end{funcproto}
+
+Le prime due funzioni inizializzano l'insieme di segnali indicato
+dall'argomento \param{set} rispettivamente ad un contenuto vuoto (in cui cioè
+non c'è nessun segnale) e pieno (in cui cioè ci sono tutti i segnali). Le
+altre due funzioni consentono di inserire o rimuovere uno specifico segnale
+indicato con l'argomento \param{signum} in un insieme.
+
+A queste funzioni si aggiunge l'ulteriore \funcd{sigismember}, che consente di
+verificare la presenza di un segnale in un insieme, il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{int sigismember(const sigset\_t *set, int signum)}
+\fdesc{Controlla se un segnale è in un insieme di segnali.}
+}
+
+{La funzione ritorna $1$ il segnale è nell'insieme e $0$ altrimenti, e $-1$
+ per un errore, nel qual caso \var{errno} assumerà il valore \errval{EINVAL}
+ se si è specificato un puntatore \var{NULL}.}
+\end{funcproto}
+
+La \acr{glibc} prevede inoltre altre funzioni non standardizzate, accessibili
+definendo la macro \macro{\_GNU\_SOURCE}. La prima di queste è
+\funcd{sigisemptyset}, che consente di verificare un insieme è vuoto, il suo
+prototipo è:
+
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{int sigisemptyset(sigset\_t *set)}
+\fdesc{Controlla se un insieme di segnali è vuoto.}
+}
+
+{La funzione ritorna $1$ l'insieme è vuoto e $0$ altrimenti, non sono previste
+ condizioni di errore.}
+\end{funcproto}
+
+Alla precedente si aggiungono altre due funzioni consentono di effettuare
+delle operazioni logiche con gli insiemi di segnali, esse sono
+\funcd{sigorset} e \funcd{sigandset}, ed i rispettivi prototipi sono:
+
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{sigorset(sigset\_t *dest, sigset\_t *left, sigset\_t *right)}
+\fdesc{Crea l'unione di due insieme di segnali.}
+\fdecl{sigandset(sigset\_t *dest, sigset\_t *left, sigset\_t *right)}
+\fdesc{Crea l'intersezione di due insieme di segnali.}
+}
+
+{Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà il valore \errcode{EINVAL}.}
+\end{funcproto}
+
+
+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}). La modalità più comune, che
+è anche quella più portabile, prevede che possano essere definiti 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}.
+
+\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 principale funzione di sistema prevista dall'interfaccia POSIX.1 per la
+gestione dei 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{funcproto}{
+\fhead{signal.h}
+\fdecl{int sigaction(int signum, const struct sigaction *act, struct sigaction
+ *oldact)}
+\fdesc{Installa una nuova azione per un segnale.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EFAULT}] si sono specificati indirizzi non validi.
+ \item[\errcode{EINVAL}] si è specificato un numero di segnale invalido o si è
+ cercato di installare il gestore per \signal{SIGKILL} o
+ \signal{SIGSTOP}.
+ \end{errlist}
+}
+\end{funcproto}
+
+La funzione serve ad installare una nuova \textsl{azione} per il segnale
+indicato dall'argomento \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 motivo lo standard POSIX.1 raccomanda di usare sempre questa
+funzione al posto della precedente \func{signal}, che in genere viene
+ridefinita in termini di \func{sigaction}, in quanto la nuova interfaccia
+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. Se
+sia \param{act} che \param{oldact} sono nulli la funzione può essere
+utilizzata per verificare che il segnale indicato sia valido per la
+piattaforma che si sta usando (se non lo è darà errore).
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{0.8\textwidth}
+ \includestruct{listati/sigaction.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{sigaction}.}
+ \label{fig:sig_sigaction}
+\end{figure}
+
+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.
+
+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 la maschera dei segnali bloccati (vedi sez.~\ref{sec:sig_sigmask})
+viene comunque 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 \signal{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
+ \constd{SA\_NOCLDSTOP}& Se il segnale è \signal{SIGCHLD} allora non deve
+ essere notificato quando il processo figlio viene
+ fermato da uno dei segnali \signal{SIGSTOP},
+ \signal{SIGTSTP}, \signal{SIGTTIN} o
+ \signal{SIGTTOU}, questo flag ha significato solo
+ quando si imposta un gestore per \signal{SIGCHLD}.\\
+ \constd{SA\_NOCLDWAIT}& Se il segnale è \signal{SIGCHLD} e si richiede di
+ ignorare il segnale con \const{SIG\_IGN} allora i
+ processi figli non diventano \textit{zombie} quando
+ terminano; questa funzionalità è stata introdotta
+ nel kernel 2.6 e va a modificare il comportamento
+ di \func{waitpid} come illustrato in
+ sez.~\ref{sec:proc_wait}, se si installa un gestore
+ con questo flag attivo il segnale \signal{SIGCHLD}
+ viene comunque generato.\\
+ \constd{SA\_NODEFER} & Evita che il segnale corrente sia bloccato durante
+ l'esecuzione del gestore.\\
+ \constd{SA\_NOMASK} & Nome obsoleto e sinonimo non standard di
+ \const{SA\_NODEFER}, non deve essere più
+ utilizzato.\\
+ \constd{SA\_ONESHOT} & Nome obsoleto e sinonimo non standard di
+ \const{SA\_RESETHAND}, non deve essere più
+ utilizzato.\\
+ \constd{SA\_ONSTACK} & Stabilisce l'uso di uno \textit{stack} alternativo
+ per l'esecuzione del gestore (vedi
+ sez.~\ref{sec:sig_specific_features}).\\
+ \constd{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.\\
+ \constd{SA\_RESTART} & Riavvia automaticamente le \textit{slow system
+ call} quando vengono interrotte dal suddetto
+ segnale, riproduce cioè il comportamento standard
+ di BSD.\\
+ \constd{SA\_RESTORER} & Ad uso delle implementazioni delle liberie del C,
+ non deve essere usato nelle applicazioni, serve ad
+ indicare che il campo \var{sa\_restorer} contiene
+ l'indirizzo di un cosiddetto \textit{signal
+ trampoline}.\footnotemark \\
+ \constd{SA\_SIGINFO} & Deve essere specificato quando si vuole usare un
+ gestore in forma estesa usando
+ \var{sa\_sigaction} al posto di
+ \var{sa\_handler}.\\
+ \hline
+ \end{tabular}
+ \caption{Valori del campo \var{sa\_flag} della struttura \struct{sigaction}.}
+ \label{tab:sig_sa_flag}
+\end{table}