Correzioni varie, finito esempio sleep

[gapil.git] / signal.tex

diff --git a/signal.tex b/signal.tex
index 3ad72097f971bb9f03e7e7fea5e3240556ce13a2..31f4ee834aecd58194165c93c4f9e630988d389a 100644 (file)
--- a/signal.tex
+++ b/signal.tex
@@ -351,18 +351,19 @@ stato dello stack e delle variabili al momento della ricezione del segnale.
   \centering
   \begin{tabular}[c]{|l|c|c|p{8cm}|}
     \hline
   \centering
   \begin{tabular}[c]{|l|c|c|p{8cm}|}
     \hline

-    \textbf{Segnale}&\textbf{Standard}&\textbf{Azione}&\textbf{Descrizione} \\
+    \textbf{Segnale} &\textbf{Standard}&\textbf{Azione}&\textbf{Descrizione} \\

     \hline
     \hline
     \hline
     \hline

-    \macro{SIGHUP}   &PL & A &Hangup o terminazione del processo di controllo\\
-    \macro{SIGINT}   &PL & A & Interrupt da tastiera (\cmd{C-c})            \\
-    \macro{SIGQUIT}  &PL & C & Quit da tastiera (\cmd{C-y})                 \\
-    \macro{SIGILL}   &PL & C & Istruzione illegale                          \\
-    \macro{SIGABRT}  &PL & C & Segnale di abort da \func{abort}             \\
-    \macro{SIGFPE}   &PL & C & Errore aritmetico                            \\
-    \macro{SIGKILL}  &PL &AEF& Segnale di terminazione forzata              \\
-    \macro{SIGSEGV}  &PL & C & Errore di accesso in memoria                 \\
-    \macro{SIGPIPE}  &PL & A & Pipe spezzata                                \\
+    \macro{SIGHUP}   &PL & A & Hangup o terminazione del processo di 
+                               controllo                                     \\
+    \macro{SIGINT}   &PL & A & Interrupt da tastiera (\cmd{C-c})             \\
+    \macro{SIGQUIT}  &PL & C & Quit da tastiera (\cmd{C-y})                  \\
+    \macro{SIGILL}   &PL & C & Istruzione illegale                           \\
+    \macro{SIGABRT}  &PL & C & Segnale di abort da \func{abort}              \\
+    \macro{SIGFPE}   &PL & C & Errore aritmetico                             \\
+    \macro{SIGKILL}  &PL &AEF& Segnale di terminazione forzata               \\
+    \macro{SIGSEGV}  &PL & C & Errore di accesso in memoria                  \\
+    \macro{SIGPIPE}  &PL & A & Pipe spezzata                                 \\

     \macro{SIGALRM}  &PL & A & Segnale del timer da \func{alarm}             \\
     \macro{SIGTERM}  &PL & A & Segnale di terminazione \verb|C-\|            \\
     \macro{SIGUSR1}  &PL & A & Segnale utente numero 1                       \\
     \macro{SIGALRM}  &PL & A & Segnale del timer da \func{alarm}             \\
     \macro{SIGTERM}  &PL & A & Segnale di terminazione \verb|C-\|            \\
     \macro{SIGUSR1}  &PL & A & Segnale utente numero 1                       \\


@@ -376,7 +377,7 @@ stato dello stack e delle variabili al momento della ricezione del segnale.
     \macro{SIGTTOU}  &PL & D & Output sul terminale per un processo          
                                in background                                 \\
     \macro{SIGBUS}   &SL & C & Errore sul bus (bad memory access)            \\
     \macro{SIGTTOU}  &PL & D & Output sul terminale per un processo          
                                in background                                 \\
     \macro{SIGBUS}   &SL & C & Errore sul bus (bad memory access)            \\

-    \macro{SIGPOLL}  &SL & A & Pollable event (Sys V).                      
+    \macro{SIGPOLL}  &SL & A & \textit{Pollable event} (Sys V).  

                                Sinonimo di \macro{SIGIO}                     \\
     \macro{SIGPROF}  &SL & A & Timer del profiling scaduto                   \\
     \macro{SIGSYS}   &SL & C & Argomento sbagliato per una subroutine (SVID) \\
                                Sinonimo di \macro{SIGIO}                     \\
     \macro{SIGPROF}  &SL & A & Timer del profiling scaduto                   \\
     \macro{SIGSYS}   &SL & C & Argomento sbagliato per una subroutine (SVID) \\


