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
+eccezionali (come errori di accesso, eccezioni aritmetiche, ecc.) ma possono
anche essere usati come forma elementare di comunicazione fra processi (ad
esempio vengono usati per il controllo di sessione), per notificare eventi
(come la terminazione di un processo figlio), ecc.
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
+di generazione fino ad esaminare in dettaglio le funzioni e le metodologie di
gestione avanzate e le estensioni fatte all'interfaccia classica nelle nuovi
versioni dello standard POSIX.
\begin{itemize*}
\item un errore del programma, come una divisione per zero o un tentativo di
- accesso alla memoria fuori dai limiti validi.
-\item la terminazione di un processo figlio.
-\item la scadenza di un timer o di un allarme.
+ accesso alla memoria fuori dai limiti validi;
+\item la terminazione di un processo figlio;
+\item la scadenza di un timer o di un allarme;
\item il tentativo di effettuare un'operazione di input/output che non può
- essere eseguita.
+ essere eseguita;
\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
+ \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}).
Ciascuno di questi eventi (compresi gli ultimi due che pure sono controllati
dall'utente o da un altro processo) comporta l'intervento diretto da parte del
-kernel che causa la generazione un particolare tipo di segnale.
+kernel che causa la generazione di un particolare tipo di segnale.
Quando un processo riceve un segnale, invece del normale corso del programma,
viene eseguita una azione predefinita o una apposita routine di gestione
(quello che da qui in avanti chiameremo il \textsl{gestore} del segnale,
-dall'inglese\textit{signal handler}) che può essere stata specificata
+dall'inglese \textit{signal handler}) che può essere stata specificata
dall'utente (nel qual caso si dice che si \textsl{intercetta} il segnale).
sono sempre possibili delle race condition\index{\textit{race~condition}}
(sull'argomento vedi quanto detto in sez.~\ref{sec:proc_multi_prog}).
-Un'altro problema è che in questa semantica non esiste un modo per bloccare i
+Un altro problema è che in questa semantica non esiste un modo per bloccare i
segnali quando non si vuole che arrivino; i processi possono ignorare il
segnale, ma non è possibile istruire il sistema a non fare nulla in occasione
di un segnale, pur mantenendo memoria del fatto che è avvenuto.
Un errore significa che un programma ha fatto qualcosa di sbagliato e non può
continuare ad essere eseguito. Non tutti gli errori causano dei segnali, in
-genere la condizione di errore più comune comporta la restituzione di un
-codice di errore da parte di una funzione di libreria, sono gli errori che
-possono avvenire ovunque in un programma che causano l'emissione di un
-segnale, come le divisioni per zero o l'uso di indirizzi di memoria non validi.
+genere le condizioni di errore più comuni comportano la restituzione di un
+codice di errore da parte di una funzione di libreria; sono gli errori che
+possono avvenire nella esecuzione delle istruzioni di un programma che causano
+l'emissione di un segnale, come le divisioni per zero o l'uso di indirizzi di
+memoria non validi.
Un evento esterno ha in genere a che fare con l'I/O o con altri processi;
esempi di segnali di questo tipo sono quelli legati all'arrivo di dati di
Si ricordi però che se l'azione specificata per un segnale è quella di essere
ignorato questo sarà scartato immediatamente al momento della sua generazione,
e questo anche se in quel momento il segnale è bloccato (perché bloccare su un
-segnale significa bloccarne è la notifica). Per questo motivo un segnale,
+segnale significa bloccarne la notifica). Per questo motivo un segnale,
fintanto che viene ignorato, non sarà mai notificato, anche se prima è stato
bloccato ed in seguito si è specificata una azione diversa (nel qual caso solo
i segnali successivi alla nuova specificazione saranno notificati).
una delle tre possibilità seguenti:
\begin{itemize*}
-\item ignorare il segnale.
-\item catturare il segnale, ed utilizzare il gestore specificato.
+\item ignorare il segnale;
+\item catturare il segnale, ed utilizzare il gestore specificato;
\item accettare l'azione predefinita per quel segnale.
\end{itemize*}
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
+terminazione esaminando il codice di stato riportato dalle funzioni
\func{wait} e \func{waitpid} (vedi sez.~\ref{sec:proc_wait}); questo è il modo
in cui la shell determina i motivi della terminazione di un programma e scrive
un eventuale messaggio di errore.
\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}.
+avviene se i suddetti segnali vengono generati con una \func{kill}.
\section{La classificazione dei segnali}
\end{table}
La descrizione dettagliata del significato dei vari segnali, raggruppati per
-tipologia, verrà affrontate nei paragrafi successivi.
+tipologia, verrà affrontata nei paragrafi successivi.
\subsection{Segnali di errore di programma}
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.
+ inizializzato leggendo al di là della fine di un vettore.
\item[\const{SIGBUS}] Il nome deriva da \textit{bus error}. Come
\const{SIGSEGV} questo è un segnale che viene generato di solito quando si
dereferenzia un puntatore non inizializzato, la differenza è che
funzione \func{abort} che genera questo segnale.
\item[\const{SIGTRAP}] È il segnale generato da un'istruzione di breakpoint o
dall'attivazione del tracciamento per il processo. È usato dai programmi per
- il debugging e se un programma normale non dovrebbe ricevere questo segnale.
+ il debugging e un programma normale non dovrebbe ricevere questo segnale.
\item[\const{SIGSYS}] Sta ad indicare che si è eseguita una istruzione che
richiede l'esecuzione di una system call, ma si è fornito un codice
sbagliato per quest'ultima.
\label{sec:sig_job_control}
Questi sono i segnali usati dal controllo delle sessioni e dei processi, il
-loro uso è specifico e viene trattato in maniera specifica nelle sezioni in
-cui si trattano gli argomenti relativi. Questi segnali sono:
+loro uso è specializzato e viene trattato in maniera specifica nelle sezioni
+in cui si trattano gli argomenti relativi. Questi segnali sono:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\const{SIGCHLD}] Questo è il segnale mandato al processo padre quando un
figlio termina o viene fermato. L'azione predefinita è di ignorare il
segnale. Se il segnale è bloccato, intercettato o ignorato la chiamata che
lo ha causato fallisce, restituendo l'errore \errcode{EPIPE}.
\item[\const{SIGLOST}] Sta per \textit{Resource lost}. Tradizionalmente è il
- segnale che generato quando si ha un advisory lock su un file su NFS che
- viene perso perché il server NFS è stato riavviato. Il progetto GNU lo
- utilizza per indicare ad un client il crollo inaspettato di un server. In
- Linux è definito come sinonimo di \const{SIGIO}.\footnote{ed è segnalato
- come BUG nella pagina di manuale.}
+ segnale che viene generato quando si perde un advisory lock su un file su
+ NFS perché il server NFS è stato riavviato. Il progetto GNU lo utilizza per
+ indicare ad un client il crollo inaspettato di un server. In Linux è
+ definito come sinonimo di \const{SIGIO}.\footnote{ed è segnalato come BUG
+ nella pagina di manuale.}
\item[\const{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 sez.~\ref{sec:sys_resource_limit}.
\subsection{Ulteriori segnali}
\label{sec:sig_misc_sig}
-Raccogliamo qui infine usa serie di segnali che hanno scopi differenti non
+Raccogliamo qui infine una serie di segnali che hanno scopi differenti non
classificabili in maniera omogenea. Questi segnali sono:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\const{SIGUSR1}] Insieme a \const{SIGUSR2} è un segnale a disposizione
\end{prototype}
Una modalità alternativa per utilizzare le descrizioni restituite da
-\func{strsignal} e \func{psignal} è quello di fare usare la variabile
+\func{strsignal} e \func{psignal} è quello di usare la variabile
\var{sys\_siglist}, che è definita in \file{signal.h} e può essere acceduta
con la dichiarazione:
\includecodesnip{listati/siglist.c}
-l'array \var{sys\_siglist} contiene i puntatori alle stringhe di descrizione,
+
+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]}.
effettuata all'interno del normale flusso di esecuzione dello stesso, ma è
delegata appunto agli eventuali gestori che si sono installati.
-In questa sezione vedremo come si effettua gestione dei segnali, a partire
+In questa sezione vedremo come si effettua la gestione dei segnali, a partire
dalla loro interazione con le system call, passando per le varie funzioni che
-permettono di installare i gestori e controllare le reazioni di un
-processo alla loro occorrenza.
+permettono di installare i gestori e controllare le reazioni di un processo
+alla loro occorrenza.
-\subsection{Il comportamento generale del sistema.}
+\subsection{Il comportamento generale del sistema}
\label{sec:sig_gen_beha}
Abbiamo già trattato in sez.~\ref{sec:sig_intro} le modalità con cui il sistema
\begin{itemize*}
\item la lettura da file che possono bloccarsi in attesa di dati non ancora
presenti (come per certi file di dispositivo\index{file!di~dispositivo}, i
- socket\index{socket} o le pipe).
+ socket\index{socket} o le pipe);
\item la scrittura sugli stessi file, nel caso in cui dati non possano essere
- accettati immediatamente (di nuovo comune per i socket).
+ accettati immediatamente (di nuovo comune per i socket);
\item l'apertura di un file di dispositivo che richiede operazioni non
immediate per una risposta (ad esempio l'apertura di un nastro che deve
- essere riavvolto).
+ essere riavvolto);
\item le operazioni eseguite con \func{ioctl} che non è detto possano essere
- eseguite immediatamente.
+ eseguite immediatamente;
\item le funzioni di intercomunicazione che si bloccano in attesa di risposte
- da altri processi.
+ da altri processi;
\item la funzione \func{pause} (usata appunto per attendere l'arrivo di un
- segnale).
+ segnale);
\item la funzione \func{wait} (se nessun processo figlio è ancora terminato).
\end{itemize*}
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
errore, gli errori sono gli stessi di \func{kill}.}
\end{prototype}
-\noindent e che permette di inviare un segnale a tutto un \textit{process
- group} (vedi sez.~\ref{sec:sess_proc_group}).
+\noindent e permette di inviare un segnale a tutto un \textit{process group}
+(vedi sez.~\ref{sec:sess_proc_group}).
\begin{table}[htb]
\footnotesize
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
+consentano. Lo standard permette comunque alle varie implementazioni di
escludere alcuni processi specifici: nel caso in questione Linux non invia il
segnale al processo che ha effettuato la chiamata.
\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 \const{SIGALRM}.
+ l'emissione di \const{SIGALRM};
\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 \const{SIGVTALRM}.
+ di questo timer provoca l'emissione di \const{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
\func{setitimer}.
-L'ultima funzione che permette l'invio diretto di un segnale è \funcd{abort};
+L'ultima funzione che permette l'invio diretto di un segnale è \funcd{abort},
che, come accennato in sez.~\ref{sec:proc_termination}, permette di abortire
l'esecuzione di un programma tramite l'invio di \const{SIGABRT}. Il suo
prototipo è:
ed usa il nome di \const{SIGCLD} come sinonimo di \const{SIGCHLD}.} In
generale dunque, quando non interessa elaborare lo stato di uscita di un
processo, si può completare la gestione della terminazione installando un
-gestore per \const{SIGCHLD} il cui unico compito sia quello chiamare
+gestore per \const{SIGCHLD} il cui unico compito sia quello di chiamare
\func{waitpid} per completare la procedura di terminazione in modo da evitare
la formazione di zombie\index{zombie}.
Il codice del gestore è di lettura immediata; come buona norma di
programmazione (si ricordi quanto accennato sez.~\ref{sec:sys_errno}) si
-comincia (\texttt{\small 12-13}) con il salvare lo stato corrente di
+comincia (\texttt{\small 6--7}) con il salvare lo stato corrente di
\var{errno}, in modo da poterlo ripristinare prima del ritorno del gestore
-(\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}.
+(\texttt{\small 16--17}). In questo modo si preserva il valore della variabile
+visto dal corso di esecuzione principale del processo, che altrimenti sarebbe
+sovrascritto dal valore restituito nella successiva chiamata di \func{wait}.
Il compito principale del gestore è 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
+(\texttt{\small 9--15}). 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 gestore possa passare un certo
lasso di tempo e niente ci assicura che il gestore venga eseguito prima della
\section{Gestione avanzata}
\label{sec:sig_control}
-Le funzioni esaminate finora fanno riferimento ad alle modalità più elementari
+Le funzioni esaminate finora fanno riferimento 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\index{\textit{race~condition}} che i segnali possono generare e alla
fig.~\ref{fig:sig_sleep_wrong}.
Dato che è nostra intenzione utilizzare \const{SIGALRM} il primo passo della
-nostra implementazione di sarà quello di installare il relativo gestore
-salvando il precedente (\texttt{\small 14-17}). Si effettuerà poi una
-chiamata ad \func{alarm} per specificare il tempo d'attesa per l'invio del
-segnale a cui segue la chiamata a \func{pause} per fermare il programma
-(\texttt{\small 17-19}) fino alla sua ricezione. Al ritorno di \func{pause},
-causato dal ritorno del gestore (\texttt{\small 1-9}), si ripristina il
-gestore originario (\texttt{\small 20-21}) restituendo l'eventuale tempo
-rimanente (\texttt{\small 22-23}) che potrà essere diverso da zero qualora
+nostra implementazione sarà quello di installare il relativo gestore salvando
+il precedente (\texttt{\small 14-17}). Si effettuerà poi una chiamata ad
+\func{alarm} per specificare il tempo d'attesa per l'invio del segnale a cui
+segue la chiamata a \func{pause} per fermare il programma (\texttt{\small
+ 18-20}) fino alla sua ricezione. Al ritorno di \func{pause}, causato dal
+ritorno del gestore (\texttt{\small 1-9}), si ripristina il gestore originario
+(\texttt{\small 21-22}) restituendo l'eventuale tempo rimanente
+(\texttt{\small 23-24}) che potrà essere diverso da zero qualora
l'interruzione di \func{pause} venisse causata da un altro segnale.
\begin{figure}[!htb]
projects / gapil.git / commitdiff