+La funzione permette di ricavare quali sono i segnali pendenti per il processo
+in corso, cioè i segnali che sono stato 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 stack alternativo per i segnali; è cioè possibile fare usare al
+sistema un altro stack (invece di quello relativo al processo, vedi
+\secref{sec:proc_mem_layout}) solo durante l'esecuzione di un
+gestore. L'uso di uno 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
+ stack alternativo.
+\item Usare la funzione \func{sigaltstack} per rendere noto al sistema
+ l'esistenza e la locazione dello stack alternativo.
+\item Quando si installa un gestore occorre usare \func{sigaction}
+ specificando il flag \const{SA\_ONSTACK} (vedi \tabref{tab:sig_sa_flag}) per
+ dire al sistema di usare lo 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 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
+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 stack di dimensione sufficiente.
+
+Come accennato per poter essere usato lo 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 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 stack è minore
+ di \const{MINSIGSTKSZ}.
+ \item[\errcode{EPERM}] Uno degli indirizzi non è valido.
+ \item[\errcode{EFAULT}] Si è cercato di cambiare lo 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 \figref{fig:sig_stack_t}. I due valori \param{ss}
+e \param{oss}, se non nulli, indicano rispettivamente il nuovo stack da
+installare e quello corrente (che viene restituito dalla funzione per un
+successivo ripristino).
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \begin{lstlisting}[stepnumber=0]{}
+typedef struct {
+ void *ss_sp; /* Base address of stack */
+ int ss_flags; /* Flags */
+ size_t ss_size; /* Number of bytes in stack */
+} stack_t;
+ \end{lstlisting}
+ \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 stack,
+mentre \var{ss\_size} ne indica la dimensione; il campo \var{ss\_flags} invece
+indica lo stato dello stack. Nell'indicare un nuovo 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 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 stack corrente nei relativi campi, mentre \var{ss\_flags}
+potrà assumere il valore \const{SS\_ONSTACK} se il processo è in esecuzione
+sullo stack alternativo (nel qual caso non è possibile cambiarlo) e
+\const{SS\_DISABLE} se questo non è abilitato.
+
+In genere si installa uno stack alternativo per i segnali quando si teme di
+avere problemi di esaurimento dello stack standard o di superamento di un
+limite imposto con chiamata de 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 stack alternativo.
+
+Si tenga presente che le funzioni chiamate durante l'esecuzione sullo stack
+alternativo continueranno ad usare quest'ultimo, che, al contrario di quanto
+avviene per lo 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 stack alternativo.
+
+Abbiamo visto in \secref{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 BSD ripristina la maschera dei segnali
+precedente l'invocazione, come per un normale ritorno, mentre 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
+\secref{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 stack per un salto non-locale\index{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 \secref{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 stack per permettere il salto non-locale
+\index{salto non-locale}; nel caso specifico essa è di tipo
+\type{sigjmp\_buf}, e non \type{jmp\_buf} come per le analoghe di
+\secref{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{I segnali real-time}
+\label{sec:sig_real_time}
+
+
+Lo standard POSIX.1b, nel definire una serie di nuove interfacce per i servizi
+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 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 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}
+
+Queste nuove funzionalità (eccetto l'ultima, che, come vedremo, è parzialmente
+disponibile anche con i segnali ordinari) si applicano solo ai nuovi segnali
+real-time; questi ultimi sono accessibili in un range di valori specificati
+dalle due macro \const{SIGRTMIN} e \const{SIGRTMAX},\footnote{in Linux di
+ solito il primo valore è 32, ed il secondo \code{\_NSIG-1}, che di norma è
+ 63, 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.
+
+I segnali con un numero più basso hanno una priorità maggiore e vengono
+consegnati per primi, inoltre i segnali 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
+real-time.
+
+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 \secref{sec:file_asyncronous_io}) o per le code di
+messaggi POSIX (vedi \secref{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 la modalità
+\const{SA\_SIGINFO} che permette di utilizzare la forma estesa
+\var{sa\_sigaction} (vedi \secref{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 è
+riportata in \figref{fig:sig_siginfo_t}).
+
+In particolare i campi utilizzati dai segnali real-time sono \var{si\_pid} e
+\var{si\_uid} in cui vengono memorizzati rispettivamente \acr{pid} e userid
+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 \figref{fig:sig_sigval}) in
+cui può essere memorizzato o un valore numerico o un indirizzo,\footnote{un
+ campo di tipo \struct{sigval\_t} è presente anche nella struttura
+ \struct{sigevent} che viene usata dai meccanismi di notifica come quelli per
+ l'I/O asincrono (vedi \secref{sec:file_asyncronous_io}) o le code di
+ messaggi POSIX (vedi \secref{sec:ipc_posix_mq}).}
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \begin{lstlisting}[stepnumber=0]{}
+union sigval_t {
+ int sival_int;
+ void *sival_ptr;
+}
+ \end{lstlisting}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{sigval\_t}, una \ctyp{union} usata dai
+ segnali real-time e dai meccanismi di notifica per restituire dati al
+ gestore, (in alcune definizione essa viene identificata anche come
+ \code{union sigval}).}
+ \label{fig:sig_sigval}
+\end{figure}