@@ -394,7 +395,8 @@ stato dello stack e delle variabili al momento della ricezione del segnale.
     \macro{SIGINFO}  &L  &   & Sinonimo di \macro{SIGPWR}                    \\
     \macro{SIGLOST}  &L  & A & Perso un lock sul file (per NFS)              \\
     \macro{SIGWINCH} &LB & B & Finestra ridimensionata (4.3 BSD, Sun)        \\
     \macro{SIGINFO}  &L  &   & Sinonimo di \macro{SIGPWR}                    \\
     \macro{SIGLOST}  &L  & A & Perso un lock sul file (per NFS)              \\
     \macro{SIGWINCH} &LB & B & Finestra ridimensionata (4.3 BSD, Sun)        \\

-    \macro{SIGUNUSED}&L  & A &Segnale inutilizzato (diventerà \macro{SIGSYS})\\
+    \macro{SIGUNUSED}&L  & A & Segnale inutilizzato (diventerà 
+                               \macro{SIGSYS})                               \\

     \hline
   \end{tabular}
   \caption{Lista dei segnali in Linux.}
     \hline
   \end{tabular}
   \caption{Lista dei segnali in Linux.}


@@ -680,8 +682,8 @@ classificabili in maniera omogenea. Questi segnali sono:
   implementare una comunicazione elementare fra processi diversi, o per
   eseguire a richiesta una operazione utilizzando un manipolatore. L'azione di
   default è terminare il processo.
   implementare una comunicazione elementare fra processi diversi, o per
   eseguire a richiesta una operazione utilizzando un manipolatore. L'azione di
   default è terminare il processo.

-\item[\macro{SIGWINCH}] Il nome sta per \textit{window (size) change} ed è
-  generato da molti sistemi (GNU/Linux compreso) quando le dimensioni (in
+\item[\macro{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 di default è di essere ignorato.
   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 di default è di essere ignorato.


@@ -994,6 +996,18 @@ termini di \func{kill}, ed 
 standard ISO C, non esiste in alcune vecchie versioni di Unix, in generale
 l'uso di \func{kill} finisce per essere più portabile.
 
 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} è
+\func{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 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}
+e che permette di inviare un segnale a tutto un \textit{process group} (vedi
+\secref{sec:sess_xxx}).
+

 Solo l'amministratore può inviare un segnale ad un processo qualunque, in
 tutti gli altri casi il \textit{real user id} o l'\textit{effective user id}
 del processo chiamante devono corrispondere al \textit{real user id} o al
 Solo l'amministratore può inviare un segnale ad un processo qualunque, in
 tutti gli altri casi il \textit{real user id} o l'\textit{effective user id}
 del processo chiamante devono corrispondere al \textit{real user id} o al


@@ -1401,7 +1415,7 @@ la creazione di zombie.
   \footnotesize \centering
   \begin{minipage}[c]{15cm}
     \begin{lstlisting}{}
   \footnotesize \centering
   \begin{minipage}[c]{15cm}
     \begin{lstlisting}{}

-#include <errno.h>       /* error simbol definitions */
+#include <errno.h>       /* error symbol definitions */

 #include <signal.h>      /* signal handling declarations */
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>      /* signal handling declarations */
 #include <sys/types.h>
 #include <sys/wait.h>


@@ -1459,7 +1473,7 @@ 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 sarà recapitato un solo segnale.
 
 segnali emessi durante il periodo di blocco, una volta che quest'ultimo sarà
 rimosso sarà recapitato un solo segnale.
 

-Allora nel caso della terminazione dei processi figli, se si chiamasse
+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 zombie per un tempo indefinito.
 \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 zombie per un tempo indefinito.


@@ -1499,43 +1513,44 @@ versione di \func{sleep} potrebbe essere quella illustrata in
 
 Dato che è nostra intenzione utilizzare \macro{SIGALRM} il primo passo della
 nostra implementazione di sarà quello di installare il relativo manipolatore
 
 Dato che è nostra intenzione utilizzare \macro{SIGALRM} il primo passo della
 nostra implementazione di sarà quello di installare il relativo manipolatore

-salvando il precedente (\texttt{\small 4-7}).  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
-  8-9}) fino alla sua ricezione.  Al ritorno di \func{pause}, causato dal
-ritorno del manipolatore (\texttt{\small 15-23}), si ripristina il
-manipolatore originario (\texttt{\small 10-11}) restituendo l'eventuale tempo
-rimanente (\texttt{\small 12-13}) che potrà essere diverso da zero qualora
+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 17-19}) fino alla sua ricezione.  Al ritorno di \func{pause},
+causato dal ritorno del manipolatore (\texttt{\small 1-9}), si ripristina il
+manipolatore originario (\texttt{\small 20-21}) restituendo l'eventuale tempo
+rimanente (\texttt{\small 22-23}) che potrà essere diverso da zero qualora

 l'interruzione di \func{pause} venisse causata da un altro segnale.
 
 \begin{figure}[!htb]
   \footnotesize \centering
   \begin{minipage}[c]{15cm}
     \begin{lstlisting}{}
 l'interruzione di \func{pause} venisse causata da un altro segnale.
 
 \begin{figure}[!htb]
   \footnotesize \centering
   \begin{minipage}[c]{15cm}
     \begin{lstlisting}{}

