X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=signal.tex;h=aad92a9a6ff9ac9e9a3310f0888d2e0f3403ddd5;hp=6f45f11b5aeabad947ea85b88b837c77f60531c9;hb=12f3d0def93dbdf672e012934826df53c44a79a6;hpb=af29167e31ac4adf834095368a716b489d8f0b8e diff --git a/signal.tex b/signal.tex index 6f45f11..aad92a9 100644 --- a/signal.tex +++ b/signal.tex @@ -73,7 +73,7 @@ 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 @@ -762,18 +762,111 @@ indicizzate per numero di segnale, per cui una chiamata del tipo di \code{char -\section{Le funzioni di base dei segnali} -\label{sec:sig_base_func} +\section{La gestione dei segnali} +\label{sec:sig_management} -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. +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:prog_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 nemmeno 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 +indenfinitamente, 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 dispositivi, 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 dipositivo 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. + +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}. + +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 +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 @@ -792,7 +885,7 @@ comportamento, pur mantenendone immutato il prototipo\footnote{in realt \end{prototype} In questa definizione si è usato il tipo \type{sighandler\_t} che è una -estensione GNU definita dalle \acr{glibc} che permette di riscrivere il +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) @@ -822,36 +915,100 @@ installare l'azione di di default\footnote{si ricordi per \macro{SIGKILL} e \macro{SIGSTOP} non possono essere ignorati né intercettati}. +La funzione \func{signal} originale (e quella attuale in System V) era +conforme alla semantica inaffidabile e resettava l'azione di default a +\macro{SIG\_DEF}; Linux fino alle \acr{libc4} e le \acr{libc5} seguiva la +stessa semantica; al contrario con l'utilizzo delle \acr{glibc2}, Linux, come +BSD, non resetta il manipolatore e blocca il segnale durante la chiamata. La +versione originale della funzione, il cui uso è deprecato, può essere +utilizzata chiamando \func{sysv\_signal}. - -\subsection{La funzione \func{sigpending}} -\label{sec:sig_sigpending} - - +È 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 +``artificialmente'' attraverso l'uso delle funzioni \func{kill} e +\func{raise}, i cui prototipi sono: +\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}. + \funcdecl{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, nel qual caso \var{errno} assumerà i valori: + \begin{errlist} + \item[\macro{EINVAL}] Si è specificato un numero di segnale invalido. + \item[\macro{EPERM}] Il processo non ha il permesso di inviare il segnale + alla destinazione specificata. + \item[\macro{ESRCH}] Il \acr{pid} o il process group indicati non + esistono. Gli zombie (vedi \ref{sec:proc_termination}) sono considerati come + processi esistenti. + \end{errlist}} +\end{functions} + +La funzione \code{raise(sig)} è sostanzialmente equivalente ad una +\code{kill(getpid(), sig)}. Il valore di \param{sig} specifica il segnale che +si vuole inviare e può essere specificato con una delle macro definite in +\ref{sec:sig_classification}. + +Lo standard POSIX poi prevede che il valore 0 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}, così come visto 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. + +Per poter effettuare l'invio del segnale ad un altro processo, si devono +possedere i privilegi di amministratore, oppure il \textit{real user id} o +l'\textit{effective user id} del chiamante devono corrispondere al +\textit{real user id} o al \textit{aved user id} della destinazione. Nel caso +del segnale \macro{SIGCONT} entrambi i processi devono appartenere alla stessa +sessione. + +Il valore dell'argomento \param{pid} specifica la destinazione a cui inviare +il segnale e può assumere i seguenti significati: +\begin{basedescript}{\desclabelwidth{2cm}\desclabelstyle{\nextlinelabel}} +\item[$\texttt{pid}>0$] il segnale è mandato al processo con il \acr{pid} + indicato. +\item[$\texttt{pid}=0$] il segnale è mandato ad ogni processo del + \textit{process group} del chiamante. +\item[$\texttt{pid}=-1$] il segnale è mandato ad ogni processo (eccetto + \cmd{init}). +\item[$\texttt{pid}<-1$] il segnale è mandato ad ogni processo del process + group $|\code{pid}|$. +\end{basedescript} + + \subsection{Le funzioni \func{alarm} e \func{pause}} -\label{sec:sig_kill_raise} +\label{sec:sig_alarm_pause} +\subsection{Funzioni rientranti e default dei segnali} +\label{sec:sig_reentrant} -\section{La programmazione con i segnali} -\label{sec:sig_use} -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. Dato che la loro gestione non è sotto il controllo del programma -essa non può essere effettuata all'interno del normale flusso di esecuzione, -per cui tutto quello che si può fare è di specificare (al kernel, installando -un manipolatore) quale azione andrà intrapresa quando essi si verificano. +\section{Gestione avanzata} +\label{sec:sig_control} -\subsection{Funzioni rientranti e default dei segnali} -\label{sec:sig_reentrant} + + +\subsection{Le funzioni \func{sigprocmask} e \func{sigpending}} +\label{sec:sig_sigpending} + \subsection{La funzione \func{sigaction}} @@ -860,6 +1017,11 @@ un manipolatore) quale azione andr +, affrontando inoltre le varie problematiche di programmazione che si devono +tenere presenti quando si ha a che fare con essi. + + + %%% Local Variables: %%% mode: latex %%% TeX-master: "gapil"