X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=signal.tex;h=aa47a4dc18514364b4fc05abe80f633cf14761f4;hp=66485bbcb2a63eeb751b91ef4390898b59e89ada;hb=6f8e0ca42d3d0b97b5e5747798a1eaffb44e8521;hpb=fa6f00d7ff97c2b7e88a40885be73ae54824f139;ds=sidebyside

diff --git a/signal.tex b/signal.tex
index 66485bb..aa47a4d 100644
--- a/signal.tex
+++ b/signal.tex
@@ -60,7 +60,7 @@ il seguente:
   \code{C-z};\footnote{indichiamo con \code{C-x} la pressione simultanea al
     tasto \code{x} del tasto control (ctrl in molte tastiere).}
 \item l'esecuzione di una \func{kill} o di una \func{raise} da parte del
-  processo stesso o di un'altro (solo nel caso della \func{kill}).
+  processo stesso o di un altro (solo nel caso della \func{kill}).
 \end{itemize*}
 
 Ciascuno di questi eventi (compresi gli ultimi due che pure sono controllati
@@ -125,12 +125,12 @@ segnale, ma non 
 di un segnale, pur mantenendo memoria del fatto che è avvenuto.
 
 Nella semantica \textsl{affidabile} (quella utilizzata da Linux e da ogni Unix
-moderno) il gestore una volta installato resta attivo e non si hanno
-tutti i problemi precedenti. In questa semantica i segnali vengono
-\textsl{generati} dal kernel per un processo all'occorrenza dell'evento che
-causa il segnale. In genere questo viene fatto dal kernel impostando l'apposito
-campo della \struct{task\_struct} del processo nella process table (si veda
-fig.~\ref{fig:proc_task_struct}).
+moderno) il gestore una volta installato resta attivo e non si hanno tutti i
+problemi precedenti. In questa semantica i segnali vengono \textsl{generati}
+dal kernel per un processo all'occorrenza dell'evento che causa il segnale. In
+genere questo viene fatto dal kernel impostando l'apposito campo della
+\struct{task\_struct} del processo nella \itindex{process~table}
+\textit{process table} (si veda fig.~\ref{fig:proc_task_struct}).
 
 Si dice che il segnale viene \textsl{consegnato} al processo (dall'inglese
 \textit{delivered}) quando viene eseguita l'azione per esso prevista, mentre
@@ -261,10 +261,10 @@ un eventuale messaggio di errore.
 I segnali che rappresentano errori del programma (divisione per zero o
 violazioni di accesso) hanno anche la caratteristica di scrivere un file di
 \itindex{core~dump}\textit{core dump} che registra lo stato del processo (ed
-in particolare della memoria e dello stack) prima della terminazione.  Questo
-può essere esaminato in seguito con un debugger per investigare sulla causa
-dell'errore.  Lo stesso avviene se i suddetti segnali vengono generati con una
-\func{kill}.
+in particolare della memoria e dello \itindex{stack} stack) prima della
+terminazione.  Questo può essere esaminato in seguito con un debugger per
+investigare sulla causa dell'errore.  Lo stesso avviene se i suddetti segnali
+vengono generati con una \func{kill}.
 
 
 \section{La classificazione dei segnali}
@@ -348,8 +348,8 @@ In alcuni casi alla terminazione del processo 
 file (posto nella directory corrente del processo e chiamato \file{core}) su
 cui viene salvata un'immagine della memoria del processo (il cosiddetto
 \itindex{core~dump}\textit{core dump}), che può essere usata da un debugger
-per esaminare lo stato dello stack e delle variabili al momento della
-ricezione del segnale.
+per esaminare lo stato dello \itindex{stack} stack e delle variabili al
+momento della ricezione del segnale.
 
 \begin{table}[htb]
   \footnotesize
@@ -448,6 +448,7 @@ programma al momento della terminazione.  Questi segnali sono:
 %   molte diverse eccezioni che \texttt{SIGFPE} non distingue, mentre lo
 %   standard IEEE per le operazioni in virgola mobile definisce varie eccezioni
 %   aritmetiche e richiede che esse siano notificate.  
