%% signal.tex
%%
-%% Copyright (C) 2000-2012 Simone Piccardi. Permission is granted to
+%% Copyright (C) 2000-2015 Simone Piccardi. Permission is granted to
%% copy, distribute and/or modify this document under the terms of the GNU Free
%% Documentation License, Version 1.1 or any later version published by the
%% Free Software Foundation; with the Invariant Sections being "Un preambolo",
\textit{delivered}) quando viene eseguita l'azione per esso prevista, mentre
per tutto il tempo che passa fra la generazione del segnale e la sua consegna
esso è detto \textsl{pendente} (o \textit{pending}). In genere questa
-procedura viene effettuata dallo \itindex{scheduler} scheduler quando,
-riprendendo l'esecuzione del processo in questione, verifica la presenza del
-segnale nella \struct{task\_struct} e mette in esecuzione il gestore.
+procedura viene effettuata dallo \textit{scheduler} quando, riprendendo
+l'esecuzione del processo in questione, verifica la presenza del segnale nella
+\struct{task\_struct} e mette in esecuzione il gestore.
In questa semantica un processo ha la possibilità di bloccare la consegna dei
segnali, in questo caso, se l'azione per il suddetto segnale non è quella di
ignorarlo.
Normalmente l'invio al processo che deve ricevere il segnale è immediato ed
-avviene non appena questo viene rimesso in esecuzione dallo
-\itindex{scheduler} scheduler che esegue l'azione specificata. Questo a meno
-che il segnale in questione non sia stato bloccato prima della notifica, nel
-qual caso l'invio non avviene ed il segnale resta \textsl{pendente}
-indefinitamente.
+avviene non appena questo viene rimesso in esecuzione dallo \textit{scheduler}
+che esegue l'azione specificata. Questo a meno che il segnale in questione non
+sia stato bloccato prima della notifica, nel qual caso l'invio non avviene ed
+il segnale resta \textsl{pendente} indefinitamente.
Quando lo si sblocca un segnale \textsl{pendente} sarà subito notificato. Si
tenga presente però che tradizionalmente i segnali \textsl{pendenti} non si
caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{EINVAL}] il segnale specificato non esiste.
- \item[\errcode{ESRCH}] il processo o il gruppo di processi indicato non
- esiste.
\item[\errcode{EPERM}] non si hanno privilegi sufficienti ad inviare il
segnale.
+ \item[\errcode{ESRCH}] il processo o il gruppo di processi indicato non
+ esiste.
\end{errlist}
}
\end{funcproto}
stato consegnato. In questo caso, per il comportamento dei segnali descritto
in sez.~\ref{sec:sig_sigchld}, un solo segnale sarà consegnato. Per questo
oggi l'uso di questa funzione è deprecato a favore degli
-\index{High~Resolution~Timer~(HRT)} \textit{high-resolution timer} e della
+\itindex{High~Resolution~Timer~(HRT)} \textit{high-resolution timer} e della
cosiddetta \itindex{POSIX~Timer~API} \textit{POSIX Timer API}, che tratteremo
in sez.~\ref{sec:sig_timer_adv}.
\begin{funcproto}{
\fhead{unistd.h}
\fdecl{int nanosleep(const struct timespec *req, struct timespec *rem)}
-\fdesc{Pone il processo in pausa per un periodo di tempo.}
+\fdesc{Pone il processo in pausa per un intervallo di tempo.}
}
{La funzione ritorna $0$ se l'attesa viene completata e $-1$ per un errore,
nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
+ \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale.
\item[\errcode{EINVAL}] si è specificato un numero di secondi negativo o un
numero di nanosecondi maggiore di 999.999.999.
- \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale.
\end{errlist}
}
\end{funcproto}
occorrerà almeno attendere la successiva interruzione del timer di sistema,
cioè un tempo che a seconda dei casi può arrivare fino a 1/\const{HZ}, (sempre
che il sistema sia scarico ed il processa venga immediatamente rimesso in
-esecuzione); per questo motivo il valore restituito in \param{rem} è sempre
-arrotondato al multiplo successivo di 1/\const{HZ}.
+esecuzione). Per questo motivo il valore restituito in \param{rem} è sempre
+arrotondato al multiplo successivo di 1/\const{HZ}.
Con i kernel della serie 2.4 in realtà era possibile ottenere anche pause più
-precise del centesimo di secondo usando politiche di \itindex{scheduler}
-scheduling \textit{real-time} come \const{SCHED\_FIFO} o \const{SCHED\_RR}; in
-tal caso infatti il calcolo sul numero di interruzioni del timer veniva
-evitato utilizzando direttamente un ciclo di attesa con cui si raggiungevano
-pause fino ai 2~ms con precisioni del $\mu$s. Questa estensione è stata
-rimossa con i kernel della serie 2.6, che consentono una risoluzione più alta
-del timer di sistema; inoltre a partire dal kernel 2.6.21, \func{nanosleep}
-può avvalersi del supporto dei timer ad alta risoluzione, ottenendo la massima
-precisione disponibile sull'hardware della propria macchina.
+precise del centesimo di secondo usando politiche di \textit{scheduling}
+\textit{real-time} come \const{SCHED\_FIFO} o \const{SCHED\_RR} (vedi
+sez.~\ref{sec:proc_real_time}); in tal caso infatti il calcolo sul numero di
+interruzioni del timer veniva evitato utilizzando direttamente un ciclo di
+attesa con cui si raggiungevano pause fino ai 2~ms con precisioni del
+$\mu$s. Questa estensione è stata rimossa con i kernel della serie 2.6, che
+consentono una risoluzione più alta del timer di sistema; inoltre a partire
+dal kernel 2.6.21, \func{nanosleep} può avvalersi del supporto dei timer ad
+alta risoluzione, ottenendo la massima precisione disponibile sull'hardware
+della propria macchina.
\subsection{Un esempio elementare}
Dato che è nostra intenzione utilizzare \signal{SIGALRM} il primo passo della
nostra implementazione sarà quello di installare il relativo gestore salvando
-il precedente (\texttt{\small 14-17}). Si effettuerà poi una chiamata ad
+il precedente (\texttt{\small 14--17}). Si effettuerà poi una chiamata ad
\func{alarm} per specificare il tempo d'attesa per l'invio del segnale a cui
segue la chiamata a \func{pause} per fermare il programma (\texttt{\small
- 18-20}) fino alla sua ricezione. Al ritorno di \func{pause}, causato dal
-ritorno del gestore (\texttt{\small 1-9}), si ripristina il gestore originario
-(\texttt{\small 21-22}) restituendo l'eventuale tempo rimanente
-(\texttt{\small 23-24}) che potrà essere diverso da zero qualora
+ 18--20}) fino alla sua ricezione. Al ritorno di \func{pause}, causato dal
+ritorno del gestore (\texttt{\small 1--9}), si ripristina il gestore originario
+(\texttt{\small 21--22}) restituendo l'eventuale tempo rimanente
+(\texttt{\small 23--24}) che potrà essere diverso da zero qualora
l'interruzione di \func{pause} venisse causata da un altro segnale.
Questo codice però, a parte il non gestire il caso in cui si è avuta una
\label{fig:sig_sleep_incomplete}
\end{figure}
-In questo caso il gestore (\texttt{\small 18-27}) non ritorna come in
+In questo caso il gestore (\texttt{\small 18--27}) non ritorna come in
fig.~\ref{fig:sig_sleep_wrong}, ma usa la funzione \func{longjmp}
(\texttt{\small 25}) per rientrare direttamente nel corpo principale del
programma. Dato che in questo caso il valore di uscita che verrà restituito da
-\func{setjmp} è 1, grazie alla condizione impostata in (\texttt{\small 9-12})
+\func{setjmp} è 1, grazie alla condizione impostata in (\texttt{\small 9--12})
si potrà evitare comunque che \func{pause} sia chiamata a vuoto.
Ma anche questa implementazione comporta dei problemi, in questo caso infatti
quello riportato in fig.~\ref{fig:sig_event_wrong}.
La logica del programma è quella di far impostare al gestore (\texttt{\small
- 14-19}) una \index{variabili!globali} variabile globale, preventivamente
+ 14--19}) una \index{variabili!globali} variabile globale, preventivamente
inizializzata nel programma principale, ad un diverso valore. In questo modo
dal corpo principale del programma si potrà determinare, osservandone il
contenuto di detta variabile, l'occorrenza o meno del segnale, ed eseguire le
-azioni conseguenti (\texttt{\small 6-11}) relative.
+azioni conseguenti (\texttt{\small 6--11}) relative.
\begin{figure}[!htbp]
\footnotesize\centering
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
caso \var{errno} assumerà uno dei valori:
\begin{errlist}
+ \item[\errcode{EFAULT}] si sono specificati indirizzi non validi.
\item[\errcode{EINVAL}] si è specificato un numero di segnale invalido o si è
cercato di installare il gestore per \signal{SIGKILL} o
\signal{SIGSTOP}.
- \item[\errcode{EFAULT}] si sono specificati indirizzi non validi.
\end{errlist}
}
\end{funcproto}
\const{SI\_SIGIO} & Segnale di \signal{SIGIO} da una coda (vedi
sez.~\ref{sec:file_asyncronous_operation}).\\
\const{SI\_TKILL} & Inviato da \func{tkill} o \func{tgkill} (vedi
- sez.~\ref{cha:threads_xxx}), introdotto con il kernel
+ sez.~\ref{cha:thread_xxx}), introdotto con il kernel
2.4.19.\\
\hline
\end{tabular}
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
{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{EINVAL}] si è specificato un numero di segnale invalido.
\item[\errcode{EFAULT}] si sono specificati indirizzi non validi.
+ \item[\errcode{EINVAL}] si è specificato un numero di segnale invalido.
\end{errlist}
}
\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
{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{EINVAL}] si è specificato un numero di segnale invalido.
\item[\errcode{EFAULT}] si sono specificati indirizzi non validi.
+ \item[\errcode{EINVAL}] si è specificato un numero di segnale invalido.
\end{errlist}
}
\end{funcproto}
Per evitare i problemi di interferenza con gli altri segnali in questo caso
non si è usato l'approccio di fig.~\ref{fig:sig_sleep_incomplete} evitando
-l'uso di \func{longjmp}. Come in precedenza il gestore (\texttt{\small 27-30})
-non esegue nessuna operazione, limitandosi a ritornare per interrompere il
-programma messo in attesa.
+l'uso di \func{longjmp}. Come in precedenza il gestore (\texttt{\small
+ 27--30}) non esegue nessuna operazione, limitandosi a ritornare per
+interrompere il programma messo in attesa.
-La prima parte della funzione (\texttt{\small 6-10}) provvede ad installare
+La prima parte della funzione (\texttt{\small 6--10}) provvede ad installare
l'opportuno gestore per \signal{SIGALRM}, salvando quello originario, che
sarà ripristinato alla conclusione della stessa (\texttt{\small 23}); il passo
-successivo è quello di bloccare \signal{SIGALRM} (\texttt{\small 11-14}) per
+successivo è quello di bloccare \signal{SIGALRM} (\texttt{\small 11--14}) per
evitare che esso possa essere ricevuto dal processo fra l'esecuzione di
\func{alarm} (\texttt{\small 16}) e la sospensione dello stesso. Nel fare
questo si salva la maschera corrente dei segnali, che sarà ripristinata alla
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]
+\item[\textbf{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;
-\item[I segnali non trasportano informazione]
+ accorgersi di quante volte l'evento che ha generato il segnale è accaduto.
+\item[\textbf{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);
-\item[I segnali non hanno un ordine di consegna]
+ l'informazione che il kernel associa ad un segnale è il suo numero).
+\item[\textbf{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
certi segnali ha la precedenza rispetto ad altri.
\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
-\struct{siginfo\_t}, la cui definizione è stata già vista in
-fig.~\ref{fig:sig_siginfo_t}, nella trattazione dei gestori in forma estesa.
+forma estesa \var{sa\_sigaction} del gestore (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 \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
-sostituito dalla risorsa \const{RLIMIT\_SIGPENDING} associata al singolo
-utente, che può essere modificata con \func{setrlimit} come illustrato in
+\sysctlfile{kernel/rtsig-max} 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}.
-Lo standard POSIX.1b definisce inoltre delle nuove funzioni che permettono di
-gestire l'attesa di segnali specifici su una coda, esse servono in particolar
-modo nel caso dei \itindex{thread} \textit{thread}, in cui si possono usare i
-segnali \textit{real-time} come meccanismi di comunicazione elementare; la
-prima di queste funzioni è \funcd{sigwait}, il cui prototipo è:
-\begin{prototype}{signal.h}
- {int sigwait(const sigset\_t *set, int *sig)}
-
- Attende che uno dei segnali specificati in \param{set} sia pendente.
-
- \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori:
+Lo standard POSIX.1b definisce inoltre delle nuove funzioni di sistema che
+permettono di gestire l'attesa di segnali specifici su una coda, esse servono
+in particolar modo nel caso dei \itindex{thread} \textit{thread}, in cui si
+possono usare i segnali \textit{real-time} come meccanismi di comunicazione
+elementare; la prima di queste è \funcd{sigwait}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{int sigwait(const sigset\_t *set, int *sig)}
+\fdesc{Attende la ricezione di un segnale.}
+}
+{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{EINTR}] la funzione è stata interrotta.
\item[\errcode{EINVAL}] si è specificato un valore non valido per
- \param{set}.
\end{errlist}
- ed inoltre \errval{EFAULT}.}
-\end{prototype}
-
-La funzione estrae dall'insieme dei segnali pendenti uno qualunque dei segnali
-specificati da \param{set}, il cui valore viene restituito in \param{sig}. Se
-sono pendenti più segnali, viene estratto quello a priorità più alta (cioè con
-il numero più basso). Se, nel caso di segnali \textit{real-time}, c'è più di
-un segnale pendente, ne verrà estratto solo uno. Una volta estratto il segnale
-non verrà più consegnato, e se era in una coda il suo posto sarà liberato. Se
-non c'è nessun segnale pendente il processo viene bloccato fintanto che non ne
-arriva uno.
+ ed inoltre \errval{EFAULT} nel suo significato generico.}
+\end{funcproto}
+
+La funzione estrae dall'insieme dei segnali pendenti uno qualunque fra quelli
+indicati nel \textit{signal set} specificato in \param{set}, il cui valore
+viene restituito nella variabile puntata da \param{sig}. Se sono pendenti più
+segnali, viene estratto quello a priorità più alta, cioè quello con il numero
+più basso. Se, nel caso di segnali \textit{real-time}, c'è più di un segnale
+pendente, ne verrà estratto solo uno. Una volta estratto il segnale non verrà
+più consegnato, e se era in una coda il suo posto sarà liberato. Se non c'è
+nessun segnale pendente il processo viene bloccato fintanto che non ne arriva
+uno.
Per un funzionamento corretto la funzione richiede che alla sua chiamata i
segnali di \param{set} siano bloccati. In caso contrario si avrebbe un
consegnato che essere ricevuto da \func{sigwait}, il tutto in maniera non
prevedibile.
-Lo standard POSIX.1b definisce altre due funzioni, anch'esse usate
+Lo standard POSIX.1b definisce altre due funzioni di sistema, anch'esse usate
prevalentemente con i \itindex{thread} \textit{thread}; \funcd{sigwaitinfo} e
\funcd{sigtimedwait}, i relativi prototipi sono:
-\begin{functions}
- \headdecl{signal.h}
- \funcdecl{int sigwaitinfo(const sigset\_t *set, siginfo\_t *info)}
-
- Analoga a \func{sigwait}, ma riceve anche le informazioni associate al
- segnale in \param{info}.
-
- \funcdecl{int sigtimedwait(const sigset\_t *set, siginfo\_t *info, const
- struct timespec *timeout)}
-
- Analoga a \func{sigwaitinfo}, con un la possibilità di specificare un
- timeout in \param{timeout}.
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{int sigwaitinfo(const sigset\_t *set, siginfo\_t *info)}
+\fdesc{Attende un segnale con le relative informazioni.}
+\fdecl{int sigtimedwait(const sigset\_t *set, siginfo\_t *info, const
+ struct timespec *timeout)}
+\fdesc{Attende un segnale con le relative informazioni per un tempo massimo.}
+}
-
- \bodydesc{Le funzioni restituiscono 0 in caso di successo e $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori già visti per
- \func{sigwait}, ai quali si aggiunge, per \func{sigtimedwait}:
+{Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno gli stessi valori di \func{sigwait} ai quali
+ si aggiunge per \func{sigtimedwait}:
\begin{errlist}
\item[\errcode{EAGAIN}] si è superato il timeout senza che un segnale atteso
- fosse emesso.
+ sia stato ricevuto.
\end{errlist}
}
-\end{functions}
+\end{funcproto}
+
Entrambe le funzioni sono estensioni di \func{sigwait}. La prima permette di
ricevere, oltre al numero del segnale, anche le informazioni ad esso associate
-tramite \param{info}; in particolare viene restituito il numero del segnale
-nel campo \var{si\_signo}, la sua causa in \var{si\_code}, e se il segnale è
-stato immesso sulla coda con \func{sigqueue}, il valore di ritorno ad esso
-associato viene riportato in \var{si\_value}, che altrimenti è indefinito.
-
-La seconda è identica alla prima ma in più permette di specificare un timeout,
-scaduto il quale ritornerà con un errore. Se si specifica un puntatore nullo
-il comportamento sarà identico a \func{sigwaitinfo}, se si specifica un tempo
-di timeout nullo, e non ci sono segnali pendenti la funzione ritornerà
-immediatamente; in questo modo si può eliminare un segnale dalla coda senza
-dover essere bloccati qualora esso non sia presente.
+tramite l'argomento \param{info}; in particolare viene restituito il numero
+del segnale nel campo \var{si\_signo}, la sua causa in \var{si\_code}, e se il
+segnale è stato immesso sulla coda con \func{sigqueue}, il valore di ritorno
+ad esso associato viene riportato in \var{si\_value}, che altrimenti è
+indefinito.
+
+La seconda è identica alla prima ma in più permette di specificare un timeout
+con l'argomento omonimo, scaduto il quale ritornerà con un errore. Se si
+specifica per \param{timeout} un puntatore nullo il comportamento sarà
+identico a \func{sigwaitinfo}. Se si specifica un tempo di timeout nullo e non
+ci sono segnali pendenti la funzione ritornerà immediatamente, in questo modo
+si può eliminare un segnale dalla coda senza dover essere bloccati qualora
+esso non sia presente.
\itindbeg{thread}
% TODO: indicizzare i termini \itindex{POSIX~Timer~API} e HRT
-
Sia le funzioni per la gestione dei tempi viste in
sez.~\ref{sec:sys_cpu_times} che quelle per la gestione dei timer di
sez.~\ref{sec:sig_alarm_abort} sono state a lungo limitate dalla risoluzione
massima dei tempi dell'orologio interno del kernel, che era quella ottenibile
-dal timer di sistema che governa lo \textit{scheduler},\footnote{e quindi
- limitate dalla frequenza dello stesso che si ricordi, come già illustrato in
- sez.~\ref{sec:proc_hierarchy}, è data dal valore della costante
- \texttt{HZ}.} i contatori usati per il calcolo dei tempi infatti erano
-basati sul numero di \itindex{jiffies} \textit{jiffies} che vengono
-incrementati ad ogni \textit{clock tick} del timer di sistema.\footnote{il che
- comportava anche, come accennato in sez.~\ref{sec:sig_alarm_abort} per
- \func{setitimer}, problemi per il massimo periodo di tempo copribile da
- alcuni di questi orologi, come quelli associati al \textit{process time}
- almeno fino a quando, con il kernel 2.6.16, non è stato rimosso il limite di
- un valore a 32 bit per i \textit{jiffies}.}
+dal timer di sistema che governa lo \textit{scheduler}, e quindi limitate
+dalla frequenza dello stesso che si ricordi, come già illustrato in
+sez.~\ref{sec:proc_hierarchy}, è data dal valore della costante \texttt{HZ}.
+
+I contatori usati per il calcolo dei tempi infatti erano basati sul numero di
+\itindex{jiffies} \textit{jiffies} che vengono incrementati ad ogni
+\textit{clock tick} del timer di sistema, il che comportava anche, come
+accennato in sez.~\ref{sec:sig_alarm_abort} per \func{setitimer}, problemi per
+il massimo periodo di tempo copribile da alcuni di questi orologi, come quelli
+associati al \textit{process time} almeno fino a quando, con il kernel 2.6.16,
+non è stato rimosso il limite di un valore a 32 bit per i \textit{jiffies}.
+
+\itindbeg{POSIX~Timer~API}
Nelle architetture moderne però tutti i computer sono dotati di temporizzatori
hardware che possono supportare risoluzioni molto elevate, ed in maniera del
tutto indipendente dalla frequenza scelta per il timer di sistema che governa
-lo \textit{scheduler};\footnote{normalmente si possono ottenere precisioni
- fino al microsecondo, andando molto oltre in caso di hardware dedicato.} per
-questo lo standard POSIX.1-2001 ha previsto una serie di nuove funzioni
+lo \textit{scheduler}, normalmente si possono ottenere precisioni fino al
+microsecondo, andando molto oltre in caso di hardware dedicato.
+
+Per questo lo standard POSIX.1-2001 ha previsto una serie di nuove funzioni
relative a quelli che vengono chiamati ``\textsl{orologi}
\textit{real-time}'', in grado di supportare risoluzioni fino al
nanosecondo. Inoltre le CPU più moderne sono dotate a loro volta di contatori
occorre però un opportuno supporto da parte del kernel, ed i cosiddetti
\itindex{High~Resolution~Timer~(HRT)} \textit{high resolution timer} che
consentono di fare ciò sono stati introdotti nel kernel ufficiale solo a
-partire dalla versione 2.6.21.\footnote{deve essere stata abilitata l'opzione
- di compilazione \texttt{CONFIG\_HIGH\_RES\_TIMERS}, erano però disponibili
- anche in precedenza come patch facenti parte dello sviluppo delle estensioni
- \textit{real-time} del kernel, per cui alcune distribuzioni possono avere
- questo supporto anche con versioni precedenti del kernel.} Le funzioni
-definite dallo standard POSIX per gestire orologi ad alta definizione però
-erano già presenti, essendo stata introdotte insieme ad altre funzioni per il
-supporto delle estensioni \textit{real-time} con il rilascio del kernel 2.6,
-ma la risoluzione effettiva era nominale.
+partire dalla versione 2.6.21.\footnote{per il supporto deve essere stata
+ abilitata l'opzione di compilazione \texttt{CONFIG\_HIGH\_RES\_TIMERS}, il
+ supporto era però disponibile anche in precedenza nei patch facenti parte
+ dello sviluppo delle estensioni \textit{real-time} del kernel, per cui
+ alcune distribuzioni possono averlo anche con versioni precedenti del
+ kernel.} Le funzioni definite dallo standard POSIX per gestire orologi ad
+alta definizione però erano già presenti, essendo stata introdotte insieme ad
+altre funzioni per il supporto delle estensioni \textit{real-time} con il
+rilascio del kernel 2.6, ma la risoluzione effettiva era nominale.
A tutte le implementazioni che si rifanno a queste estensioni è richiesto di
disporre di una versione \textit{real-time} almeno per l'orologio generale di
sistema, quello che mantiene il \textit{calendar time} (vedi
sez.~\ref{sec:sys_time_base}), che in questa forma deve indicare il numero di
secondi e nanosecondi passati a partire dal primo gennaio 1970 (\textit{The
- Epoch}).\footnote{si ricordi che l'orologio ordinario usato dal
- \textit{calendar time} riporta solo un numero di secondi, e che la
- risoluzione effettiva normalmente non raggiunge il nanosecondo (a meno di
- hardware specializzato).} Oltre all'orologio generale di sistema possono
-essere presenti altri tipi di orologi \textit{real-time}, ciascuno dei quali
-viene identificato da un opportuno valore di una variabile di tipo
+ Epoch}). Si ricordi infatti che l'orologio ordinario usato dal
+\textit{calendar time} riporta solo un numero di secondi, e che la risoluzione
+effettiva normalmente non raggiunge il nanosecondo (a meno di hardware
+specializzato). Oltre all'orologio generale di sistema possono essere
+presenti altri tipi di orologi \textit{real-time}, ciascuno dei quali viene
+identificato da un opportuno valore di una variabile di tipo
\type{clockid\_t}; un elenco di quelli disponibili su Linux è riportato in
tab.~\ref{tab:sig_timer_clockid_types}.
specificato) che non può essere modificato e
non cambia neanche in caso di reimpostazione
dell'orologio di sistema.\\
- \const{CLOCK\_MONOTONIC\_RAW}&Simile al precedente, ma non subisce gli
- aggiustamenti dovuti all'uso di NTP (viene
- usato per fare riferimento ad una fonte
- hardware).\footnotemark\\
- \const{CLOCK\_PROCESS\_CPUTIME\_ID}& contatore del tempo di CPU usato
+ \const{CLOCK\_PROCESS\_CPUTIME\_ID}& Contatore del tempo di CPU usato
da un processo (il \textit{process time} di
sez.~\ref{sec:sys_cpu_times}, nel totale di
\textit{system time} e \textit{user time})
comprensivo di tutto il tempo di CPU usato
da eventuali \itindex{thread}
\textit{thread}.\\
- \const{CLOCK\_THREAD\_CPUTIME\_ID}& contatore del tempo di CPU
+ \const{CLOCK\_THREAD\_CPUTIME\_ID}& Contatore del tempo di CPU
(\textit{user time} e \textit{system time})
usato da un singolo \itindex{thread}
\textit{thread}.\\
+ \hline
+ \const{CLOCK\_MONOTONIC\_RAW}&Simile al precedente, ma non subisce gli
+ aggiustamenti dovuti all'uso di NTP (viene
+ usato per fare riferimento ad una fonte
+ hardware). Questo orologio è specifico di
+ Linux, ed è disponibile a partire dal kernel
+ 2.6.28.\\
+ \const{CLOCK\_BOOTTIME} & Identico a \const{CLOCK\_MONOTONIC} ma tiene
+ conto anche del tempo durante il quale il
+ sistema è stato sospeso (nel caso di
+ sospensione in RAM o \textsl{ibernazione} su
+ disco. Questo orologio è specifico di Linux,
+ ed è disponibile a partire dal kernel
+ 2.6.39.\\
+ \const{CLOCK\_REALTIME\_ALARM}&Identico a \const{CLOCK\_REALTIME}, ma se
+ usato per un timer il sistema sarà riattivato
+ anche se è in sospensione. Questo orologio è
+ specifico di Linux, ed è disponibile a
+ partire dal kernel 3.0.\\
+ \const{CLOCK\_BOOTTIME\_ALARM}&Identico a \const{CLOCK\_BOOTTIME}, ma se
+ usato per un timer il sistema sarà riattivato
+ anche se è in sospensione. Questo orologio è
+ specifico di Linux, ed è disponibile a
+ partire dal kernel 3.0.\\
% \const{} & .\\
\hline
\end{tabular}
\label{tab:sig_timer_clockid_types}
\end{table}
-\footnotetext{specifico di Linux, introdotto a partire dal kernel 2.6.28, non
- previsto da POSIX e non presente in altri sistemi unix-like.}
-% TODO: aggiungere le estensioni introdotte con il 2.6.38, verificandone il
-% funzionamento, vedi http://lwn.net/Articles/429595/
-% TODO: dal 2.6.39 anche CLOCK_BOOTTIME_ALARM e CLOCK_BOOTTIME, vedi
-% http://lwn.net/Articles/429925/
-% TODP: dal 3.0 anche i cosiddetti Posix Alarm Timers, con
+% NOTE: dal 3.0 anche i cosiddetti Posix Alarm Timers, con
% CLOCK_REALTIME_ALARM vedi http://lwn.net/Articles/429925/
+% TODO: dal 3.10 anche CLOCK_TAI
Per poter utilizzare queste funzionalità le \acr{glibc} richiedono che la
macro \macro{\_POSIX\_C\_SOURCE} sia definita ad un valore maggiore o uguale
di \texttt{199309L} (vedi sez.~\ref{sec:intro_gcc_glibc_std}), inoltre i
programmi che le usano devono essere collegati con la libreria delle
-estensioni \textit{real-time} usando esplicitamente l'opzione
-\texttt{-lrt}. Si tenga presente inoltre che la disponibilità di queste
-funzionalità avanzate può essere controllato dalla definizione della macro
-\macro{\_POSIX\_TIMERS} ad un valore maggiore di 0, e che le ulteriori macro
+estensioni \textit{real-time} usando esplicitamente l'opzione \texttt{-lrt}.
+
+Si tenga presente inoltre che la disponibilità di queste funzionalità avanzate
+può essere controllato dalla definizione della macro \macro{\_POSIX\_TIMERS}
+ad un valore maggiore di 0, e che le ulteriori macro
\macro{\_POSIX\_MONOTONIC\_CLOCK}, \macro{\_POSIX\_CPUTIME} e
\macro{\_POSIX\_THREAD\_CPUTIME} indicano la presenza dei rispettivi orologi
di tipo \const{CLOCK\_MONOTONIC}, \const{CLOCK\_PROCESS\_CPUTIME\_ID} e
-\const{CLOCK\_PROCESS\_CPUTIME\_ID}.\footnote{tutte queste macro sono definite
- in \headfile{unistd.h}, che pertanto deve essere incluso per poterle
- controllarle.} Infine se il kernel ha il supporto per gli \textit{high
+\const{CLOCK\_PROCESS\_CPUTIME\_ID}; tutte queste macro sono definite in
+\headfile{unistd.h}, che pertanto deve essere incluso per poterle
+controllarle. Infine se il kernel ha il supporto per gli \textit{high
resolution timer} un elenco degli orologi e dei timer può essere ottenuto
tramite il file \procfile{/proc/timer\_list}.
Le due funzioni che ci consentono rispettivamente di modificare o leggere il
valore per uno degli orologi \textit{real-time} sono \funcd{clock\_settime} e
\funcd{clock\_gettime}; i rispettivi prototipi sono:
-\begin{functions}
- \headdecl{time.h}
- \funcdecl{int clock\_settime(clockid\_t clockid, const struct timespec *tp)}
- \funcdecl{int clock\_gettime(clockid\_t clockid, struct timespec *tp)}
-
- Imposta o legge un orologio \textit{real-time}.
-
- \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei seguenti valori:
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{int clock\_settime(clockid\_t clockid, const struct timespec *tp)}
+\fdesc{Imposta un orologio \textit{real-time}.}
+\fdecl{int clock\_gettime(clockid\_t clockid, struct timespec *tp)}
+\fdesc{Legge un orologio \textit{real-time}.}
+}
+
+{Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
\begin{errlist}
+ \item[\errcode{EFAULT}] l'indirizzo \param{tp} non è valido.
\item[\errcode{EINVAL}] il valore specificato per \param{clockid} non è
valido o il relativo orologio \textit{real-time} non è supportato dal
sistema.
\item[\errcode{EPERM}] non si ha il permesso di impostare l'orologio
indicato (solo per \func{clock\_settime}).
- \item[\errcode{EFAULT}] l'indirizzo \param{tp} non è valido.
\end{errlist}
}
-\end{functions}
+\end{funcproto}
Entrambe le funzioni richiedono che si specifichi come primo argomento il tipo
di orologio su cui si vuole operare con uno dei valori di
\func{clock\_getcpuclockid} (che tratteremo a breve), il secondo argomento
invece è sempre il puntatore \param{tp} ad una struttura \struct{timespec}
(vedi fig.~\ref{fig:sys_timespec_struct}) che deve essere stata
-precedentemente allocata; nel primo caso questa dovrà anche essere stata
-inizializzata con il valore che si vuole impostare sull'orologio, mentre nel
-secondo verrà restituito al suo interno il valore corrente dello stesso.
+precedentemente allocata. Per \func{clock\_settime} questa dovrà anche essere
+stata inizializzata con il valore che si vuole impostare sull'orologio, mentre
+per \func{clock\_gettime} verrà restituito al suo interno il valore corrente
+dello stesso.
Si tenga presente inoltre che per eseguire un cambiamento sull'orologio
generale di sistema \const{CLOCK\_REALTIME} occorrono i privilegi
\const{CLOCK\_THREAD\_CPUTIME\_ID}, il kernel non le consente.
Oltre alle due funzioni precedenti, lo standard POSIX prevede una terza
-funzione che consenta di ottenere la risoluzione effettiva fornita da un certo
-orologio, la funzione è \funcd{clock\_getres} ed il suo prototipo è:
-\begin{functions}
- \headdecl{time.h}
+funzione di sistema che consenta di ottenere la risoluzione effettiva fornita
+da un certo orologio, la funzione è \funcd{clock\_getres} ed il suo prototipo
+è:
- \funcdecl{int clock\_getres(clockid\_t clockid, struct timespec *res)}
-
- Legge la risoluzione di un orologio \textit{real-time}.
-
- \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei seguenti valori:
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{int clock\_getres(clockid\_t clockid, struct timespec *res)}
+\fdesc{Legge la risoluzione di un orologio \textit{real-time}.}
+}
+
+{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{EFAULT}] l'indirizzo di \param{res} non è valido.
\item[\errcode{EINVAL}] il valore specificato per \param{clockid} non è
valido.
- \item[\errcode{EFAULT}] l'indirizzo di \param{res} non è valido.
\end{errlist}
}
-\end{functions}
+\end{funcproto}
La funzione richiede come primo argomento l'indicazione dell'orologio di cui
si vuole conoscere la risoluzione (effettuata allo stesso modo delle due
precedenti) e questa verrà restituita in una struttura \struct{timespec}
-all'indirizzo puntato dall'argomento \param{res}.
+all'indirizzo puntato dall'argomento \param{res}.
Come accennato il valore di questa risoluzione dipende sia dall'hardware
disponibile che dalla implementazione delle funzioni, e costituisce il limite
voglia utilizzare nelle funzioni di impostazione che non corrisponda ad un
multiplo intero di questa risoluzione, sarà troncato in maniera automatica.
+Gli orologi elencati nella seconda sezione di
+tab.~\ref{tab:sig_timer_clockid_types} sono delle estensioni specifiche di
+Linux, create per rispondere ad alcune esigenze specifiche, come quella di
+tener conto di eventuali periodi di sospensione del sistema, e presenti solo
+nelle versioni più recenti del kernel. In particolare gli ultimi due,
+contraddistinti dal suffisso \texttt{\_ALARM}, hanno un impiego particolare,
+derivato dalle esigenze emerse con Android per l'uso di Linux sui cellulari,
+che consente di creare timer che possono scattare, riattivando il sistema,
+anche quando questo è in sospensione. Per il loro utilizzo è prevista la
+necessità di una capacità specifica, \const{CAP\_WAKE\_ALARM} (vedi
+sez.~\ref{sec:proc_capabilities}).
+
Si tenga presente inoltre che con l'introduzione degli \textit{high resolution
timer} i due orologi \const{CLOCK\_PROCESS\_CPUTIME\_ID} e
\const{CLOCK\_THREAD\_CPUTIME\_ID} fanno riferimento ai contatori presenti in
apposita funzione che sia in grado di ottenere l'identificativo dell'orologio
associato al \textit{process time} di un processo, la funzione è
\funcd{clock\_getcpuclockid} ed il suo prototipo è:
-\begin{functions}
- \headdecl{time.h}
- \funcdecl{int clock\_getcpuclockid(pid\_t pid, clockid\_t *clockid)}
-
- Ottiene l'identificatore dell'orologio di CPU usato da un processo.
-
- \bodydesc{La funzione restituisce 0 in caso di successo o un numero positivo
- in caso di errore, nel qual caso \var{errno} assumerà uno dei seguenti
- valori:
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{int clock\_getcpuclockid(pid\_t pid, clockid\_t *clockid)}
+\fdesc{Ottiene l'identificatore dell'orologio di CPU usato da un processo.}
+}
+
+{La funzione ritorna $0$ in caso di successo ed un numero positivo per un
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{ENOSYS}] non c'è il supporto per ottenere l'orologio relativo
al \textit{process time} di un altro processo, e \param{pid} non
corrisponde al processo corrente.
\item[\errcode{EPERM}] il chiamante non ha il permesso di accedere alle
- informazioni relative al processo \param{pid}.
+ informazioni relative al processo \param{pid}, avviene solo se è
+ disponibile il supporto per leggere l'orologio relativo ad un altro
+ processo.
\item[\errcode{ESRCH}] non esiste il processo \param{pid}.
\end{errlist}
}
-\end{functions}
-
+\end{funcproto}
La funzione ritorna l'identificativo di un orologio di sistema associato ad un
processo indicato tramite l'argomento \param{pid}. Un utente normale, posto
Del tutto analoga a \func{clock\_getcpuclockid}, ma da utilizzare per ottenere
l'orologio associato ad un \textit{thread} invece che a un processo, è
-\funcd{pthread\_getcpuclockid},\footnote{per poter usare la funzione, come per
+\funcd{pthread\_getcpuclockid},\footnote{per poterla utilizzare, come per
qualunque funzione che faccia riferimento ai \textit{thread}, occorre
effettuare il collegamento alla relativa libreria di gestione compilando il
programma con \texttt{-lpthread}.} il cui prototipo è:
-\begin{functions}
- \headdecl{pthread.h}
- \headdecl{time.h}
- \funcdecl{int pthread\_getcpuclockid(pthread\_t thread, clockid\_t *clockid)}
-
- Ottiene l'identificatore dell'orologio di CPU associato ad un
- \textit{thread}.
-
- \bodydesc{La funzione restituisce 0 in caso di successo o un numero positivo
- in caso di errore, nel qual caso \var{errno} assumerà uno dei seguenti
- valori:
+\begin{funcproto}{
+\fhead{pthread.h}
+\fhead{time.h}
+\fdecl{int pthread\_getcpuclockid(pthread\_t thread, clockid\_t *clockid)}
+\fdesc{Ottiene l'identificatore dell'orologio di CPU associato ad un
+ \textit{thread}.}
+}
+
+{La funzione ritorna $0$ in caso di successo ed un numero positivo per un
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{ENOENT}] la funzione non è supportata dal sistema.
\item[\errcode{ESRCH}] non esiste il \textit{thread} identificato
- da \param{thread}.
\end{errlist}
-}
-\end{functions}
+ }
+\end{funcproto}
-% TODO, dal 2.6.39 aggiunta clock_adjtime
-% TODO manca clock_nanosleep, referenziata in sez.~\ref{sec:sig_gen_beha}
+% TODO, dal 2.6.39 aggiunta clock_adjtime
Con l'introduzione degli orologi ad alta risoluzione è divenuto possibile
ottenere anche una gestione più avanzata degli allarmi; abbiamo già visto in
sez.~\ref{sec:sig_alarm_abort} come l'interfaccia di \func{setitimer} derivata
-da BSD presenti delle serie limitazioni,\footnote{in particolare la
- possibilità di perdere un segnale sotto carico.} tanto che nello standard
-POSIX.1-2008 questa viene marcata come obsoleta, e ne viene fortemente
-consigliata la sostituzione con nuova interfaccia definita dallo standard
-POSIX.1-2001 che va sotto il nome di \textit{POSIX Timer API}. Questa
-interfaccia è stata introdotta a partire dal kernel 2.6, anche se il supporto
-di varie funzionalità è stato aggiunto solo in un secondo tempo.
+da BSD presenti delle serie limitazioni, come la possibilità di perdere un
+segnale sotto carico, tanto che nello standard POSIX.1-2008 questa viene
+marcata come obsoleta, e ne viene fortemente consigliata la sostituzione con
+nuova interfaccia definita dallo standard POSIX.1-2001 che va sotto il nome di
+\textit{POSIX Timer API}. Questa interfaccia è stata introdotta a partire dal
+kernel 2.6, anche se il supporto di varie funzionalità da essa previste è
+stato aggiunto solo in un secondo tempo.
Una delle principali differenze della nuova interfaccia è che un processo può
utilizzare un numero arbitrario di timer; questi vengono creati (ma non
-avviati) tramite la funzione \funcd{timer\_create}, il cui prototipo è:
-\begin{functions}
- \headdecl{signal.h}
- \headdecl{time.h}
+avviati) tramite la funzione di sistema \funcd{timer\_create}, il cui
+prototipo è:
- \funcdecl{int timer\_create(clockid\_t clockid, struct sigevent *evp,
+\begin{funcproto}{
+\fhead{signal.h}
+\fhead{time.h}
+\fdecl{int timer\_create(clockid\_t clockid, struct sigevent *evp,
timer\_t *timerid)}
-
- Crea un nuovo timer Posix.
-
- \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei seguenti valori:
+\fdesc{Crea un nuovo timer POSIX.}
+}
+
+{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}] fallimento nel tentativo di allocare le strutture
dei timer.
\item[\errcode{ENOMEM}] errore di allocazione della memoria.
\end{errlist}
}
-\end{functions}
+\end{funcproto}
La funzione richiede tre argomenti: il primo argomento serve ad indicare quale
tipo di orologio si vuole utilizzare e prende uno dei valori di
-tab.~\ref{tab:sig_timer_clockid_types},\footnote{di detti valori però non è
- previsto l'uso di \const{CLOCK\_MONOTONIC\_RAW} mentre
- \const{CLOCK\_PROCESS\_CPUTIME\_ID} e \const{CLOCK\_THREAD\_CPUTIME\_ID}
- sono disponibili solo a partire dal kernel 2.6.12.} si può così fare
-riferimento sia ad un tempo assoluto che al tempo utilizzato dal processo (o
-\textit{thread}) stesso.
+tab.~\ref{tab:sig_timer_clockid_types}; di detti valori però non è previsto
+l'uso di \const{CLOCK\_MONOTONIC\_RAW} mentre
+\const{CLOCK\_PROCESS\_CPUTIME\_ID} e \const{CLOCK\_THREAD\_CPUTIME\_ID} sono
+disponibili solo a partire dal kernel 2.6.12. Si può così fare riferimento sia
+ad un tempo assoluto che al tempo utilizzato dal processo (o \textit{thread})
+stesso. Si possono inoltre utilizzare, posto di avere un kernel che li
+supporti, gli orologi aggiuntivi della seconda parte di
+tab.~\ref{tab:sig_timer_clockid_types}.
Il secondo argomento richiede una trattazione più dettagliata, in quanto
introduce una struttura di uso generale, \struct{sigevent}, che viene
utilizzata anche da altre funzioni, come quelle per l'I/O asincrono (vedi
sez.~\ref{sec:file_asyncronous_io}) o le code di messaggi POSIX (vedi
-sez.~\ref{sec:ipc_posix_mq})) e che serve ad indicare in maniera generica un
-meccanismo di notifica.
+sez.~\ref{sec:ipc_posix_mq}) e che serve ad indicare in maniera generica un
+meccanismo di notifica.
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{\textwidth}
+ \begin{minipage}[c]{0.8\textwidth}
\includestruct{listati/sigevent.h}
\end{minipage}
\normalsize
\end{figure}
La struttura \struct{sigevent} (accessibile includendo \headfile{time.h}) è
-riportata in fig.~\ref{fig:struct_sigevent};\footnote{la definizione effettiva
- dipende dall'implementazione, quella mostrata è la versione descritta nella
- pagina di manuale di \func{timer\_create}.} il campo \var{sigev\_notify} è
-il più importante essendo quello che indica le modalità della notifica, gli
-altri dipendono dal valore che si è specificato per \var{sigev\_notify}, si
-sono riportati in tab.~\ref{tab:sigevent_sigev_notify}. La scelta del
-meccanismo di notifica viene fatta impostando uno dei valori di
+riportata in fig.~\ref{fig:struct_sigevent}, la definizione effettiva dipende
+dall'implementazione, quella mostrata è la versione descritta nella pagina di
+manuale di \func{timer\_create}. Il campo \var{sigev\_notify} è il più
+importante essendo quello che indica le modalità della notifica, gli altri
+dipendono dal valore che si è specificato per \var{sigev\_notify}, si sono
+riportati in tab.~\ref{tab:sigevent_sigev_notify}. La scelta del meccanismo di
+notifica viene fatta impostando uno dei valori di
tab.~\ref{tab:sigevent_sigev_notify} per \var{sigev\_notify}, e fornendo gli
eventuali ulteriori argomenti necessari a secondo della scelta
effettuata. Diventa così possibile indicare l'uso di un segnale o l'esecuzione
\footnotetext{nel caso dei \textit{timer} questa funzionalità è considerata un
esempio di pessima implementazione di una interfaccia, richiesta dallo
- standard POSIX, ma da evitare totalmente, a causa della possibilità di
- creare disservizi generando una gran quantità di processi, tanto che ne è
- stata richiesta addirittura la rimozione.}
+ standard POSIX, ma da evitare totalmente nell'uso ordinario, a causa della
+ possibilità di creare disservizi generando una gran quantità di processi,
+ tanto che ne è stata richiesta addirittura la rimozione.}
Nel caso di \func{timer\_create} occorrerà passare alla funzione come secondo
argomento l'indirizzo di una di queste strutture per indicare le modalità con
Una volta creato il timer \func{timer\_create} ed ottenuto il relativo
identificatore, si può attivare o disattivare un allarme (in gergo
-\textsl{armare} o \textsl{disarmare} il timer) con la funzione
+\textsl{armare} o \textsl{disarmare} il timer) con la funzione di sistema
\funcd{timer\_settime}, il cui prototipo è:
-\begin{functions}
- \headdecl{signal.h}
- \headdecl{time.h}
- \funcdecl{int timer\_settime(timer\_t timerid, int flags, const struct
+\begin{funcproto}{
+\fhead{signal.h}
+\fhead{time.h}
+\fdecl{int timer\_settime(timer\_t timerid, int flags, const struct
itimerspec *new\_value, struct itimerspec *old\_value)}
-
- Arma o disarma il timer POSIX.
-
- \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei seguenti valori:
+\fdesc{Arma o disarma un timer POSIX.}
+}
+
+{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{EFAULT}] si è specificato un indirizzo non valido
+ per \param{new\_value} o \param{old\_value}.
\item[\errcode{EINVAL}] all'interno di \param{new\_value.value} si è
specificato un tempo negativo o un numero di nanosecondi maggiore di
999999999.
- \item[\errcode{EFAULT}] si è specificato un indirizzo non valido
- per \param{new\_value} o \param{old\_value}.
\end{errlist}
}
-\end{functions}
+\end{funcproto}
La funzione richiede che si indichi la scadenza del timer con
l'argomento \param{new\_value}, che deve essere specificato come puntatore ad
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{\textwidth}
+ \begin{minipage}[c]{0.8\textwidth}
\includestruct{listati/itimerspec.h}
\end{minipage}
\normalsize
per \param{flags} il valore \const{TIMER\_ABSTIME}, che al momento è l'unico
valore valido per \param{flags}, allora \var{it\_value} viene considerato come
un valore assoluto rispetto al valore usato dall'orologio a cui è associato il
-timer.\footnote{quindi a seconda dei casi lo si potrà indicare o come un tempo
- assoluto, quando si opera rispetto all'orologio di sistema (nel qual caso il
- valore deve essere in secondi e nanosecondi dalla \textit{epoch}) o come
- numero di secondi o nanosecondi rispetto alla partenza di un orologio di
- CPU, quando si opera su uno di questi.} Infine un valore nullo di
-\var{it\_value}, dover per nullo si intende con valori nulli per entrambi i
-campi \var{tv\_sec} e \var{tv\_nsec}, può essere utilizzato, indipendentemente
-dal tipo di orologio utilizzato, per disarmare l'allarme.
+timer.
+
+Quindi a seconda dei casi si potrà impostare un timer o con un tempo assoluto,
+quando si opera rispetto all'orologio di sistema (nel qual caso il valore deve
+essere in secondi e nanosecondi dalla \textit{epoch}) o con un numero di
+secondi o nanosecondi rispetto alla partenza di un orologio di CPU, quando si
+opera su uno di questi. Infine un valore nullo di \var{it\_value}, dove per
+nullo si intende con valori nulli per entrambi i campi \var{tv\_sec} e
+\var{tv\_nsec}, può essere utilizzato, indipendentemente dal tipo di orologio
+utilizzato, per disarmare l'allarme.
Il campo \var{it\_interval} di \struct{itimerspec} viene invece utilizzato per
impostare un allarme periodico. Se il suo valore è nullo, se cioè sono nulli
passate prima della ricezione della notifica dell'allarme.
É infatti possibile, qualunque sia il meccanismo di notifica scelto, che
-quest'ultima venga ricevuta dopo che il timer è scaduto più di una
-volta.\footnote{specialmente se si imposta un timer con una ripetizione a
- frequenza elevata.} Nel caso dell'uso di un segnale infatti il sistema mette
-in coda un solo segnale per timer,\footnote{questo indipendentemente che si
- tratti di un segnale ordinario o \textit{real-time}; per questi ultimi
- sarebbe anche possibile inviare un segnale per ogni scadenza, questo però
- non viene fatto per evitare il rischio, tutt'altro che remoto, di riempire
- la coda.} e se il sistema è sotto carico o se il segnale è bloccato, prima
-della sua ricezione può passare un intervallo di tempo sufficientemente lungo
-ad avere scadenze multiple, e lo stesso può accadere anche se si usa un
-\textit{thread} di notifica.
+quest'ultima venga ricevuta dopo che il timer è scaduto più di una volta,
+specialmente se si imposta un timer con una ripetizione a frequenza
+elevata. Nel caso dell'uso di un segnale infatti il sistema mette in coda un
+solo segnale per timer,\footnote{questo indipendentemente che si tratti di un
+ segnale ordinario o \textit{real-time}, per questi ultimi sarebbe anche
+ possibile inviare un segnale per ogni scadenza, questo però non viene fatto
+ per evitare il rischio, tutt'altro che remoto, di riempire la coda.} e se il
+sistema è sotto carico o se il segnale è bloccato, prima della sua ricezione
+può passare un intervallo di tempo sufficientemente lungo ad avere scadenze
+multiple, e lo stesso può accadere anche se si usa un \textit{thread} di
+notifica.
Per questo motivo il gestore del segnale o il \textit{thread} di notifica può
ottenere una indicazione di quante volte il timer è scaduto dall'invio della
-notifica utilizzando la funzione \funcd{timer\_getoverrun}, il cui prototipo è:
-\begin{functions}
- \headdecl{time.h}
+notifica utilizzando la funzione di sistema \funcd{timer\_getoverrun}, il cui
+prototipo è:
- \funcdecl{int timer\_getoverrun(timer\_t timerid)}
-
- Ottiene il numero di scadenze di un timer POSIX.
-
- \bodydesc{La funzione restituisce il numero di scadenze di un timer in caso
- di successo e $-1$ in caso di errore, nel qual caso \var{errno} assumerà
- il valore:
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{int timer\_getoverrun(timer\_t timerid)}
+\fdesc{Ottiene il numero di scadenze di un timer POSIX.}
+}
+
+{La funzione ritorna il numero di scadenze di un timer in caso di successo e
+ $-1$ per un errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{EINVAL}] \param{timerid} non indica un timer valido.
\end{errlist}
}
-\end{functions}
+\end{funcproto}
La funzione ritorna il numero delle scadenze avvenute, che può anche essere
nullo se non ve ne sono state. Come estensione specifica di Linux,\footnote{in
Qualora si voglia rileggere lo stato corrente di un timer, ed ottenere il
tempo mancante ad una sua eventuale scadenza, si deve utilizzare la funzione
-\funcd{timer\_gettime}, il cui prototipo è:
-\begin{functions}
- \headdecl{time.h}
+di sistema \funcd{timer\_gettime}, il cui prototipo è:
- \funcdecl{int timer\_gettime(timer\_t timerid, int flags, struct
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{int timer\_gettime(timer\_t timerid, int flags, struct
itimerspec *curr\_value)}
-
- Legge lo stato di un timer POSIX.
-
- \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei seguenti valori:
+\fdesc{Legge lo stato di un timer POSIX.}
+}
+
+{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{EINVAL}] \param{timerid} non indica un timer valido.
\item[\errcode{EFAULT}] si è specificato un indirizzo non valido
per \param{curr\_value}.
+ \item[\errcode{EINVAL}] \param{timerid} non indica un timer valido.
\end{errlist}
}
-\end{functions}
+\end{funcproto}
La funzione restituisce nella struttura \struct{itimerspec} puntata
da \param{curr\_value} il tempo restante alla prossima scadenza nel campo
Infine, quando un timer non viene più utilizzato, lo si può cancellare,
rimuovendolo dal sistema e recuperando le relative risorse, effettuando in
sostanza l'operazione inversa rispetto a \funcd{timer\_create}. Per questo
-compito lo standard prevede una apposita funzione \funcd{timer\_delete}, il
-cui prototipo è:
-\begin{functions}
- \headdecl{time.h}
+compito lo standard prevede una apposita funzione di sistema,
+\funcd{timer\_delete}, il cui prototipo è:
- \funcdecl{int timer\_delete(timer\_t timerid)}
-
- Cancella un timer POSIX.
-
- \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei seguenti valori:
- \begin{errlist}
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{int timer\_delete(timer\_t timerid)}
+\fdesc{Cancella un timer POSIX.}
+}
+
+{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{EINVAL}] \param{timerid} non indica un timer valido.
- \end{errlist}
+ \end{errlist}
}
-\end{functions}
+\end{funcproto}
La funzione elimina il timer identificato da \param{timerid}, disarmandolo se
questo era stato attivato. Nel caso, poco probabile ma comunque possibile, che
un timer venga cancellato prima della ricezione del segnale pendente per la
notifica di una scadenza, il comportamento del sistema è indefinito.
+Infine a partire dal kernel 2.6 e per le versioni della \acr{libc} superiori
+alla 2.1, si può utilizzare la nuova interfaccia dei timer POSIX anche per le
+funzioni di attesa, per questo è disponibile la funzione di sistema
+\funcd{clock\_nanosleep}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{int clock\_nanosleep(clockid\_t clock\_id, int flags, const struct
+ timespec *request,\\
+\phantom{int clock\_nanosleep(}struct timespec *remain)}
+\fdesc{Pone il processo in pausa per un tempo specificato.}
+}
+
+{La funzione ritorna $0$ in caso di successo ed un valore positivo per un
+ errore, espresso dai valori:
+ \begin{errlist}
+ \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale.
+ \item[\errcode{EINVAL}] si è specificato un numero di secondi negativo o
+ un numero di nanosecondi maggiore di 999.999.999 o indicato un orologio
+ non valido.
+ \end{errlist}
+ ed inoltre \errval{EFAULT} nel suo significato generico.}
+\end{funcproto}
+
+I due argomenti \param{request} e \param{remain} sono identici agli analoghi di
+\func{nanosleep} che abbiamo visto in sez.~\ref{sec:sig_pause_sleep}, ed hanno
+lo stesso significato. L'argomento \param{clock\_id} consente di indicare
+quale orologio si intende utilizzare per l'attesa con uno dei valori della
+prima parte di tab.~\ref{tab:sig_timer_clockid_types} (eccetto
+\const{CLOCK\_THREAD\_CPUTIME\_ID}). L'argomento \param{flags} consente di
+modificare il comportamento della funzione, il suo unico valore valido al
+momento è \const{TIMER\_ABSTIME} che, come per \func{timer\_settime} indica di
+considerare il tempo indicato in \param{request} come assoluto anziché
+relativo.
+
+Il comportamento della funzione è analogo a \func{nanosleep}, se la chiamata
+viene interrotta il tempo rimanente viene restituito in \param{remain}.
+Utilizzata normalmente con attese relative può soffrire degli stessi problemi
+di deriva di cui si è parlato in sez.~\ref{sec:sig_pause_sleep} dovuti ad
+interruzioni ripetute per via degli arrotondamenti fatti a questo tempo. Ma
+grazie alla possibilità di specificare tempi assoluti con \param{flags} si può
+ovviare a questo problema ricavando il tempo corrente con
+\func{clock\_gettime}, aggiungendovi l'intervallo di attesa, ed impostando
+questa come tempo assoluto.
+
+Si tenga presente che se si è usato il valore \const{TIMER\_ABSTIME}
+per \param{flags} e si è indicato un tempo assoluto che è già passato la
+funzione ritorna immediatamente senza nessuna sospensione. In caso di
+interruzione da parte di un segnale il tempo rimanente viene restituito
+in \param{remain} soltanto se questo non è un puntatore \val{NULL} e non si è
+specificato \const{TIMER\_ABSTIME} per \param{flags} .
+
+% TODO manca clock_nanosleep, referenziata in sez.~\ref{sec:sig_gen_beha}
+
+\itindend{POSIX~Timer~API}
+
+
+
\subsection{Ulteriori funzioni di gestione}
\label{sec:sig_specific_features}
segnali non descritte finora, relative agli aspetti meno utilizzati e più
``\textsl{esoterici}'' della interfaccia.
-La prima di queste funzioni è \funcd{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 prima di queste funzioni è la funzione di sistema \funcd{sigpending},
+anch'essa introdotta dallo standard POSIX.1, il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{signal.h}
+\fdecl{int sigpending(sigset\_t *set)}
+\fdesc{Legge l'insieme dei segnali pendenti.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà solo il valore \errcode{EFAULT} nel suo
+ significato generico.}
+\end{funcproto}
La funzione permette di ricavare quali sono i segnali pendenti per il processo
in corso, cioè i segnali che sono stati inviati dal kernel ma non sono stati
Come accennato, per poter essere usato, lo \itindex{stack} \textit{stack} per
i segnali deve essere indicato al sistema attraverso la funzione
\funcd{sigaltstack}; il suo prototipo è:
-\begin{prototype}{signal.h}
-{int sigaltstack(const stack\_t *ss, stack\_t *oss)}
-
-Installa un nuovo \textit{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{funcproto}{
+\fhead{signal.h}
+\fdecl{int sigaltstack(const stack\_t *ss, stack\_t *oss)}
+\fdesc{Installa uno \textit{stack} alternativo per i gestori di segnali.}
+}
+
+{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{EFAULT}] uno degli indirizzi degli argomenti non è valido.
+ \item[\errcode{EINVAL}] \param{ss} non è nullo e \var{ss\_flags} contiene un
+ valore diverso da zero che non è \const{SS\_DISABLE}.
\item[\errcode{ENOMEM}] la dimensione specificata per il nuovo
\textit{stack} è minore di \const{MINSIGSTKSZ}.
- \item[\errcode{EPERM}] uno degli indirizzi non è valido.
- \item[\errcode{EFAULT}] si è cercato di cambiare lo \textit{stack}
+ \item[\errcode{EPERM}] si è cercato di cambiare lo \textit{stack}
alternativo mentre questo è attivo (cioè il processo è in esecuzione su di
esso).
- \item[\errcode{EINVAL}] \param{ss} non è nullo e \var{ss\_flags} contiene un
- valore diverso da zero che non è \const{SS\_DISABLE}.
- \end{errlist}}
-\end{prototype}
+ \end{errlist}
+}
+\end{funcproto}
La funzione prende come argomenti puntatori ad una struttura di tipo
\var{stack\_t}, definita in fig.~\ref{fig:sig_stack_t}. I due valori
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{\textwidth}
+ \begin{minipage}[c]{0.8\textwidth}
\includestruct{listati/stack_t.h}
\end{minipage}
\normalsize
Abbiamo visto in fig.~\ref{fig:sig_sleep_incomplete} come si possa usare
\func{longjmp} per uscire da un gestore rientrando direttamente nel corpo
-del programma; sappiamo però che nell'esecuzione di un gestore il segnale
+del programma, sappiamo però che nell'esecuzione di un gestore il segnale
che l'ha invocato viene bloccato, e abbiamo detto che possiamo ulteriormente
modificarlo con \func{sigprocmask}.
Resta quindi il problema di cosa succede alla maschera dei segnali quando si
esce da un gestore usando questa funzione. Il comportamento dipende
-dall'implementazione; in particolare la semantica usata da BSD prevede che sia
+dall'implementazione. In particolare la semantica usata da BSD prevede che sia
ripristinata la maschera dei segnali precedente l'invocazione, come per un
normale ritorno, mentre quella usata da System V no.
sez.~\ref{sec:intro_gcc_glibc_std}.
Lo standard POSIX però prevede anche la presenza di altre due funzioni
-\funcd{sigsetjmp} e \funcd{siglongjmp}, che permettono di decidere quale dei
-due comportamenti il programma deve assumere; i loro prototipi sono:
-\begin{functions}
- \headdecl{setjmp.h}
-
- \funcdecl{int sigsetjmp(sigjmp\_buf env, int savesigs)} Salva il contesto
- dello \textit{stack} per un \index{salto~non-locale} salto non-locale.
-
- \funcdecl{void siglongjmp(sigjmp\_buf env, int val)} Esegue un salto
- non-locale su un precedente contesto.
+\funcd{sigsetjmp} e \funcd{siglongjmp}, che permettono di decidere in maniera
+esplicita quale dei due comportamenti il programma deve assumere; i loro
+prototipi sono:
+
+\begin{funcproto}{
+\fhead{setjmp.h}
+\fdecl{int sigsetjmp(sigjmp\_buf env, int savesigs)}
+\fdesc{Salva il contesto dello \textit{stack} e la maschera dei segnali.}
+\fdecl{void siglongjmp(sigjmp\_buf env, int val)}
+\fdesc{Ripristina il contesto dello \textit{stack} e la maschera dei segnali.}
+}
- \bodydesc{Le due funzioni sono identiche alle analoghe \func{setjmp} e
- \func{longjmp} di sez.~\ref{sec:proc_longjmp}, ma consentono di specificare
- il comportamento sul ripristino o meno della maschera dei segnali.}
-\end{functions}
+{La funzioni sono identiche alle analoghe \func{setjmp} e \func{longjmp} di
+ sez.~\ref{sec:proc_longjmp} ed hanno gli stessi errori e valori di uscita.}
+\end{funcproto}
Le due funzioni prendono come primo argomento la variabile su cui viene
salvato il contesto dello \itindex{stack} \textit{stack} per permettere il
\index{salto~non-locale} salto non-locale; nel caso specifico essa è di tipo
\type{sigjmp\_buf}, e non \type{jmp\_buf} come per le analoghe di
sez.~\ref{sec:proc_longjmp} in quanto in questo caso viene salvata anche la
-maschera dei segnali.
+maschera dei segnali.
Nel caso di \func{sigsetjmp}, se si specifica un valore di \param{savesigs}
-diverso da zero la maschera dei valori sarà salvata in \param{env} e
-ripristinata in un successivo \func{siglongjmp}; quest'ultima funzione, a
-parte l'uso di \type{sigjmp\_buf} per \param{env}, è assolutamente identica a
+diverso da zero la maschera dei valori verrà salvata in \param{env} insieme al
+contesto dello \itindex{stack} \textit{stack} usato per il salto non
+locale. Se così si è fatto la maschera dei segnali verrà ripristinata in una
+successiva chiamata a \func{siglongjmp}. Quest'ultima, a parte l'uso di un
+valore di \param{env} di tipo \type{sigjmp\_buf}, è assolutamente identica a
\func{longjmp}.
% 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 HRT
+% LocalWords: sigorset sigandset BOOTTIME Android request remain
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "gapil"
%%% End:
-% LocalWords: pwait msgrcv msgsnd semop semtimedop runnable
projects / gapil.git / blobdiff