+void alarm_hand(int sig) {
+    /* check if the signal is the right one */
+    if (sig != SIGALRM) { /* if not exit with error */
+        printf("Something wrong, handler for SIGALRM\n");
+        exit(1);
+    } else {    /* do nothing, just interrupt pause */
+        return;
+    }
+}

 unsigned int sleep(unsigned int seconds)
 {
 unsigned int sleep(unsigned int seconds)
 {

-    signandler_t prev_handler;
+    sighandler_t prev_handler;
+    /* install and check new handler */

     if ((prev_handler = signal(SIGALRM, alarm_hand)) == SIG_ERR) {
     if ((prev_handler = signal(SIGALRM, alarm_hand)) == SIG_ERR) {

-        printf("Cannot set handler for alarm\n");
-        exit(1);
+        printf("Cannot set handler for alarm\n"); 
+        exit(-1);

     }
     }

-    alarm(second);
+    /* set alarm and go to sleep */
+    alarm(seconds); 

     pause(); 
     /* restore previous signal handler */
     signal(SIGALRM, prev_handler);
     pause(); 
     /* restore previous signal handler */
     signal(SIGALRM, prev_handler);

-    /* remove alarm, return remaining time */
+    /* return remaining time */

     return alarm(0);
 }
     return alarm(0);
 }

-void alarm_hand(int sig) 
-{
-    /* check if the signal is the right one */
-    if (sig != SIGALRM) { /* if not exit with error */
-        printf("Something wrong, handler for SIGALRM\n");
-        exit(1);
-    } else {    /* do nothing, just interrupt pause */
-        return;
-    }
-}      

     \end{lstlisting}
   \end{minipage} 
   \normalsize 
     \end{lstlisting}
   \end{minipage} 
   \normalsize 


@@ -1600,7 +1615,7 @@ void alarm_hand(int sig)
 In questo caso il manipolatore (\texttt{\small 18-26}) non ritorna come in
 \figref{fig:sig_sleep_wrong}, ma usa \func{longjmp} (\texttt{\small 24}) per
 rientrare nel corpo principale del programma; dato che in questo caso il
 In questo caso il manipolatore (\texttt{\small 18-26}) non ritorna come in
 \figref{fig:sig_sleep_wrong}, ma usa \func{longjmp} (\texttt{\small 24}) per
 rientrare nel corpo principale del programma; dato che in questo caso il

-valore di uscita di \func{setjmp} è 1 grazie alla condizione in
+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.
 
 (\texttt{\small 9-12}) si evita comunque che \func{pause} sia chiamata a
 vuoto.
 


