From e397070555910d790f746fa9d5ad995ba8537cba Mon Sep 17 00:00:00 2001 From: Simone Piccardi Date: Sun, 21 Apr 2002 22:15:59 +0000 Subject: [PATCH] Aggiunte varie --- signal.tex | 170 +++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 157 insertions(+), 13 deletions(-) diff --git a/signal.tex b/signal.tex index 31f4ee8..6f6c111 100644 --- a/signal.tex +++ b/signal.tex @@ -1828,15 +1828,18 @@ dettagli si consulti la man page di \func{sigaction}). Il campo \var{sa\_mask} serve ad indicare l'insieme dei segnali che devono essere bloccati durante l'esecuzione del manipolatore, ad essi viene comunque sempre aggiunto il segnale che ne ha causato la chiamata, a meno che non si -sia specificato con \var{sa\_flag} un comportamento diverso. +sia specificato con \var{sa\_flag} un comportamento diverso. Quando il +manipolatore ritorna comunque la maschera dei segnali bloccati (vedi +\secref{sec:sig_sigmask}) viene ripristinata al valore precedente +l'invocazione. L'uso di questo campo permette ad esempio di risolvere il problema residuo dell'implementazione di \code{sleep} mostrata in -\secref{fig:sig_sleep_incomplete}: in quel caso infatti se il segnale di -allarme interrompe un altro manipolatore questo non sarà eseguito -correttamente, la cosa può essere prevenuta installando quest'ultimo usando -\var{sa\_mask} per bloccare \macro{SIGALRM} durante la sua esecuzione. - +\secref{fig:sig_sleep_incomplete}. In quel caso infatti se il segnale di +allarme avesse interrotto un altro manipolatore questo non sarebbe stato +eseguito correttamente; la cosa poteva essere prevenuta installando gli altri +manipolatori usando \var{sa\_mask} per bloccare \macro{SIGALRM} durante la +loro esecuzione. Il valore di \var{sa\_flag} permette di specificare vari aspetti del comportamento di \func{sigaction}, e della reazione del processo ai vari segnali; i valori possibili ed il relativo significato sono riportati in @@ -1872,7 +1875,7 @@ segnali; i valori possibili ed il relativo significato sono riportati in \var{sa\_sigaction} al posto di \var{sa\_handler}.\\ \macro{SA\_ONSTACK} & Stabilisce l'uso di uno stack alternativo per l'esecuzione del manipolatore (vedi - \secref{sec:sig_xxx}).\\ + \secref{sec:sig_specific_features}).\\ \hline \end{tabular} \caption{Valori del campo \var{sa\_flag} della struttura \var{sigaction}.} @@ -1898,7 +1901,8 @@ l'uso di \func{signal} a favore di \func{sigaction}. -\subsection{La gestione del blocco dei segnali} +\subsection{La gestione della \textsl{maschera dei segnali} o + \textit{signal mask}} \label{sec:sig_sigmask} Come spiegato in \secref{sec:sig_semantics} tutti i moderni sistemi unix-like @@ -1972,6 +1976,11 @@ critica. La funzione permette di risolvere problemi come quelli mostrati in \secref{fig:sig_event_wrong}, proteggendo la sezione fra il controllo del flag e la sua cancellazione. +La funzione può essere usata anche all'interno di un manipolatore, ad esempio +per riabilitare la consegna del segnale che l'ha invocato, in questo caso però +occorre ricordare che qualunque modifica alla maschera dei segnali viene +perduta alla conclusione del terminatore. + Benché con l'uso di \func{sigprocmask} si possano risolvere la maggior parte dei casi di race condition restano aperte alcune possibilità legate all'uso di \func{pause}; il caso è simile a quello del problema illustrato nell'esempio @@ -2069,14 +2078,149 @@ evitare che esso possa essere ricevuto dal processo fra l'esecuzione di questo si salva la maschera corrente dei segnali, che sarà ripristinata alla fine (\texttt{\small 27}), e al contempo si prepara la maschera dei segnali \var{sleep\_mask} per riattivare \macro{SIGALRM} all'esecuzione di -\func{sigsuspend}. In questo modo non sono più possibili race condition dato -che \macro{SIGALRM} viene disabilitato con \func{sigprocmask} fino alla -chiamata di \func{sigsuspend}. +\func{sigsuspend}. + +In questo modo non sono più possibili race condition dato che \macro{SIGALRM} +viene disabilitato con \func{sigprocmask} fino alla chiamata di +\func{sigsuspend}. Questo metodo è assolutamente generale e può essere +applicato a qualunque altra situazione in cui si deve attendere per un +segnale, i passi sono sempre i seguenti: +\begin{enumerate} +\item Leggere la maschera dei segnali corrente e bloccare il segnale voluto + con \func{sigprocmask}. +\item Mandare il processo in attesa con \func{sigsuspend} abilitando la + ricezione del segnale voluto. +\item Ripristinare la maschera dei segnali originaria. +\end{enumerate} +Per quanto possa sembrare strano bloccare la ricezione di un segnale per poi +riabilitarla immediatamente dopo, in questo modo si evita il deadlock dovuto +all'arrivo del segnale prima dell'esecuzione di \func{sigsuspend}. + + +\subsection{Ulteriori funzioni di gestione} +\label{sec:sig_specific_features} +In questa ultimo paragrafo esamineremo varie funzioni di gestione dei segnali +non descritte finora, relative agli aspetti meno utilizzati. La prima di esse +è \func{sigpending}, anch'essa introdotta dallo standard POSIX.1; il suo +prototipo è: +\begin{prototype}{signal.h} +{int sigpending(sigset\_t *set)} + +Scrive in \param{set} l'insieme dei segnali pendenti. + + \bodydesc{La funzione restituisce zero in caso di successo e -1 per un + errore.} +\end{prototype} +La funzione permette di ricavare quali sono i segnali pendenti per il processo +in corso, cioè i segnali che sono stato inviati dal kernel ma non sono stati +ancora ricevuti dal processo in quanto bloccati. Non esiste una funzione +equivalente nella vecchia interfaccia, ma essa è tutto sommato poco utile, +dato che essa può solo assicurare che un segnale è stato inviato, dato che +escluderne l'avvenuto invio al momento della chiamata non significa nulla +rispetto a quanto potrebbe essere in un qualunque momento successivo. + +Una delle caratteristiche di BSD, disponibile anche in Linux, è la possibilità +di usare uno stack alternativo per i segnali; è cioè possibile fare usare al +sistema un altro stack (invece di quello relativo al processo, vedi +\secref{sec:proc_mem_layout}) solo durante l'esecuzione di un +manipolatore. L'uso di uno stack alternativo è del tutto trasparente ai +manipolatori, occorre però seguire una certa procedura: +\begin{enumerate} +\item Allocare un'area di memoria di dimensione sufficiente da usare come + stack alternativo. +\item Usare la funzione \func{sigaltstack} per rendere noto al sistema + l'esistenza e la locazione dello stack alternativo. +\item Quando si installa un manipolatore occorre usare \func{sigaction} + specificando il flag \macro{SA\_ONSTACK} (vedi \tabref{tab:sig_sa_flag}) per + dire al sistema di usare lo stack alternativo durante l'esecuzione del + manipolatore. +\end{enumerate} + +In genere il primo passo viene effettuato allocando un'opportuna area di +memoria con \code{malloc}; in \file{signal.h} sono definite due costanti, +\macro{SIGSTKSZ} e \macro{MINSIGSTKSZ}, che possono essere utilizzate per +allocare una quantità di spazio opportuna, in modo da evitare overflow. La +prima delle due è la dimensione canonica per uno stack di segnali e di norma è +sufficiente per tutti gli usi normali. La seconda è lo spazio che occorre al +sistema per essere in grado di lanciare il manipolatore e la dimensione di uno +stack alternativo deve essere sempre maggiore di questo valore. Quando si +conosce esattamente quanto è lo spazio necessario al manipolatore gli si può +aggiungere questo valore per allocare uno stack di dimensione sufficiente. + +Come accennato per poter essere usato lo stack per i segnali deve essere +indicato al sistema attraverso la funzione \func{sigaltstack}; il suo +prototipo è: +\begin{prototype}{signal.h} +{int sigaltstack(const stack\_t *ss, stack\_t *oss)} + +Installa un nuovo stack per i segnali. + + \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{ENOMEM}] La dimensione specificata per il nuovo stack è minore + di \macro{MINSIGSTKSZ}. + \item[\macro{EPERM}] Uno degli indirizzi non è valido. + \item[\macro{EFAULT}] Si è cercato di cambiare lo stack alternativo mentre + questo è attivo (cioè il processo è in esecuzione su di esso). + \item[\macro{EINVAL}] \param{ss} non è nullo e \var{ss\_flags} contiene un + valore diverso da zero che non è \macro{SS\_DISABLE}. + \end{errlist}} +\end{prototype} + +La funzione prende come argomenti puntatori ad una struttura di tipo +\var{stack\_t}, definita in \figref{fig:sig_stack_t}. I due valori \param{ss} +e \param{oss}, se non nulli, indicano rispettivamente il nuovo stack da +installare e quello corrente (che viene restituito dalla funzione per un +successivo ripristino). + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +typedef struct { + void *ss_sp; /* Base address of stack */ + int ss_flags; /* Flags */ + size_t ss_size; /* Number of bytes in stack */ +} stack_t; + \end{lstlisting} + \end{minipage} + \normalsize + \caption{La struttura \var{stack\_t}.} + \label{fig:sig_stack_t} +\end{figure} + +Il campo \var{ss\_sp} di \var{stack\_t} indica l'indirizzo base dello stack, +mentre \var{ss\_size} ne indica la dimensione; il campo \var{ss\_flags} invece +indica lo stato dello stack. Nell'indicare un nuovo stack occorre +inizializzare \var{ss\_sp} e \var{ss\_size} rispettivamente al puntatore e +alla dimensione della memoria allocata, mentre \var{ss\_flags} deve essere +nullo. Se invece si vuole disabilitare uno stack occorre indicare +\macro{SS\_DISABLE} come valore di \var{ss\_flags} e gli altri valori saranno +ignorati. + +Se \param{oss} non è nullo verrà restituito dalla funzione indirizzo e +dimensione dello stack corrente nei relativi campi, mentre \var{ss\_flags} +potrà assumere il valore \macro{SS\_ONSTACK} se il processo è in esecuzione +sullo stack alternativo (nel qual caso non è possibile cambiarlo) e +\macro{SS\_DISABLE} se questo non è abilitato. + +In genere si installa uno stack alternativo per i segnali quando si teme di +avere problemi di esaurimento dello stack standard o di superamento di un +limite imposto con chiamata de tipo \code{setrlimit(RLIMIT\_STACK, \&rlim)}. +In tal caso infatti si avrebbe un segnale di \macro{SIGSEGV}, che potrebbe +essere gestito soltanto avendo abilitato uno stack alternativo. + +Si tenga presente che le funzioni chiamate durante l'esecuzione sullo stack +alternativo continueranno ad usare quest'ultimo, che, al contrario di quanto +avviene per lo stack ordinario dei processi, non si accresce automaticamente +(ed infatti eccederne le dimensioni può portare a conseguenze imprevedibili). +Si ricordi infine che una chiamata ad una funzione della famiglia +\func{exec} cancella ogni stack alternativo. -\subsection{Caratteristiche ulteriori} -\label{sec:sig_specific_features} -- 2.30.2