\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
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*}
\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. Dato che la loro gestione non è sotto il controllo del programma
+essa non può essere effettuata all'interno del normale flusso di esecuzione.
+
+In questa sezione vedremo come si effettua gestione dei segnali, a partire dal
+comportamento del sistema, passando per le varie funzioni relative ai segnali,
+affrontando inoltre le varie promblematiche di programmazione che si devono
+tenere presenti quando si ha a che fare con essi.
+
+
+\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 lente (\textit{slow}) e 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 \textit{fast} proprio in quanto attendere la
+loro esecuzione per eseguire un manipolatore non comporta nessun
+inconveniente.
+
+Esistono però dei casi (ad esempio le funzioni di I/O che si bloccano in
+attesa di dati in ingresso) in cui tutto questo non è possibile proprio perché
+renderebbe impossibile una risposta pronta al segnale (per questo sono
+chiamate \textit{slow}), pertanto un eventuale manipolatore sarà eseguito
+prima che la system call sia ritornata.
+
+In quest'ultimo caso si pone il problema di cosa fare una volta che il
+manipolatori ritorni. La scelta
-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.
-
-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é
+\subsection{Le funzioni \func{sigprocmask} e \func{sigpending}}
+\label{sec:sig_sigpending}
+
+
+
+
+\subsection{Le funzioni \func{kill} e \func{raise}}
+\label{sec:sig_kill_raise}
+
+\subsection{Le funzioni \func{alarm} e \func{pause}}
+\label{sec:sig_kill_raise}
+
+
+
+
\subsection{Funzioni rientranti e default dei segnali}
\label{sec:sig_reentrant}
+\subsection{La funzione \func{sigaction}}
+\label{sec:sig_sigaction}
-\subsection{La funzione \func{sigpending}}
-\label{sec:sig_sigpending}
-
%%% Local Variables:
%%% mode: latex
projects / gapil.git / blobdiff