@@ -1616,7 +1631,7 @@ Un secondo esempio 
 qualche forma di evento; in genere quello che si fa in questo caso è settare
 nel manipolatore un opportuno flag da controllare nel corpo principale del
 programma (con un codice del tipo di quello riportato in
 qualche forma di evento; in genere quello che si fa in questo caso è settare
 nel manipolatore un opportuno flag da controllare nel corpo principale del
 programma (con un codice del tipo di quello riportato in

-\secref{fig:sig_event_wrong}.
+\figref{fig:sig_event_wrong}).

 
 \begin{figure}[!htb]
   \footnotesize \centering
 
 \begin{figure}[!htb]
   \footnotesize \centering


@@ -1661,13 +1676,14 @@ della cancellazione del flag (\texttt{\small 7}), la sua occorrenza sar
 perduta.
 
 Questi esempi ci mostrano che per una gestione effettiva dei segnali occorrono
 perduta.
 
 Questi esempi ci mostrano che per una gestione effettiva dei segnali occorrono

-funzioni più sofisticate della semplice interfaccia dei primi sistemi Unix,
-che permettano di gestire tutti i possibili aspetti con cui un processo deve
+funzioni più sofisticate di quelle illustrate finora, che hanno origine dalla
+interfaccia semplice, ma poco sofisticata, dei primi sistemi Unix, in modo da
+consentire la gestione di tutti i possibili aspetti con cui un processo deve

 reagire alla ricezione di un segnale.
 
 
 
 reagire alla ricezione di un segnale.
 
 
 

-\subsection{I \textit{signal set}}
+\subsection{Gli \textsl{insiemi di segnali} o \textit{signal set}}

 \label{sec:sig_sigset}
 
 Come evidenziato nel paragrafo precedente, le funzioni di gestione dei segnali
 \label{sec:sig_sigset}
 
 Come evidenziato nel paragrafo precedente, le funzioni di gestione dei segnali


@@ -1739,13 +1755,13 @@ insieme.
 \label{sec:sig_sigaction}
 
 La funzione principale dell'interfaccia standard POSIX.1 per i segnali è
 \label{sec:sig_sigaction}
 
 La funzione principale dell'interfaccia standard POSIX.1 per i segnali è

-\func{sigaction}, essa ha sostanzialemente le stesse funzioni di
-\func{signal}, permette cioè di specificare come un segnale può essere gestito
+\func{sigaction}, essa ha sostanzialemente 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)} 
   
 da un processo. Il suo prototipo è:
 \begin{prototype}{signal.h}{int sigaction(int signum, const struct sigaction
     *act, struct sigaction *oldact)} 
   

-  Installa un nuovo manipolatore per il segnale \param{signum}.
+  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:
   
   \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
     errore, nel qual caso \var{errno} assumerà i valori:


@@ -1760,11 +1776,12 @@ da un processo. Il suo prototipo 
 La funzione serve ad installare una nuova \textsl{azione} per il segnale
 \param{signum}; si parla di \textsl{azione} e non di \textsl{manipolatore}
 come nel caso di \func{signal}, in quanto la funzione consente di specificare
 La funzione serve ad installare una nuova \textsl{azione} per il segnale
 \param{signum}; si parla di \textsl{azione} e non di \textsl{manipolatore}
 come nel caso di \func{signal}, in quanto la funzione consente di specificare

-le varie caratteristiche della risposta al segnale, non solo la funzione del
-manipolatore.  Per questo lo standard raccomanda di usare sempre questa
-funzione al posto di \func{signal} (che in genere viene definita tramite
-essa), in quanto offre un controllo completo su tutti gli aspetti della
-gestione di un segnale, sia pure al prezzo di una maggiore complessità d'uso.
+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
 
 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


@@ -1811,7 +1828,14 @@ dettagli si consulti la man page di \func{sigaction}).
 Il campo \var{sa\_mask} serve ad indicare l'insieme dei segnali che devono
 essere bloccati durante l'esecuzione del manipolatore, ad essi viene comunque
 sempre aggiunto il segnale che ne ha causato la chiamata, a meno che non si
 Il campo \var{sa\_mask} serve ad indicare l'insieme dei segnali che devono
 essere bloccati durante l'esecuzione del manipolatore, 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.
+sia specificato con \var{sa\_flag} un comportamento diverso. 
+
+L'uso di questo campo permette ad esempio di risolvere il problema residuo
+dell'implementazione di \code{sleep} mostrata in
+\secref{fig:sig_sleep_incomplete}: in quel caso infatti se il segnale di
+allarme interrompe un altro manipolatore questo non sarà eseguito
+correttamente, la cosa può essere prevenuta installando quest'ultimo usando
+\var{sa\_mask} per bloccare \macro{SIGALRM} durante la sua esecuzione.

 
 Il valore di \var{sa\_flag} permette di specificare vari aspetti del
 comportamento di \func{sigaction}, e della reazione del processo ai vari
 
 Il valore di \var{sa\_flag} permette di specificare vari aspetti del
 comportamento di \func{sigaction}, e della reazione del processo ai vari


