Questo è il tipico esempio di caso, già citato in
sez.~\ref{sec:proc_race_cond}, in cui si genera una \itindex{race~condition}
\textit{race condition}. Infatti, in una situazione in cui un segnale è già
-arrivato (e quindi \var{flag} è già stata impostata ad 1 nel gestre) se un
+arrivato (e quindi \var{flag} è già stata impostata ad 1 nel gestore) se un
altro segnale arriva immediatamente dopo l'esecuzione del controllo
(\texttt{\small 6}) ma prima della cancellazione di \var{flag} fatta subito
dopo (\texttt{\small 7}), la sua occorrenza sarà perduta.
Questi esempi ci mostrano come per poter eseguire una gestione effettiva dei
segnali occorrono delle funzioni più sofisticate di quelle finora
-illustrate. La fuzione \func{signal} infatti ha la sua origine nella
+illustrate. La funzione \func{signal} infatti ha la sua origine nella
interfaccia alquanto primitiva che venne adottata nei primi sistemi Unix, ma
-con questa funzione è sostanzilmente impossibile gestire in maniera adeguata
+con questa funzione è sostanzialmente impossibile gestire in maniera adeguata
di tutti i possibili aspetti con cui un processo deve reagire alla ricezione
di un segnale.
\fhead{signal.h}
\fdecl{int sigaction(int signum, const struct sigaction *act, struct sigaction
*oldact)}
-\fdesc{Installa una nuova azione pr un segnale.}
+\fdesc{Installa una nuova azione per un segnale.}
}
{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
riportato in fig.~\ref{fig:sig_Signal_code} (il codice completo si trova nel
file \file{SigHand.c} nei sorgenti allegati). Anche in questo caso, per
semplificare la definizione si è poi definito un apposito tipo
-\texttt{SigFunc} per esprimere in forma più comprensibile la forma di un
-gestore di segnale.
+\texttt{SigFunc} per esprimere in modo più comprensibile la forma di un
+gestore di segnale.
Si noti come, essendo la funzione estremamente semplice, essa è definita come
\direct{inline}. Questa direttiva viene usata per dire al compilatore di
codice direttamente nel testo del programma. Anche se i compilatori più
moderni sono in grado di effettuare da soli queste manipolazioni (impostando
le opportune ottimizzazioni) questa è una tecnica usata per migliorare le
-prestazioni per le funzioni piccole ed usate di frequente (in particolare nel
+prestazioni per le funzioni piccole ed usate di frequente, in particolare nel
kernel, dove in certi casi le ottimizzazioni dal compilatore, tarate per l'uso
-in user space, non sono sempre adatte).
+in \textit{user space}, non sono sempre adatte.
In tal caso infatti le istruzioni per creare un nuovo frame nello
\itindex{stack} \textit{stack} per chiamare la funzione costituirebbero una
\index{maschera dei segnali|(}
Come spiegato in sez.~\ref{sec:sig_semantics} tutti i moderni sistemi unix-like
permettono di bloccare temporaneamente (o di eliminare completamente,
-impostando \const{SIG\_IGN} come azione) la consegna dei segnali ad un
+impostando come azione \const{SIG\_IGN}) la consegna dei segnali ad un
processo. Questo è fatto specificando la cosiddetta \textsl{maschera dei
segnali} (o \textit{signal mask}) del processo\footnote{nel caso di Linux
essa è mantenuta dal campo \var{blocked} della \struct{task\_struct} del
}
\end{funcproto}
-La funzione usa l'insieme di segnali posto all'indirizzo passanto
+La funzione usa l'insieme di segnali posto all'indirizzo passato
nell'argomento \param{set} per modificare la maschera dei segnali del processo
corrente. La modifica viene effettuata a seconda del valore
dell'argomento \param{how}, secondo le modalità specificate in
Il concetto è comunque più generale e porta ad una distinzione fra quelle che
POSIX chiama \textsl{funzioni insicure} (\textit{signal unsafe function}) e
-\textsl{funzioni sicure} (o più precisamente \textit{signal safe function});
-quando un segnale interrompe una funzione insicura ed il gestore chiama al suo
+\textsl{funzioni sicure} (o più precisamente \textit{signal safe function}).
+Quando un segnale interrompe una funzione insicura ed il gestore chiama al suo
interno una funzione insicura il sistema può dare luogo ad un comportamento
indefinito, la cosa non avviene invece per le funzioni sicure.
funzioni considerate sicure.
L'elenco delle funzioni considerate sicure varia a seconda della
-implementazione utilizzata e dello standard a cui si fa
-riferimento;\footnote{non è riportata una lista specifica delle funzioni
- sicure per Linux, si suppone pertanto che siano quelle richieste dallo
- standard.} secondo quanto riportato dallo standard POSIX 1003.1 nella
-revisione del 2003, le ``\textit{signal safe function}'' che possono essere
-chiamate anche all'interno di un gestore di segnali sono tutte quelle della
-lista riportata in fig.~\ref{fig:sig_safe_functions}.
+implementazione utilizzata e dello standard a cui si fa riferimento. Non è
+riportata una lista specifica delle funzioni sicure per Linux, e si suppone
+pertanto che siano quelle richieste dallo standard. Secondo quanto richiesto
+dallo standard POSIX 1003.1 nella revisione del 2003, le ``\textit{signal safe
+ function}'' che possono essere chiamate anche all'interno di un gestore di
+segnali sono tutte quelle della lista riportata in
+fig.~\ref{fig:sig_safe_functions}.
\begin{figure}[!htb]
\footnotesize \centering
Lo standard POSIX.1b, nel definire una serie di nuove interfacce per i servizi
\textit{real-time}, ha introdotto una estensione del modello classico dei
segnali che presenta dei significativi miglioramenti,\footnote{questa
- estensione è stata introdotta in Linux a partire dal kernel 2.1.43, e dalle
- \acr{glibc} 2.1.} in particolare sono stati superati tre limiti fondamentali
-dei segnali classici:
+ estensione è stata introdotta in Linux a partire dal kernel 2.1.43, e dalla
+ versione 2.1 della \acr{glibc}.} in particolare sono stati superati tre
+limiti fondamentali dei segnali classici:
\begin{basedescript}{\desclabelwidth{1cm}\desclabelstyle{\nextlinelabel}}
\item[I segnali non sono accumulati]
se più segnali vengono generati prima dell'esecuzione di un gestore
questo sarà eseguito una sola volta, ed il processo non sarà in grado di
- accorgersi di quante volte l'evento che ha generato il segnale è accaduto;
+ accorgersi di quante volte l'evento che ha generato il segnale è accaduto.
\item[I segnali non trasportano informazione]
i segnali classici non prevedono altra informazione sull'evento
che li ha generati se non il fatto che sono stati emessi (tutta
- l'informazione che il kernel associa ad un segnale è il suo numero);
+ l'informazione che il kernel associa ad un segnale è il suo numero).
\item[I segnali non hanno un ordine di consegna]
l'ordine in cui diversi segnali vengono consegnati è casuale e non
prevedibile. Non è possibile stabilire una priorità per cui la reazione a
\item i segnali sono inseriti in una coda che permette di consegnare istanze
multiple dello stesso segnale qualora esso venga inviato più volte prima
dell'esecuzione del gestore; si assicura così che il processo riceva un
- segnale per ogni occorrenza dell'evento che lo genera.
+ segnale per ogni occorrenza dell'evento che lo genera;
\item è stata introdotta una priorità nella consegna dei segnali: i segnali
vengono consegnati in ordine a seconda del loro valore, partendo da quelli
- con un numero minore, che pertanto hanno una priorità maggiore.
+ con un numero minore, che pertanto hanno una priorità maggiore;
\item è stata introdotta la possibilità di restituire dei dati al gestore,
attraverso l'uso di un apposito campo \var{si\_value} nella struttura
\struct{siginfo\_t}, accessibile tramite gestori di tipo
presente però che i primi segnali \textit{real-time} disponibili vendono usati
dalle \acr{glibc} per l'implementazione dei \textit{thread} POSIX (vedi
sez.~\ref{sec:thread_posix_intro}), ed il valore di \const{SIGRTMIN} viene
-modificato di conseguenza.\footnote{vengono usati i primi tre per la vecchia
- implementazione dei \textit{LinuxThread} ed i primi due per la nuova NTPL
- (\textit{New Thread Posix Library}), il che comporta che \const{SIGRTMIN} a
- seconda dei casi può essere 34 o 35.}
+modificato di conseguenza.\footnote{per la precisione vengono usati i primi
+ tre per la vecchia implementazione dei \textit{LinuxThread} ed i primi due
+ per la nuova NTPL (\textit{New Thread Posix Library}), il che comporta che
+ \const{SIGRTMIN} a seconda dei casi può assumere i valori 34 o 35.}
Per questo motivo nei programmi che usano i segnali \textit{real-time} non si
deve mai usare un valore assoluto dato che si correrebbe il rischio di
interrompere l'esecuzione di un gestore di un segnale a priorità più alta; la
loro azione predefinita è quella di terminare il programma. I segnali
ordinari hanno tutti la stessa priorità, che è più alta di quella di qualunque
-segnale \textit{real-time}.\footnote{lo standard non definisce niente al
- riguardo ma Linux, come molte altre implementazioni, adotta questa
- politica.}
+segnale \textit{real-time}. Lo standard non definisce niente al riguardo ma
+Linux, come molte altre implementazioni, adotta questa politica.
Si tenga presente che questi nuovi segnali non sono associati a nessun evento
specifico, a meno di non richiedere specificamente il loro utilizzo in
meccanismi di notifica come quelli per l'I/O asincrono (vedi
sez.~\ref{sec:file_asyncronous_io}) o per le code di messaggi POSIX (vedi
-sez.~\ref{sec:ipc_posix_mq}); pertanto devono essere inviati esplicitamente.
+sez.~\ref{sec:ipc_posix_mq}), pertanto devono essere inviati esplicitamente.
Inoltre, per poter usufruire della capacità di restituire dei dati, i relativi
gestori devono essere installati con \func{sigaction}, specificando per
\var{sa\_flags} la modalità \const{SA\_SIGINFO} che permette di utilizzare la
-forma estesa \var{sa\_sigaction} (vedi sez.~\ref{sec:sig_sigaction}). In
-questo modo tutti i segnali \textit{real-time} possono restituire al gestore
-una serie di informazioni aggiuntive attraverso l'argomento
+forma estesa \var{sa\_sigaction} (vedi sez.~\ref{sec:sig_sigaction}) del
+gestore. In questo modo tutti i segnali \textit{real-time} possono restituire
+al gestore una serie di informazioni aggiuntive attraverso l'argomento
\struct{siginfo\_t}, la cui definizione è stata già vista in
fig.~\ref{fig:sig_siginfo_t}, nella trattazione dei gestori in forma estesa.
In particolare i campi utilizzati dai segnali \textit{real-time} sono
\var{si\_pid} e \var{si\_uid} in cui vengono memorizzati rispettivamente il
-\ids{PID} e l'\ids{UID} effettivo del processo che ha inviato il segnale, mentre
-per la restituzione dei dati viene usato il campo \var{si\_value}.
+\ids{PID} e l'\ids{UID} effettivo del processo che ha inviato il segnale,
+mentre per la restituzione dei dati viene usato il campo \var{si\_value}.
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{\textwidth}
+ \begin{minipage}[c]{0.8\textwidth}
\includestruct{listati/sigval_t.h}
\end{minipage}
\normalsize
\label{fig:sig_sigval}
\end{figure}
-Questo è una \direct{union} di tipo \struct{sigval} (la sua definizione è in
+Detto campo, identificato con il tipo di dato \type{sigval\_t}, è una
+\direct{union} di tipo \struct{sigval} (la sua definizione è in
fig.~\ref{fig:sig_sigval}) in cui può essere memorizzato o un valore numerico,
-se usata nella forma \var{sival\_int}, o un indirizzo, se usata nella forma
+se usata nella forma \var{sival\_int}, o un puntatore, se usata nella forma
\var{sival\_ptr}. L'unione viene usata dai segnali \textit{real-time} e da
-vari meccanismi di notifica\footnote{un campo di tipo \type{sigval\_t} è
- presente anche nella struttura \struct{sigevent} (definita in
- fig.~\ref{fig:struct_sigevent}) che viene usata dai meccanismi di notifica
- come quelli per \itindex{POSIX~Timer~API} i timer POSIX (vedi
- sez.~\ref{sec:sig_timer_adv}), l'I/O asincrono (vedi
- sez.~\ref{sec:file_asyncronous_io}) o le code di messaggi POSIX (vedi
- sez.~\ref{sec:ipc_posix_mq}).} per restituire dati al gestore del segnale;
-in alcune definizioni essa viene identificata anche con l'abbreviazione
-\type{sigval\_t}.
+vari meccanismi di notifica per restituire dati al gestore del segnale in
+\var{si\_value}. Un campo di tipo \type{sigval\_t} è presente anche nella
+struttura \struct{sigevent} (definita in fig.~\ref{fig:struct_sigevent}) che
+viene usata dai meccanismi di notifica come quelli per
+\itindex{POSIX~Timer~API} i timer POSIX (vedi sez.~\ref{sec:sig_timer_adv}),
+l'I/O asincrono (vedi sez.~\ref{sec:file_asyncronous_io}) o le code di
+messaggi POSIX (vedi sez.~\ref{sec:ipc_posix_mq}).
A causa delle loro caratteristiche, la funzione \func{kill} non è adatta ad
inviare segnali \textit{real-time}, poiché non è in grado di fornire alcun
-valore per \struct{sigval}; per questo motivo lo standard ha previsto una
-nuova funzione, \funcd{sigqueue}, il cui prototipo è:
-\begin{prototype}{signal.h}
- {int sigqueue(pid\_t pid, int signo, const union sigval value)}
-
- Invia il segnale \param{signo} al processo \param{pid}, restituendo al
- gestore il valore \param{value}.
-
- \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori:
+valore per il campo \var{si\_value} restituito nella struttura
+\struct{siginfo\_t} prevista da un gestore in forma estesa. Per questo motivo
+lo standard ha previsto una nuova funzione, \funcd{sigqueue}, il cui prototipo
+è:
+
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{int sigqueue(pid\_t pid, int signo, const union sigval value)}
+\fdesc{Invia un segnale con un valore di informazione.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{EAGAIN}] la coda è esaurita, ci sono già
\const{SIGQUEUE\_MAX} segnali in attesa si consegna.
+ \item[\errcode{EINVAL}] si è specificato un valore non valido per
+ \param{signo}.
\item[\errcode{EPERM}] non si hanno privilegi appropriati per inviare il
segnale al processo specificato.
\item[\errcode{ESRCH}] il processo \param{pid} non esiste.
- \item[\errcode{EINVAL}] si è specificato un valore non valido per
- \param{signo}.
\end{errlist}
- ed inoltre \errval{ENOMEM}.}
-\end{prototype}
+}
+\end{funcproto}
+
-Il comportamento della funzione è analogo a quello di \func{kill}, ed i
-privilegi occorrenti ad inviare il segnale ad un determinato processo sono gli
-stessi; un valore nullo di \param{signo} permette di verificare le condizioni
-di errore senza inviare nessun segnale.
+La funzione invia il segnale indicato dall'argomento \param{signo} al processo
+indicato dall'argomento \param{pid}. Per il resto il comportamento della
+funzione è analogo a quello di \func{kill}, ed i privilegi occorrenti ad
+inviare il segnale ad un determinato processo sono gli stessi; un valore nullo
+di \param{signo} permette di verificare le condizioni di errore senza inviare
+nessun segnale.
Se il segnale è bloccato la funzione ritorna immediatamente, se si è
installato un gestore con \const{SA\_SIGINFO} e ci sono risorse disponibili,
(vale a dire che c'è posto nella coda dei segnali \textit{real-time}) esso
-viene inserito e diventa pendente; una volta consegnato riporterà nel campo
-\var{si\_code} di \struct{siginfo\_t} il valore \const{SI\_QUEUE} e il campo
-\var{si\_value} riceverà quanto inviato con \param{value}. Se invece si è
-installato un gestore nella forma classica il segnale sarà generato, ma tutte
-le caratteristiche tipiche dei segnali \textit{real-time} (priorità e coda)
-saranno perse.
+viene inserito e diventa pendente. Una volta consegnato il segnale il gestore
+otterrà nel campo \var{si\_code} di \struct{siginfo\_t} il valore
+\const{SI\_QUEUE} e nel campo \var{si\_value} il valore indicato
+nell'argomento \param{value}. Se invece si è installato un gestore nella forma
+classica il segnale sarà generato, ma tutte le caratteristiche tipiche dei
+segnali \textit{real-time} (priorità e coda) saranno perse.
Secondo lo standard POSIX la profondità della coda è indicata dalla costante
-\const{SIGQUEUE\_MAX},\footnote{una della tante costanti di sistema definite
- dallo standard POSIX che non abbiamo riportato esplicitamente in
- sez.~\ref{sec:sys_limits}.} il suo valore minimo secondo lo standard,
+\const{SIGQUEUE\_MAX}, una della tante costanti di sistema definite dallo
+standard POSIX che non abbiamo riportato esplicitamente in
+sez.~\ref{sec:sys_limits}, il suo valore minimo secondo lo standard,
\const{\_POSIX\_SIGQUEUE\_MAX}, è pari a 32. Nel caso di Linux la coda ha una
dimensione variabile; fino alla versione 2.6.7 c'era un limite massimo globale
che poteva essere impostato come parametro del kernel in
-\sysctlfile{kernel/rtsig-max};\footnote{ed il valore predefinito era
- pari a 1024.} a partire dal kernel 2.6.8 il valore globale è stato rimosso e
+\sysctlfile{kernel/rtsig-max};\footnote{ed il valore predefinito era pari a
+ 1024.} a partire dal kernel 2.6.8 il valore globale è stato rimosso e
sostituito dalla risorsa \const{RLIMIT\_SIGPENDING} associata al singolo
utente, che può essere modificata con \func{setrlimit} come illustrato in
sez.~\ref{sec:sys_resource_limit}.
% LocalWords: ENOSYS pthread ENOENT NULL attribute itimerspec new old ABSTIME
% LocalWords: epoch multiplexing overrun res lpthread sec nsec curr one shot
% LocalWords: delete stopped gdb alpha mips emulation locking ppoll epoll PGID
+% LocalWords: pwait msgrcv msgsnd semop semtimedop runnable sigisemptyset
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "gapil"
%%% End:
-% LocalWords: pwait msgrcv msgsnd semop semtimedop runnable
+% LocalWords: sigorset sigandset
projects / gapil.git / commitdiff