\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
-\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
\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)
\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}}
+, 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"
projects / gapil.git / blobdiff