+% TODO trovare altre info su SIGFPE e trattare la notifica delle eccezioni 
   
 \item[\const{SIGILL}] Il nome deriva da \textit{illegal instruction},
   significa che il programma sta cercando di eseguire una istruzione
@@ -456,10 +457,10 @@ programma al momento della terminazione.  Questi segnali sono:
   file eseguibile è corrotto o si stanno cercando di eseguire dei dati.
   Quest'ultimo caso può accadere quando si passa un puntatore sbagliato al
   posto di un puntatore a funzione, o si eccede la scrittura di un vettore di
-  una variabile locale, andando a corrompere lo stack. Lo stesso segnale viene
-  generato in caso di overflow dello stack o di problemi nell'esecuzione di un
-  gestore. Se il gestore ritorna il comportamento del processo è
-  indefinito.
+  una variabile locale, andando a corrompere lo \itindex{stack} stack. Lo
+  stesso segnale viene generato in caso di overflow dello \itindex{stack}
+  stack o di problemi nell'esecuzione di un gestore. Se il gestore ritorna il
+  comportamento del processo è indefinito.
 \item[\const{SIGSEGV}] Il nome deriva da \textit{segment violation}, e
   significa che il programma sta cercando di leggere o scrivere in una zona di
   memoria protetta al di fuori di quella che gli è stata riservata dal
@@ -473,9 +474,9 @@ programma al momento della terminazione.  Questi segnali sono:
   \const{SIGSEGV} questo è un segnale che viene generato di solito quando si
   dereferenzia un puntatore non inizializzato, la differenza è che
   \const{SIGSEGV} indica un accesso non permesso su un indirizzo esistente
-  (tipo fuori dallo heap o dallo stack), mentre \const{SIGBUS} indica
-  l'accesso ad un indirizzo non valido, come nel caso di un puntatore non
-  allineato.
+  (tipo fuori dallo heap o dallo \itindex{stack} stack), mentre \const{SIGBUS}
+  indica l'accesso ad un indirizzo non valido, come nel caso di un puntatore
+  non allineato.
 \item[\const{SIGABRT}] Il nome deriva da \textit{abort}. Il segnale indica che
   il programma stesso ha rilevato un errore che viene riportato chiamando la
   funzione \func{abort} che genera questo segnale.
@@ -656,7 +657,7 @@ processo, questi segnali sono:
 \begin{basedescript}{\desclabelwidth{2.0cm}}
 \item[\const{SIGPIPE}] Sta per \textit{Broken pipe}. Se si usano delle pipe,
   (o delle FIFO o dei socket) è necessario, prima che un processo inizi a
-  scrivere su una di esse, che un'altro l'abbia aperta in lettura (si veda
+  scrivere su una di esse, che un altro l'abbia aperta in lettura (si veda
   sez.~\ref{sec:ipc_pipes}). Se il processo in lettura non è partito o è
   terminato inavvertitamente alla scrittura sulla pipe il kernel genera questo
   segnale. Se il segnale è bloccato, intercettato o ignorato la chiamata che
@@ -950,7 +951,7 @@ suo prototipo 
 \begin{prototype}{signal.h}{int raise(int sig)}
   Invia il segnale \param{sig} al processo corrente.
   
-  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+  \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
     errore, il solo errore restituito è \errval{EINVAL} qualora si sia
     specificato un numero di segnale invalido.}
 \end{prototype}
@@ -973,7 +974,7 @@ prototipo 
   \funcdecl{int kill(pid\_t pid, int sig)} Invia il segnale \param{sig} al
   processo specificato con \param{pid}.
   
-  \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+  \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
     errore nel qual caso \var{errno} assumerà uno dei valori:
     \begin{errlist}
     \item[\errcode{EINVAL}] Il segnale specificato non esiste.
@@ -1007,12 +1008,14 @@ Una seconda funzione che pu
 \code{kill(-pidgrp, signal)}; il suo prototipo è:
 \begin{prototype}{signal.h}{int killpg(pid\_t pidgrp, int signal)} 
   
-  Invia il segnale \param{signal} al process group \param{pidgrp}.
-  \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+  Invia il segnale \param{signal} al \itindex{process~group} \textit{process
+    group} \param{pidgrp}.
+
+  \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
     errore, gli errori sono gli stessi di \func{kill}.}
 \end{prototype}
