X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=signal.tex;h=aafb4ecebfd83541240c676c89f5f59970ec2dec;hp=f071289d2b18776b56e58cb47c1b608a0e01b87c;hb=d4c16890a0197a513327a43fbed7d95c48bee8cb;hpb=fc12632f7fb1e94a4e2b2c4ee8c4bbbf347733e8 diff --git a/signal.tex b/signal.tex index f071289..aafb4ec 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 @@ -267,9 +267,8 @@ segnale. Per alcuni segnali (\macro{SIGKILL} e \macro{SIGSTOP}) questa azione 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*} @@ -764,66 +763,133 @@ indicizzate per numero di segnale, per cui una chiamata del tipo di \code{char \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: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. +\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. +Dato che dimenticarsi di richiamare una funzione interrotta è un errore comune -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. \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 è: \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: +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} -che, per la poca chiarezza della sintassi del C quando si vanno a trattare -puntatori a funzioni, è molto meno comprensibile, da questo si può dedurre la -definizione di \type{sighandler\_t} che è: +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} -si tratta cioè un puntatore ad una funzione \type{void} (cioè senza valore di -rtorno) e che prende un argomento di tipo \type{int}\footnote{si devono usare - le parentesi intorno al nome della funzione per via delle precedenze degli +e cioè un puntatore ad una funzione \type{void} (cioè senza valore di ritorno) +e che prende un argomento 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}}. 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} segnale può essere indicato +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\footnote{si ricordi però che i due segnali \macro{SIGKILL} e \macro{SIGSTOP} non possono essere ignorati né @@ -831,19 +897,40 @@ installare l'azione di di default\footnote{si ricordi per - - \subsection{Funzioni rientranti e default dei segnali} \label{sec:sig_reentrant} +\subsection{Le funzioni \func{kill} e \func{raise}} +\label{sec:sig_kill_raise} + +\subsection{Le funzioni \func{alarm} e \func{pause}} +\label{sec:sig_alarm_pause} + + +\section{Il controllo dei segnali} +\label{sec:sig_control} + -\subsection{La funzione \func{sigpending}} + +\subsection{Le funzioni \func{sigprocmask} e \func{sigpending}} \label{sec:sig_sigpending} + +\subsection{La funzione \func{sigaction}} +\label{sec:sig_sigaction} + + + + +, 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"