X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=signal.tex;h=59d28704a94022447e8e29eb4cbcfaba85122781;hp=31f4ee834aecd58194165c93c4f9e630988d389a;hb=06a411c6242a35082817a74e9a86ec226d8bf0e3;hpb=ca90fc9480e327dbf716d34888b7e21f213e921c diff --git a/signal.tex b/signal.tex index 31f4ee8..59d2870 100644 --- a/signal.tex +++ b/signal.tex @@ -2,9 +2,9 @@ \label{cha:signals} I segnali sono il primo e più semplice meccanismo di comunicazione nei -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. +confronti dei processi. Nella loro versione originale essi portano con sé +nessuna informazione che non sia il loro tipo; si tratta in sostanza di +un'interruzione software portata ad un processo. In genere essi vengono usati dal kernel per riportare ai processi situazioni eccezionali (come errori di accesso, eccezioni aritmetiche, etc.) ma possono @@ -16,7 +16,8 @@ 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 generazione fino ad esaminare in dettaglio funzioni e le metodologie di -gestione. +gestione avanzate e le estensioni fatte all'interfaccia classica nelle nuovi +versioni dello standard POSIX. \section{Introduzione} @@ -120,8 +121,8 @@ int sig_handler() Questa è la ragione per cui l'implementazione dei segnali secondo questa 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}). +atomiche, e sono sempre possibili delle race condition\index{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 @@ -242,7 +243,8 @@ Un programma pu \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). +venga automaticamente bloccato (così si possono evitare race +condition\index{race condition}). Nel caso non sia stata specificata un'azione, viene utilizzata l'azione standard che (come vedremo in \secref{sec:sig_standard}) è propria di ciascun @@ -411,9 +413,9 @@ tipologia, verr \label{sec:sig_prog_error} Questi segnali sono generati quando il sistema, o in certi casi direttamente -l'hardware (come per i page fault non validi) rileva un qualche errore -insanabile nel programma in esecuzione. In generale la generazione di questi -segnali significa che il programma ha dei gravi problemi (ad esempio ha +l'hardware (come per i \textit{page fault} non validi) rileva un qualche +errore insanabile nel programma in esecuzione. In generale la generazione di +questi segnali significa che il programma ha dei gravi problemi (ad esempio ha dereferenziato un puntatore non valido o ha eseguito una operazione aritmetica proibita) e l'esecuzione non può essere proseguita. @@ -662,11 +664,11 @@ segnali sono: situazione precedente. \item[\macro{SIGXCPU}] Sta per \textit{CPU time limit exceeded}. Questo segnale è generato quando un processo eccede il limite impostato per il - tempo di CPU disponibile, vedi \secref{sec:sys_xxx}. + tempo di CPU disponibile, vedi \secref{sec:sys_resource_limit}. \item[\macro{SIGXFSZ}] Sta per \textit{File size limit exceeded}. Questo segnale è generato quando un processo tenta di estendere un file oltre le dimensioni specificate dal limite impostato per le dimensioni massime di un - file, vedi \secref{sec:sys_xxx}. + file, vedi \secref{sec:sys_resource_limit}. \end{basedescript} @@ -714,7 +716,7 @@ di \func{strsignal}. Nel caso si debba mantenere traccia del messaggio sar necessario copiarlo. La seconda funzione deriva da BSD ed è analoga alla funzione \func{perror} -descritta in \secref{sec:sys_strerror}; il suo prototipo è: +descritta sempre in \secref{sec:sys_strerror}; il suo prototipo è: \begin{prototype}{signal.h}{void psignal(int sig, const char *s)} Stampa sullo standard error un messaggio costituito dalla stringa \param{s}, seguita da due punti ed una descrizione del segnale indicato da \param{sig}. @@ -750,7 +752,7 @@ processo alla loro occorrenza. \subsection{Il comportamento generale del sistema.} - \label{sec:sig_gen_beha} +\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 @@ -778,28 +780,29 @@ manipolatore; viene mantenuto invece ogni eventuale settaggio dell'azione a 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: +Per quanto riguarda il comportamento di tutte le altre system call si danno +sostanzialmente due casi, a seconda che esse siano \textsl{lente} +(\textit{slow}) o \textsl{veloci} (\textit{fast}). La gran parte di esse +appartiene a quest'ultima categoria, che non è influenzata dall'arrivo di un +segnale. Esse sono dette \textsl{veloci} in quanto la loro esecuzione è +sostanzialmente immediata; la risposta al segnale viene sempre data dopo che +la system call è stata completata, in quanto attendere per eseguire un +manipolatore non comporta nessun inconveniente. + +In alcuni casi però alcune system call (che per questo motivo vengono chiamate +\textsl{lente}) possono bloccarsi indefinitamente. In questo caso non si può +attendere la conclusione della sistem call, perché questo renderebbe +impossibile una risposta pronta al segnale, per cui il manipolatore viene +eseguito prima che la system call sia ritornata. 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 +\item la lettura da file che possono bloccarsi in attesa di dati non ancora + presenti (come per certi file di dispositivo, i socket o le pipe). +\item la 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 +\item l'apertura di un file di dispositivo che richiede operazioni non + immediate per una una risposta. +\item le 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. @@ -1120,7 +1123,7 @@ illustrati in precedenza usare; i possibili valori sono riportati in 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}. +struttura \type{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 @@ -1141,16 +1144,10 @@ 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 + \caption{La struttura \type{itimerval}, che definisce i valori dei timer di sistema.} \label{fig:sig_itimerval} \end{figure} @@ -1336,9 +1333,9 @@ 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. +delle strutture di tipo \var{timespec}, la cui definizione è riportata in +\figref{fig:sys_timeval_struct}, 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 @@ -1355,21 +1352,6 @@ 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 @@ -1421,7 +1403,7 @@ la creazione di zombie. #include #include "macro.h" -void Hand_CHLD(int sig) +void sigchld_hand(int sig) { int errno_save; int status; @@ -1492,8 +1474,9 @@ tutti gli stati di terminazione sono stati ricevuti. 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. +considerazione le tematiche più complesse, collegate alle varie race +condition\index{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 @@ -1560,13 +1543,13 @@ unsigned int sleep(unsigned int seconds) 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). +presenta una pericolosa race condition\index{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{longjmp} (vedi \secref{sec:proc_longjmp}) per @@ -1670,10 +1653,10 @@ quale potr 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. +in cui si genera una race condition\index{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 di quelle illustrate finora, che hanno origine dalla @@ -1815,32 +1798,24 @@ struct 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. +sia specificato con \var{sa\_flag} un comportamento diverso. Quando il +manipolatore ritorna comunque la maschera dei segnali bloccati (vedi +\secref{sec:sig_sigmask}) viene ripristinata al valore precedente +l'invocazione. L'uso di questo campo permette ad esempio di risolvere il problema residuo dell'implementazione di \code{sleep} mostrata in -\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 -segnali; i valori possibili ed il relativo significato sono riportati in -\tabref{tab:sig_sa_flag}. +\secref{fig:sig_sleep_incomplete}. In quel caso infatti se il segnale di +allarme avesse interrotto un altro manipolatore questo non sarebbe stato +eseguito correttamente; la cosa poteva essere prevenuta installando gli altri +manipolatori usando \var{sa\_mask} per bloccare \macro{SIGALRM} durante la +loro esecuzione. Il valore di \var{sa\_flag} permette di specificare vari +aspetti del comportamento di \func{sigaction}, e della reazione del processo +ai vari segnali; i valori possibili ed il relativo significato sono riportati +in \tabref{tab:sig_sa_flag}. \begin{table}[htb] \footnotesize @@ -1872,13 +1847,88 @@ segnali; i valori possibili ed il relativo significato sono riportati in \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_xxx}).\\ + \secref{sec:sig_specific_features}).\\ \hline \end{tabular} \caption{Valori del campo \var{sa\_flag} della struttura \var{sigaction}.} \label{tab:sig_sa_flag} \end{table} +Come si può notare in \figref{fig:sig_sigaction} \func{sigaction} +permette\footnote{La possibilità è prevista dallo standard POSIX.1b, ed è + stata aggiunta nei kernel della serie 2.1.x con l'introduzione dei segnali + real-time (vedi \secref{sec:sig_real_time}). In precedenza era possibile + ottenere alcune informazioni addizionali usando \var{sa\_handler} con un + secondo parametro addizionale di tipo \var{struct sigcontext}, che adesso è + deprecato.} di utilizzare due forme diverse di manipolatore, da +specificare, a seconda dell'uso o meno del flag \macro{SA\_SIGINFO}, +rispettivamente attraverso i campi \var{sa\_sigaction} o \var{sa\_handler}, +(che devono essere usati in maniera alternativa, in certe implementazioni +questi vengono addirittura definiti 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, +attraverso la struttura \type{siginfo\_t}, riportata in +\figref{fig:sig_siginfo_t}. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +siginfo_t { + int si_signo; /* Signal number */ + int si_errno; /* An errno value */ + int si_code; /* Signal code */ + pid_t si_pid; /* Sending process ID */ + uid_t si_uid; /* Real user ID of sending process */ + int si_status; /* Exit value or signal */ + clock_t si_utime; /* User time consumed */ + clock_t si_stime; /* System time consumed */ + sigval_t si_value; /* Signal value */ + int si_int; /* POSIX.1b signal */ + void * si_ptr; /* POSIX.1b signal */ + void * si_addr; /* Memory location which caused fault */ + int si_band; /* Band event */ + int si_fd; /* File descriptor */ +} + \end{lstlisting} + \end{minipage} + \normalsize + \caption{La struttura \type{siginfo\_t}.} + \label{fig:sig_siginfo_t} +\end{figure} + +Installando un manipolatore di tipo \var{sa\_sigaction} diventa allora +possibile accedere alle informazioni restituite attraverso il puntatore a +questa struttura. Tutti i segnali settano i campi \var{si\_signo}, che riporta +il numero del segnale ricevuto, \var{si\_errno}, che riporta, quando diverso +da zero, il codice dell'errore associato al segnale, e \var{si\_code}, che +viene usato dal kernel per specificare maggiori dettagli riguardo l'evento che +ha causato l'emissione del segnale. + +In generale \var{si\_code} contiene, per i segnali generici, per quelli +real-time e per tutti quelli inviati tramite \func{kill}, informazioni circa +l'origine del segnale (se generato dal kernel, da un timer, da \func{kill}, +ecc.). Alcuni segnali però usano \var{si\_code} per fornire una informazione +specifica: ad esempio i vari segnali di errore (\macro{SIGFPE}, +\macro{SIGILL}, \macro{SIGBUS} e \macro{SIGSEGV}) lo usano per fornire +maggiori dettagli riguardo l'errore (come il tipo di errore aritmetico, di +istruzione illecita o di violazione di memoria) mentre alcuni segnali di +controllo (\macro{SIGCHLD}, \macro{SIGTRAP} e \macro{SIGPOLL}) forniscono +altre informazioni speecifiche. In tutti i casi il valore del campo è +riportato attraverso delle costanti (le cui definizioni si trovano +\file{bits/siginfo.h}) il cui elenco dettagliato è disponibile nella man page +di \func{sigaction}. + +Il resto della struttura è definito come \ctyp{union} ed i valori +eventualmente presenti dipendono dal segnale, così \macro{SIGCHLD} ed i +segnali real-time (vedi \secref{sec:sig_real_time}) inviati tramite +\func{kill} avvalorano \var{si\_pid} e \var{si\_uid} coi valori corrispondenti +al processo che ha emesso il segnale, \macro{SIGILL}, \macro{SIGFPE}, +\macro{SIGSEGV} e \macro{SIGBUS} avvalorano \var{si\_addr} con l'indirizzo cui +è avvenuto l'errore, \macro{SIGIO} (vedi \secref{sec:file_asyncronous_io}) +avvalora \var{si\_fd} con il numero del file descriptor e \var{si\_band} per i +dati urgenti su un socket. + 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 @@ -1892,13 +1942,49 @@ Per questo 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}. +che in certi sistemi questi possono essere diversi. In definitiva dunque, a +meno che non si sia vincolati all'aderenza stretta allo standard ISO C, è +sempre il caso di evitare l'uso di \func{signal} a favore di \func{sigaction}. +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}{} +typedef void SigFunc(int); +inline SigFunc * Signal(int signo, SigFunc *func) +{ + struct sigaction new_handl, old_handl; + new_handl.sa_handler=func; + /* clear signal mask: no signal blocked during execution of func */ + if (sigemptyset(&new_handl.sa_mask)!=0){ /* initialize signal set */ + perror("cannot initializes the signal set to empty"); /* see mess. */ + exit(1); + } + new_handl.sa_flags=0; /* init to 0 all flags */ + /* change action for signo signal */ + if (sigaction(signo,&new_handl,&old_handl)){ + perror("sigaction failed on signal action setting"); + exit(1); + } + return (old_handl.sa_handler); +} + \end{lstlisting} + \end{minipage} + \normalsize + \caption{Una funzione equivalente a \func{signal} definita attraverso + \func{sigaction}.} + \label{fig:sig_Signal_code} +\end{figure} +Per questo motivo si è provveduto, per mantenere un'interfaccia semplificata +che abbia le stesse caratteristiche di \func{signal}, a definire una funzione +equivalente attraverso \func{sigaction}; la funzione è \code{Signal}, e si +trova definita come \code{inline} nel file \file{wrapper.h} (nei sorgenti +allegati), riportata in \figref{fig:sig_Signal_code}. La riutilizzeremo spesso +in seguito. -\subsection{La gestione del blocco dei segnali} +\subsection{La gestione della \textsl{maschera dei segnali} o + \textit{signal mask}} \label{sec:sig_sigmask} Come spiegato in \secref{sec:sig_semantics} tutti i moderni sistemi unix-like @@ -1972,16 +2058,21 @@ 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. +La funzione può essere usata anche all'interno di un manipolatore, ad esempio +per riabilitare la consegna del segnale che l'ha invocato, in questo caso però +occorre ricordare che qualunque modifica alla maschera dei segnali viene +perduta alla conclusione del terminatore. + 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 è: +dei casi di race condition\index{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)} @@ -2009,14 +2100,9 @@ presenta neanche questa necessit \footnotesize \centering \begin{minipage}[c]{15cm} \begin{lstlisting}{} -#include /* unix standard library */ -#include /* 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 */ @@ -2040,9 +2126,6 @@ unsigned int sleep(unsigned int seconds) /* return remaining time */ return alarm(0); } -/* - * Signal Handler for SIGALRM - */ void alarm_hand(int sig) { return; /* just return to interrupt sigsuspend */ @@ -2069,16 +2152,416 @@ evitare che esso possa essere ricevuto dal processo fra l'esecuzione di 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}. +\func{sigsuspend}. + +In questo modo non sono più possibili race condition\index{race condition} +dato che \macro{SIGALRM} viene disabilitato con \func{sigprocmask} fino alla +chiamata di \func{sigsuspend}. Questo metodo è assolutamente generale e può +essere applicato a qualunque altra situazione in cui si deve attendere per un +segnale, i passi sono sempre i seguenti: +\begin{enumerate*} +\item Leggere la maschera dei segnali corrente e bloccare il segnale voluto + con \func{sigprocmask}. +\item Mandare il processo in attesa con \func{sigsuspend} abilitando la + ricezione del segnale voluto. +\item Ripristinare la maschera dei segnali originaria. +\end{enumerate*} +Per quanto possa sembrare strano bloccare la ricezione di un segnale per poi +riabilitarla immediatamente dopo, in questo modo si evita il deadlock dovuto +all'arrivo del segnale prima dell'esecuzione di \func{sigsuspend}. + + +\subsection{Ulteriori funzioni di gestione} +\label{sec:sig_specific_features} + +In questa ultimo paragrafo esamineremo varie funzioni di gestione dei segnali +non descritte finora, relative agli aspetti meno utilizzati. La prima di esse +è \func{sigpending}, anch'essa introdotta dallo standard POSIX.1; il suo +prototipo è: +\begin{prototype}{signal.h} +{int sigpending(sigset\_t *set)} + +Scrive in \param{set} l'insieme dei segnali pendenti. + + \bodydesc{La funzione restituisce zero in caso di successo e -1 per un + errore.} +\end{prototype} +La funzione permette di ricavare quali sono i segnali pendenti per il processo +in corso, cioè i segnali che sono stato inviati dal kernel ma non sono stati +ancora ricevuti dal processo in quanto bloccati. Non esiste una funzione +equivalente nella vecchia interfaccia, ma essa è tutto sommato poco utile, +dato che essa può solo assicurare che un segnale è stato inviato, dato che +escluderne l'avvenuto invio al momento della chiamata non significa nulla +rispetto a quanto potrebbe essere in un qualunque momento successivo. + +Una delle caratteristiche di BSD, disponibile anche in Linux, è la possibilità +di usare uno stack alternativo per i segnali; è cioè possibile fare usare al +sistema un altro stack (invece di quello relativo al processo, vedi +\secref{sec:proc_mem_layout}) solo durante l'esecuzione di un +manipolatore. L'uso di uno stack alternativo è del tutto trasparente ai +manipolatori, occorre però seguire una certa procedura: +\begin{enumerate*} +\item Allocare un'area di memoria di dimensione sufficiente da usare come + stack alternativo. +\item Usare la funzione \func{sigaltstack} per rendere noto al sistema + l'esistenza e la locazione dello stack alternativo. +\item Quando si installa un manipolatore occorre usare \func{sigaction} + specificando il flag \macro{SA\_ONSTACK} (vedi \tabref{tab:sig_sa_flag}) per + dire al sistema di usare lo stack alternativo durante l'esecuzione del + manipolatore. +\end{enumerate*} + +In genere il primo passo viene effettuato allocando un'opportuna area di +memoria con \code{malloc}; in \file{signal.h} sono definite due costanti, +\macro{SIGSTKSZ} e \macro{MINSIGSTKSZ}, che possono essere utilizzate per +allocare una quantità di spazio opportuna, in modo da evitare overflow. La +prima delle due è la dimensione canonica per uno stack di segnali e di norma è +sufficiente per tutti gli usi normali. La seconda è lo spazio che occorre al +sistema per essere in grado di lanciare il manipolatore e la dimensione di uno +stack alternativo deve essere sempre maggiore di questo valore. Quando si +conosce esattamente quanto è lo spazio necessario al manipolatore gli si può +aggiungere questo valore per allocare uno stack di dimensione sufficiente. + +Come accennato per poter essere usato lo stack per i segnali deve essere +indicato al sistema attraverso la funzione \func{sigaltstack}; il suo +prototipo è: +\begin{prototype}{signal.h} +{int sigaltstack(const stack\_t *ss, stack\_t *oss)} + +Installa un nuovo stack per i segnali. + + \bodydesc{La funzione restituisce zero in caso di successo e -1 per un + errore, nel qual caso \var{errno} assumerà i valori: + \begin{errlist} + \item[\macro{ENOMEM}] La dimensione specificata per il nuovo stack è minore + di \macro{MINSIGSTKSZ}. + \item[\macro{EPERM}] Uno degli indirizzi non è valido. + \item[\macro{EFAULT}] Si è cercato di cambiare lo stack alternativo mentre + questo è attivo (cioè il processo è in esecuzione su di esso). + \item[\macro{EINVAL}] \param{ss} non è nullo e \var{ss\_flags} contiene un + valore diverso da zero che non è \macro{SS\_DISABLE}. + \end{errlist}} +\end{prototype} -\subsection{Caratteristiche ulteriori} -\label{sec:sig_specific_features} +La funzione prende come argomenti puntatori ad una struttura di tipo +\var{stack\_t}, definita in \figref{fig:sig_stack_t}. I due valori \param{ss} +e \param{oss}, se non nulli, indicano rispettivamente il nuovo stack da +installare e quello corrente (che viene restituito dalla funzione per un +successivo ripristino). +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +typedef struct { + void *ss_sp; /* Base address of stack */ + int ss_flags; /* Flags */ + size_t ss_size; /* Number of bytes in stack */ +} stack_t; + \end{lstlisting} + \end{minipage} + \normalsize + \caption{La struttura \var{stack\_t}.} + \label{fig:sig_stack_t} +\end{figure} + +Il campo \var{ss\_sp} di \var{stack\_t} indica l'indirizzo base dello stack, +mentre \var{ss\_size} ne indica la dimensione; il campo \var{ss\_flags} invece +indica lo stato dello stack. Nell'indicare un nuovo stack occorre +inizializzare \var{ss\_sp} e \var{ss\_size} rispettivamente al puntatore e +alla dimensione della memoria allocata, mentre \var{ss\_flags} deve essere +nullo. Se invece si vuole disabilitare uno stack occorre indicare +\macro{SS\_DISABLE} come valore di \var{ss\_flags} e gli altri valori saranno +ignorati. + +Se \param{oss} non è nullo verrà restituito dalla funzione indirizzo e +dimensione dello stack corrente nei relativi campi, mentre \var{ss\_flags} +potrà assumere il valore \macro{SS\_ONSTACK} se il processo è in esecuzione +sullo stack alternativo (nel qual caso non è possibile cambiarlo) e +\macro{SS\_DISABLE} se questo non è abilitato. + +In genere si installa uno stack alternativo per i segnali quando si teme di +avere problemi di esaurimento dello stack standard o di superamento di un +limite imposto con chiamata de tipo \code{setrlimit(RLIMIT\_STACK, \&rlim)}. +In tal caso infatti si avrebbe un segnale di \macro{SIGSEGV}, che potrebbe +essere gestito soltanto avendo abilitato uno stack alternativo. + +Si tenga presente che le funzioni chiamate durante l'esecuzione sullo stack +alternativo continueranno ad usare quest'ultimo, che, al contrario di quanto +avviene per lo stack ordinario dei processi, non si accresce automaticamente +(ed infatti eccederne le dimensioni può portare a conseguenze imprevedibili). +Si ricordi infine che una chiamata ad una funzione della famiglia +\func{exec} cancella ogni stack alternativo. + +Abbiamo visto in \secref{fig:sig_sleep_incomplete} come si possa usare +\func{longjmp} per uscire da un manipolatore rientrando direttamente nel corpo +del programma; sappiamo però che nell'esecuzione di un manipolatore il segnale +che l'ha invocato viene bloccato, e abbiamo detto che possiamo ulteriormente +modificarlo con \func{sigprocmask}. + +Resta quindi il problema di cosa succede alla maschera dei segnali quando si +esce da un manipolatore usando questa funzione. Il comportamento dipende +dall'implementazione; in particolare BSD ripristina la maschera dei segnali +precedente l'invocazione, come per un normale ritorno, mentre System V no. Lo +standard POSIX.1 non specifica questo comportamento per \func{setjmp} e +\func{longjmp}, ed il comportamento delle \acr{glibc} dipende da quale delle +caratteristiche si sono abilitate con le macro viste in +\secref{sec:intro_gcc_glibc_std}. + +Lo standard POSIX però prevede anche la presenza di altre due funzioni +\func{sigsetjmp} e \func{siglongjmp}, che permettono di decidere quale dei due +comportamenti il programma deve assumere; i loro prototipi sono: +\begin{functions} + \headdecl{setjmp.h} + + \funcdecl{int sigsetjmp(sigjmp\_buf env, int savesigs)} Salva il contesto + dello stack per un salto non locale. + + \funcdecl{void siglongjmp(sigjmp\_buf env, int val)} Esegue un salto non + locale su un precedente contesto. + + \bodydesc{Le due funzioni sono identiche alle analoghe \func{setjmp} e + \func{longjmp} di \secref{sec:proc_longjmp}, ma consentono di specificare + il comportamento sul ripristino o meno della maschera dei segnali.} +\end{functions} + +Le due funzioni prendono come primo argomento la variabile su cui viene +salvato il contesto dello stack per permettere il salto non locale; nel caso +specifico essa è di tipo \type{sigjmp\_buf}, e non \type{jmp\_buf} come per le +analoghe di \secref{sec:proc_longjmp} in quanto in questo caso viene salvata +anche la maschera dei segnali. + +Nel caso di \func{sigsetjmp} se si specifica un valore di \param{savesigs} +diverso da zero la maschera dei valori sarà salvata in \param{env} e +ripristinata in un successivo \func{siglongjmp}; quest'ultima funzione, a +parte l'uso di \type{sigjmp\_buf} per \param{env}, è assolutamente identica a +\func{longjmp}. + + + +\subsection{I segnali real-time} +\label{sec:sig_real_time} + + +Lo standard POSIX.1b, nel definire una serie di nuove interfacce per i servizi +real-time, ha introdotto una estensione del modello classico dei segnali che +presenta dei significativi miglioramenti,\footnote{questa estensione è stata + introdotta in Linux a partire dal kernel 2.1.43(?), e dalle \acr{glibc} + 2.1(?).} in particolare sono stati superati tre limiti fondamentali dei +segnali classici: +\begin{description} +\item[I segnali non sono accumulati] + + se più segnali vengono generati prima dell'esecuzione di un manipolatore + questo sarà eseguito una sola volta, ed il processo non sarà in grado di + accorgersi di quante volte l'evento che ha generato il segnale è accaduto. +\item[I segnali non trasportano informazione] + + i segnali classici non prevedono prevedono altra informazione sull'evento + che li ha generati se non il fatto che sono stati emessi (tutta + l'informazione che il kernel associa ad un segnale è il suo numero). +\item[I segnali non hanno un ordine di consegna] + + l'ordine in cui diversi segnali vengono consegnati è casuale e non + prevedibile. Non è possibile stabilire una priorità per cui la reazione a + certi segnali ha la precedenza rispetto ad altri. +\end{description} + + +Per poter superare queste limitazioni lo standard ha introdotto delle nuove +caratteristiche, che sono state associate ad una nuova classe di segnali, che +vengono chiamati \textsl{segnali real-time}, in particolare: + +\begin{itemize*} +\item i segnali sono inseriti in una coda che permette di consegnare istanze + multiple dello stesso segnale qualora esso venga inviato più volte prima + dell'esecuzione del manipolatore; si assicura così che il processo riceva un + segnale per ogni occorrenza dell'evento che lo genera. +\item è stata introdotta una priorità nella consegna dei segnali: i segnali + vengono consegnati in ordine a seconda del loro valore, partendo da quelli + con un numero minore, che pertanto hanno una priorità maggiore. +\item è stata introdotta la possibilità di restituire dei dati al + manipolatore, attraverso l'uso di un campo apposito nella struttura + \type{siginfo\_t} accessibile tramite manipolatori di tipo + \var{sa\_sigaction}. +\end{itemize*} + +Queste nuove caratteristiche (eccetto l'ultima, che, come visto in +\secref{sec:sig_sigaction}, è parzialmente disponibile anche con i segnali +ordinari) si applicano solo ai nuovi segnali real-time; questi ultimi sono +accessibili in un range di valori specificati dalle due macro \macro{SIGRTMIN} +e \macro{SIGRTMAX},\footnote{in Linux di solito il primo valore è 32, ed il + secondo \code{\_NSIG-1}, che di norma è 63, per un totale di 32 segnali + disponibili, contro gli almeno 8 richiesti da POSIX.1b.} che specificano il +numero minimo e massimo associato ad un segnale real-time. + +I segnali con un numero più basso hanno una priorità maggiore e vengono +consegnati per primi, inoltre i segnali real-time non possono interrompere +l'esecuzione di un manipolatore di un segnale a priorità più alta; la loro +azione di default è quella di terminare il programma. I segnali ordinari +hanno tutti la stessa priorità, che è più alta di quella di qualunque segnale +real-time. + +Si tenga presente che questi nuovi segnali non sono associati a nessun evento +sepcifico (a meno di non utilizzarli, come vedremo in +\secref{sec:file_asyncronous_io}, per l'I/O asincrono) e devono essere inviati +esplicitamente. Tutti i segnali real-time restituiscono al manipolatore, oltre +ai campi \var{si\_pid} e \var{si\_uid} di \type{siginfo\_t} una struttura +\type{sigval} (riportata in \figref{fig:sig_sigval}) in cui può essere +restituito al processo un valore o un indirizzo, che costituisce il meccanismo +con cui il segnale è in grado di inviare una ulteriore informazione al +processo. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +union sigval { + int sival_int; + void *sival_ptr; +} + \end{lstlisting} + \end{minipage} + \normalsize + \caption{La struttura \type{sigval}, usata dai segnali real time per + restituire dati al manipolatore.} + \label{fig:sig_sigval} +\end{figure} + +A causa di queste loro caratteristiche, la funzione \func{kill} non è adatta +ad inviare un segnale real time, in quanto non è in grado di fornire alcun +valore per \var{sigval}; per questo motivo lo standard ha previsto una nuova +funzione, \func{sigqueue}, il cui prototipo è: +\begin{prototype}{signal.h} + {int sigqueue(pid\_t pid, int signo, const union sigval value)} + + Invia il segnale \param{signo} al processo \param{pid}, restituendo al + manipolatore il valore \param{value}. + + \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di + errore, nel qual caso \var{errno} viene settata ai valori: + \begin{errlist} + \item[\macro{EAGAIN}] La coda è esarita, ci sono già \macro{SIGQUEUE\_MAX} + segnali in attesa si consegna. + \item[\macro{EPERM}] Non si hanno privilegi appropriati per inviare il + segnale al processo specificato. + \item[\macro{ESRCH}] Il processo \param{pid} non esiste. + \item[\macro{EINVAL}] Si è specificato un valore non valido per + \param{signo}. + \end{errlist} + ed inoltre \macro{ENOMEM}.} +\end{prototype} + +Il comportamento della funzione è analogo a quello di \func{kill}, ed i +privilegi occorrenti ad inviare il segnale ad un determinato processo sono gli +stessi; un valore nullo di \func{signo} permette di verificare le condizioni +di errore senza inviare nessun segnale. + +Se il segnale è bloccato la funzione ritorna immediatamente, se si è +installato un manipolatore con \macro{SA\_SIGINFO} e ci sono risorse +disponibili, vale a dire che c'è posto nella coda\footnote{la profondità della + coda è indicata dalla costante \macro{SIGQUEUE\_MAX}, una della tante + costanti di sistema definite dallo standard POSIX, che non abbiamo riportato + esplicitamente in \secref{sec:sys_limits}. Il suo valore minimo secondo lo + standard, \macro{\_POSIX\_SIGQUEUE\_MAX}, è pari a 32.}, esso viene inserito +e diventa pendente; una volta consegnato riporterà nel campo \var{si\_code} di +\var{siginfo} il valore \macro{SI\_QUEUE} e il campo \var{si\_value} riceverà +quanto inviato con \param{value}. Se invece si è installato un manipolatore +nella forma classica il segnale sarà generato, ma tutte le caratteristiche +tipiche dei segnali real-time (priorità e coda) saranno perse. + +Lo standard POSIX.1b definisce inoltre delle nuove funzioni che permettono di +gestire l'attesa di segnali specifici su una coda, esse servono in particolar +modo nel caso dei thread, in cui si possono usare i segnali real-time come +meccanismi di comunicazione elementare; la prima di queste funzioni è +\func{sigwait}, il cui prototipo è: +\begin{prototype}{signal.h} + {int sigwait(const sigset\_t *set, int *sig)} + + Attende che uno dei segnali specificati in \param{set} sia pendente. + + \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di + errore, nel qual caso \var{errno} viene settata ai valori: + \begin{errlist} + \item[\macro{EINTR}] La funzione è stata interrotta. + \item[\macro{EINVAL}] Si è specificato un valore non valido per + \param{set}. + \end{errlist} + ed inoltre \macro{EFAULT}.} +\end{prototype} + +La funzione estrae dall'insieme dei segnali pendenti uno qualunque dei segnali +specificati da \param{set}, il cui valore viene restituito in \param{sig}. Se +sono pendenti più segnali, viene estratto quello a priorità più alta (cioè con +il numero più basso). Se, nel caso di segnali real-time, c'è più di un segnale +pendente, ne verrà estratto solo uno. Una volta estratto il segnale non verrà +più consegnato, e se era in una coda il suo posto sarà liberato. Se non c'è +nessun segnale pendente il processo viene bloccato fintanto che non ne arriva +uno. + +Per un funzionamento corretto la funzione richiede che alla sua chiamata i +segnali di \param{set} siano bloccati. In caso contrario si avrebbe un +conflitto con gli eventuali manipolatori: pertanto non si deve utilizzare per +lo stesso segnale questa funzione e \func{sigaction}. Se questo non avviene il +comportamento del sistema è indeterminato: il segnale può sia essere +consegnato che essere ricevuto da \func{sigwait}, il tutto in maniera non +prevedibile. + +Lo standard POSIX.1b definisce altre due funzioni, anch'esse usate +prevalentemente con i thread; \func{sigwaitinfo} e \func{sigtimedwait}, i +relativi prototipi sono: +\begin{functions} + \headdecl{signal.h} + + \funcdecl{int sigwaitinfo(const sigset\_t *set, siginfo\_t *info)} + + Analoga a \func{sigwait}, ma riceve anche le informazioni associate al + segnale in \param{info}. + + \funcdecl{int sigtimedwait(const sigset\_t *set, siginfo\_t *value, const + struct timespec *info)} + + Analoga a \func{sigwaitinfo}, con un la possibilità di specificare un + timeout in \param{timeout}. + + + \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso di + errore, nel qual caso \var{errno} viene settata ai valori già visti per + \func{sigwait}, ai quali se aggiunge, per \func{sigtimedwait}: + \begin{errlist} + \item[\macro{EAGAIN}] Si è superato il timeout senza che un segnale atteso + fosse emmesso. + \end{errlist} +} +\end{functions} +Entrambe le funzioni sono estensioni di \func{sigwait}. La prima permette di +ricevere, oltre al numero del segnale, anche le informazioni ad esso associate +tramite \param{info}; in particolare viene restituito il numero del segnale +nel campo \var{si\_signo}, la sua causa in \var{si\_code}, e se il segnale è +stato immesso sulla coda con \func{sigqueue}, il valore di ritorno ad esso +associato viene riportato in \var{si\_value}, che altrimenti è indefinito. + +La seconda è identica alla prima ma in più permette di specificare un timeout, +scaduto il quale ritornerà con un errore. Se si specifica un puntatore nullo +il comportamento sarà identico a \func{sigwaitinfo}, se si specifica un tempo +di timeout nullo, e non ci sono sengali pendenti la funzione ritornerà +immediatamente; in questo modo si può eliminare un segnale dalla coda senza +dover essere bloccati qualora esso non sia presente. + + +L'uso di queste funzioni è principalmente associato alla gestione dei segnali +com i thread. In genere esse vengono chiamate dal thread incaricato della +gestione, che al ritorno della funzione esegue il codice che usualmente +sarebbe messo nel manipolatore, per poi ripetere la chiamata per mettersi in +attesa del segnale successivo. Questo ovviamente comporta che non devono +essere installati manipolatori, che solo il thread di gestione deve usare +\func{sigwait} e che, per evitare che venga eseguita l'azione di default, i +segnali gestiti in questa maniera devono essere mascherati per tutti i thread, +compreso quello dedicato alla gestione, che potrebbe riceverlo fra due +chiamate successive. %%% Local Variables: %%% mode: latex