@@ -1880,10 +1904,10 @@ l'uso di \func{signal} a favore di \func{sigaction}.
 Come spiegato in \secref{sec:sig_semantics} tutti i moderni sistemi unix-like
 permettono si bloccare temporaneamente (o di eliminare completamente, settando
 \macro{SIG\_IGN} come azione) la consegna dei segnali ad un processo. Questo è
 Come spiegato in \secref{sec:sig_semantics} tutti i moderni sistemi unix-like
 permettono si bloccare temporaneamente (o di eliminare completamente, settando
 \macro{SIG\_IGN} come azione) la consegna dei segnali ad un processo. Questo è

-fatto specificando la \textsl{maschera dei segnali} (o \textit{signal mask})
-del processo\footnote{nel caso di Linux essa è mantenuta dal campo
-  \var{blocked} della \var{task\_struct} del processo.} cioè l'insieme dei
-segnali la cui consegna è bloccata. Abbiamo accennato in
+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 \var{task\_struct} del processo.} cioè
+l'insieme dei segnali la cui consegna è bloccata. Abbiamo accennato in

 \secref{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 manipolatore,
 \secref{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 manipolatore,


@@ -1891,7 +1915,7 @@ attraverso l'uso dal campo \var{sa\_mask} di \var{sigaction}.
 
 Uno dei problemi evidenziatisi con l'esempio di \secref{fig:sig_event_wrong} è
 che in molti casi è necessario proteggere delle sezioni di codice (nel caso in
 
 Uno dei problemi evidenziatisi con l'esempio di \secref{fig:sig_event_wrong} è
 che in molti casi è necessario proteggere delle sezioni di codice (nel caso in

-questoine la sezione fra il controllo e la eventuale cancellazione del flag
+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 eseguiti senza interruzioni.
 
 che testimoniava l'avvenuta occorrenza del segnale) in modo da essere sicuri
 che essi siano eseguiti senza interruzioni.
 


@@ -1915,9 +1939,9 @@ segnali; il suo prototipo 
 
 La funzione usa l'insieme di segnali dato all'indirizzo \param{set} per
 modificare la maschera dei segnali del processo corrente. La modifica viene
 
 La funzione usa l'insieme di segnali dato all'indirizzo \param{set} per
 modificare la maschera dei segnali del processo corrente. La modifica viene

-effettuta a seconda del valore dell'argomento \param{how}, secondo le modalità
+effettuata a seconda del valore dell'argomento \param{how}, secondo le modalità

 specificate in \tabref{tab:sig_procmask_how}. Qualora si specifichi un valore
 specificate in \tabref{tab:sig_procmask_how}. Qualora si specifichi un valore

-non nullo per \param{oldset} la mashera dei segnali corrente viene salvata a
+non nullo per \param{oldset} la maschera dei segnali corrente viene salvata a

 quell'indirizzo.
 
 \begin{table}[htb]
 quell'indirizzo.
 
 \begin{table}[htb]


@@ -1942,12 +1966,26 @@ quell'indirizzo.
   \label{tab:sig_procmask_how}
 \end{table}
 
   \label{tab:sig_procmask_how}
 \end{table}
 

-Un altro 
-
+In questo modo diventa possibile proteggere delle sezioni di codice bloccando
+l'insieme di segnali voluto per poi riabilitarli alla fine della sezione
+critica. La funzione permette di risolvere problemi come quelli mostrati in
+\secref{fig:sig_event_wrong}, proteggendo la sezione fra il controllo del flag
+e la sua cancellazione. 
+
+Benché con l'uso di \func{sigprocmask} si possano risolvere la maggior parte
+dei casi di race condition restano aperte alcune possibilità legate all'uso di
+\func{pause}; il caso è simile a quello del problema illustrato nell'esempio
+di \secref{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 \func{sigsuspend}, il cui
+prototipo è:

 \begin{prototype}{signal.h}
 {int sigsuspend(const sigset\_t *mask)} 
   
 \begin{prototype}{signal.h}
 {int sigsuspend(const sigset\_t *mask)} 
   

-  Cambia la \textit{signal mask} del processo corrente.
+  Setta 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:
   
   \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
     errore, nel qual caso \var{errno} assumerà i valori:


@@ -1957,16 +1995,88 @@ Un altro
   \end{errlist}}
 \end{prototype}
 
   \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
+\secref{sec:sig_sigaction} come con \func{sigaction} sia possibile bloccare
+\macro{SIGALRM} nell'installazione dei manipolatori degli altri segnali, per
+poter usare l'implementazione vista in \secref{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 \figref{fig:sig_sleep_ok} che non
+presenta neanche questa necessità.

 
 

+\begin{figure}[!htb]
+  \footnotesize \centering
+  \begin{minipage}[c]{15cm}
+    \begin{lstlisting}{}
+#include <unistd.h>      /* unix standard library */
+#include <signal.h>      /* POSIX signal library */
+void alarm_hand(int);
+unsigned int sleep(unsigned int seconds)
+{
+/* 
+ * Variables definition  
+ */
+    struct sigaction new_action, old_action;
+    sigset_t old_mask, stop_mask, sleep_mask;
+    /* set the signal handler */
+    sigemptyset(&new_action.sa_mask);              /* no signal blocked */
+    new_action.sa_handler = alarm_hand;            /* set handler */
+    new_action.sa_flags = 0;                       /* no flags */
+    sigaction(SIGALRM, &new_action, &old_action);  /* install action */
+    /* block SIGALRM to avoid race conditions */
+    sigemptyset(&stop_mask);                       /* init mask to empty */
+    sigaddset(&stop_mask, SIGALRM);                /* add SIGALRM */
+    sigprocmask(SIG_BLOCK, &stop_mask, &old_mask); /* add SIGALRM to blocked */
+    /* send the alarm */
+    alarm(seconds); 
+    /* going to sleep enabling SIGALRM */
+    sleep_mask = old_mask;                         /* take mask */
+    sigdelset(&sleep_mask, SIGALRM);               /* remove SIGALRM */
+    sigsuspend(&sleep_mask);                       /* go to sleep */
+    /* restore previous settings */
+    sigprocmask(SIG_SETMASK, &old_mask, NULL);     /* reset signal mask */    
+    sigaction(SIGALRM, &old_action, NULL);         /* reset signal action */
+    /* return remaining time */
+    return alarm(0);
+}
+/*
+ * Signal Handler for SIGALRM
+ */
+void alarm_hand(int sig) 
+{
+    return;     /* just return to interrupt sigsuspend */
+}
+    \end{lstlisting}
+  \end{minipage} 
+  \normalsize 
+  \caption{Una implementazione completa di \func{sleep}.} 
+  \label{fig:sig_sleep_ok}
+\end{figure}

 
 

-
-
-
-
-\subsection{Funzioni rientranti e default dei segnali}
-\label{sec:sig_reentrant}
-
-
+Per evitare i problemi di interferenza con gli altri segnali in questo caso
+non si è usato l'approccio di \figref{fig:sig_sleep_incomplete} evitando l'uso
+di \func{longjmp}. Come in precedenza il manipolatore (\texttt{\small 35-37})
+non esegue nessuna operazione, limitandosi a ritornare per interrompere il
+programma messo in attesa.
+
+La prima parte della funzione (\texttt{\small 11-15}) provvede ad installare
+l'opportuno manipolatore per \macro{SIGALRM}, salvando quello originario, che
+sarà ripristinato alla conclusione della stessa (\texttt{\small 28}); il passo
+successivo è quello di bloccare \macro{SIGALRM} (\texttt{\small 17-19}) per
+evitare che esso possa essere ricevuto dal processo fra l'esecuzione di
+\func{alarm} (\texttt{\small 21}) e la sospensione dello stesso. Nel fare
+questo si salva la maschera corrente dei segnali, che sarà ripristinata alla
+fine (\texttt{\small 27}), e al contempo si prepara la maschera dei segnali
+\var{sleep\_mask} per riattivare \macro{SIGALRM} all'esecuzione di
+\func{sigsuspend}.  In questo modo non sono più possibili race condition dato
+che \macro{SIGALRM} viene disabilitato con \func{sigprocmask} fino alla
+chiamata di \func{sigsuspend}.
+
+
+
+\subsection{Caratteristiche ulteriori}
+\label{sec:sig_specific_features}