-Quando un processo riceve un segnale il kernel esegue una apposita routine di
-gestione (il cosiddetto \textit{signal handler}) che può essere specificata
-dall'utente. Negli anni il comportamento del sistema in risposta ai segnali è
-stato modificato in vari modi nelle differenti implementazioni di unix.
-Attualmente si possono individuare due tipologie fondamentali di comportamento
-dei segnali (dette semantiche) che vengono chiamate rispettivamente
-\textit{reliable} e \textit{unreliable}.
-
-Nella semantica \textit{unreliable} la routine di gestione del segnale
-specificata dall'utente non resta installata una volta chiamata; è perciò a
-carico dell'utente stesso ripetere l'installazione all'interno della routine
-di gestione stessa in tutti i casi in cui si vuole che il signal handler
-esterno resti attivo.
-
-Per questo motivo è possibile una race-condition in cui un secondo segnale
-arriva prima che il manipolatore abbia eseguito la re-installazione di se
-stesso, nel qual caso il segnale può essere perso o causare il comportamento
-originale assegnato al segnale (in genere la terminazione del processo).
-Questa è la ragione per cui detti segnali sono chiamati \textit{inaffidabili},
-in quanto la ricezione del segnale e la reinstallazione del suo manipolatore
-non sono operazioni atomiche.
-
-Nel caso di implementazione inaffidabile le chiamate di sistema non
-sono fatte ripartire automaticamente quando sono interrotte da un segnale, per
-questo il programma deve controllare lo stato di uscita della chiamata al
-sistema e riperterla nel caso l'errore riportato da \texttt{errno} sia
-\texttt{EINTR}.
-
-Inoltre in questo caso non esiste una modalità semplice per ottenere una
-operazione di pausa atomica (cioè mandare in sleep un processo fino all'arrivo
-di un segnale), dato che ci sono casi in cui un segnale può arrivare quando il
-programma non è in grado di accorgersene.
-
-In caso di segnali \textit{reliable} invece il signal handler resta installato
-quando viene chiamato e i problemi precedenti sono evitati. Inoltre alcune
-chiamate di sistema possono essere fatte ripartire automaticamente e si può
-ottenere un'operazione di pausa atomica (usando la funzione POSIX
-\texttt{sigsuspend}).
-
-
-\subsubsection{Tipi di segnali}
+Negli anni il comportamento del sistema in risposta ai segnali è stato
+modificato in vari modi nelle differenti implementazioni di Unix. Si possono
+individuare due tipologie fondamentali di comportamento dei segnali (dette
+semantiche) che vengono chiamate rispettivamente semantica \textsl{affidabile}
+(o \textit{reliable}) e semantica \textsl{inaffidabile} (o
+\textit{unreliable}).
+
+Nella semantica \textsl{inaffidabile} (quella implementata dalle prime
+versioni di unix) la routine di gestione del segnale specificata dall'utente
+non resta attiva una volta che è stata eseguita; è perciò compito dell'utente
+stesso ripetere l'installazione della stessa all'interno della routine di
+gestione, in tutti i casi in cui si vuole che il manipolatore esterno resti
+attivo.
+
+In questo caso è possibile una situazione in cui i segnali possono essere
+perduti; si consideri il seguente segmento di codice in cui la prima
+operazione del manipolatore è quella di reinstallare se stesso:
+
+\footnotesize
+\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
+ int sig_handler(); /* handler function */
+ ...
+ signal(SIGINT, sig_handler); /* establish handler */
+ ...
+
+int sig_handler()
+{
+ signal(SIGINT, sig_handler); /* restablish handler */
+ ... /* process signal */
+}
+\end{lstlisting}
+\normalsize
+se un secondo segnale arriva prima che il manipolatore invocato dal primo
+abbia eseguito la reinstallazione di se stesso il segnale può essere perso o
+causare il comportamento originale assegnato al segnale (in genere la
+terminazione del processo).
+
+Questa è la ragione per cui l'implementazione dei segnali secondo questa
+semantica viene chiamata \textsl{inaffidabile}, in quanto la ricezione del
+segnale e la reinstallazione del suo manipolatore non sono operazioni
+atomiche, e sono sempre possibili delle race condition (sull'argomento vedi
+quanto detto in \secref{sec:proc_multi_prog}).
+
+Un'altro problema è che in questa semantica non esiste un modo per bloccare i
+segnali quando non si vuole che arrivino; i processi possono ignorare il
+segnale, ma non è possibile istruire il sistema a non fare nulla in occasione
+di un segnale, pur mantenendo memoria del fatto che è avvenuto.
+
+Un caso classico in cui si incontra questo problema, è quello in cui si usa il
+manipolatore per settare un flag che riporta al processo l'occorrenza del
+segnale, così che questo possa prendere provvedimenti al di fuori del
+manipolatore. Si consideri il seguente segmento di codice il cui scopo sarebbe
+quello di fermare il processo fino all'occorrenza di un opportuno segnale:
+
+\footnotesize
+\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
+int signal_flag = 0;
+main()
+{
+ int sig_handler(); /* handler function */
+ ...
+ signal(SIGINT, sig_handler); /* establish handler */
+ ...
+ while(signal_flag == 0) { /* while flag is zero */
+ pause(); /* go to sleep */
+ }
+ ...
+}
+int sig_handler()
+{
+ signal(SIGINT, sig_handler); /* restablish handler */
+ signal_flag = 1; /* set flag */
+}
+\end{lstlisting}
+\normalsize
+l'idea è che quando il processo trova il flag a zero viene messo in sleep e
+verrà risvegliato solo dalla ricezione di un segnale. Il manipolatore si
+limita in questo caso a settare il flag a uno; all'uscita dal manipolatore la
+chiamata a \func{pause} è interrotta ed il processo viene risvegliato e
+riprende l'esecuzione all'istruzione successiva, ma essendo cambiato il flag
+la condizione non è più soddisfatta e il programma prosegue.
+
+Il problema con l'implementazione inaffidabile è che niente ci garantisce che
+il segnale arrivi fra la valutazione della condizione del \code{while} e la
+chiamata a \func{pause}, nel qual caso, se il segnale non viene più generato,
+il processo resterà in sleep permanentemente.
+
+% Un'altra caratteristica della implementazione inaffidabile è che le chiamate
+% di sistema non sono fatte ripartire automaticamente quando sono interrotte da
+% un segnale, per questo un programma deve controllare lo stato di uscita della
+% chiamata al sistema e ripeterla nel caso l'errore riportato da \texttt{errno}
+% sia \texttt{EINTR}.
+
+Questo ci mostra ad esempio come con la semantica inaffidabile non esista una
+modalità semplice per ottenere una operazione di pausa (cioè mandare in sleep
+un processo fino all'arrivo di un segnale).
+
+Nella semantica \textsl{affidabile} (quella utilizzata da Linux e da ogni Unix
+moderno) il manipolatore una volta installato resta attivo e non si hanno
+tutti i problemi precedenti. In questa semantica i segnali vengono
+\textsl{generati} dal kernel per un processo all'occorrenza dell'evento che
+causa il segnale. In genere questo viene fatto dal kernel settando l'apposito
+campo della \var{task\_struct} del processo nella process table (si veda
+\figref{fig:proc_task_struct}).
+
+Si dice che il segnale viene \textsl{consegnato} al processo (dall'inglese
+\textit{delivered}) quando viene eseguita l'azione per esso prevista, mentre
+per tutto il tempo che passa fra la generazione del segnale e la sua consegna
+esso è detto \textsl{pendente} (o \textit{pending}). In genere questa
+procedura viene effettuata dallo scheduler quando, riprendendo l'esecuzione
+del processo in questione, verifica la presenza del segnale nella
+\var{task\_struct} e mette in esecuzione il manipolatore.
+
+In questa semantica un processo ha la possibilità di bloccare la consegna dei
+segnali, in questo caso, se l'azione per il suddetto segnale non è quella di
+ignorarlo, il segnale resta \textsl{pendente} fintanto che il processo non lo
+sblocca (nel qual caso viene consegnato) o setta l'azione di default per
+ignorarlo.
+
+Si tenga presente che il kernel stabilisce cosa fare con un segnale che è
+stato bloccato al momento della consegna, non quando viene generato; questo
+consente di cambiare l'azione per il segnale prima che esso venga consegnato,
+e si può usare la funzione \func{sigpending} (vedi
+\secref{sec:sig_sigpending}) per determinare quali segnali sono bloccati e
+quali sono pendenti.
+
+
+\subsection{Tipi di segnali}