-\noindent e permette di inviare un segnale a tutto un \textit{process group}
-(vedi sez.~\ref{sec:sess_proc_group}).
+\noindent e permette di inviare un segnale a tutto un \itindex{process~group}
+\textit{process group} (vedi sez.~\ref{sec:sess_proc_group}).
 
 \begin{table}[htb]
   \footnotesize
@@ -1023,11 +1026,11 @@ Una seconda funzione che pu
     \hline
     \hline
     $>0$ & il segnale è mandato al processo con il \acr{pid} indicato.\\
-    0    & il segnale è mandato ad ogni processo del \textit{process group}
-    del chiamante.\\ 
+    0    & il segnale è mandato ad ogni processo del \itindex{process~group}
+           \textit{process group} del chiamante.\\ 
     $-1$ & il segnale è mandato ad ogni processo (eccetto \cmd{init}).\\
-    $<-1$ & il segnale è mandato ad ogni processo del process group 
-    $|\code{pid}|$.\\
+    $<-1$ & il segnale è mandato ad ogni processo del \textit{process group} 
+            \itindex{process~group} $|\code{pid}|$.\\
     \hline
   \end{tabular}
   \caption{Valori dell'argomento \param{pid} per la funzione
@@ -1117,7 +1120,7 @@ suo prototipo 
   Predispone l'invio di un segnale di allarme alla scadenza dell'intervallo
   \param{value} sul timer specificato da \param{which}.
   
-  \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+  \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
     errore, nel qual caso \var{errno} assumerà uno dei valori \errval{EINVAL} o
     \errval{EFAULT}.}
 \end{prototype}
@@ -1213,7 +1216,7 @@ valore corrente di un timer senza modificarlo, 
   
   Legge in \param{value} il valore del timer specificato da \param{which}.
   
-  \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+  \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
     errore e restituisce gli stessi errori di \func{getitimer}}
 \end{prototype}
 \noindent i cui argomenti hanno lo stesso significato e formato di quelli di
@@ -1265,7 +1268,7 @@ segnale 
   Pone il processo in stato di sleep fino al ritorno di un gestore.
   
   \bodydesc{La funzione ritorna solo dopo che un segnale è stato ricevuto ed
-    il relativo gestore è ritornato, nel qual caso restituisce -1 e
+    il relativo gestore è ritornato, nel qual caso restituisce $-1$ e
     \var{errno} assumerà il valore \errval{EINTR}.}
 \end{prototype}
 
@@ -1315,8 +1318,8 @@ seguono quella di SUSv2 che prevede il seguente prototipo:
   
   Pone il processo in stato di sleep per \param{usec} microsecondi.
   
