X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=signal.tex;h=3187101587105ffb6066fb68ecd5345f0a9bd0e1;hp=86a66b6c390b25c1f9cfd4df30f64fef423ea1eb;hb=689b99ce22ba645115d553468ec3bfed263a69fa;hpb=56a7803a5e9f18850548c186b7aa9813b071107d diff --git a/signal.tex b/signal.tex index 86a66b6..3187101 100644 --- a/signal.tex +++ b/signal.tex @@ -2,7 +2,7 @@ \label{cha:signals} I segnali sono il primo e più semplice meccanismo di comunicazione nei -confronti dei processi. Non portano con se nessuna informazione che non sia il +confronti dei processi. Non portano con sé nessuna informazione che non sia il loro tipo; si tratta in sostanza di un'interruzione software portata ad un processo. @@ -15,16 +15,18 @@ esempio vengono usati per il controllo di sessione), per notificare eventi In questo capitolo esamineremo i vari aspetti della gestione dei segnali, partendo da una introduzione relativa ai concetti base con cui essi vengono realizzati, per poi affrontarne la classificazione a secondo di uso e modalità -di generazionem fino ad esaminare in dettaglio funzioni e le metodologie di +di generazione fino ad esaminare in dettaglio funzioni e le metodologie di gestione. + \section{Introduzione} \label{sec:sig_intro} -In questa sezione esamineremo i concetti base dei segnali, introducendo le -caratteristiche essenziali con cui il sistema interagisce con i processi -attraverso di essi. +In questa sezione esamineremo i concetti generali relativi ai segnali, vedremo +le loro caratteristiche di base, introdurremo le nozioni di fondo relative +all'architettura del funzionamento dei segnali e alle modalità con cui il +sistema gestisce l'interazione fra di essi ed i processi. \subsection{I concetti base} @@ -45,8 +47,8 @@ il seguente: \item una richiesta dell'utente di terminare o fermare il programma. In genere si realizza attraverso un segnale mandato dalla shell in corrispondenza della pressione di tasti del terminale come \code{C-c} o - \code{C-z}\footnote{indichiamo con \code{C-x} la pressione simultanea al - tasto \code{x} del tasto control (ctrl in molte tastiere)}. + \code{C-z}.\footnote{indichiamo con \code{C-x} la pressione simultanea al + tasto \code{x} del tasto control (ctrl in molte tastiere).} \item l'esecuzione di una \func{kill} o di una \func{raise} da parte del processo stesso o di un'altro (solo nel caso della \func{kill}). \end{itemize*} @@ -73,16 +75,15 @@ semantiche) che vengono chiamate rispettivamente semantica \textsl{affidabile} \textit{unreliable}). Nella semantica \textsl{inaffidabile} (quella implementata dalle prime -versioni di unix) la routine di gestione del segnale specificata dall'utente +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 +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 */ @@ -103,7 +104,7 @@ 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 +semantica viene chiamata \textsl{inaffidabile}; infatti 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}). @@ -113,54 +114,48 @@ 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). +% 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. + +% Questo ci mostra ad esempio come con la semantica inaffidabile non esista una +% modalità semplice per ottenere una operazione di attesa mandando in stato di +% sleep (vedi \ref{sec:proc_sched}) 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 @@ -243,7 +238,7 @@ non \var{task\_struct} del processo; si dice così che il segnale diventa \textsl{pendente} (o \textit{pending}), e rimane tale fino al momento in cui verrà notificato al processo (o verrà specificata come azione di default -quella di ingorarlo). +quella di ignorarlo). Normalmente l'invio al processo che deve ricevere il segnale è immediato ed avviene non appena questo viene rimesso in esecuzione dallo scheduler che @@ -260,31 +255,29 @@ ignorato, non sar è specificata una azione diversa (nel qual caso solo i segnali successivi alla nuova specificazione saranno notificati). -Una volta che il segnale viene notificato (che questo avvenga subito o dopo -una attesa più o meno lunga) viene eseguita l'azione specificata per detto +Una volta che un segnale viene notificato (che questo avvenga subito o dopo +una attesa più o meno lunga) viene eseguita l'azione specificata per il segnale. Per alcuni segnali (\macro{SIGKILL} e \macro{SIGSTOP}) questa azione -è fissa e non può essere cambiata, ma per tutti gli altri si può specificare -una scelta fra le tre seguenti: +è fissa e non può essere cambiata, ma per tutti gli altri si può selezionare +una delle tre possibilità seguenti: \begin{itemize*} -\item \textsl{ignorare} il segnale. -\item \textsl{catturare} il segnale, ed utilizzare il manipolatore - specificato. +\item ignorare il segnale. +\item catturare il segnale, ed utilizzare il manipolatore specificato. \item accettare l'azione di default per quel segnale. \end{itemize*} -Un programma può specificare queste scelte usano le due funzioni \func{signal} -e \func{sigaction} (vedi \secref{sec:sig_signal} e ); se si è installato un -manipolatore sarà quest'ultimo ad essere eseguito alla notifica del segnale. -Inoltre il sistema fa si che mentre viene eseguito il manipolatore di un -segnale, questo ultimo venga automaticamente bloccato (così si possono evitare -race condition). +Un programma può specificare queste scelte usando le due funzioni +\func{signal} e \func{sigaction} (vedi \secref{sec:sig_signal} e +\secref{sec:sig_sigaction}). Se si è installato un manipolatore sarà +quest'ultimo ad essere eseguito alla notifica del segnale. Inoltre il sistema +farà si che mentre viene eseguito il manipolatore di un segnale, quest'ultimo +venga automaticamente bloccato (così si possono evitare race condition). -Se arriva un segnale per il quale non è stato specificata un'azione viene -utilizzata l'azione standard. Questa è diversa da segnale a segnale (come -vedremo in \secref{sec:sig_standard}); nella maggior parte dei casi essa -comporta la terminazione del processo, per alcuni segnali che rappresentano -eventi innocui invece l'azione di default è quella di essere ignorati. +Nel caso non sia stata specificata un'azione, viene utilizzata l'azione +standard che (come vedremo in \secref{sec:sig_standard}) è propria di ciascun +segnale; nella maggior parte dei casi essa porta alla terminazione del +processo, ma alcuni segnali che rappresentano eventi innocui vengono ignorati. Quando un segnale termina un processo, il padre può determinare la causa della terminazione esaminando il codice di stato riportato delle funzioni @@ -294,18 +287,18 @@ un eventuale messaggio di errore. I segnali che rappresentano errori del programma (divisione per zero o violazioni di accesso) hanno anche la caratteristica di scrivere un file di -\textit{core dump} che registra lo stato del processo prima della -terminazione, che e può essere esaminato da un debugger per investigare sulla -causa dell'errore. Lo stesso avviene se i suddetti segnale vengono generati -con una \func{kill}. +\textit{core dump} che registra lo stato del processo (ed in particolare della +memoria e dello stack) prima della terminazione. Questo può essere esaminato +in seguito con un debugger per investigare sulla causa dell'errore. Lo stesso +avviene se i suddetti segnale vengono generati con una \func{kill}. \section{La classificazione dei segnali} \label{sec:sig_classification} -Esamineremo in questa sezione i vari segnali definiti nel sistema, le loro -caratteristiche e tipologia, le varie macro e costanti che permettono di -identificarli, e le funzioni che ne stampano la descrizione. +Esamineremo in questa sezione quali sono i vari segnali definiti nel sistema, +le loro caratteristiche e tipologia, le varie macro e costanti che permettono +di identificarli, e le funzioni che ne stampano la descrizione. \subsection{I segnali standard} @@ -313,66 +306,11 @@ identificarli, e le funzioni che ne stampano la descrizione. Ciascun segnale è identificato rispetto al sistema da un numero, ma l'uso diretto di questo numero da parte dei programmi è da evitare, in quanto esso -può variare a seconda dell'implementazione del sistema. - -\begin{table}[htb] - \footnotesize - \centering - \begin{tabular}[c]{|l|c|c|p{8cm}|} - \hline - \textbf{Segnale}&\textbf{Standard}&\textbf{Azione}&\textbf{Descrizione} \\ - \hline - \hline - \macro{SIGHUP} &PL& A &Hangup o fine 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{SIGUSR2} &PL& A & Segnale utente numero 2\\ - \macro{SIGCHLD} &PL& B & Figlio terminato o fermato\\ - \macro{SIGCONT} &PL& & Continua se fermato\\ - \macro{SIGSTOP} &PL&DEF& Ferma il processo\\ - \macro{SIGTSTP} &PL& D & Stop typed at tty \\ - \macro{SIGTTIN} &PL& D & Input sul terminale per un processo - in background\\ - \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). - Sinonimo di \macro{SIGIO}\\ - \macro{SIGPROF} &SL& A & Timer del profiling scaduto \\ - \macro{SIGSYS} &SL& C & Bad argument to routine (SVID)\\ - \macro{SIGTRAP} &SL & C & Trace/breakpoint trap \\ - \macro{SIGURG} &SLB& B & Urgent condition on socket\\ - \macro{SIGVTALRM}&SLB& A & Virtual alarm clock\\ - \macro{SIGXCPU} &SLB& C & Ecceduto il limite sul CPU time\\ - \macro{SIGXFSZ} &SLB& C & Ecceduto il limite sulla dimezsione dei file\\ - \macro{SIGIOT} &L & C & IOT trap. A synonym for SIGABRT \\ - \macro{SIGEMT} &L & & \\ - \macro{SIGSTKFLT}&L & A & Stack fault on coprocessor \\ - \macro{SIGIO} &LB& A & I/O now possible (4.2 BSD) \\ - \macro{SIGCLD} &L & & A synonym for SIGCHLD \\ - \macro{SIGPWR} &L & A & Power failure (System V) \\ - \macro{SIGINFO} &L & & A synonym for SIGPWR \\ - \macro{SIGLOST} &L & A & File lock lost \\ - \macro{SIGWINCH} &LB& B & Window resize signal (4.3 BSD, Sun) \\ - \macro{SIGUNUSED}&L & A & Unused signal (will be SIGSYS) \\ - \hline - \end{tabular} - \caption{Lista dei segnali in Linux.} - \label{tab:sig_signal_list} -\end{table} - -Per questo motivo ad ogni segnale viene associato un nome, che corrisponde, -tramite una macro di preprocessore, al suddetto numero. Sono questi nomi, che -sono standardizzati e sostanzialemnte uniformi rispetto alle varie +può variare a seconda dell'implementazione del sistema, e nel caso si Linux, +anche a seconda dell'architettura hardware. +Per questo motivo ad ogni segnale viene associato un nome, definendo con una +macro di preprocessore una costante uguale al suddetto numero. Sono questi +nomi, che sono standardizzati e sostanzialmente uniformi rispetto alle varie implementazioni, che si devono usare nei programmi. Tutti i nomi e le funzioni che concernono i segnali sono definiti nell'header di sistema \file{signal.h}. @@ -383,13 +321,6 @@ In \tabref{tab:sig_signal_list} si definiti in Linux (estratto dalle man page), comparati con quelli definiti in vari standard. -In \tabref{tab:sig_signal_list} si sono anche riportate le azioni di default -di ciascun segnale (riassunte con delle lettere, la cui legenda completa è in -\tabref{tab:sig_action_leg}), quando nessun manipolatore è installato un -segnale può essere ignorato o causare la terminazione del processo. Nella -colonna standard sono stati indicati anche gli standard in cui ciascun segnale -è definito, secondo lo schema di \tabref{tab:sig_standard_leg}. - \begin{table}[htb] \footnotesize \centering @@ -412,11 +343,13 @@ colonna standard sono stati indicati anche gli standard in cui ciascun segnale \label{tab:sig_action_leg} \end{table} -In alcuni casi alla terminazione del processo è associata la creazione di un -file (posto nella directory corrente del processo e chiamato \file{core}) su -cui viene salvata un'immagine della memoria del processo (il cosiddetto -\textit{core dump}), che può essere usata da un debugger per esaminare lo -stato dello stack e delle variabili al momento della ricezione del segnale. +In \tabref{tab:sig_signal_list} si sono anche riportate le azioni di default +di ciascun segnale (riassunte con delle lettere, la cui legenda completa è in +\tabref{tab:sig_action_leg}), quando nessun manipolatore è installato un +segnale può essere ignorato o causare la terminazione del processo. Nella +colonna standard sono stati indicati anche gli standard in cui ciascun segnale +è definito, secondo lo schema di \tabref{tab:sig_standard_leg}. + \begin{table}[htb] \footnotesize @@ -428,8 +361,8 @@ stato dello stack e delle variabili al momento della ricezione del segnale. \hline P & POSIX. \\ B & BSD. \\ - L & Linux \\ - S & SUSv2 \\ + L & Linux.\\ + S & SUSv2.\\ \hline \end{tabular} \caption{Legenda dei valori della colonna \textbf{Standard} di @@ -437,8 +370,69 @@ stato dello stack e delle variabili al momento della ricezione del segnale. \label{tab:sig_standard_leg} \end{table} +In alcuni casi alla terminazione del processo è associata la creazione di un +file (posto nella directory corrente del processo e chiamato \file{core}) su +cui viene salvata un'immagine della memoria del processo (il cosiddetto +\textit{core dump}), che può essere usata da un debugger per esaminare lo +stato dello stack e delle variabili al momento della ricezione del segnale. + +\begin{table}[htb] + \footnotesize + \centering + \begin{tabular}[c]{|l|c|c|p{8cm}|} + \hline + \textbf{Segnale}&\textbf{Standard}&\textbf{Azione}&\textbf{Descrizione} \\ + \hline + \hline + \macro{SIGHUP} &PL & A & Hangup o fine 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{SIGUSR2} &PL & A & Segnale utente numero 2 \\ + \macro{SIGCHLD} &PL & B & Figlio terminato o fermato \\ + \macro{SIGCONT} &PL & & Continua se fermato \\ + \macro{SIGSTOP} &PL &DEF& Ferma il processo \\ + \macro{SIGTSTP} &PL & D & Stop typed at tty \\ + \macro{SIGTTIN} &PL & D & Input sul terminale per un processo + in background \\ + \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). + Sinonimo di \macro{SIGIO} \\ + \macro{SIGPROF} &SL & A & Timer del profiling scaduto \\ + \macro{SIGSYS} &SL & C & Bad argument to routine (SVID) \\ + \macro{SIGTRAP} &SL & C & Trace/breakpoint trap \\ + \macro{SIGURG} &SLB& B & Urgent condition on socket \\ + \macro{SIGVTALRM}&SLB& A & Virtual alarm clock \\ + \macro{SIGXCPU} &SLB& C & Ecceduto il limite sul CPU time \\ + \macro{SIGXFSZ} &SLB& C & Ecceduto il limite sulla dimensione dei file \\ + \macro{SIGIOT} &L & C & IOT trap. A synonym for \macro{SIGABRT} \\ + \macro{SIGEMT} &L & & \\ + \macro{SIGSTKFLT}&L & A & Stack fault on coprocessor \\ + \macro{SIGIO} &LB & A & I/O now possible (4.2 BSD) \\ + \macro{SIGCLD} &L & & A synonym for \macro{SIGCHLD} \\ + \macro{SIGPWR} &L & A & Fallimento dell'alimentazione \\ + \macro{SIGINFO} &L & & A synonym for \macro{SIGPWR} \\ + \macro{SIGLOST} &L & A & Perso un lock sul file (per NFS) \\ + \macro{SIGWINCH} &LB & B & Window resize signal (4.3 BSD, Sun) \\ + \macro{SIGUNUSED}&L & A & Unused signal (will be SIGSYS) \\ + \hline + \end{tabular} + \caption{Lista dei segnali in Linux.} + \label{tab:sig_signal_list} +\end{table} + La descrizione dettagliata del significato dei vari segnali, raggruppati per -tipologia, verrà affrontate nel seguito. +tipologia, verrà affrontate nei paragrafi successivi. \subsection{Segnali di errore di programma} @@ -471,6 +465,9 @@ Questi segnali sono: \item[\macro{SIGFPE}] Riporta un errore aritmetico fatale. Benché il nome derivi da \textit{floating point exception} si applica a tutti gli errori aritmetici compresa la divisione per zero e l'overflow. + + Se il manipolatore ritorna il comportamento del processo è indefinito, ed + ignorare questo segnale può condurre ad un loop infinito. % Per questo segnale le cose sono complicate dal fatto che possono esserci % molte diverse eccezioni che \texttt{SIGFPE} non distingue, mentre lo @@ -486,12 +483,14 @@ Questi segnali sono: posto di un puntatore a funzione, o si eccede la scrittura di un vettore di una variabile locale, andando a corrompere lo stack. Lo stesso segnale viene generato in caso di overflow dello stack o di problemi nell'esecuzione di un - manipolatore. + manipolatore. Se il manipolatore ritorna il comportamento del processo è + indefinito. \item[\macro{SIGSEGV}] Il nome deriva da \textit{segment violation}, e significa che il programma sta cercando di leggere o scrivere in una zona di memoria protetta al di fuori di quella che gli è stata riservata dal sistema. In genere è il meccanismo della protezione della memoria che si - accorge dell'errore ed il kernel genera il segnale. + accorge dell'errore ed il kernel genera il segnale. Se il manipolatore + ritorna il comportamento del processo è indefinito. È tipico ottenere questo segnale dereferenziando un puntatore nullo o non inizializzato leggendo al di la della fine di un vettore. @@ -750,87 +749,1242 @@ descritta in \secref{sec:sys_strerror}; il suo prototipo Una modalità alternativa per utilizzare le descrizioni restituite da \func{strsignal} e \func{psignal} è quello di fare usare la variabile -\var{sys\_siglist}, che può essere acceduta dichiarando: +\var{sys\_siglist}, che è definita in \file{signal.h} e può essere acceduta +con la dichiarazione: \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{} extern const char *const sys_siglist[] \end{lstlisting} -\var{sys\_siglist} contiene le stringhe di descrizione indicizzate per numero -di segnale, per cui \code{char *decr = strsignal(SIGINT)} può essere -sostituito dall'equivalente \code{char *decr = sys\_siglist[SIGINT]}. +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 dei segnali} -\label{sec:sig_handlers} +\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 manipolatori che si sono installati. + +In questa sezione vedremo come si effettua gestione dei segnali, a partire +dalla loro interazione con le system call, passando per le varie funzioni che +permettono di installare i manipolatori 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 \secref{sec:sig_intro} le modalità con cui il sistema +gestisce l'interazione fra segnali e processi, ci resta da esaminare però il +comportamento delle system call; in particolare due di esse, \func{fork} ed +\func{exec}, dovranno essere prese esplicitamente in considerazione, data la +loro stretta relazione con la creazione di nuovi processi. + +Come accennato in \secref{sec:proc_fork} quando viene creato un nuovo processo +con \func{fork} esso eredita dal padre sia le azioni che sono state settate +per i singoli segnali, che la maschera dei segnali bloccati (tratteremo +quest'ultimo argomento in \ref{sec:sig_sigpending}). 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 \secref{sec:proc_exec}) tutti i segnali per i quali è stato +installato un manipolatore vengono resettati a \macro{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 +manipolatore; viene mantenuto invece ogni eventuale settaggio dell'azione a +\macro{SIG\_IGN}. Questo permette ad esempio alla shell di settare ad +\macro{SIG\_IGN} le risposte per \macro{SIGINT} e \macro{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 tutte le altre system call esse vengono tradizionalmente +classificate, proprio in base al loro comportamento nei confronti dei segnali, +in \textsl{lente} (\textit{slow}) e \textsl{veloci} (\textit{fast}). La gran +parte appartiene a quest'ultima categoria che non è influenzata dall'arrivo di +un segnale. In tal caso un eventuale manipolatore viene sempre eseguito dopo +che la system call è stata completata. Esse sono dette \textsl{veloci} proprio +in quanto la loro esecuzione è sostanzialmente immediata e attendere per +eseguire un manipolatore non comporta nessun inconveniente. + +Esistono però dei casi in cui questo non è possibile perché renderebbe +impossibile una risposta pronta al segnale. In generale questo avviene tutte +le volte che si ha a che fare con system call che possono bloccarsi +indefinitamente, (quelle che, per questo, vengono chiamate \textsl{lente}). Un +elenco dei casi in cui si presenta questa situazione è il seguente: +\begin{itemize*} +\item lettura da file che possono bloccarsi in attesa di dati non ancora + presenti (come per certi file di dispositivo, la rete o le pipe). +\item scrittura sugli stessi file, nel caso in cui dati non possano essere + accettati immediatamente. +\item apertura di un file di dispositivo che richiede operazioni non immediate + per una una risposta. +\item operazioni eseguite con \func{ioctl} che non è detto possano essere + eseguite immediatamente. +\item le funzioni di intercomunicazione che si bloccano in attesa di risposte + da altri processi. +\item la funzione \func{pause} (usata appunto per attendere l'-arrivo di un + segnale). +\item la funzione \func{wait} (se nessun processo figlio è ancora terminato). +\end{itemize*} + +In questo caso si pone il problema di cosa fare una volta che il manipolatore +sia ritornato. La scelta originaria dei primi Unix era quella di far ritornare +anche la system call restituendo l'errore di \macro{EINTR}. Questa è a +tutt'oggi una scelta corrente, ma comporta che i programmi che usano dei +manipolatori controllino lo stato di uscita delle funzioni per ripeterne la +chiamata qualora l'errore fosse questo. -I segnali sono il primo e più classico esempio di eventi asincroni, che -possono accadere in un qualunque momento durante l'esecuzione di un programma. -Non essendo sotto il controllo del programma la gestione dei segnali non potrà -essere controllata all'interno del flusso di esecuzione di quest'ultimo, ma -tutto quello che si potrà fare è di specificare (al kernel, che li genera) -quale azione andrà intrapresa quando essi si verificano. +Dimenticarsi di richiamare una system call interrotta da un segnale è un +errore comune, tanto che le \acr{glibc} provvedono una macro +\code{TEMP\_FAILURE\_RETRY(expr)} che esegue l'operazione automaticamente, +ripetendo l'esecuzione dell'espressione \var{expr} fintanto che il risultato +non è diverso dall'uscita con un errore \macro{EINTR}. -In questa sezione vedremo allora come si gestiscono i segnali, esaminando le -funzioni che si usano per effettuare la gestione dei segnali ed analizzando le -problematiche relative alla gestione di eventi asincroni di questo tipo. +La soluzione è comunque poco elegante e BSD ha scelto un approccio molto +diverso, che è quello di fare ripartire automaticamente la system call invece +di farla fallire. In questo caso ovviamente non c'è da preoccuparsi di +controllare il codice di errore; si perde però la possibilità di eseguire +azioni specifiche all'occorrenza di questa particolare condizione. + +Linux e le \acr{glibc} consentono di utilizzare entrambi gli approcci, +attraverso una opportuna opzione di \func{sigaction} (vedi +\secref{sec:sig_sigaction}). È da chiarire comunque che nel caso di +interruzione nel mezzo di un trasferimento parziale di dati, le system call +ritornano sempre indicando i byte trasferiti. \subsection{La funzione \func{signal}} \label{sec:sig_signal} -L'interfaccia più semplice alla manipolazione dei segnali è costituita dalla -funzione \func{signal}; questa funzione è definita fin dallo standard ANSI C -che però non considera sistemi multitasking, per cui la sua definizione in -tale standard è tanto vaga da essere del tutto inutile in un sistema unix, per -questo ogni implementazione successiva ne ha modificato e ridefinito il +L'interfaccia più semplice per la gestione dei segnali è costituita dalla +funzione \func{signal} che è definita fin dallo standard ANSI C. Quest'ultimo +però non considera sistemi multitasking, per cui la definizione è tanto vaga +da essere del tutto inutile in un sistema Unix; è questo il motivo per cui +ogni implementazione successiva ne ha modificato e ridefinito il comportamento, pur mantenendone immutato il prototipo\footnote{in realtà alcune vecchie implementazioni (SVR4 e 4.3+BSD) usano parametri aggiuntivi - per definire il comportamento della funzione} che è: + per definire il comportamento della funzione.} che è: \begin{prototype}{signal.h} {sighandler\_t signal(int signum, sighandler\_t handler)} - Installa una nuova funzione di gestione (manipolatore) per il segnale - \param{signum}, usando il manipolatore \param{handler}. + Installa la funzione di gestione \param{handler} (il manipolatore) per il + segnale \param{signum}. \bodydesc{La funzione ritorna il precedente manipolatore in caso di successo o \macro{SIG\_ERR} in caso di errore.} \end{prototype} In questa definizione si è usato il tipo \type{sighandler\_t} che è una -estensione GNU definita in Linux che permette di riscrivere il prototipo in -forma più leggibile dell'originario \code{void (*signal(int signum, void - (*handler)(int)))int)}, e che è sostanzialmente equivalente alla -definizione: +estensione GNU, definita dalle \acr{glibc}, che permette di riscrivere il +prototipo in una forma più leggibile dell'originario: +\begin{verbatim} +void (*signal(int signum, void (*handler)(int)))int) +\end{verbatim} +questa infatti, per la poca chiarezza della sintassi del C quando si vanno a +trattare puntatori a funzioni, è molto meno comprensibile. Da un confronto +con il precedente prototipo si può dedurre la definizione di +\type{sighandler\_t} che è: \begin{verbatim} typedef void (* sighandler_t)(int) \end{verbatim} -cioè un puntatore ad una funzione di tipo \type{void} con un parametro di tipo -\type{int}\footnote{si devono usare le parentesi intorno al nome della - funzione per via delle precedenze degli operatori del C, senza di esse si - sarebbe definita una funzione che ritorna un puntatore a \type{void} e non - un puntatore ad una funzione \type{void}}. - -Il numero di segnale passato in \param{signum} segnale può essere indicato -direttamente con una delle costanti definite in \secref{sec:sig_standard}, il +e cioè un puntatore ad una funzione \ctyp{void} (cioè senza valore di ritorno) +e che prende un argomento di tipo \ctyp{int}.\footnote{si devono usare le + parentesi intorno al nome della funzione per via delle precedenze degli + operatori del C, senza di esse si sarebbe definita una funzione che ritorna + un puntatore a \ctyp{void} e non un puntatore ad una funzione \ctyp{void}.} +La funzione \func{signal} quindi restituisce e prende come secondo argomento +un puntatore a una funzione di questo tipo, che è appunto il manipolatore del +segnale. + +Il numero di segnale passato in \param{signum} può essere indicato +direttamente con una delle costanti definite in \secref{sec:sig_standard}. Il manipolatore \param{handler} invece, oltre all'indirizzo della funzione da -chiamare all'occorrenza del segnale, può assumere anche i valori costanti +chiamare all'occorrenza del segnale, può assumere anche i due valori costanti \macro{SIG\_IGN} con cui si dice ignorare il segnale e \macro{SIG\_DFL} per -installare l'azione di di default (si ricordi però che i due segnali -\macro{SIGKILL} e \macro{SIGSTOP} non possono essere ignorati né -intercettati). +installare l'azione di di default.\footnote{si ricordi però che i due segnali + \macro{SIGKILL} e \macro{SIGSTOP} non possono essere ignorati né + intercettati.} + +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 setta come azione \macro{SIG\_IGN} (o si +setta un \macro{SIG\_DFL} per un segnale il cui default è 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 manipolatore viene disinstallato alla sua chiamata, +secondo la semantica inaffidabile; Linux seguiva questa convenzione fino alle +\acr{libc5}. Al contrario BSD segue la semantica affidabile, non resettando il +manipolatore e bloccando il segnale durante l'esecuzione dello stesso. Con +l'utilizzo delle \acr{glibc2} anche Linux è passato a questo comportamento; +quello della versione originale della funzione, il cui uso è deprecato per i +motivi visti in \secref{sec:sig_semantics}, può essere ottenuto chiamando +\func{sysv\_signal}. In generale, per evitare questi problemi, tutti i nuovi +programmi dovrebbero usare \func{sigaction}. + +È da tenere presente che, seguendo lo standard POSIX, il comportamento di un +processo che ignora i segnali \macro{SIGFPE}, \macro{SIGILL}, o +\macro{SIGSEGV} (qualora non originino da una \func{kill} o una \func{raise}) +è indefinito. Un manipolatore che ritorna da questi segnali può dare luogo ad +un ciclo infinito. + + +\subsection{Le funzioni \func{kill} e \func{raise}} +\label{sec:sig_kill_raise} + +Come accennato in \secref{sec:sig_types}, un segnale può essere generato +direttamente da un processo. L'invio di un segnale generico può essere +effettuato attraverso delle funzioni \func{kill} e \func{raise}. La prima +serve per inviare un segnale al processo corrente, ed il suo prototipo è: +\begin{prototype}{signal.h}{int raise(int sig)} + Invia il segnale \param{sig} al processo corrente. + + \bodydesc{La funzione restituisce zero in caso di successo e -1 per un + errore, il solo errore restituito è \macro{EINVAL} qualora si sia + specificato un numero di segnale invalido.} +\end{prototype} + +Il valore di \param{sig} specifica il segnale che si vuole inviare e può +essere specificato con una delle macro definite in +\secref{sec:sig_classification}. In genere questa funzione viene usata per +riprodurre il comportamento di default di un segnale che sia stato +intercettato. In questo caso, una volta eseguite le operazioni volute, il +manipolatore potrà reinstallare l'azione di default, e attivarla con +\func{raise}. + +Se invece si vuole inviare un segnale ad un altro processo occorre utilizzare +la funzione \func{kill}; il cui prototipo è: +\begin{functions} + \headdecl{sys/types.h} + \headdecl{signal.h} + \funcdecl{int kill(pid\_t pid, int sig)} Invia il segnale \param{sig} al + processo specificato con \param{pid}. + + \bodydesc{ La funzione restituisce 0 in caso di successo e -1 in caso di + errore nel qual caso \var{errno} può assumere i valori: + \begin{errlist} + \item[\macro{EINVAL}] Il segnale specificato non esiste. + \item[\macro{ESRCH}] Il processo selezionato non esiste. + \item[\macro{EPERM}] Non si hanno privilegi sufficienti ad inviare il + segnale. + \end{errlist}} +\end{functions} + +Lo standard POSIX prevede che il valore 0 per \param{sig} sia usato per +specificare il segnale nullo. Se le funzioni vengono chiamate con questo +valore non viene inviato nessun segnale, ma viene eseguito il controllo degli +errori, in tal caso si otterrà un errore \macro{EPERM} se non si hanno i +permessi necessari ed un errore \macro{ESRCH} se il processo specificato non +esiste. Si tenga conto però che il sistema ricicla i \acr{pid} (come accennato +in \secref{sec:proc_pid}) per cui l'esistenza di un processo non significa che +esso sia realmente quello a cui si intendeva mandare il segnale. + +Il valore dell'argomento \param{pid} specifica il processo (o i processi) di +destinazione a cui il segnale deve essere inviato e può assumere i valori +riportati in \tabref{tab:sig_kill_values}. +\begin{table}[htb] + \footnotesize + \centering + \begin{tabular}[c]{|r|l|} + \hline + \textbf{Valore} & \textbf{Significato} \\ + \hline + \hline + $>0$ & il segnale è mandato al processo con il \acr{pid} indicato.\\ + 0 & il segnale è mandato ad ogni processo del \textit{process group} + del chiamante.\\ + $-1$ & il segnale è mandato ad ogni processo (eccetto \cmd{init}).\\ + $<-1$ & il segnale è mandato ad ogni processo del process group + $|\code{pid}|$.\\ + \hline + \end{tabular} + \caption{Valori dell'argomento \param{pid} per la funzione + \func{kill}.} + \label{tab:sig_kill_values} +\end{table} +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. + +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 +\textit{saved user id} della destinazione. Fa eccezione il caso in cui il +segnale inviato sia \macro{SIGCONT}, nel quale occorre che entrambi i processi +appartengano alla stessa sessione. Inoltre, dato il ruolo fondamentale che +riveste nel sistema (si ricordi quanto visto in \secref{sec:sig_termination}), +non è possibile inviare al processo 1 (cioè a \cmd{init}) segnali per i quali +esso non abbia un manipolatore 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 implementazione di +escludere alcuni processi specifici: nel caso in questione Linux non invia il +segnale al processo che ha effettuato la chiamata. + + +\subsection{Le funzioni \func{alarm} e \func{abort}} +\label{sec:sig_alarm_abort} + +Un caso particolare di segnali generati a richiesta è quello che riguarda i +vari segnali di temporizzazione e \macro{SIGABORT}, per ciascuno di questi +segnali sono previste funzioni specifiche che ne effettuino l'invio. La più +comune delle funzioni usate per la temporizzazione è \func{alarm} il cui +prototipo è: +\begin{prototype}{unistd.h}{unsigned int alarm(unsigned int seconds)} + Predispone l'invio di \macro{SIGALARM} dopo \param{seconds} secondi. + + \bodydesc{La funzione restituisce il numero di secondi rimanenti ad un + precedente allarme, o zero se non c'erano allarmi pendenti.} +\end{prototype} -\subsection{Funzioni rientranti e default dei segnali} -\label{sec:sig_reentrant} +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 \macro{SIGALARM}) dopo il numero di secondi specificato da +\param{seconds}. + +Se si specifica per \param{seconds} un valore nullo non verrà inviato nessun +segnale; siccome alla chiamata viene cancellato ogni precedente allarme, +questo può essere usato per cancellare una programmazione precedente. + +La funzione inoltre ritorna il numero di secondi rimanenti all'invio +dell'allarme precedentemente programmato, in modo che sia possibile +controllare se non si cancella un precedente allarme ed eventualmente +predisporre le opportune misure per gestire il caso di necessità di più +interruzioni. + +In \secref{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 \macro{SIGALARM}. +\item un \textit{virtual timer} che calcola il tempo di processore usato dal + processo in user space (che corrisponde all'\textit{user time}). La scadenza + di questo timer provoca l'emissione di \macro{SIGVTALRM}. +\item un \textit{profiling timer} che calcola la somma dei tempi di processore + utilizzati direttamente dal processo in user space, e dal kernel nelle + system call ad esso relative (che corrisponde a quello che in + \secref{sec:sys_unix_time} abbiamo chiamato \textit{CPU time}). La scadenza + di questo timer provoca l'emissione di \macro{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 \func{setitimer} +che permette di usare un timer qualunque e l'invio di segnali periodici, al +costo però di una maggiore complessità d'uso e di una minore portabilità. Il +suo prototipo è: +\begin{prototype}{sys/time.h}{int setitimer(int which, const struct + itimerval *value, struct itimerval *ovalue)} + + Predispone l'invio di un segnale di allarme alla scadenza dell'intervallo + \param{value} sul timer specificato da \func{which}. + + \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di + errore, nel qual caso \var{errno} può assumere i valori \macro{EINVAL} e + \macro{EFAULT}.} +\end{prototype} + +Il valore di \param{which} permette di specificare quale dei tre timer +illustrati in precedenza usare; i possibili valori sono riportati in +\tabref{tab:sig_setitimer_values}. +\begin{table}[htb] + \footnotesize + \centering + \begin{tabular}[c]{|l|l|} + \hline + \textbf{Valore} & \textbf{Timer} \\ + \hline + \hline + \macro{ITIMER\_REAL} & \textit{real-time timer}\\ + \macro{ITIMER\_VIRTUAL} & \textit{virtual timer}\\ + \macro{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 settare 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 \var{itimerval}, definita in \figref{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 \var{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 resetta \var{it\_value} al valore di \var{it\_interval}, in +questo modo il ciclo verrà ripetuto; se invece il valore di \var{it\_interval} +è nullo il timer si ferma. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +struct itimerval +{ + struct timeval it_interval; /* next value */ + struct timeval it_value; /* current value */ +}; + +struct timeval +{ + long tv_sec; /* seconds */ + long tv_usec; /* microseconds */ +}; + \end{lstlisting} + \end{minipage} + \normalsize + \caption{La struttura \var{itimerval}, che definisce i valori dei timer di + sistema.} + \label{fig:sig_itimerval} +\end{figure} + +L'uso di \func{setitimer} consente dunque un controllo completo di tutte le +caratteristiche dei timer, ed in effetti la stessa \func{alarm}, benché +definita direttamente nello standard POSIX.1, può a sua volta essere espressa +in termini di \func{setitimer}, come evidenziato dal manuale delle \acr{glibc} +\cite{glibc} che ne riporta la definizione mostrata in +\figref{fig:sig_alarm_def}. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +unsigned int alarm(unsigned int seconds) +{ + struct itimerval old, new; + new.it_interval.tv_usec = 0; + new.it_interval.tv_sec = 0; + new.it_value.tv_usec = 0; + new.it_value.tv_sec = (long int) seconds; + if (setitimer(ITIMER_REAL, &new, &old) < 0) { + return 0; + } + else { + return old.it_value.tv_sec; + } +} + \end{lstlisting} + \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 la precisione di queste funzioni è +limitata da quella della frequenza del timer di sistema (che nel caso dei PC +significa circa 10~ms). Il sistema assicura comunque che il segnale non sarà +mai generato prima della scadenza programmata (l'arrotondamento cioè è sempre +effettuato per eccesso). + +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 \macro{ITIMER\_VIRT}) la consegna è +immediata, altrimenti può esserci un ulteriore ritardo che può variare a +seconda del carico del sistema. + +Questo ha una conseguenza che può indurre ad errori molto subdoli, si tenga +conto poi che in caso di sistema molto carico, si può avere il caso patologico +in cui un timer scade prima che il segnale di una precedente scadenza sia +stato consegnato; in questo caso, per il comportamento dei segnali descritto +in \secref{sec:sig_sigchld}, un solo segnale sarà consegnato. + + +Dato che sia \func{alarm} che \func{setitimer} non consentono di leggere il +valore corrente di un timer senza modificarlo, è possibile usare la funzione +\func{getitimer}, il cui prototipo è: +\begin{prototype}{sys/time.h}{int getitimer(int which, struct + itimerval *value)} + + Legge in \param{value} il valore del timer specificato da \func{which}. + + \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di + errore e restituisce gli stessi errori di \func{getitimer}} +\end{prototype} +\noindent i cui parametri hanno lo stesso significato e formato di quelli di +\func{setitimer}. + + +L'ultima funzione che permette l'invio diretto di un segnale è \func{abort}; +che, come accennato in \ref{sec:proc_termination}, permette di abortire +l'esecuzione di un programma tramite l'invio di \macro{SIGABRT}. Il suo +prototipo è: +\begin{prototype}{stdlib.h}{void abort(void)} + + Abortisce il processo corrente. + + \bodydesc{La funzione non ritorna, il processo è terminato inviando il + segnale di \macro{SIGABRT}.} +\end{prototype} + +La differenza fra questa funzione e l'uso di \func{raise} è che anche se il +segnale è bloccato o ignorato, la funzione ha effetto lo stesso. Il segnale +può però essere intercettato per effettuare eventuali operazioni di chiusura +prima della terminazione del processo. + +Lo standard ANSI C richiede inoltre che anche se il manipolatore ritorna, la +funzione non ritorni comunque. Lo standard POSIX.1 va oltre e richiede che se +il processo non viene terminato direttamente dal manipolatore 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{at\_exit} e \func{on\_exit}. + + +\subsection{Le funzioni \func{pause} e \func{sleep}} +\label{sec:sig_pause_sleep} + +Il metodo tradizionale per fare attendere\footnote{cioè di porre + temporanemente il processo in stato di \textit{sleep}, vedi + \ref{sec:proc_sched}.} ad un processo fino all'arrivo di un segnale è +quello di usare la funzione \func{pause}, il cui prototipo è: +\begin{prototype}{unistd.h}{int pause(void)} + + Pone il processo in stato di sleep fino al ritorno di un manipolatore. + + \bodydesc{La funzione ritorna solo dopo che un segnale è stato ricevuto ed + il relativo manipolatore è ritornato, nel qual caso restituisce -1 e setta + \var{errno} a \macro{EINTR}.} +\end{prototype} +La funzione segnala sempre una condizione di errore (il successo sarebbe +quello di aspettare indefinitamente). In genere si usa questa funzione quando +si vuole mettere un processo in attesa di un qualche evento specifico che non +è sotto il suo diretto controllo (ad esempio la si può usare per far reagire +il processo ad un segnale inviato da un altro processo). +Se invece si vuole fare attendere un processo per un determinato intervallo di +tempo nello standard POSIX.1 viene definita la funzione \func{sleep}, il cui +prototipo è: +\begin{prototype}{unistd.h}{unsigned int sleep(unsigned int seconds)} + + Pone il processo in stato di sleep per \param{seconds} secondi. + + \bodydesc{La funzione restituisce zero se l'attesa viene completata, o il + numero di secondi restanti se viene interrotta da un segnale.} +\end{prototype} +La funzione attende per il tempo specificato, a meno di non essere interrotta +da un segnale. In questo caso non è una buona idea ripetere la chiamata per il +tempo rimanente, in quanto la riattivazione del processo può avvenire in un +qualunque momento, ma il valore restituito sarà sempre arrotondato al secondo, +con la conseguenza che, se la successione dei segnali è particolarmente +sfortunata e le differenze si accumulano, si potranno avere ritardi anche di +parecchi secondi. In genere la scelta più sicura è quella di stabilire un +termine per l'attesa, e ricalcolare tutte le volte il numero di secondi da +aspettare. + +In alcune implementazioni inoltre l'uso di \func{sleep} può avere conflitti +con quello di \macro{SIGALRM}, dato che la funzione può essere realizzata con +l'uso di \func{pause} e \func{alarm} (in maniera analoga all'esempio che +vedremo in \secref{sec:sig_example}). In tal caso mescolare chiamata di +\func{alarm} e \func{sleep} o modificare l'azione di \macro{SIGALRM}, può +causare risultati indefiniti. Nel caso delle \acr{glibc} è stata usata una +implementazione completamente indipendente e questi problemi non ci sono. + +La granularità di \func{sleep} permette di specificare attese in secondi, per +questo sia sotto BSD4.3 che in SUSv2 è stata definita la funzione +\func{usleep} (dove la \texttt{u} è intesa come sostituzione di $\mu$); i due +standard hanno delle definizioni diverse, ma le \acr{glibc} +seguono\footnote{secondo la man page almeno dalla versione 2.2.2.} seguono +quella di SUSv2 che prevede il seguente prototipo: +\begin{prototype}{unistd.h}{int usleep(unsigned long usec)} + + Pone il processo in stato di sleep per \param{usec} microsecondi. + + \bodydesc{La funzione restituisce zero se l'attesa viene completata, o -1 in + caso di errore, nel qual caso \var{errno} è settata a \macro{EINTR}.} + +\end{prototype} + +Anche questa funzione, a seconda delle implementazioni, può presentare +problemi nell'interazione con \func{alarm} e \macro{SIGALRM}. È pertanto +deprecata in favore della funzione \func{nanosleep}, definita dallo standard +POSIX1.b, il cui prototipo è: +\begin{prototype}{unistd.h}{int nanosleep(const struct timespec *req, struct + timespec *rem)} + + Pone il processo in stato di sleep per il tempo specificato da \param{req}. + In caso di interruzione restituisce il tempo restante in \param{rem}. + + \bodydesc{La funzione restituisce zero se l'attesa viene completata, o -1 in + caso di errore, nel qual caso \var{errno} è settata a + \begin{errlist} + \item[\macro{EINVAL}] si è specificato un numero di secondi negativo o un + numero di nanosecondi maggiore di 999.999.999. + \item[\macro{EINTR}] la funzione è stata interrotta da un segnale. + \end{errlist}} +\end{prototype} + +Lo standard richiede che la funzione sia implementata in maniera del tutto +indipendente da \func{alarm}\footnote{nel caso di Linux questo è fatto + utilizzando direttamente il timer del kernel.} e sia utilizzabile senza +interferenze con l'uso di \macro{SIGALRM}. La funzione prende come parametri +delle strutture di tipo \var{timespec}, la cui definizione è riportata in +\figref{fig:sig_timespec_def}, che permettono 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, e +basta richiamare la funzione per completare l'attesa. + +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 il successivo giro di scheduler e cioè un tempo che +a seconda dei casi può arrivare fino a 1/\macro{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/\macro{HZ}. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +struct timespec { + time_t tv_sec; /* seconds */ + long tv_nsec; /* nanoseconds */ +}; + \end{lstlisting} + \end{minipage} + \normalsize + \caption{La struttura \var{timespec} di \func{nanosleep}.} + \label{fig:sig_timespec_def} +\end{figure} + +In realtà è possibile ottenere anche pause più precise del centesimo di +secondo usando politiche di scheduling real time come \macro{SCHED\_FIFO} o +\macro{SCHED\_RR}; in tal caso infatti il meccanismo di scheduling ordinario +viene evitato, e si raggiungono pause fino ai 2~ms con precisioni del $\mu$s. + + + +\subsection{Un esempio elementare} +\label{sec:sig_sigchld} + +Un semplice esempio per illustrare il funzionamento di un manipolatore di +segnale è quello della gestione di \macro{SIGCHLD}. Abbiamo visto in +\secref{sec:proc_termination} che una delle azioni eseguite dal kernel alla +conclusione di un processo è quella di inviare questo segnale al +padre.\footnote{in realtà in SRV4 eredita la semantica di System V, in cui il + segnale si chiama \macro{SIGCLD} e viene trattato in maniera speciale; in + System V infatti se si setta esplicitamente l'azione a \macro{SIG\_IGN} il + segnale non viene generato ed il sistema non genera zombie (lo stato di + terminazione viene scartato senza dover chiamare una \func{wait}). L'azione + di default è sempre quella di ignorare il segnale, ma non attiva questo + comportamento. Linux, come BSD e POSIX, non supporta questa semantica ed usa + il nome di \macro{SIGCLD} come sinonimo di \macro{SIGCHLD}.} In generale +dunque, quando non interessa elaborare lo stato di uscita di un processo, si +può completare la gestione della terminazione installando un manipolatore per +\macro{SIGCHLD} il cui unico compito sia quello chiamare \func{waitpid} per +completare la procedura di terminazione in modo da evitare la formazione di +zombie. + +In \figref{fig:sig_sigchld_handl} è mostrato il codice della nostra +implementazione del manipolatore; se aggiungiamo al codice di +\file{ForkTest.c} l'intallazione di questo manipolatore potremo verificare che +ripetendo l'esempio visto in \secref{sec:proc_termination} che non si ha più +la creazione di zombie. + +% è pertanto +% naturale usare un esempio che ci permette di concludere la trattazione della +% terminazione dei processi. +% In questo caso si è tratterà di illustrare un esempio relativo ad un +% manipolatore per che è previsto ritornare, + + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}{} +#include /* error simbol definitions */ +#include /* signal handling declarations */ +#include +#include +#include "macro.h" + +void Hand_CHLD(int sig) +{ + int errno_save; + int status; + pid_t pid; + /* save errno current value */ + errno_save = errno; + /* loop until no */ + do { + errno = 0; + pid = waitpid(WAIT_ANY, &status, WNOHANG); + if (pid > 0) { + debug("child %d terminated with status %x\n", pid, status); + } + } while ((pid > 0) && (errno == EINTR)); + /* restore errno value */ + errno = errno_save; + /* return */ + return; +} + \end{lstlisting} + \end{minipage} + \normalsize + \caption{Un manipolatore per il segnale \texttt{SIGCHLD}.} + \label{fig:sig_sigchld_handl} +\end{figure} + +Il codice del manipolatore è di lettura immediata; come buona norma di +programmazione (si ricordi quanto accennato \secref{sec:sys_errno}) si +comincia (\texttt{\small 12-13}) con il salvare lo stato corrente di +\var{errno}, in modo da poterlo ripristinare prima del ritorno del +manipolatore (\texttt{\small 22-23}). In questo modo si preserva il valore +della variabile visto dal corso di esecuzione principale del processo, che +sarebbe altrimenti sarebbe sovrascritto dal valore restituito nella successiva +chiamata di \func{wait}. + +Il compito principale del manipolatore è quello di ricevere lo stato di +terminazione del processo, cosa che viene eseguita nel ciclo in +(\texttt{\small 15-21}). 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 manipolatore possa passare un +certo lasso di tempo e niente ci assicura che il manipolatore venga eseguito +prima della generazione di ulteriori segnali dello stesso tipo. In questo caso +normalmente i segnali segnali successivi vengono ``fusi'' col primo ed al +processo ne viene recapitato soltanto uno. + +Questo può essere un caso comune proprio con \macro{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 sarà 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 teminazione 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. + +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 \secref{sec:proc_wait} per +la sintassi della funzione). Si noti anche come la funzione venga invocata con +il parametro \macro{WNOHANG} che permette di evitare il suo blocco quando +tutti gli stati di terminazione sono stati ricevuti. + + + +\section{Gestione avanzata} +\label{sec:sig_control} + +Le funzioni esaminate finora fanno riferimento ad alle modalità più elementari +della gestione dei segnali; non si sono pertanto ancora prese in +considerazione le tematiche più complesse, collegate alle varie 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 \secref{sec:sig_pause_sleep} è possibile implementare +\func{sleep} a partire da 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 +\figref{fig:sig_sleep_wrong}. + + +Dato che è nostra intenzione utilizzare \macro{SIGALARM} 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 +l'interruzione di \func{pause} venisse causata da un altro segnale. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}{} +unsigned int sleep(unsigned int seconds) +{ + signandler_t prev_handler; + if ((prev_handler = signal(SIGALRM, alarm_hand)) == SIG_ERR) { + printf("Cannot set handler for alarm\n"); + exit(1); + } + alarm(second); + pause(); + /* restore previous signal handler */ + signal(SIGALRM, prev_handler); + /* remove alarm, return remaining time */ + 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 + \caption{Una implementazione pericolosa di \func{sleep}.} + \label{fig:sig_sleep_wrong} +\end{figure} + +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 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 quest'ultima, cosicchè essa sarebbe eseguita dopo l'arrivo di +\macro{SIGALRM}. In questo caso ci si troverebbe di fronte ad un 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{longjump} (vedi \secref{sec:proc_longjmp}) per +uscire dal manipolatore; 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 \figref{fig:sig_sleep_incomplete}. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}{} +static jmp_buff alarm_return; +unsigned int sleep(unsigned int seconds) +{ + signandler_t prev_handler; + if ((prev_handler = signal(SIGALRM, alarm_hand)) == SIG_ERR) { + printf("Cannot set handler for alarm\n"); + exit(1); + } + if (setjmp(alarm_return) == 0) { /* if not returning from handler */ + alarm(second); /* call alarm */ + pause(); /* then wait */ + } + /* restore previous signal handler */ + signal(SIGALRM, prev_handler); + /* remove alarm, return remaining time */ + 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 { /* return in main after the call to pause */ + longjump(alarm_return, 1); + } +} + \end{lstlisting} + \end{minipage} + \normalsize + \caption{Una implementazione ancora malfunzionante di \func{sleep}.} + \label{fig:sig_sleep_incomplete} +\end{figure} + +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 +(\texttt{\small 9-12}) si evita comunque che \func{pause} sia chiamata a +vuoto. + +Ma anche questa implementazione comporta dei problemi; in questo caso infatti +non viene gestita correttamente l'interazione con gli altri segnali; se +infatti il segnale di allarme interrompe un altro manipolatore, in questo caso +l'esecuzione non riprenderà nel manipolatore in questione, ma nel ciclo +principale, interrompendone inopportunamente l'esecuzione. Lo stesso tipo di +problemi si presenterebbero se si volesse usare \func{alarm} per stabilire un +timeout su una qualunque system call bloccante. + +Un secondo esempio è quello in cui si usa il segnale per notificare una +quelche 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}. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}{} +sig_atomic_t flag; +int main() +{ + flag = 0; + ... + if (flag) { /* test if signal occurred */ + flag = 0; /* reset flag */ + do_response(); /* do things */ + } else { + do_other(); /* do other things */ + } + ... +} +void alarm_hand(int sig) +{ + /* set the flag + flag = 1; + return; +} + \end{lstlisting} + \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} + +La logica è quella di far settare al manipolatore (\texttt{\small 14-19}) una +variabile globale preventivamente inizializzata nel programma principale, il +quale potrà determinare, osservandone il contenuto, l'occorrenza o meno del +segnale, e prendere le relative azioni conseguenti (\texttt{\small 6-11}). + +Questo è il tipico esempio di caso, già citato in \secref{sec:proc_race_cond}, +in cui si genera una race condition; se infatti il segnale arriva +immediatamente dopo l'esecuzione del controllo (\texttt{\small 6}) ma prima +della cancellazione del flag (\texttt{\small 7}), la sua occorrenza sarà +perduta. + +Questi esempi ci mostrano che per una gestione effettiva dei segnali occorrono +funzioni più sofisticate della semplice interfaccia dei primi sistemi Unix, +che permettano di gestire tutti i possibili aspetti con cui un processo deve +reagire alla ricezione di un segnale. + + + +\subsection{I \textit{signal set}} +\label{sec:sig_sigset} + +Come evidenziato nel paragrafo precedente, le funzioni di gestione dei segnali +dei primi Unix, nate con la semantica inaffidabile, hanno dei limiti non +superabili; in particolare non è prevista nessuna funzione che permetta di +gestire 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 ottenete un controllo molto più dettagliato. In particolare lo +standard ha introdotto un nuovo tipo di dato \type{sigset\_t}, che permette di +rappresentare un insieme di segnali (un \textit{signal set}, come viene +usualmente chiamato), che è il tipo di dato che viene usato per gestire il +blocco dei segnali. + +In genere un \textit{signal set} è rappresentato da un intero di dimensione +opportuna, di solito si pari al numero di bit dell'architettura della +macchina\footnote{nel caso dei PC questo comporta un massimo di 32 segnali + distinti, dato che in Linux questi sono sufficienti non c'è necessità di + nessuna struttura più complicata.}, ciascun bit del quale è associato ad uno +specifico segnale; in questo modo è di solito possibile implementare le +operazioni direttamente con istruzioni elementari del processore; lo standard +POSIX.1 definisce cinque funzioni per la manipolazione dei \textit{signal set}, +\func{sigemptyset}, \func{sigfillset}, \func{sigaddset}, \func{sigdelset} e +\func{sigismember}, i cui prototipi sono: +\begin{functions} + \headdecl{signal.h} + + \funcdecl{int sigemptyset(sigset\_t *set)} Inizializza un \textit{signal set} + vuoto. + + \funcdecl{int sigfillset(sigset\_t *set)} Inizializza un \textit{signal set} + pieno (con tutti i segnali). + + \funcdecl{int sigaddset(sigset\_t *set, int signum)} Aggiunge il segnale + \param{signum} al \textit{signal set} \param{set}. -\subsection{La funzione \func{sigpending}} + \funcdecl{int sigdelset(sigset\_t *set, int signum)} Toglie il segnale + \param{signum} dal \textit{signal set} \param{set}. + + \funcdecl{int sigismember(const sigset\_t *set, int signum)} Controlla se il + segnale \param{signum} è nel \textit{signal set} \param{set} + + \bodydesc{Le prime quattro funzioni ritornano 0 in caso di successo, mentre + \func{sigismember} ritorna 1 se \param{signum} è in \param{set} e 0 + altrimenti. In caso di errore tutte ritornano -1, con \var{errno} settata a + \macro{EINVAL} (il solo errore possibile è che \param{signum} non sia un + segnale valido).} +\end{functions} + +Dato che in generale non si può fare conto sulle caratteristiche di una +implementazione (non è detto che si disponga di un numero di bit sufficienti +per mettere tutti i segnali in un intero, o in \type{sigset\_t} possono essere +immagazzinate ulteriori informazioni) tutte le operazioni devono essere +comunque eseguite attraverso queste funzioni. + +In genere si usa un \textit{signal set} per specificare quali segnali si vuole +bloccare, o per riottenere dalle varie funzioni di gestione la maschera dei +segnali attivi. Essi possono essere definiti in due diverse maniere, +aggiungendo i segnali voluti ad un insieme vuoto ottenuto con +\func{sigemptyset} o togliendo quelli che non servono da un insieme completo +ottenuto con \func{sigfillset}. Infine \func{sigismember} permette di vericare +la presenza di uno specifico segnale in un \textit{signal set}. + + +\subsection{La funzione \func{sigaction}} +\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 +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}. + + \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[\macro{EINVAL}] Si è specificato un numero di segnale invalido o si è + cercato di installare il manipolatore per \macro{SIGKILL} o + \macro{SIGSTOP}. + \item[\macro{EFAULT}] Si sono specificati indirizzi non validi. + \end{errlist}} +\end{prototype} + +La funzione serve ad installare una nuova \textsl{azione} per il segnale +\param{signum}; si parla di \textsl{azione} e non di \textsl{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. + +Se il puntatore \param{act} non è nullo, la funzione installa la nuova azione +da esso specificata, se \param{oldact} non è nullo il valore dell'azione +corrente viene restituito indietro. Questo permette (specificando \param{act} +nullo e \param{oldact} non nullo) di superare uno dei limiti di \func{signal}, +che non consente di ottenere l'azione corrente senza installarne una nuova. + +Entrambi i puntatori fanno riferimento alla struttura \var{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 \figref{fig:sig_sigaction}. Il campo +\var{sa\_restorer}, non previsto dallo standard, è obsoleto e non deve essere +più usato. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +struct sigaction +{ + void (*sa_handler)(int); + void (*sa_sigaction)(int, siginfo_t *, void *); + sigset_t sa_mask; + int sa_flags; + void (*sa_restorer)(void); +} + \end{lstlisting} + \end{minipage} + \normalsize + \caption{La struttura \var{sigaction}.} + \label{fig:sig_sigaction} +\end{figure} + +Come si può notare da quanto riportato in \figref{fig:sig_sigaction} in Linux +\func{sigaction} permette di specificare il manipolatore in due forme diverse, +indicate dai campi \var{sa\_handler} e \var{sa\_sigaction}; esse devono essere +usate in maniera alternativa (in certe implementazioni questi vengono +specificati come \ctyp{union}): la prima è quella classica usata anche con +\func{signal}, la seconda permette invece di usare un manipolatore in grado di +ricevere informazioni più dettagliate dal sistema (ad esempio il tipo di +errore in caso di \macro{SIGFPE}), attraverso dei parametri aggiuntivi; per i +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 +sia specificato con \var{sa\_flag} un comportamento diverso. + +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 +\tabref{tab:sig_sa_flag}. + +\begin{table}[htb] + \footnotesize + \centering + \begin{tabular}[c]{|l|p{8cm}|} + \hline + \textbf{Valore} & \textbf{Significato} \\ + \hline + \hline + \macro{SA\_NOCLDSTOP}& Se il segnale è \macro{SIGCHLD} allora non deve + essere notificato quando il processo figlio viene fermato da uno dei + segnali \macro{SIGSTOP}, \macro{SIGTSTP}, \macro{SIGTTIN} or + \macro{SIGTTOU}.\\ + \macro{SA\_ONESHOT} & Ristabilisce l'azione per il segnale al valore di + default una volta che il manipolatore è stato lanciato, riproduce cioè il + comportamento della semantica inaffidabile.\\ + \macro{SA\_RESETHAND}& Sinonimo di \macro{SA\_ONESHOT}. \\ + \macro{SA\_RESTART} & Riavvia automaticamente le \textit{slow system + call} quando vengono interrotte dal suddetto segnale; riproduce cioè il + comportamento standard di BSD.\\ + \macro{SA\_NOMASK} & Evita che il segnale corrente sia bloccato durante + l'esecuzione del manipolatore.\\ + \macro{SA\_NODEFER} & Sinonimo di \macro{SA\_NOMASK}.\\ + \macro{SA\_SIGINFO} & Deve essere specificato quando si vuole usare un + manipolatore in forma estesa usando \var{sa\_sigaction} al posto di + \var{sa\_handler}. \\ + \macro{SA\_ONSTACK} & Stabilisce l'uso di uno stack alternativo per + l'esecuzione del manipolatore (vedi \secref{sec:sig_altstack}).\\ + \hline + \end{tabular} + \caption{Valori del campo \var{sa\_flag} della struttura \var{sigaction}.} + \label{tab:sig_sa_flag} +\end{table} + +Benché sia possibile usare nello stesso programma sia \func{sigaction} che +\func{signal} occorre molta attenzione, in quanto le due funzioni possono +interagire in maniera anomala. Infatti l'azione specificata con +\var{sigaction} contiene un maggior numero di informazioni rispetto al +semplice indirizzo del manipolatore restituito da \func{signal}. Per questo +motivo se si usa quest'ultima per installare un manipolatore sostituendone uno +precedentemente installato con \func{sigaction}, non sarà possibile effettuare +un ripristino corretto dello stesso. + +Per questo è sempre opportuno usare \func{sigaction}, che è in grado di +ripristinare correttamente un manipolatore precedente, anche se questo è stato +installato con \func{signal}. In generale poi non è il caso di usare il valore +di ritorno di \func{signal} come campo \var{sa\_handler}, o viceversa, dato +che in certi sistemi questi possono essere diversi. In generale dunque, a meno +che non si sia vincolati allo standard ISO C, è sempre il caso di evitare +l'uso di \func{signal} a favore di \func{sigaction}. + + + +\subsection{La gestione del blocco dei segnali} +\label{sec:sig_sigmask} + +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 cosiddetta \textit{signal mask} del +processo\footnote{nel caso di Linux essa è mantenuta dal campo \var{blocked} + della \var{task\_struct} del processo.} che viene espressa come il signal +set 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 specificata, durante l'esecuzione di un manipolatore, +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 la +sezione fra il test e la eventuale cancellazione del flag che testimoniava +l'avvenuta occorrenza del segnale) in modo da essere sicuri che essi siano +eseguiti senza interruzioni. Le operazioni più semplici, come l'assegnazione o +il controllo di una variabile (per essere sicuri si può usare il tipo +\type{sig\_atomic\_t}) di norma sono atomiche, ma quando le operazioni sono +più complesse si può usare la funzione \func{sigprocmask} per bloccare uno o +più segnali; il suo prototipo è: +\begin{prototype}{signal.h} +{int sigprocmask(int how, const sigset\_t *set, sigset\_t *oldset)} + + Cambia la \textit{signal mask} del processo corrente. + + \bodydesc{La funzione restituisce zero in caso di successo e -1 per un + errore, nel qual caso \var{errno} assumerà i valori: + \begin{errlist} + \item[\macro{EINVAL}] Si è specificato un numero di segnale invalido. + \item[\macro{EFAULT}] Si sono specificati indirizzi non validi. + \end{errlist}} +\end{prototype} + +La funzione + + +\begin{table}[htb] + \footnotesize + \centering + \begin{tabular}[c]{|l|p{8cm}|} + \hline + \textbf{Valore} & \textbf{Significato} \\ + \hline + \hline + \macro{SIG\_BLOCK} & .\\ + \macro{SIG\_UNBLOCK} & .\\ + \macro{SIG\_SETMASK} & .\\ + \hline + \end{tabular} + \caption{Valori e significato dell'argomento \param{how} della funzione + \func{sigprocmask}.} + \label{tab:sig_procmask_how} +\end{table} + + +Un altro +\begin{prototype}{signal.h} +{int sigsuspend(const sigset\_t *mask)} + + Cambia la \textit{signal mask} del processo corrente. + + \bodydesc{La funzione restituisce zero in caso di successo e -1 per un + errore, nel qual caso \var{errno} assumerà i valori: + \begin{errlist} + \item[\macro{EINVAL}] Si è specificato un numero di segnale invalido. + \item[\macro{EFAULT}] Si sono specificati indirizzi non validi. + \end{errlist}} +\end{prototype} + + + +\subsection{Le funzioni \func{sigpending} e \func{sigsuspend}} \label{sec:sig_sigpending} + + + +\subsection{Funzioni rientranti e default dei segnali} +\label{sec:sig_reentrant} + + + + + %%% Local Variables: %%% mode: latex %%% TeX-master: "gapil"