-  \bodydesc{La funzione restituisce zero se l'attesa viene completata, o -1 in
-    caso di errore, nel qual caso \var{errno} assumerà il valore
+  \bodydesc{La funzione restituisce zero se l'attesa viene completata, o $-1$
+    in caso di errore, nel qual caso \var{errno} assumerà il valore
     \errval{EINTR}.}
 
 \end{prototype}
@@ -1331,8 +1334,8 @@ POSIX1.b, il cui prototipo 
   Pone il processo in stato di sleep per il tempo specificato da \param{req}.
   In caso di interruzione restituisce il tempo restante in \param{rem}.
   
-  \bodydesc{La funzione restituisce zero se l'attesa viene completata, o -1 in
-    caso di errore, nel qual caso \var{errno} assumerà uno dei valori: 
+  \bodydesc{La funzione restituisce zero se l'attesa viene completata, o $-1$
+    in caso di errore, nel qual caso \var{errno} assumerà uno dei valori:
     \begin{errlist}
     \item[\errcode{EINVAL}] si è specificato un numero di secondi negativo o un
       numero di nanosecondi maggiore di 999.999.999.
@@ -1620,7 +1623,7 @@ segnali: \funcd{sigemptyset}, \funcd{sigfillset}, \funcd{sigaddset},
   
   \bodydesc{Le prime quattro funzioni ritornano 0 in caso di successo, mentre
     \func{sigismember} ritorna 1 se \param{signum} è in \param{set} e 0
-    altrimenti. In caso di errore tutte ritornano -1, con \var{errno}
+    altrimenti. In caso di errore tutte ritornano $-1$, con \var{errno}
     impostata a \errval{EINVAL} (il solo errore possibile è che \param{signum}
     non sia un segnale valido).}
 \end{functions}
@@ -1660,7 +1663,7 @@ da un processo. Il suo prototipo 
   
   Installa una nuova azione per il segnale \param{signum}.
   
-  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+  \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
     errore, nel qual caso \var{errno} assumerà i valori:
   \begin{errlist}
   \item[\errcode{EINVAL}] Si è specificato un numero di segnale invalido o si è
@@ -1750,8 +1753,8 @@ in tab.~\ref{tab:sig_sa_flag}.
     \const{SA\_SIGINFO}  & Deve essere specificato quando si vuole usare un
                            gestore in forma estesa usando
                            \var{sa\_sigaction} al posto di \var{sa\_handler}.\\
-    \const{SA\_ONSTACK}  & Stabilisce l'uso di uno stack alternativo per
-                           l'esecuzione del gestore (vedi
+    \const{SA\_ONSTACK}  & Stabilisce l'uso di uno \itindex{stack} stack 
+                           alternativo per l'esecuzione del gestore (vedi
                            sez.~\ref{sec:sig_specific_features}).\\ 
     \hline
   \end{tabular}
@@ -1759,6 +1762,8 @@ in tab.~\ref{tab:sig_sa_flag}.
   \label{tab:sig_sa_flag}
 \end{table}
 
+% TODO con il 2.6 sono stati aggiunti SA_NOCLDWAIT e altro, documentare
+
 Come si può notare in fig.~\ref{fig:sig_sigaction} \func{sigaction} permette
 di utilizzare due forme diverse di gestore,\footnote{La possibilità è prevista
   dallo standard POSIX.1b, ed è stata aggiunta nei kernel della serie 2.1.x
@@ -1860,11 +1865,11 @@ estremamente semplice, 
   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 tal caso infatti le istruzioni per creare
-  un nuovo frame nello stack per chiamare la funzione costituirebbero una
-  parte rilevante del codice, appesantendo inutilmente il programma.
-  Originariamente questo comportamento veniva ottenuto con delle macro, ma
-  queste hanno tutta una serie di problemi di sintassi nel passaggio degli
-  argomenti (si veda ad esempio \cite{PratC}) che in questo modo possono
+  un nuovo frame nello \itindex{stack} stack per chiamare la funzione
+  costituirebbero una parte rilevante del codice, appesantendo inutilmente il
+  programma.  Originariamente questo comportamento veniva ottenuto con delle
+  macro, ma queste hanno tutta una serie di problemi di sintassi nel passaggio
+  degli argomenti (si veda ad esempio \cite{PratC}) che in questo modo possono
   essere evitati.}
 
 
@@ -1902,7 +1907,7 @@ segnali; il suo prototipo 
   
   Cambia la \textsl{maschera dei segnali} del processo corrente.
   
-  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+  \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
     errore, nel qual caso \var{errno} assumerà i valori:
   \begin{errlist}
   \item[\errcode{EINVAL}] Si è specificato un numero di segnale invalido.
@@ -1965,7 +1970,7 @@ sospensione del processo lo standard POSIX ha previsto la funzione
   
   Imposta la \textit{signal mask} specificata, mettendo in attesa il processo.
   
-  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+  \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
     errore, nel qual caso \var{errno} assumerà i valori:
   \begin{errlist}
   \item[\errcode{EINVAL}] Si è specificato un numero di segnale invalido.
@@ -2045,7 +2050,7 @@ standard POSIX.1; il suo prototipo 
   
 Scrive in \param{set} l'insieme dei segnali pendenti.
   
-  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+  \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
     errore.}
 \end{prototype}
 
@@ -2058,11 +2063,11 @@ escluderne l'avvenuto invio al momento della chiamata non significa nulla
 rispetto a quanto potrebbe essere in un qualunque momento successivo.
 
 Una delle caratteristiche di BSD, disponibile anche in Linux, è la possibilità
-di usare uno stack alternativo per i segnali; è cioè possibile fare usare al
-sistema un altro stack (invece di quello relativo al processo, vedi
-sez.~\ref{sec:proc_mem_layout}) solo durante l'esecuzione di un
-gestore. L'uso di uno stack alternativo è del tutto trasparente ai
-gestori, occorre però seguire una certa procedura:
+di usare uno \itindex{stack} stack alternativo per i segnali; è cioè possibile
+fare usare al sistema un altro \itindex{stack} stack (invece di quello
+relativo al processo, vedi sez.~\ref{sec:proc_mem_layout}) solo durante
+l'esecuzione di un gestore.  L'uso di uno stack alternativo è del tutto
+trasparente ai gestori, occorre però seguire una certa procedura:
 \begin{enumerate}
 \item Allocare un'area di memoria di dimensione sufficiente da usare come
   stack alternativo;
@@ -2078,24 +2083,24 @@ In genere il primo passo viene effettuato allocando un'opportuna area di
 memoria con \code{malloc}; in \file{signal.h} sono definite due costanti,
 \const{SIGSTKSZ} e \const{MINSIGSTKSZ}, che possono essere utilizzate per
 allocare una quantità di spazio opportuna, in modo da evitare overflow. La
-prima delle due è la dimensione canonica per uno stack di segnali e di norma è
-sufficiente per tutti gli usi normali. 
+prima delle due è la dimensione canonica per uno \itindex{stack} stack di
+segnali e di norma è sufficiente per tutti gli usi normali.
 
 La seconda è lo spazio che occorre al sistema per essere in grado di lanciare
 il gestore e la dimensione di uno stack alternativo deve essere sempre
 maggiore di questo valore. Quando si conosce esattamente quanto è lo spazio
 necessario al gestore gli si può aggiungere questo valore per allocare uno
-stack di dimensione sufficiente.
+\itindex{stack} stack di dimensione sufficiente.
 
-Come accennato, per poter essere usato, lo stack per i segnali deve essere
-indicato al sistema attraverso la funzione \funcd{sigaltstack}; il suo
-prototipo è:
+Come accennato, per poter essere usato, lo \itindex{stack} 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 stack per i segnali.
   
-  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+  \bodydesc{La funzione restituisce zero in caso di successo e $-1$ per un
     errore, nel qual caso \var{errno} assumerà i valori:
 
   \begin{errlist}
@@ -2110,10 +2115,10 @@ Installa un nuovo stack per i segnali.
 \end{prototype}
 
 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 \param{ss}
-e \param{oss}, se non nulli, indicano rispettivamente il nuovo stack da
-installare e quello corrente (che viene restituito dalla funzione per un
-successivo ripristino).
+\var{stack\_t}, definita in fig.~\ref{fig:sig_stack_t}. I due valori
+\param{ss} e \param{oss}, se non nulli, indicano rispettivamente il nuovo
+\itindex{stack} stack da installare e quello corrente (che viene restituito
+dalla funzione per un successivo ripristino).
 
 \begin{figure}[!htb]
   \footnotesize \centering
@@ -2125,33 +2130,34 @@ successivo ripristino).
   \label{fig:sig_stack_t}
 \end{figure}
 
-Il campo \var{ss\_sp} di \struct{stack\_t} indica l'indirizzo base dello stack,
-mentre \var{ss\_size} ne indica la dimensione; il campo \var{ss\_flags} invece
-indica lo stato dello stack. Nell'indicare un nuovo stack occorre
-inizializzare \var{ss\_sp} e \var{ss\_size} rispettivamente al puntatore e
-alla dimensione della memoria allocata, mentre \var{ss\_flags} deve essere
-nullo.  Se invece si vuole disabilitare uno stack occorre indicare
+Il campo \var{ss\_sp} di \struct{stack\_t} indica l'indirizzo base dello
+\itindex{stack} stack, mentre \var{ss\_size} ne indica la dimensione; il campo
+\var{ss\_flags} invece indica lo stato dello stack. Nell'indicare un nuovo
+stack occorre inizializzare \var{ss\_sp} e \var{ss\_size} rispettivamente al
+puntatore e alla dimensione della memoria allocata, mentre \var{ss\_flags}
+deve essere nullo.  Se invece si vuole disabilitare uno stack occorre indicare
 \const{SS\_DISABLE} come valore di \var{ss\_flags} e gli altri valori saranno
 ignorati.
 
 Se \param{oss} non è nullo verrà restituito dalla funzione indirizzo e
-dimensione dello stack corrente nei relativi campi, mentre \var{ss\_flags}
-potrà assumere il valore \const{SS\_ONSTACK} se il processo è in esecuzione
-sullo stack alternativo (nel qual caso non è possibile cambiarlo) e
-\const{SS\_DISABLE} se questo non è abilitato.
-
-In genere si installa uno stack alternativo per i segnali quando si teme di
-avere problemi di esaurimento dello stack standard o di superamento di un
-limite imposto con chiamate del tipo \code{setrlimit(RLIMIT\_STACK, \&rlim)}.
-In tal caso infatti si avrebbe un segnale di \const{SIGSEGV}, che potrebbe
-essere gestito soltanto avendo abilitato uno stack alternativo. 
+dimensione dello \itindex{stack} stack corrente nei relativi campi, mentre
+\var{ss\_flags} potrà assumere il valore \const{SS\_ONSTACK} se il processo è
+in esecuzione sullo stack alternativo (nel qual caso non è possibile
+cambiarlo) e \const{SS\_DISABLE} se questo non è abilitato.
+
+In genere si installa uno \itindex{stack} stack alternativo per i segnali
+quando si teme di avere problemi di esaurimento dello stack standard o di
+superamento di un limite (vedi sez.~\ref{sec:sys_resource_limit}) imposto con
+chiamate del tipo \code{setrlimit(RLIMIT\_STACK, \&rlim)}.  In tal caso
+infatti si avrebbe un segnale di \const{SIGSEGV}, che potrebbe essere gestito
+soltanto avendo abilitato uno \itindex{stack} stack alternativo.
 
 Si tenga presente che le funzioni chiamate durante l'esecuzione sullo stack
 alternativo continueranno ad usare quest'ultimo, che, al contrario di quanto
-avviene per lo stack ordinario dei processi, non si accresce automaticamente
-(ed infatti eccederne le dimensioni può portare a conseguenze imprevedibili).
-Si ricordi infine che una chiamata ad una funzione della famiglia
-\func{exec} cancella ogni stack alternativo.
+avviene per lo \itindex{stack} stack ordinario dei processi, non si accresce
+automaticamente (ed infatti eccederne le dimensioni può portare a conseguenze
+imprevedibili).  Si ricordi infine che una chiamata ad una funzione della
+famiglia \func{exec} cancella ogni stack alternativo.
 
 Abbiamo visto in fig.~\ref{fig:sig_sleep_incomplete} come si possa usare
 \func{longjmp} per uscire da un gestore rientrando direttamente nel corpo
@@ -2188,7 +2194,7 @@ due comportamenti il programma deve assumere; i loro prototipi sono:
 \end{functions}
 
 Le due funzioni prendono come primo argomento la variabile su cui viene
-salvato il contesto dello stack per permettere il
+salvato il contesto dello \itindex{stack} 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
@@ -2314,7 +2320,7 @@ funzione, \funcd{sigqueue}, il cui prototipo 
   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
+  \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
     errore, nel qual caso \var{errno} assumerà uno dei valori:
   \begin{errlist}
   \item[\errcode{EAGAIN}] La coda è esaurita, ci sono già \const{SIGQUEUE\_MAX}
@@ -2359,7 +2365,7 @@ meccanismi di comunicazione elementare; la prima di queste funzioni 
   
   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
+  \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
     errore, nel qual caso \var{errno} assumerà uno dei valori:
   \begin{errlist}
   \item[\errcode{EINTR}] La funzione è stata interrotta.
@@ -2404,7 +2410,7 @@ relativi prototipi sono:
   timeout in \param{timeout}.
 
   
-  \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso di
+  \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}:
   \begin{errlist}