Sistemata la parte della allocazione della memoria, le variadic
authorSimone Piccardi <piccardi@gnulinux.it>
Thu, 5 Jan 2012 02:45:14 +0000 (02:45 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Thu, 5 Jan 2012 02:45:14 +0000 (02:45 +0000)
function e un sacco di indici.

17 files changed:
errors.tex
fileadv.tex
filedir.tex
fileintro.tex
filestd.tex
fileunix.tex
intro.tex
ipc.tex
macro.tex
othersock.tex
process.tex
prochand.tex
session.tex
signal.tex
sockctrl.tex
system.tex
tcpsock.tex

index c8f07ee..16babfd 100644 (file)
 
 Si riportano in questa appendice tutti i codici di errore. Essi sono
 accessibili attraverso l'inclusione del file di header \file{errno.h}, che
-definisce anche la variabile globale \var{errno}. Per ogni errore definito
-riporteremo la stringa stampata da \func{perror} ed una breve spiegazione. Si
-tenga presente che spiegazioni più particolareggiate del significato
-dell'errore, qualora necessarie per casi specifici, possono essere trovate
-nella descrizione del prototipo della funzione per cui detto errore si è
-verificato.
+definisce anche la \index{variabili!globali} variabile globale
+\var{errno}. Per ogni errore definito riporteremo la stringa stampata da
+\func{perror} ed una breve spiegazione. Si tenga presente che spiegazioni più
+particolareggiate del significato dell'errore, qualora necessarie per casi
+specifici, possono essere trovate nella descrizione del prototipo della
+funzione per cui detto errore si è verificato.
 
 I codici di errore sono riportati come costanti di tipo \ctyp{int}, i valori
 delle costanti sono definiti da macro di preprocessore nel file citato, e
@@ -116,9 +116,9 @@ gestione dei file.
   vedi sez.~\ref{sec:sys_limits}).
 \item \errcode{EPIPE} \textit{Broken pipe}. Non c'è un processo che stia
   leggendo l'altro capo della pipe. Ogni funzione che restituisce questo
-  errore genera anche un segnale \const{SIGPIPE}, la cui azione predefinita è
+  errore genera anche un segnale \signal{SIGPIPE}, la cui azione predefinita è
   terminare il programma; pertanto non si potrà vedere questo errore fintanto
-  che \const{SIGPIPE} non viene gestito o bloccato.
+  che \signal{SIGPIPE} non viene gestito o bloccato.
 \item \errcode{ENOTEMPTY} \textit{Directory not empty}. La directory non è
   vuota quando l'operazione richiede che lo sia. È l'errore tipico che si ha
   quando si cerca di cancellare una directory contenente dei file.
@@ -280,7 +280,7 @@ specificati nelle sezioni precedenti.
 \item \errcode{EFAULT} \textit{Bad address}. Una stringa passata come
   argomento è fuori dello spazio di indirizzi del processo, in genere questa
   situazione provoca direttamente l'emissione di un segnale di
-  \itindex{segment~violation} \textit{segment violation} (\const{SIGSEGV}).
+  \itindex{segment~violation} \textit{segment violation} (\signal{SIGSEGV}).
 \item \errcode{EINVAL} \textit{Invalid argument}. Errore utilizzato per
   segnalare vari tipi di problemi dovuti all'aver passato un argomento
   sbagliato ad una funzione di libreria.
index accebc0..16e7a7f 100644 (file)
@@ -1173,13 +1173,14 @@ funzione.
 L'uso di \param{sigmask} è stato introdotto allo scopo di prevenire possibili
 \textit{race condition} \itindex{race~condition} quando ci si deve porre in
 attesa sia di un segnale che di dati. La tecnica classica è quella di
-utilizzare il gestore per impostare una variabile globale e controllare questa
-nel corpo principale del programma; abbiamo visto in
-sez.~\ref{sec:sig_example} come questo lasci spazio a possibili race
-condition, per cui diventa essenziale utilizzare \func{sigprocmask} per
-disabilitare la ricezione del segnale prima di eseguire il controllo e
-riabilitarlo dopo l'esecuzione delle relative operazioni, onde evitare
-l'arrivo di un segnale immediatamente dopo il controllo, che andrebbe perso.
+utilizzare il gestore per impostare una \index{variabili!globali} variabile
+globale e controllare questa nel corpo principale del programma; abbiamo visto
+in sez.~\ref{sec:sig_example} come questo lasci spazio a possibili
+\itindex{race~condition} \textit{race condition}, per cui diventa essenziale
+utilizzare \func{sigprocmask} per disabilitare la ricezione del segnale prima
+di eseguire il controllo e riabilitarlo dopo l'esecuzione delle relative
+operazioni, onde evitare l'arrivo di un segnale immediatamente dopo il
+controllo, che andrebbe perso.
 
 Nel nostro caso il problema si pone quando oltre al segnale si devono tenere
 sotto controllo anche dei file descriptor con \func{select}, in questo caso si
@@ -1650,7 +1651,7 @@ definizione è riportata in fig.~\ref{fig:epoll_event}.
 Il primo campo, \var{events}, è una maschera binaria in cui ciascun bit
 corrisponde o ad un tipo di evento, o una modalità di notifica; detto campo
 deve essere specificato come OR aritmetico delle costanti riportate in
-tab.~\ref{tab:epoll_events}. Il secondo campo, \var{data}, è una \ctyp{union}
+tab.~\ref{tab:epoll_events}. Il secondo campo, \var{data}, è una \direct{union}
 che serve a identificare il file descriptor a cui si intende fare riferimento,
 ed in astratto può contenere un valore qualsiasi (specificabile in diverse
 forme) che ne permetta una indicazione univoca. Il modo più comune di usarlo
@@ -1974,8 +1975,8 @@ specificato tramite l'argomento \param{mask}. Questo deve essere passato come
 puntatore ad una maschera di segnali creata con l'uso delle apposite macro già
 illustrate in sez.~\ref{sec:sig_sigset}. La maschera deve indicare su quali
 segnali si intende operare con \func{signalfd}; l'elenco può essere modificato
-con una successiva chiamata a \func{signalfd}. Dato che \const{SIGKILL} e
-\const{SIGSTOP} non possono essere intercettati (e non prevedono neanche la
+con una successiva chiamata a \func{signalfd}. Dato che \signal{SIGKILL} e
+\signal{SIGSTOP} non possono essere intercettati (e non prevedono neanche la
 possibilità di un gestore) un loro inserimento nella maschera verrà ignorato
 senza generare errori. 
 
@@ -2133,8 +2134,8 @@ fifo.
 Il primo passo (\texttt{\small 19--20}) è la crezione di un file descriptor
 \texttt{epfd} di \itindex{epoll} \textit{epoll} con \func{epoll\_create} che è
 quello che useremo per il controllo degli altri.  É poi necessario
-disabilitare la ricezione dei segnali (nel caso \const{SIGINT},
-\const{SIGQUIT} e \const{SIGTERM}) per i quali si vuole la notifica tramite
+disabilitare la ricezione dei segnali (nel caso \signal{SIGINT},
+\signal{SIGQUIT} e \signal{SIGTERM}) per i quali si vuole la notifica tramite
 file descriptor. Per questo prima li si inseriscono (\texttt{\small 22--25}) in
 una maschera di segnali \texttt{sigmask} che useremo con (\texttt{\small 26})
 \func{sigprocmask} per disabilitarli.  Con la stessa maschera si potrà per
@@ -2493,7 +2494,7 @@ Quello che succede è che per tutti i file posti in questa modalità\footnote{si
   tenga presente però che essa non è utilizzabile con i file ordinari ma solo
   con socket, file di terminale o pseudo terminale, ed anche, a partire dal
   kernel 2.6, anche per fifo e pipe.} il sistema genera un apposito segnale,
-\const{SIGIO}, tutte le volte che diventa possibile leggere o scrivere dal
+\signal{SIGIO}, tutte le volte che diventa possibile leggere o scrivere dal
 file descriptor che si è posto in questa modalità. Inoltre è possibile, come
 illustrato in sez.~\ref{sec:file_fcntl}, selezionare con il comando
 \const{F\_SETOWN} di \func{fcntl} quale processo o quale gruppo di processi
@@ -2535,7 +2536,7 @@ sez.~\ref{sec:sig_sigaction}).
 Per far questo però occorre utilizzare le funzionalità dei segnali real-time
 (vedi sez.~\ref{sec:sig_real_time}) impostando esplicitamente con il comando
 \const{F\_SETSIG} di \func{fcntl} un segnale real-time da inviare in caso di
-I/O asincrono (il segnale predefinito è \const{SIGIO}). In questo caso il
+I/O asincrono (il segnale predefinito è \signal{SIGIO}). In questo caso il
 gestore, tutte le volte che riceverà \const{SI\_SIGIO} come valore del campo
 \var{si\_code}\footnote{il valore resta \const{SI\_SIGIO} qualunque sia il
   segnale che si è associato all'I/O, ed indica appunto che il segnale è stato
@@ -2553,7 +2554,7 @@ la coda.
 
 Se infatti si eccedono le dimensioni di quest'ultima, il kernel, non potendo
 più assicurare il comportamento corretto per un segnale real-time, invierà al
-suo posto un solo \const{SIGIO}, su cui si saranno accumulati tutti i segnali
+suo posto un solo \signal{SIGIO}, su cui si saranno accumulati tutti i segnali
 in eccesso, e si dovrà allora determinare con un ciclo quali sono i file
 diventati attivi. L'unico modo per essere sicuri che questo non avvenga è di
 impostare la lunghezza della coda dei segnali real-time ad una dimensione
@@ -2581,7 +2582,7 @@ classico non prevedeva alcun meccanismo per cui un processo possa essere
 \textsl{notificato} di eventuali modifiche avvenute su un file. Questo è il
 motivo per cui i demoni devono essere \textsl{avvisati} in qualche
 modo\footnote{in genere questo vien fatto inviandogli un segnale di
-  \const{SIGHUP} che, per una convenzione adottata dalla gran parte di detti
+  \signal{SIGHUP} che, per una convenzione adottata dalla gran parte di detti
   programmi, causa la rilettura della configurazione.} se il loro file di
 configurazione è stato modificato, perché possano rileggerlo e riconoscere le
 modifiche.
@@ -2622,9 +2623,9 @@ questo è un meccanismo che consente ad un processo, detto \textit{lease
 \textit{lease}.
 La notifica avviene in maniera analoga a come illustrato in precedenza per
 l'uso di \const{O\_ASYNC}: di default viene inviato al \textit{lease holder}
-il segnale \const{SIGIO}, ma questo segnale può essere modificato usando il
+il segnale \signal{SIGIO}, ma questo segnale può essere modificato usando il
 comando \const{F\_SETSIG} di \func{fcntl}.\footnote{anche in questo caso si
-  può rispecificare lo stesso \const{SIGIO}.} Se si è fatto questo\footnote{è
+  può rispecificare lo stesso \signal{SIGIO}.} Se si è fatto questo\footnote{è
   in genere è opportuno farlo, come in precedenza, per utilizzare segnali
   real-time.} e si è installato il gestore del segnale con \const{SA\_SIGINFO}
 si riceverà nel campo \var{si\_fd} della struttura \struct{siginfo\_t} il
@@ -2737,7 +2738,7 @@ un'altra interfaccia,\footnote{si ricordi che anche questa è una interfaccia
   stata definita la macro \macro{\_GNU\_SOURCE}.} chiamata \textit{dnotify},
 che consente di richiedere una notifica quando una directory, o uno qualunque
 dei file in essa contenuti, viene modificato.  Come per i \textit{file lease}
-la notifica avviene di default attraverso il segnale \const{SIGIO}, ma se ne
+la notifica avviene di default attraverso il segnale \signal{SIGIO}, ma se ne
 può utilizzare un altro.\footnote{e di nuovo, per le ragioni già esposte in
   precedenza, è opportuno che si utilizzino dei segnali real-time.} Inoltre,
 come in precedenza, si potrà ottenere nel gestore del segnale il file
@@ -3430,10 +3431,10 @@ Si tenga inoltre presente che deallocare la memoria indirizzata da
 operazione può dar luogo a risultati impredicibili, perché l'accesso ai vari
 campi per eseguire l'operazione può avvenire in un momento qualsiasi dopo la
 richiesta.  Questo comporta che non si devono usare per \param{aiocbp}
-variabili automatiche e che non si deve riutilizzare la stessa struttura per
-un'altra operazione fintanto che la precedente non sia stata ultimata. In
-generale per ogni operazione si deve utilizzare una diversa struttura
-\struct{aiocb}.
+\index{variabili!automatiche} variabili automatiche e che non si deve
+riutilizzare la stessa struttura per un'altra operazione fintanto che la
+precedente non sia stata ultimata. In generale per ogni operazione si deve
+utilizzare una diversa struttura \struct{aiocb}.
 
 Dato che si opera in modalità asincrona, il successo di \func{aio\_read} o
 \func{aio\_write} non implica che le operazioni siano state effettivamente
@@ -3785,7 +3786,7 @@ Il valore dell'argomento \param{prot} indica la protezione\footnote{come
   pagine di memoria reale, ed le modalità di accesso (lettura, esecuzione,
   scrittura); una loro violazione causa quella una \itindex{segment~violation}
   \textit{segment violation}, e la relativa emissione del segnale
-  \const{SIGSEGV}.} da applicare al segmento di memoria e deve essere
+  \signal{SIGSEGV}.} da applicare al segmento di memoria e deve essere
 specificato come maschera binaria ottenuta dall'OR di uno o più dei valori
 riportati in tab.~\ref{tab:file_mmap_prot}; il valore specificato deve essere
 compatibile con la modalità di accesso con cui si è aperto il file.
@@ -3841,7 +3842,7 @@ tab.~\ref{tab:file_mmap_flag}.
                              modifiche fatte alla regione mappata, in
                              questo caso dopo una scrittura, se non c'è più
                              memoria disponibile, si ha l'emissione di
-                             un \const{SIGSEGV}.\\
+                             un \signal{SIGSEGV}.\\
     \const{MAP\_LOCKED}    & Se impostato impedisce lo swapping delle pagine
                              mappate.\\
     \const{MAP\_GROWSDOWN} & Usato per gli \itindex{stack} \textit{stack}. 
@@ -3888,7 +3889,7 @@ piuttosto complessi, essi si possono comprendere solo tenendo presente che
 tutto quanto è comunque basato sul meccanismo della \index{memoria~virtuale}
 memoria virtuale. Questo comporta allora una serie di conseguenze. La più
 ovvia è che se si cerca di scrivere su una zona mappata in sola lettura si
-avrà l'emissione di un segnale di violazione di accesso (\const{SIGSEGV}),
+avrà l'emissione di un segnale di violazione di accesso (\signal{SIGSEGV}),
 dato che i permessi sul segmento di memoria relativo non consentono questo
 tipo di accesso.
 
@@ -3915,7 +3916,7 @@ verrà il file sarà mappato su un segmento di memoria che si estende fino al
 bordo della pagina successiva.
 
 In questo caso è possibile accedere a quella zona di memoria che eccede le
-dimensioni specificate da \param{length}, senza ottenere un \const{SIGSEGV}
+dimensioni specificate da \param{length}, senza ottenere un \signal{SIGSEGV}
 poiché essa è presente nello spazio di indirizzi del processo, anche se non è
 mappata sul file. Il comportamento del sistema è quello di restituire un
 valore nullo per quanto viene letto, e di non riportare su file quanto viene
@@ -3929,8 +3930,8 @@ quella della mappatura in memoria.
 In questa situazione, per la sezione di pagina parzialmente coperta dal
 contenuto del file, vale esattamente quanto visto in precedenza; invece per la
 parte che eccede, fino alle dimensioni date da \param{length}, l'accesso non
-sarà più possibile, ma il segnale emesso non sarà \const{SIGSEGV}, ma
-\const{SIGBUS}, come illustrato in fig.~\ref{fig:file_mmap_exceed}.
+sarà più possibile, ma il segnale emesso non sarà \signal{SIGSEGV}, ma
+\signal{SIGBUS}, come illustrato in fig.~\ref{fig:file_mmap_exceed}.
 
 Non tutti i file possono venire mappati in memoria, dato che, come illustrato
 in fig.~\ref{fig:file_mmap_layout}, la mappatura introduce una corrispondenza
@@ -4537,7 +4538,7 @@ sez.~\ref{sec:file_read} e \ref{sec:file_write}); le due funzioni sono
     per \var{errno} anche i valori:
   \begin{errlist}
   \item[\errcode{EOVERFLOW}] \param{offset} ha un valore che non può essere
-    usato come \ctyp{off\_t}.
+    usato come \type{off\_t}.
   \item[\errcode{ESPIPE}] \param{fd} è associato ad un socket o una pipe.
   \end{errlist}
 }
@@ -5174,7 +5175,7 @@ nelle operazioni successive.
 
 Il concetto di \func{readahead} viene generalizzato nello standard
 POSIX.1-2001 dalla funzione \func{posix\_fadvise},\footnote{anche se
-  l'argomento \param{len} è stato modificato da \ctyp{size\_t} a \ctyp{off\_t}
+  l'argomento \param{len} è stato modificato da \type{size\_t} a \type{off\_t}
   nella revisione POSIX.1-2003 TC5.} che consente di ``\textsl{avvisare}'' il
 kernel sulle modalità con cui si intende accedere nel futuro ad una certa
 porzione di un file,\footnote{la funzione però è stata introdotta su Linux
index 956d32c..f467b08 100644 (file)
@@ -722,9 +722,9 @@ serie 2.4 alla serie 2.6 è stata aumentata a 32 bit la dimensione del tipo
 \type{dev\_t}, con delle dimensioni passate a 12 bit per il
 \itindex{major~number} \textit{major number} e 20 bit per il
 \itindex{minor~number} \textit{minor number}. La transizione però ha anche
-comportato il passaggio di \type{dev\_t} a tipo opaco, e la necessità di
-specificare il numero tramite delle opportune macro, così da non avere
-problemi di compatibilità con eventuali ulteriori estensioni.  
+comportato il passaggio di \type{dev\_t} a \index{tipo!opaco} tipo opaco, e la
+necessità di specificare il numero tramite delle opportune macro, così da non
+avere problemi di compatibilità con eventuali ulteriori estensioni.
 
 Le macro sono definite nel file \file{sys/sysmacros.h}, che viene
 automaticamente incluso quando si include \file{sys/types.h}; si possono
@@ -3619,11 +3619,12 @@ mantenere i dati di una ACL contenente fino ad un massimo di \param{count}
 voci. La funzione ritorna un valore di tipo \type{acl\_t}, da usare in tutte
 le altre funzioni che operano sulla ACL. La funzione si limita alla
 allocazione iniziale e non inserisce nessun valore nella ACL che resta vuota.
-Si tenga presente che pur essendo \type{acl\_t} un tipo opaco che identifica
-``\textsl{l'oggetto}'' ACL, il valore restituito dalla funzione non è altro
-che un puntatore all'area di memoria allocata per i dati richiesti; pertanto
-in caso di fallimento verrà restituito un puntatore nullo e si dovrà
-confrontare il valore di ritorno della funzione con ``\code{(acl\_t) NULL}''.
+Si tenga presente che pur essendo \type{acl\_t} un \index{tipo!opaco} tipo
+opaco che identifica ``\textsl{l'oggetto}'' ACL, il valore restituito dalla
+funzione non è altro che un puntatore all'area di memoria allocata per i dati
+richiesti; pertanto in caso di fallimento verrà restituito un puntatore nullo
+e si dovrà confrontare il valore di ritorno della funzione con
+``\code{(acl\_t) NULL}''.
 
 Una volta che si siano completate le operazioni sui dati di una ACL la memoria
 allocata dovrà essere liberata esplicitamente attraverso una chiamata alla
@@ -5291,17 +5292,18 @@ una libreria a parte,\footnote{la libreria è \texttt{libcap2}, nel caso di
 programma le utilizza si dovrà indicare esplicitamente l'uso della suddetta
 libreria attraverso l'opzione \texttt{-lcap} del compilatore.
 
-Le funzioni dell'interfaccia delle bozze di POSIX.1e prevedono l'uso di uno
-tipo di dato opaco, \type{cap\_t}, come puntatore ai dati mantenuti nel
-cosiddetto \textit{capability state},\footnote{si tratta in sostanza di un
-  puntatore ad una struttura interna utilizzata dalle librerie, i cui campi
-  non devono mai essere acceduti direttamente.} in sono memorizzati tutti i
-dati delle \textit{capabilities}. In questo modo è possibile mascherare i
-dettagli della gestione di basso livello, che potranno essere modificati senza
-dover cambiare le funzioni dell'interfaccia, che faranno riferimento soltanto
-ad oggetti di questo tipo.  L'interfaccia pertanto non soltanto fornisce le
-funzioni per modificare e leggere le \textit{capabilities}, ma anche quelle
-per gestire i dati attraverso \type{cap\_t}.
+Le funzioni dell'interfaccia delle bozze di POSIX.1e prevedono l'uso di un
+\index{tipo!opaco} tipo di dato opaco, \type{cap\_t}, come puntatore ai dati
+mantenuti nel cosiddetto \textit{capability state},\footnote{si tratta in
+  sostanza di un puntatore ad una struttura interna utilizzata dalle librerie,
+  i cui campi non devono mai essere acceduti direttamente.} in sono
+memorizzati tutti i dati delle \textit{capabilities}. In questo modo è
+possibile mascherare i dettagli della gestione di basso livello, che potranno
+essere modificati senza dover cambiare le funzioni dell'interfaccia, che
+faranno riferimento soltanto ad oggetti di questo tipo.  L'interfaccia
+pertanto non soltanto fornisce le funzioni per modificare e leggere le
+\textit{capabilities}, ma anche quelle per gestire i dati attraverso
+\type{cap\_t}.
 
 La prima funzione dell'interfaccia è quella che permette di inizializzare un
 \textit{capability state}, allocando al contempo la memoria necessaria per i
index 2475bcb..1d2f936 100644 (file)
@@ -270,7 +270,7 @@ Questa è l'interfaccia standard specificata dall'ANSI C e perciò si trova
 anche su tutti i sistemi non Unix. Gli \index{file!stream} \textit{stream}
 sono oggetti complessi e sono rappresentati da puntatori ad un opportuna
 struttura definita dalle librerie del C; si accede ad essi sempre in maniera
-indiretta utilizzando il tipo \ctyp{FILE *}.  L'interfaccia è definita
+indiretta utilizzando il tipo \type{FILE *}.  L'interfaccia è definita
 nell'header \file{stdio.h}.
 
 Entrambe le interfacce possono essere usate per l'accesso ai file come agli
index 87eb446..ab03a98 100644 (file)
@@ -1418,11 +1418,11 @@ Ovviamente se si usa un buffer specificato dall'utente questo deve essere
 stato allocato e rimanere disponibile per tutto il tempo in cui si opera sullo
 stream. In genere conviene allocarlo con \func{malloc} e disallocarlo dopo la
 chiusura del file; ma fintanto che il file è usato all'interno di una
-funzione, può anche essere usata una variabile automatica. In \file{stdio.h} è
-definita la macro \const{BUFSIZ}, che indica le dimensioni generiche del
-buffer di uno stream; queste vengono usate dalla funzione \func{setbuf}.  Non
-è detto però che tale dimensione corrisponda sempre al valore ottimale (che
-può variare a seconda del dispositivo).
+funzione, può anche essere usata una \index{variabili!automatiche} variabile
+automatica. In \file{stdio.h} è definita la macro \const{BUFSIZ}, che indica
+le dimensioni generiche del buffer di uno stream; queste vengono usate dalla
+funzione \func{setbuf}.  Non è detto però che tale dimensione corrisponda
+sempre al valore ottimale (che può variare a seconda del dispositivo).
 
 Dato che la procedura di allocazione manuale è macchinosa, comporta dei rischi
 (come delle scritture accidentali sul buffer) e non assicura la scelta delle
index ad19492..674d023 100644 (file)
@@ -322,7 +322,7 @@ ritorno il file descriptor con il valore più basso disponibile.
                          \const{O\_NONBLOCK}.\\
     \const{O\_ASYNC}   & Apre il file per l'I/O in modalità asincrona (vedi
                          sez.~\ref{sec:file_asyncronous_io}). Quando è
-                         impostato viene generato il segnale \const{SIGIO}
+                         impostato viene generato il segnale \signal{SIGIO}
                          tutte le volte che sono disponibili dati in input
                          sul file.\\  
     \const{O\_SYNC}    & Apre il file per l'input/output sincrono: ogni
@@ -769,7 +769,7 @@ scrivere su di esso utilizzando la funzione \funcd{write}, il cui prototipo è:
     processo o su una posizione oltre il massimo consentito.
   \item[\errcode{EPIPE}] \param{fd} è connesso ad una pipe il cui altro capo è
     chiuso in lettura; in questo caso viene anche generato il segnale
-    \const{SIGPIPE}, se questo viene gestito (o bloccato o ignorato) la
+    \signal{SIGPIPE}, se questo viene gestito (o bloccato o ignorato) la
     funzione ritorna questo errore.
   \item[\errcode{EINTR}] si è stati interrotti da un segnale prima di aver
     potuto scrivere qualsiasi dato.
@@ -1459,13 +1459,13 @@ per \var{cmd} è riportata di seguito:
     (vedi sez.~\ref{sec:sess_proc_group}) raggruppamenti di processi usati nel
     controllo di sessione; a ciascuno di essi è associato un identificatore
     (un numero positivo analogo al \acr{pid}).} che è preposto alla ricezione
-  dei segnali \const{SIGIO}\footnote{o qualunque altro segnale alternativo
+  dei segnali \signal{SIGIO}\footnote{o qualunque altro segnale alternativo
     impostato con \const{F\_FSETSIG}.} per gli eventi associati al file
   descriptor \param{fd}\footnote{il segnale viene usato sia per il
     \textit{Signal Drive I/O}, che tratteremo in
     sez.~\ref{sec:file_asyncronous_operation}, e dai vari meccanismi di
     notifica asincrona, che tratteremo in
-    sez.~\ref{sec:file_asyncronous_lease}.} e \const{SIGURG} per la notifica
+    sez.~\ref{sec:file_asyncronous_lease}.} e \signal{SIGURG} per la notifica
   dei dati urgenti di un socket.\footnote{vedi
     sez.~\ref{sec:TCP_urgent_data}.} Nel caso di un \textit{process group}
   viene restituito un valore negativo il cui valore assoluto corrisponde
@@ -1473,7 +1473,7 @@ per \var{cmd} è riportata di seguito:
   caso di errore viene restituito $-1$.
 \item[\const{F\_SETOWN}] imposta, con il valore dell'argomento \param{arg},
   l'identificatore del processo o del \itindex{process~group} \textit{process
-    group} che riceverà i segnali \const{SIGIO}  e \const{SIGURG} per gli
+    group} che riceverà i segnali \signal{SIGIO}  e \signal{SIGURG} per gli
   eventi associati al file descriptor \param{fd}, ritorna un valore nullo in
   caso di successo o $-1$ in caso di errore.  Come per \const{F\_GETOWN}, per
   impostare un \itindex{process~group} \textit{process group} si deve usare
@@ -1482,14 +1482,14 @@ per \var{cmd} è riportata di seguito:
 \item[\const{F\_GETSIG}] restituisce il valore del segnale inviato quando ci
   sono dati disponibili in ingresso su un file descriptor aperto ed impostato
   per l'I/O asincrono (si veda sez.~\ref{sec:file_asyncronous_io}). Il valore 0
-  indica il valore predefinito (che è \const{SIGIO}), un valore diverso da
+  indica il valore predefinito (che è \signal{SIGIO}), un valore diverso da
   zero indica il segnale richiesto, (che può essere anche lo stesso
-  \const{SIGIO}). In caso di errore ritorna $-1$.
+  \signal{SIGIO}). In caso di errore ritorna $-1$.
 \item[\const{F\_SETSIG}] imposta il segnale da inviare quando diventa
   possibile effettuare I/O sul file descriptor in caso di I/O asincrono,
   ritorna un valore nullo in caso di successo o $-1$ in caso di errore. Il
-  valore zero indica di usare il segnale predefinito, \const{SIGIO}. Un altro
-  valore diverso da zero (compreso lo stesso \const{SIGIO}) specifica il
+  valore zero indica di usare il segnale predefinito, \signal{SIGIO}. Un altro
+  valore diverso da zero (compreso lo stesso \signal{SIGIO}) specifica il
   segnale voluto; l'uso di un valore diverso da zero permette inoltre, se si è
   installato il gestore del segnale come \var{sa\_sigaction} usando
   \const{SA\_SIGINFO}, (vedi sez.~\ref{sec:sig_sigaction}), di rendere
@@ -1514,7 +1514,7 @@ per \var{cmd} è riportata di seguito:
   argomento può essere omesso. Questa funzionalità avanzata è trattata in
   dettaglio in sez.~\ref{sec:file_asyncronous_lease}.
 \item[\const{F\_NOTIFY}] attiva un meccanismo di notifica per cui viene
-  riportata al processo chiamante, tramite il segnale \const{SIGIO} (o altro
+  riportata al processo chiamante, tramite il segnale \signal{SIGIO} (o altro
   segnale specificato con \const{F\_SETSIG}) ogni modifica eseguita o
   direttamente sulla directory cui \var{fd} fa riferimento, o su uno dei file
   in essa contenuti; ritorna un valore nullo in caso di successo o $-1$ in caso
@@ -1663,11 +1663,11 @@ operazioni che sono predefinite per qualunque file,\footnote{in particolare
   tipo \texttt{const int *}) che contiene un valore logico (un valore nullo
   disabilita, un valore non nullo abilita).
 \item[\const{FIOSETOWN}] imposta il processo che riceverà i segnali
-  \const{SIGURG} e \const{SIGIO} generati sul file; il terzo argomento deve
+  \signal{SIGURG} e \signal{SIGIO} generati sul file; il terzo argomento deve
   essere un puntatore ad un intero (cioè di tipo \texttt{const int *}) il cui
   valore specifica il PID del processo.
 \item[\const{FIOGETOWN}] legge il processo che riceverà i segnali
-  \const{SIGURG} e \const{SIGIO} generati sul file; il terzo argomento deve
+  \signal{SIGURG} e \signal{SIGIO} generati sul file; il terzo argomento deve
   essere un puntatore ad un intero (cioè di tipo \texttt{int *}) su cui sarà
   scritto il PID del processo.
 \item[\const{FIONREAD}] legge il numero di byte disponibili in lettura sul
index d0513cf..289c5bf 100644 (file)
--- a/intro.tex
+++ b/intro.tex
@@ -936,13 +936,13 @@ una opportuna macro; queste estensioni sono illustrate nel seguente elenco:
   presente negli standard con i file di grandi dimensioni, ed in particolare
   definire le due funzioni \func{fseeko} e \func{ftello} che al contrario
   delle corrispettive \func{fseek} e \func{ftell} usano il tipo di dato
-  specifico \ctyp{off\_t} (vedi sez.~\ref{sec:file_fseek}).
+  specifico \type{off\_t} (vedi sez.~\ref{sec:file_fseek}).
 
 \item[\macro{\_LARGEFILE64\_SOURCE}] definendo questa macro si rendono
   disponibili le funzioni di una interfaccia alternativa al supporto di valori
   a 64 bit nelle funzioni di gestione dei file (non supportati in certi
   sistemi), caratterizzate dal suffisso \texttt{64} aggiunto ai vari nomi di
-  tipi di dato e funzioni (come \ctyp{off64\_t} al posto di \ctyp{off\_t} o
+  tipi di dato e funzioni (come \type{off64\_t} al posto di \type{off\_t} o
   \func{lseek64} al posto di \func{lseek}).
 
   Le funzioni di questa interfaccia alternativa sono state proposte come una
diff --git a/ipc.tex b/ipc.tex
index cb30002..c7af632 100644 (file)
--- a/ipc.tex
+++ b/ipc.tex
@@ -114,7 +114,7 @@ essere bloccante (qualora non siano presenti dati), inoltre se si legge da una
 pipe il cui capo in scrittura è stato chiuso, si avrà la ricezione di un EOF
 (vale a dire che la funzione \func{read} ritornerà restituendo 0).  Se invece
 si esegue una scrittura su una pipe il cui capo in lettura non è aperto il
-processo riceverà il segnale \const{SIGPIPE}, e la funzione di scrittura
+processo riceverà il segnale \signal{SIGPIPE}, e la funzione di scrittura
 restituirà un errore di \errcode{EPIPE} (al ritorno del gestore, o qualora il
 segnale sia ignorato o bloccato).
 
@@ -707,7 +707,7 @@ complessa e continua ad avere vari inconvenienti\footnote{lo stesso Stevens,
   che esamina questa architettura in \cite{APUE}, nota come sia impossibile
   per il server sapere se un client è andato in crash, con la possibilità di
   far restare le fifo temporanee sul filesystem, di come sia necessario
-  intercettare \const{SIGPIPE} dato che un client può terminare dopo aver
+  intercettare \signal{SIGPIPE} dato che un client può terminare dopo aver
   fatto una richiesta, ma prima che la risposta sia inviata (cosa che nel
   nostro esempio non è stata fatta).}; in generale infatti l'interfaccia delle
 fifo non è adatta a risolvere questo tipo di problemi, che possono essere
@@ -2608,7 +2608,7 @@ L'uso di \const{SHM\_RDONLY} permette di agganciare il segmento in sola
 lettura (si ricordi che anche le pagine di memoria hanno dei permessi), in tal
 caso un tentativo di scrivere sul segmento comporterà una
 \itindex{segment~violation} violazione di accesso con l'emissione di un
-segnale di \const{SIGSEGV}. Il comportamento usuale di \func{shmat} è quello
+segnale di \signal{SIGSEGV}. Il comportamento usuale di \func{shmat} è quello
 di agganciare il segmento con l'accesso in lettura e scrittura (ed il processo
 deve aver questi permessi in \var{shm\_perm}), non è prevista la possibilità
 di agganciare un segmento in sola scrittura.
@@ -2749,10 +2749,10 @@ ricavare la parte di informazione che interessa.
 
 In fig.~\ref{fig:ipc_dirmonitor_main} si è riportata la sezione principale del
 corpo del programma server, insieme alle definizioni delle altre funzioni
-usate nel programma e delle variabili globali, omettendo tutto quello che
-riguarda la gestione delle opzioni e la stampa delle istruzioni di uso a
-video; al solito il codice completo si trova con i sorgenti allegati nel file
-\file{DirMonitor.c}.
+usate nel programma e delle \index{variabili!globali} variabili globali,
+omettendo tutto quello che riguarda la gestione delle opzioni e la stampa
+delle istruzioni di uso a video; al solito il codice completo si trova con i
+sorgenti allegati nel file \file{DirMonitor.c}.
 
 \begin{figure}[!htbp]
   \footnotesize \centering
@@ -2764,11 +2764,11 @@ video; al solito il codice completo si trova con i sorgenti allegati nel file
   \label{fig:ipc_dirmonitor_main}
 \end{figure}
 
-Il programma usa delle variabili globali (\texttt{\small 2--14}) per mantenere
-i valori relativi agli oggetti usati per la comunicazione inter-processo; si è
-definita inoltre una apposita struttura \struct{DirProp} che contiene i dati
-relativi alle proprietà che si vogliono mantenere nella memoria condivisa, per
-l'accesso da parte dei client.
+Il programma usa delle \index{variabili!globali} variabili globali
+(\texttt{\small 2--14}) per mantenere i valori relativi agli oggetti usati per
+la comunicazione inter-processo; si è definita inoltre una apposita struttura
+\struct{DirProp} che contiene i dati relativi alle proprietà che si vogliono
+mantenere nella memoria condivisa, per l'accesso da parte dei client.
 
 Il programma, dopo la sezione, omessa, relativa alla gestione delle opzioni da
 riga di comando (che si limitano alla eventuale stampa di un messaggio di
@@ -2846,8 +2846,8 @@ Il codice di quest'ultima è riportato in fig.~\ref{fig:ipc_dirmonitor_sub}.
 Come si vede la funzione (\texttt{\small 2--16}) è molto semplice e si limita
 a chiamare (\texttt{\small 5}) la funzione \func{stat} sul file indicato da
 ciascuna voce, per ottenerne i dati, che poi utilizza per incrementare i vari
-contatori nella memoria condivisa, cui accede grazie alla variabile globale
-\var{shmptr}.
+contatori nella memoria condivisa, cui accede grazie alla
+\index{variabili!globali} variabile globale \var{shmptr}.
 
 Dato che la funzione è chiamata da \func{DirScan}, si è all'interno del ciclo
 principale del programma, con un mutex acquisito, perciò non è necessario
@@ -2958,7 +2958,7 @@ Totale  72 file, per 489887 byte
 %$
 
 A questo punto possiamo far uscire il server inviandogli un segnale di
-\const{SIGTERM} con il comando \code{killall dirmonitor}, a questo punto
+\signal{SIGTERM} con il comando \code{killall dirmonitor}, a questo punto
 ripetendo la lettura, otterremo un errore:
 \begin{Verbatim}
 [piccardi@gont sources]$ ./readmon 
@@ -4314,8 +4314,8 @@ Qualora il semaforo debba essere condiviso dai \itindex{thread}
 \textit{thread} di uno stesso processo (nel qual caso si parla di
 \textit{thread-shared semaphore}), occorrerà che \param{sem} sia l'indirizzo
 di una variabile visibile da tutti i \itindex{thread} \textit{thread}, si
-dovrà usare cioè una variabile globale o una variabile allocata dinamicamente
-nello \itindex{heap} \textit{heap}.
+dovrà usare cioè una \index{variabili!globali} variabile globale o una
+variabile allocata dinamicamente nello \itindex{heap} \textit{heap}.
 
 Qualora il semaforo debba essere condiviso fra più processi (nel qual caso si
 parla di \textit{process-shared semaphore}) la sola scelta possibile per
@@ -4397,9 +4397,9 @@ dall'altro programma prima di averla finita di stampare.
 
 La parte iniziale del programma contiene le definizioni (\texttt{\small 1--8})
 del gestore del segnale usato per liberare le risorse utilizzate, delle
-variabili globali contenenti i nomi di default del segmento di memoria
-condivisa e del semaforo (il default scelto è \texttt{messages}), e delle
-altre variabili utilizzate dal programma.
+\index{variabili!globali} variabili globali contenenti i nomi di default del
+segmento di memoria condivisa e del semaforo (il default scelto è
+\texttt{messages}), e delle altre variabili utilizzate dal programma.
 
 Come prima istruzione (\texttt{\small 10}) si è provveduto ad installare un
 gestore di segnale che consentirà di effettuare le operazioni di pulizia
@@ -4463,7 +4463,7 @@ ciclo.
 
 Per uscire in maniera corretta dal programma sarà necessario interromperlo con
 il break da tastiera (\texttt{C-c}), che corrisponde all'invio del segnale
-\const{SIGINT}, per il quale si è installato (\texttt{\small 10}) una
+\signal{SIGINT}, per il quale si è installato (\texttt{\small 10}) una
 opportuna funzione di gestione, riportata in
 fig.~\ref{fig:ipc_posix_sem_shm_message_server_handler}. La funzione è molto
 semplice e richiama le funzioni di rimozione sia per il segmento di memoria
index 85267ea..4adb7f3 100644 (file)
--- a/macro.tex
+++ b/macro.tex
 \newcommand{\var}[1]{\texttt{#1}}     % variable 
 \newcommand{\val}[1]{\texttt{#1}}     % value 
 
+\newcommand{\signal}[1]{%
+\index{segnale!{#1}@{{\tt {#1}}}}\texttt{#1}%
+%\index{#1@{{\tt {#1}} (costante)}}\texttt{#1}%
+}                                     % constant name
+
 \newcommand{\const}[1]{%
 \index{costante!{#1}@{{\tt {#1}}}}\texttt{#1}%
 %\index{#1@{{\tt {#1}} (costante)}}\texttt{#1}%
 }                                     % constant name
 
+\newcommand{\instruction}[1]{%
+\index{istruzione linguaggio C!{#1}@{{\tt {#1}}}}\texttt{#1}%
+%\index{#1@{{\tt {#1}} (direttiva)}}\texttt{#1}%
+}                                     % constant name
+
 \newcommand{\direct}[1]{%
-\index{direttiva!{#1}@{{\tt {#1}}}}\texttt{#1}%
+\index{direttiva linguaggio C!{#1}@{{\tt {#1}}}}\texttt{#1}%
 %\index{#1@{{\tt {#1}} (direttiva)}}\texttt{#1}%
 }                                     % constant name
 
 
 
 \newcommand{\type}[1]{%
-\index{tipo!{#1}@{{\tt {#1}}}}\texttt{#1}%
+\index{tipo di dato!{#1}@{{\tt {#1}}}}\texttt{#1}%
 %\index{#1@{{\tt {#1}} (tipo)}}\texttt{#1}%
 }                                     % system type
 \newcommand{\struct}[1]{%
 \newenvironment{funcproto}[2]
 {% defining what is done by \begin
 \centering
-\vspace{6pt}
+\vspace{3pt}
 \begin{funcbox}
 #1
 \end{funcbox}
 }
 {% defining what is done by \end
 \end{funcbox}
-\vspace{6pt}
+%\vspace{6pt}
 %\break
 }
 
index b3eff10..cd70d82 100644 (file)
@@ -167,7 +167,7 @@ prima di queste funzioni è \funcd{sendto} ed il suo prototipo\footnote{il
   \item[\errcode{EOPNOTSUPP}] il valore di \param{flag} non è appropriato per
     il tipo di socket usato.
   \item[\errcode{EPIPE}] il capo locale della connessione è stato chiuso, si
-    riceverà anche un segnale di \const{SIGPIPE}, a meno di non aver impostato
+    riceverà anche un segnale di \signal{SIGPIPE}, a meno di non aver impostato
     \const{MSG\_NOSIGNAL} in \param{flags}.
   \end{errlist}
   ed anche \errval{EFAULT}, \errval{EBADF}, \errval{EINVAL}, \errval{EINTR},
@@ -210,7 +210,7 @@ qualora si sia specificato un indirizzo è possibile ricevere un errore di
 Finora abbiamo tralasciato l'argomento \param{flags}; questo è un intero usato
 come maschera binaria che permette di impostare una serie di modalità di
 funzionamento della comunicazione attraverso il socket (come
-\const{MSG\_NOSIGNAL} che impedisce l'invio del segnale \const{SIGPIPE} quando
+\const{MSG\_NOSIGNAL} che impedisce l'invio del segnale \signal{SIGPIPE} quando
 si è già chiuso il capo locale della connessione). Torneremo con maggiori
 dettagli sul significato di questo argomento in sez.~\ref{sec:net_sendmsg},
 dove tratteremo le funzioni avanzate dei socket, per il momento ci si può
index 70ccc61..8ea65d7 100644 (file)
@@ -167,7 +167,7 @@ librerie condivise da esso utilizzate.
 
 Vedremo nel resto della guida quali sono le risorse del sistema accessibili
 attraverso le \textit{system call} e tratteremo buona parte delle funzioni
-messe a disposizione dalla Libreria Standard del C, in questa sezione però si
+messe a disposizione dalla libreria standard del C, in questa sezione però si
 forniranno alcune indicazioni generali sul come fare perché un programma possa
 utilizzare queste funzioni.
 
@@ -193,7 +193,7 @@ volta essere definite prima delle varie inclusioni.
 
 Ogni libreria fornisce i propri file di intestazione per i quali si deve
 consultare la documentazione, ma in tab.~\ref{tab:intro_posix_header} si sono
-riportati i principali \textit{header file} definiti nella Libreria Standard
+riportati i principali \textit{header file} definiti nella libreria standard
 del C (nel caso la \acr{glibc}) che contengono le varie funzioni previste
 negli standard POSIX ed ANSI C, e che prevedono la definizione sia delle
 funzioni di utilità generica che delle interfacce alle \textit{system call}. In
@@ -356,10 +356,10 @@ direttamente valori numerici.
 \label{sec:proc_conclusion}
 
 Normalmente un programma conclude la sua esecuzione quando si fa ritornare la
-funzione \func{main}, si usa cioè l'istruzione \texttt{return} del linguaggio
-C all'interno della stessa, o se si richiede esplicitamente la chiusura
-invocando direttamente la funzione \func{exit}. Queste due modalità sono
-assolutamente equivalenti, dato che \func{exit} viene chiamata in maniera
+funzione \func{main}, si usa cioè l'istruzione \instruction{return} del
+linguaggio C all'interno della stessa, o se si richiede esplicitamente la
+chiusura invocando direttamente la funzione \func{exit}. Queste due modalità
+sono assolutamente equivalenti, dato che \func{exit} viene chiamata in maniera
 trasparente anche quando \func{main} ritorna, passandogli come argomento il
 valore di ritorno (che essendo .
 
@@ -376,7 +376,7 @@ standard ANSI C, è quella che deve essere invocata per una terminazione
 \end{funcproto}
 
 La funzione è pensata per eseguire una conclusione pulita di un programma che
-usi la Libreria Standard del C; essa esegue tutte le funzioni che sono state
+usi la libreria standard del C; essa esegue tutte le funzioni che sono state
 registrate con \func{atexit} e \func{on\_exit} (vedi
 sez.~\ref{sec:proc_atexit}), chiude tutti gli stream effettuando il
 salvataggio dei dati sospesi (chiamando \func{fclose}, vedi
@@ -446,7 +446,7 @@ però non comporta il salvataggio dei dati eventualmente presenti nei buffer
 degli stream, (torneremo sulle due interfacce dei file a partire da
 cap.~\ref{cha:file_intro}). Infine fa sì che ogni figlio del processo sia
 adottato da \cmd{init} (vedi cap.~\ref{cha:process_handling}), manda un
-segnale \const{SIGCHLD} al processo padre (vedi
+segnale \signal{SIGCHLD} al processo padre (vedi
 sez.~\ref{sec:sig_job_control}) e ritorna lo stato di uscita specificato
 in \param{status} che può essere raccolto usando la funzione \func{wait} (vedi
 sez.~\ref{sec:proc_wait}).
@@ -635,6 +635,7 @@ valore massimo.\footnote{nel caso di Linux fino al kernel 2.2 detto massimo
   era, per macchine a 32bit, di 2Gb. Con il kernel 2.4 ed il supporto per la
   \textit{high-memory} il limite è stato esteso anche per macchine a 32 bit.}
 
+
 Come accennato nel cap.~\ref{cha:intro_unix} questo spazio di indirizzi è
 virtuale e non corrisponde all'effettiva posizione dei dati nella RAM del
 computer. In generale detto spazio non è neppure continuo, cioè non tutti gli
@@ -642,19 +643,25 @@ indirizzi possibili sono utilizzabili, e quelli usabili non sono
 necessariamente adiacenti.
 
 Per la gestione da parte del kernel la memoria viene divisa in pagine di
-dimensione fissa,\footnote{inizialmente questi erano di 4kb sulle macchine a
-  32 bit e di 8kb sulle alpha, con le versioni più recenti del kernel è
-  possibile anche utilizzare pagine di dimensioni maggiori (4Mb), per sistemi
-  con grandi quantitativi di memoria in cui l'uso di pagine troppo piccole
-  comporta una perdita di prestazioni.} e ciascuna pagina nello spazio di
-indirizzi virtuale è associata ad un supporto che può essere una pagina di
-memoria reale o ad un dispositivo di stoccaggio secondario (come lo spazio
-disco riservato alla \textit{swap}, o i file che contengono il codice). Per
-ciascun processo il kernel si cura di mantenere un mappa di queste
-corrispondenze nella cosiddetta \itindex{page~table} \textit{page
-  table}.\footnote{questa è una semplificazione brutale, il meccanismo è molto
-  più complesso; una buona trattazione di come Linux gestisce la memoria
-  virtuale si trova su \cite{LinVM}.}
+dimensione fissa. Inizialmente queste pagine erano di 4kb sulle macchine a 32
+bit e di 8kb sulle alpha. Con le versioni più recenti del kernel è possibile
+anche utilizzare pagine di dimensioni maggiori (di 4Mb, dette \textit{huge
+  page}), per sistemi con grandi quantitativi di memoria in cui l'uso di
+pagine troppo piccole comporta una perdita di prestazioni. In alcuni sistemi
+la costante \const{PAGE\_SIZE}, definita in \file{limits.h}, indica la
+dimensione di una pagina in byte, con Linux questo non avviene e per ottenere
+questa dimensione si deve ricorrere alla funzione \func{getpagesize} (vedi
+sez.~\ref{sec:sys_memory_res}).
+
+Ciascuna pagina di memoria nello spazio di indirizzi virtuale è associata ad
+un supporto che può essere una pagina di memoria reale o ad un dispositivo di
+stoccaggio secondario (come lo spazio disco riservato alla \textit{swap}, o i
+file che contengono il codice). Per ciascun processo il kernel si cura di
+mantenere un mappa di queste corrispondenze nella cosiddetta
+\itindex{page~table} \textit{page table}.\footnote{questa è una
+  semplificazione brutale, il meccanismo è molto più complesso; una buona
+  trattazione di come Linux gestisce la memoria virtuale si trova su
+  \cite{LinVM}.}
 
 Una stessa pagina di memoria reale può fare da supporto a diverse pagine di
 memoria virtuale appartenenti a processi diversi, come accade in genere per le
@@ -707,57 +714,70 @@ commette quando si è manipolato male un puntatore e genera quella che viene
 chiamata una \itindex{segment~violation} \textit{segment violation}. Se si
 tenta cioè di leggere o scrivere con un indirizzo per il quale non esiste
 un'associazione nella memoria virtuale, il kernel risponde al relativo
-\itindex{page~fault} \textit{page fault} mandando un segnale \const{SIGSEGV}
+\itindex{page~fault} \textit{page fault} mandando un segnale \signal{SIGSEGV}
 al processo, che normalmente ne causa la terminazione immediata.
 
 È pertanto importante capire come viene strutturata \index{memoria~virtuale}
 la memoria virtuale di un processo. Essa viene divisa in \textsl{segmenti},
 cioè un insieme contiguo di indirizzi virtuali ai quali il processo può
 accedere.  Solitamente un programma C viene suddiviso nei seguenti segmenti:
-
-\begin{enumerate}
+\begin{enumerate*}
 \item Il \index{segmento!testo} segmento di testo o \textit{text segment}.
   Contiene il codice del programma, delle funzioni di librerie da esso
   utilizzate, e le costanti.  Normalmente viene condiviso fra tutti i processi
   che eseguono lo stesso programma e nel caso delle librerie anche da processi
-  che eseguono altri programmi.  Viene marcato in sola lettura per evitare
-  sovrascritture accidentali (o maliziose) che ne modifichino le istruzioni.
-  
-  Viene allocato da \func{execve} all'avvio del programma e resta invariato
-  per tutto il tempo dell'esecuzione.
-  
-\item Il \index{segmento!dati} segmento dei dati o \textit{data segment}.
-  Contiene le variabili globali, cioè quelle definite al di fuori di tutte le
-  funzioni che compongono il programma, e le variabili statiche, cioè quelle
-  dichiarate con l'attributo \ctyp{static}. Di norma è diviso in due parti.
-  
-  La prima parte è il segmento dei dati inizializzati, che contiene le
-  variabili il cui valore è stato assegnato esplicitamente. Ad esempio
-  se si definisce:
-\includecodesnip{listati/pi.c}
-  questo valore sarà immagazzinato in questo segmento. La memoria di questo
-  segmento viene preallocata all'avvio del programma e inizializzata ai valori
-  specificati.
-  
-  La seconda parte è il segmento dei dati non inizializzati, che contiene le
-  variabili il cui valore non è stato assegnato esplicitamente. Ad esempio se
-  si definisce:
-\includecodesnip{listati/vect.c}
-  questo vettore sarà immagazzinato in questo segmento. Anch'esso viene
-  allocato all'avvio, e tutte le variabili vengono inizializzate a zero (ed i
-  puntatori a \val{NULL}).\footnote{si ricordi che questo vale solo per le
-    variabili che vanno nel segmento dati, e non è affatto vero in generale.}
-   
-  Storicamente questa seconda parte del segmento dati viene chiamata BSS (da
-  \textit{Block Started by Symbol}). La sua dimensione è fissa.
-  
-\item Lo \itindex{heap} \textit{heap}. Tecnicamente lo si può considerare
-  l'estensione del segmento dati, a cui di solito è posto giusto di seguito. È
-  qui che avviene l'allocazione dinamica della memoria; può essere
-  ridimensionato allocando e disallocando la memoria dinamica con le apposite
-  funzioni (vedi sez.~\ref{sec:proc_mem_alloc}), ma il suo limite inferiore,
-  quello adiacente al segmento dati, ha una posizione fissa.
+  che eseguono altri programmi.  
+
+  Quando l'architettura hardware lo supporta viene marcato in sola lettura per
+  evitare sovrascritture accidentali (o maliziose) che ne modifichino le
+  istruzioni.  Viene allocato da \func{execve} all'avvio del programma e resta
+  invariato per tutto il tempo dell'esecuzione.
+
+\item Il \index{segmento!dati} segmento dei dati o \textit{data
+    segment}. Contiene tutti i dati del programma, come le
+  \index{variabili!globali} variabili globali, cioè quelle definite al di
+  fuori di tutte le funzioni che compongono il programma, e le
+  \index{variabili!statiche} variabili statiche, cioè quelle dichiarate con
+  l'attributo \direct{static},\footnote{la direttiva \direct{static} indica al
+    compilatore C che una variabile così dichiarata all'interno di una
+    funzione deve essere mantenuta staticamente in memoria (nel
+    \index{segmento!dati} segmento dati appunto); questo significa che la
+    variabile verrà inizializzata una sola volta alla prima invocazione della
+    funzione e che il suo valore sarà mantenuto fra diverse esecuzioni della
+    funzione stessa, la differenza con una \index{variabili!globali} variabile
+    globale è che essa può essere vista solo all'interno della funzione in cui
+    è dichiarata.} e la memoria allocata dinamicamente. Di norma è diviso in
+  tre parti:
   
+  \begin{itemize*}
+  \item Il segmento dei dati inizializzati, che contiene le variabili il cui
+    valore è stato assegnato esplicitamente. Ad esempio se si definisce:
+    \includecodesnip{listati/pi.c}
+    questo valore sarà immagazzinato in questo segmento. La memoria di questo
+    segmento viene preallocata all'avvio del programma e inizializzata ai valori
+    specificati.
+  \item Il segmento dei dati non inizializzati, che contiene le variabili il
+    cui valore non è stato assegnato esplicitamente. Ad esempio se si
+    definisce:
+    \includecodesnip{listati/vect.c}
+    questo vettore sarà immagazzinato in questo segmento. Anch'esso viene
+    allocato all'avvio, e tutte le variabili vengono inizializzate a zero (ed
+    i puntatori a \val{NULL}).\footnote{si ricordi che questo vale solo per le
+      variabili che vanno nel \index{segmento!dati} segmento dati, e non è
+      affatto vero in generale.}  Storicamente questa seconda parte del
+    \index{segmento!dati} segmento dati viene chiamata BSS (da \textit{Block
+      Started by Symbol}). La sua dimensione è fissa.
+  \item Lo \itindex{heap} \textit{heap}, detto anche \textit{free
+      store}. Tecnicamente lo si può considerare l'estensione del segmento dei
+    dati non inizializzati, a cui di solito è posto giusto di seguito. Questo
+    è il segmento che viene utilizzato per l'allocazione dinamica della
+    memoria.  Lo \textit{heap} può essere ridimensionato allargandolo e
+    restringendolo per allocare e disallocare la memoria dinamica con le
+    apposite funzioni (vedi sez.~\ref{sec:proc_mem_alloc}), ma il suo limite
+    inferiore, quello adiacente al segmento dei dati non inizializzati, ha una
+    posizione fissa.
+  \end{itemize*}
+
 \item Il segmento di \itindex{stack} \textit{stack}, che contiene quello che
   viene chiamato \textit{stack} del programma.  Tutte le volte che si effettua
   una chiamata ad una funzione è qui che viene salvato l'indirizzo di ritorno
@@ -782,14 +802,14 @@ accedere.  Solitamente un programma C viene suddiviso nei seguenti segmenti:
   La dimensione di questo segmento aumenta seguendo la crescita dello
   \itindex{stack} \textit{stack} del programma, ma non viene ridotta quando
   quest'ultimo si restringe.
-\end{enumerate}
+\end{enumerate*}
 
 \begin{figure}[htb]
   \centering
 %  \includegraphics[height=12cm]{img/memory_layout}
   \begin{tikzpicture}
   \draw (0,0) rectangle (4,1);
-  \draw (2,0.5) node {text};
+  \draw (2,0.5) node {\textit{text}};
   \draw (0,1) rectangle (4,2.5);
   \draw (2,1.75) node {dati inizializzati};
   \draw (0,2.5) rectangle (4,5);
@@ -797,12 +817,12 @@ accedere.  Solitamente un programma C viene suddiviso nei seguenti segmenti:
   \draw (0,5) rectangle (4,9);
   \draw[dashed] (0,6) -- (4,6);
   \draw[dashed] (0,8) -- (4,8);
-  \draw (2,5.5) node {heap};
-  \draw (2,8.5) node {stack};
+  \draw (2,5.5) node {\textit{heap}};
+  \draw (2,8.5) node {\textit{stack}};
   \draw [->] (2,6) -- (2,6.5);
   \draw [->] (2,8) -- (2,7.5);
   \draw (0,9) rectangle (4,10);
-  \draw (2,9.5) node {environment};
+  \draw (2,9.5) node {\textit{environment}};
   \draw (4,0) node [anchor=west] {\texttt{0x08000000}};
   \draw (4,5) node [anchor=west] {\texttt{0x08xxxxxx}};
   \draw (4,9) node [anchor=west] {\texttt{0xC0000000}};
@@ -811,11 +831,18 @@ accedere.  Solitamente un programma C viene suddiviso nei seguenti segmenti:
   \label{fig:proc_mem_layout}
 \end{figure}
 
-Una disposizione tipica dei vari segmenti (testo, \itindex{heap}
-\textit{heap}, \itindex{stack} \textit{stack}, ecc.) è riportata in
-fig.~\ref{fig:proc_mem_layout}. Usando il comando \cmd{size} su un programma
-se ne può stampare le dimensioni dei segmenti di testo e di dati
-(inizializzati e BSS); si tenga presente però che il BSS non è mai salvato sul
+Una disposizione tipica dei vari segmenti (testo, dati inizializzati e non
+inizializzati, \itindex{heap} \textit{heap}, \itindex{stack} \textit{stack},
+ecc.) è riportata in fig.~\ref{fig:proc_mem_layout}. Si noti come in figura
+sia indicata una ulteriore regione, marcata \textit{environment}, che è quella
+che contiene i dati relativi alle variabili di ambiente passate al programma
+al suo avvio (torneremo su questo argomento in sez.~\ref{sec:proc_environ}).
+
+Usando il comando \cmd{size} su un programma se ne può stampare le dimensioni
+dei \index{segmento!testo} segmenti di testo e \index{segmento!dati} di dati
+(solo però per i dati inizializzati ed il BSS, dato che lo \itindex{heap}
+\textit{heap} ha una dimensione dinamica). Si tenga presente comunque che il
+BSS, contrariamente al segmento dei dati inizializzati, non è mai salvato sul
 file che contiene l'eseguibile, dato che viene sempre inizializzato a zero al
 caricamento del programma.
 
@@ -827,18 +854,21 @@ Il C supporta direttamente, come linguaggio di programmazione, soltanto due
 modalità di allocazione della memoria: l'\textsl{allocazione statica} e
 l'\textsl{allocazione automatica}.
 
-L'\textsl{allocazione statica} è quella con cui sono memorizzate le variabili
-globali e le variabili statiche, cioè le variabili il cui valore deve essere
-mantenuto per tutta la durata del programma. Come accennato queste variabili
-vengono allocate nel \index{segmento!dati} segmento dei dati all'avvio del
-programma come parte delle operazioni svolte da \func{exec}, e lo spazio da
-loro occupato non viene liberato fino alla sua conclusione.
+L'\textsl{allocazione statica} è quella con cui sono memorizzate le
+\index{variabili!globali} variabili globali e le \index{variabili!statiche}
+variabili statiche, cioè le variabili il cui valore deve essere mantenuto per
+tutta la durata del programma. Come accennato queste variabili vengono
+allocate nel \index{segmento!dati} segmento dei dati all'avvio del programma
+come parte delle operazioni svolte da \func{exec}, e lo spazio da loro
+occupato non viene liberato fino alla sua conclusione.
 
 L'\textsl{allocazione automatica} è quella che avviene per gli argomenti di
-una funzione e per le sue variabili locali (le cosiddette \textsl{variabili
-  automatiche}), che esistono solo per la durata della funzione.  Lo spazio
-per queste variabili viene allocato nello \itindex{stack} \textit{stack} quando
-viene eseguita la funzione e liberato quando si esce dalla medesima.
+una funzione e per le sue variabili locali, quelle che vengono definite
+all'interno della funzione che esistono solo per la durata della sua esecuzione
+e che per questo vengono anche dette \index{variabili!automatiche}
+\textsl{variabili automatiche}.  Lo spazio per queste variabili viene allocato
+nello \itindex{stack} \textit{stack} quando viene eseguita la funzione e
+liberato quando si esce dalla medesima.
 
 Esiste però un terzo tipo di allocazione, l'\textsl{allocazione dinamica}
 della memoria, che non è prevista direttamente all'interno del linguaggio C,
@@ -846,10 +876,10 @@ ma che è necessaria quando il quantitativo di memoria che serve è
 determinabile solo durante il corso dell'esecuzione del programma. Il C non
 consente di usare variabili allocate dinamicamente, non è possibile cioè
 definire in fase di programmazione una variabile le cui dimensioni possano
-essere modificate durante l'esecuzione del programma. Per questo la Libreria
-Standard del C fornisce una serie opportuna di funzioni per eseguire
-l'allocazione dinamica di memoria (in genere nello \itindex{heap}
-\textit{heap}).
+essere modificate durante l'esecuzione del programma. Per questo la libreria
+standard del C fornisce una opportuna serie di funzioni per eseguire
+l'allocazione dinamica di memoria, che come accennato avviene nello
+\itindex{heap} \textit{heap}.
 
 Le variabili il cui contenuto è allocato in questo modo non potranno essere
 usate direttamente come le altre (quelle nello \itindex{stack}
@@ -859,7 +889,7 @@ funzioni di allocazione.
 
 Le funzioni previste dallo standard ANSI C per la gestione della memoria sono
 quattro: \func{malloc}, \func{calloc}, \func{realloc} e \func{free}. Le prime
-due, \funcd{malloc} e \funcd{calloc} allocano in nuovo spazio di memoria; i
+due, \funcd{malloc} e \funcd{calloc} allocano nuovo spazio di memoria; i
 rispettivi prototipi sono:
 
 \begin{funcproto}{ 
@@ -884,8 +914,8 @@ un'area di memoria.\footnote{queste funzioni presentano un comportamento
 generico non è necessario effettuare un cast per assegnarli a puntatori al
 tipo di variabile per la quale si effettua l'allocazione, inoltre le funzioni
 garantiscono che i puntatori siano allineati correttamente per tutti i tipi di
-dati; ad esempio sulle macchine a 32 bit in genere è allineato a multipli di 4
-byte e sulle macchine a 64 bit a multipli di 8 byte.
+dati; ad esempio sulle macchine a 32 bit in genere sono allineati a multipli
+di 4 byte e sulle macchine a 64 bit a multipli di 8 byte.
 
 Nel caso di \func{calloc} l'area di memoria viene allocata nello \textit{heap}
 come un vettore di \param{nmemb} membri di \param{size} byte di dimensione, e
@@ -916,17 +946,17 @@ dei dati di gestione dell'allocazione, che può dar luogo a problemi gravi, ad
 esempio un \textit{segmentation fault} in una successiva chiamata di una di
 queste funzioni.
 
-Dato che questo errore, chiamato in gergo \textit{double free}, è abbastanza
-frequente specie quando si manipolano vettori di puntatori, e dato che le
-conseguenze possono essere pesanti ed inaspettate, si suggerisce come
-soluzione precauzionale di assegnare sempre a \val{NULL} ogni puntatore su cui
-sia stata eseguita \func{free} immediatamente dopo l'esecuzione della
-funzione. In questo modo, dato che quando l'argomento è un puntatore nullo
+Dato che questo errore, chiamato in gergo \itindex{double~free} \textit{double
+  free}, è abbastanza frequente, specie quando si manipolano vettori di
+puntatori, e dato che le conseguenze possono essere pesanti ed inaspettate, si
+suggerisce come soluzione precauzionale di assegnare sempre a \val{NULL} ogni
+puntatore su cui sia stata eseguita \func{free} immediatamente dopo
+l'esecuzione della funzione. In questo modo, dato che con un puntatore nullo
 \func{free} non esegue nessuna operazione, si evitano i problemi del
-\textit{double free}.
+\itindex{double~free} \textit{double free}.
 
-Infine la funzione \funcd{realloc} consente di modificare (in genere
-aumentare) la dimensione di un'area di memoria precedentemente allocata, il
+Infine la funzione \funcd{realloc} consente di modificare, in genere di
+aumentare, la dimensione di un'area di memoria precedentemente allocata; il
 suo prototipo è:
 
 \begin{funcproto}{ 
@@ -969,38 +999,47 @@ sez.~\ref{sec:proc_environ}), in particolare diventa possibile tracciare
 questo tipo di errori usando la variabile di ambiente \val{MALLOC\_CHECK\_}
 che quando viene definita mette in uso una versione meno efficiente delle
 funzioni suddette, che però è più tollerante nei confronti di piccoli errori
-come quello di chiamate doppie a \func{free}.  In particolare:
-\begin{itemize}
-\item se la variabile è posta a zero gli errori vengono ignorati;
-\item se è posta ad 1 viene stampato un avviso sullo \textit{standard error}
-  (vedi sez.~\ref{sec:file_std_stream});
-\item se è posta a 2 viene chiamata \func{abort}, che in genere causa
-  l'immediata conclusione del programma.
-\end{itemize}
-
-Il problema più comune e più difficile da risolvere che si incontra con le
-funzioni di allocazione è quando non viene opportunamente liberata la memoria
-non più utilizzata, quello che in inglese viene chiamato \itindex{memory~leak}
-\textit{memory leak}, cioè una \textsl{perdita di memoria}.
-
-Un caso tipico che illustra il problema è quello in cui in una subroutine si
-alloca della memoria per uso locale senza liberarla prima di uscire. La
-memoria resta così allocata fino alla terminazione del processo.  Chiamate
-ripetute alla stessa subroutine continueranno ad effettuare altre allocazioni,
-causando a lungo andare un esaurimento della memoria disponibile (e la
-probabile impossibilità di proseguire l'esecuzione del programma).
+come quello dei \itindex{double~free} \textit{double~free} o i
+\itindex{buffer~overrun} \textit{buffer overrun} di un byte.\footnote{uno
+  degli errori più comuni, causato ad esempio dalla scrittura di una stringa
+  di dimensione pari a quella del buffer, in cui ci si dimentica dello zero di
+  terminazione finale.}  In particolare:
+\begin{itemize*}
+\item se la variabile è posta a $0$ gli errori vengono ignorati;
+\item se la variabile è posta a $1$ viene stampato un avviso sullo
+  \textit{standard error} (vedi sez.~\ref{sec:file_std_stream});
+\item se la variabile è posta a $2$ viene chiamata la funzione \func{abort}
+  (vedi sez.~\ref{sec:sig_alarm_abort}), che in genere causa l'immediata
+  terminazione del programma;
+\item se la variabile è posta a $3$ viene stampato l'avviso e chiamata
+  \func{abort}. 
+\end{itemize*}
+
+L'errore di programmazione più comune e più difficile da risolvere che si
+incontra con le funzioni di allocazione è quando non viene opportunamente
+liberata la memoria non più utilizzata, quello che in inglese viene chiamato
+\itindex{memory~leak} \textit{memory leak}, cioè una \textsl{perdita di
+  memoria}.
+
+Un caso tipico che illustra il problema è quello in cui in una propria
+funzione si alloca della memoria per uso locale senza liberarla prima di
+uscire. La memoria resta così allocata fino alla terminazione del processo.
+Chiamate ripetute alla stessa funzione continueranno ad effettuare altre
+allocazioni, che si accumuleranno causando a lungo andare un esaurimento della
+memoria disponibile e la probabile impossibilità di proseguire l'esecuzione
+del programma.
 
 Il problema è che l'esaurimento della memoria può avvenire in qualunque
 momento, in corrispondenza ad una qualunque chiamata di \func{malloc} che può
-essere in una sezione del codice che non ha alcuna relazione con la subroutine
+essere in una sezione del codice che non ha alcuna relazione con la funzione
 che contiene l'errore. Per questo motivo è sempre molto difficile trovare un
 \itindex{memory~leak} \textit{memory leak}.
 
 In C e C++ il problema è particolarmente sentito. In C++, per mezzo della
 programmazione ad oggetti, il problema dei \itindex{memory~leak}
-\textit{memory leak} è notevolmente ridimensionato attraverso l'uso accurato
-di appositi oggetti come gli \textit{smartpointers}.  Questo però in genere va
-a scapito delle prestazioni dell'applicazione in esecuzione.
+\textit{memory leak} si può notevolmente ridimensionare attraverso l'uso
+accurato di appositi oggetti come gli \textit{smartpointers}.  Questo però in
+genere va a scapito delle prestazioni dell'applicazione in esecuzione.
 
 % TODO decidere cosa fare di questo che segue
 % In altri linguaggi come il java e recentemente il C\# il problema non si pone
@@ -1024,7 +1063,7 @@ a scapito delle prestazioni dell'applicazione in esecuzione.
 % allocata da un oggetto.
 
 Per limitare l'impatto di questi problemi, e semplificare la ricerca di
-eventuali errori, l'implementazione delle funzioni di allocazione delle
+eventuali errori, l'implementazione delle funzioni di allocazione nella
 \acr{glibc} mette a disposizione una serie di funzionalità che permettono di
 tracciare le allocazioni e le disallocazioni, e definisce anche una serie di
 possibili \textit{hook} (\textsl{ganci}) che permettono di sostituire alle
@@ -1035,20 +1074,20 @@ ricompilare il programma,\footnote{esempi sono \textit{Dmalloc}
   \href{http://dmalloc.com/}{\textsf{http://dmalloc.com/}} di Gray Watson ed
   \textit{Electric Fence} di Bruce Perens.} di eseguire diagnostiche anche
 molto complesse riguardo l'allocazione della memoria. Vedremo alcune delle
-funzionalità di ausilio presenti nelle \acr{glibc} in
-sez.~\ref{sec:proc_memory_adv_management}. 
+funzionalità di ausilio presenti nella \acr{glibc} in
+sez.~\ref{sec:proc_memory_adv_management}.
 
 Una possibile alternativa all'uso di \func{malloc}, per evitare di soffrire
 dei problemi di \itindex{memory~leak} \textit{memory leak} descritti in
 precedenza, è di allocare la memoria nel segmento di \itindex{stack}
 \textit{stack} della funzione corrente invece che nello \itindex{heap}
-\textit{heap}, per farlo si può usare la funzione \funcd{alloca}, la cui
+\textit{heap}. Per farlo si può usare la funzione \funcd{alloca}, la cui
 sintassi è identica a quella di \func{malloc}; il suo prototipo è:
 
 \begin{funcproto}{ 
 \fhead{stdlib.h} 
 \fdecl{void *alloca(size\_t size)}
-\fdesc{Alloca un'area di memoria nello \textit{stack}} 
+\fdesc{Alloca un'area di memoria nello \textit{stack}.
 }
 {La funzione restituisce il puntatore alla zona di memoria allocata, in caso
   di fallimento il comportamento è indefinito.}
@@ -1057,34 +1096,32 @@ sintassi è identica a quella di \func{malloc}; il suo prototipo è:
 La funzione alloca la quantità di memoria (non inizializzata) richiesta
 dall'argomento \param{size} nel segmento di \itindex{stack} \textit{stack}
 della funzione chiamante.  Con questa funzione non è più necessario liberare
-la memoria allocata (e quindi non esiste un analogo della \func{free}) in
+la memoria allocata, e quindi non esiste un analogo della \func{free}, in
 quanto essa viene rilasciata automaticamente al ritorno della funzione.
 
-Come è evidente questa funzione ha alcuni vantaggi, anzitutto permette di
-evitare alla radice i problemi di \itindex{memory~leak} \textit{memory leak},
-dato che non serve più la deallocazione esplicita; inoltre la deallocazione
-automatica funziona anche quando si usa \func{longjmp} per uscire da una
-subroutine con un salto non locale da una funzione (vedi
-sez.~\ref{sec:proc_longjmp}).
-
-Un altro vantaggio è che in Linux la funzione è molto più veloce di
-\func{malloc} e non viene sprecato spazio, infatti non è necessario gestire un
-pool di memoria da riservare e si evitano così anche i problemi di
-frammentazione di quest'ultimo, che comportano inefficienze sia
-nell'allocazione della memoria che nell'esecuzione dell'allocazione.
+Come è evidente questa funzione ha alcuni vantaggi interessanti, anzitutto
+permette di evitare alla radice i problemi di \itindex{memory~leak}
+\textit{memory leak}, dato che non serve più la deallocazione esplicita;
+inoltre la deallocazione automatica funziona anche quando si usa
+\func{longjmp} per uscire da una subroutine con un salto non locale da una
+funzione (vedi sez.~\ref{sec:proc_longjmp}).  Un altro vantaggio è che in
+Linux la funzione è molto più veloce di \func{malloc} e non viene sprecato
+spazio, infatti non è necessario gestire un pool di memoria da riservare e si
+evitano così anche i problemi di frammentazione di quest'ultimo, che
+comportano inefficienze sia nell'allocazione della memoria che nell'esecuzione
+dell'allocazione.
 
 Gli svantaggi sono che questa funzione non è disponibile su tutti gli Unix, e
 non è inserita né nello standard POSIX né in SUSv3 (ma è presente in BSD), il
 suo utilizzo quindi limita la portabilità dei programmi. Inoltre la funzione
 non può essere usata nella lista degli argomenti di una funzione, perché lo
-spazio verrebbe allocato nel mezzo degli stessi.
-
-Inoltre non è chiaramente possibile usare \func{alloca} per allocare memoria
-che deve poi essere usata anche al di fuori della funzione in cui essa viene
-chiamata, dato che all'uscita dalla funzione lo spazio allocato diventerebbe
-libero, e potrebbe essere sovrascritto all'invocazione di nuove funzioni.
-Questo è lo stesso problema che si può avere con le variabili automatiche, su
-cui torneremo in sez.~\ref{sec:proc_auto_var}.
+spazio verrebbe allocato nel mezzo degli stessi.  Inoltre non è chiaramente
+possibile usare \func{alloca} per allocare memoria che deve poi essere usata
+anche al di fuori della funzione in cui essa viene chiamata, dato che
+all'uscita dalla funzione lo spazio allocato diventerebbe libero, e potrebbe
+essere sovrascritto all'invocazione di nuove funzioni.  Questo è lo stesso
+problema che si può avere con le \index{variabili!automatiche} variabili
+automatiche, su cui torneremo in sez.~\ref{sec:proc_var_passing}.
 
 Infine non esiste un modo di sapere se l'allocazione ha avuto successo, la
 funzione infatti viene realizzata inserendo del codice \textit{inline} nel
@@ -1101,55 +1138,68 @@ disponibile.
 Le due funzioni seguenti\footnote{le due funzioni sono state definite con BSD
   4.3, sono marcate obsolete in SUSv2 e non fanno parte delle librerie
   standard del C e mentre sono state esplicitamente rimosse dallo standard
-  POSIX/1-2001.} vengono utilizzate soltanto quando è necessario effettuare
+  POSIX.1-2001.} vengono utilizzate soltanto quando è necessario effettuare
 direttamente la gestione della memoria associata allo spazio dati di un
-processo, ad esempio qualora si debba implementare la propria versione delle
-funzioni di allocazione della memoria. Per poterle utilizzare è necessario
-definire una della macro di funzionalità (vedi
-sez.~\ref{sec:intro_gcc_glibc_std}) fra \macro{\_BSD\_SOURCE},
-\macro{\_SVID\_SOURCE} e \macro{\_XOPEN\_SOURCE} (ad un valore maggiore o
-uguale di 500). La prima funzione è \funcd{brk}, ed il suo prototipo è:
-\begin{prototype}{unistd.h}{int brk(void *end\_data\_segment)}
-  Sposta la fine del segmento dei dati.
-  
-  \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
-    fallimento, nel qual caso \var{errno} assumerà il valore \errval{ENOMEM}.}
-\end{prototype}
-
-La funzione è un'interfaccia all'omonima system call ed imposta l'indirizzo
-finale del \index{segmento!dati} segmento dati di un processo all'indirizzo
-specificato da \param{end\_data\_segment}. Quest'ultimo deve essere un valore
-ragionevole, ed inoltre la dimensione totale del segmento non deve comunque
-eccedere un eventuale limite (si veda sez.~\ref{sec:sys_resource_limit})
-imposto sulle dimensioni massime dello spazio dati del processo.
-
-Il valore di ritorno della funzione fa riferimento alla versione fornita dalle
+processo, per poterle utilizzare è necessario definire una della macro di
+funzionalità (vedi sez.~\ref{sec:intro_gcc_glibc_std}) fra
+\macro{\_BSD\_SOURCE}, \macro{\_SVID\_SOURCE} e \macro{\_XOPEN\_SOURCE} (ad un
+valore maggiore o uguale di 500). La prima funzione è \funcd{brk}, ed il suo
+prototipo è:
+
+\begin{funcproto}{ 
+\fhead{unistd.h} 
+\fdecl{int brk(void *addr)}
+\fdesc{Sposta la fine del segmento dati del processo.} 
+}
+{La funzione restituisce 0 in caso di successo e $-1$ in caso di fallimento,
+  nel qual caso \var{errno} assumerà il valore \errval{ENOMEM}.}
+\end{funcproto}
+
+La funzione è un'interfaccia all'omonima \textit{system call} ed imposta
+l'indirizzo finale del \index{segmento!dati} segmento dati di un processo (più
+precisamente dello \itindex{heap} \textit{heap}) all'indirizzo specificato
+da \param{addr}. Quest'ultimo deve essere un valore ragionevole, e la
+dimensione totale non deve comunque eccedere un eventuale limite (vedi
+sez.~\ref{sec:sys_resource_limit}) imposto sulle dimensioni massime del
+\index{segmento!dati} segmento dati del processo.
+
+Il valore di ritorno della funzione fa riferimento alla versione fornita dalla
 \acr{glibc}, in realtà in Linux la \textit{system call} corrispondente
 restituisce come valore di ritorno il nuovo valore della fine del
 \index{segmento!dati} segmento dati in caso di successo e quello corrente in
-caso di fallimento, è la funzione di interfaccia usata dalle \acr{glibc} che
-fornisce i valori di ritorno appena descritti, questo può non accadere se si
-usano librerie diverse.
+caso di fallimento, è la funzione di interfaccia usata dalla \acr{glibc} che
+fornisce i valori di ritorno appena descritti; se si usano librerie diverse
+questo potrebbe non accadere.
 
 Una seconda funzione per la manipolazione diretta delle dimensioni
 \index{segmento!dati} del segmento dati\footnote{in questo caso si tratta
-  soltanto di una funzione di libreria, e non di una system call.} è
-\funcd{sbrk}, ed il suo prototipo è:
-\begin{prototype}{unistd.h}{void *sbrk(ptrdiff\_t increment)} 
-  Incrementa la dimensione dello spazio dati.
-  
-  \bodydesc{La funzione restituisce il puntatore all'inizio della nuova zona
-    di memoria allocata in caso di successo e \val{NULL} in caso di
-    fallimento, nel qual caso \var{errno} assumerà il valore \errval{ENOMEM}.}
-\end{prototype}
-\noindent la funzione incrementa la dimensione lo spazio dati di un programma
-di \param{increment} byte, restituendo il nuovo indirizzo finale dello stesso.
-Un valore nullo permette di ottenere l'attuale posizione della fine del
-\index{segmento!dati} segmento dati.
+  soltanto di una funzione di libreria, anche se basata sulla stessa
+  \textit{system call}.} è \funcd{sbrk}, ed il suo prototipo è:
 
-Queste funzioni sono state deliberatamente escluse dallo standard POSIX.1 e
-per i programmi normali è sempre opportuno usare le funzioni di allocazione
-standard descritte in precedenza, che sono costruite su di esse. 
+\begin{funcproto}{ 
+\fhead{unistd.h} 
+\fdecl{void *sbrk(intptr\_t increment)}
+\fdesc{Incrementa la dimensione del segmento dati del processo.} 
+}
+{La funzione restituisce il puntatore all'inizio della nuova zona di memoria
+  allocata in caso di successo e \val{NULL} in caso di fallimento, nel qual
+  caso \var{errno} assumerà il valore \errval{ENOMEM}.}
+\end{funcproto}
+
+La funzione incrementa la dimensione dello \itindex{heap} \textit{heap} di un
+programma del valore indicato dall'argomento \param{increment}, restituendo il
+nuovo indirizzo finale dello stesso.  L'argomento è definito come di tipo
+\type{intptr\_t}, ma a seconda della versione delle librerie e del sistema può
+essere indicato con una serie di tipi equivalenti come \type{ptrdiff\_t},
+\type{ssize\_t}, \ctyp{int}. Se invocata con un valore nullo la funzone
+permette di ottenere l'attuale posizione della fine del \index{segmento!dati}
+segmento dati.
+
+Queste due funzioni sono state deliberatamente escluse dallo standard POSIX.1
+dato che per i normali programmi è sempre opportuno usare le funzioni di
+allocazione standard descritte in precedenza, a meno di non voler realizzare
+per proprio conto un diverso meccanismo di gestione della memoria del segmento
+dati.
 
 
 \subsection{Il controllo della memoria virtuale}  
@@ -1159,15 +1209,15 @@ standard descritte in precedenza, che sono costruite su di esse.
 
 Come spiegato in sez.~\ref{sec:proc_mem_gen} il kernel gestisce la memoria
 virtuale in maniera trasparente ai processi, decidendo quando rimuovere pagine
-dalla memoria per metterle nello swap, sulla base dell'utilizzo corrente da
-parte dei vari processi.
+dalla memoria per metterle nell'area di \textit{swap}, sulla base
+dell'utilizzo corrente da parte dei vari processi.
 
 Nell'uso comune un processo non deve preoccuparsi di tutto ciò, in quanto il
 meccanismo della \index{paginazione} paginazione riporta in RAM, ed in maniera
 trasparente, tutte le pagine che gli occorrono; esistono però esigenze
 particolari in cui non si vuole che questo meccanismo si attivi. In generale i
 motivi per cui si possono avere di queste necessità sono due:
-\begin{itemize}
+\begin{itemize*}
 \item \textsl{La velocità}. Il processo della \index{paginazione} paginazione
   è trasparente solo se il programma in esecuzione non è sensibile al tempo
   che occorre a riportare la pagina in memoria; per questo motivo processi
@@ -1187,11 +1237,11 @@ motivi per cui si possono avere di queste necessità sono due:
   in memoria queste possono essere portate su disco dal meccanismo della
   \index{paginazione} paginazione. Questo rende più lungo il periodo di tempo
   in cui detti segreti sono presenti in chiaro e più complessa la loro
-  cancellazione (un processo può cancellare la memoria su cui scrive le sue
-  variabili, ma non può toccare lo spazio disco su cui una pagina di memoria
-  può essere stata salvata). Per questo motivo di solito i programmi di
-  crittografia richiedono il blocco di alcune pagine di memoria.
-\end{itemize}
+  cancellazione: un processo infatti può cancellare la memoria su cui scrive
+  le sue variabili, ma non può toccare lo spazio disco su cui una pagina di
+  memoria può essere stata salvata. Per questo motivo di solito i programmi
+  di crittografia richiedono il blocco di alcune pagine di memoria.
+\end{itemize*}
 
 Per ottenere informazioni sulle modalità in cui un programma sta usando la
 memoria virtuale è disponibile una apposita funzione, \funcd{mincore}, che
@@ -1207,7 +1257,7 @@ il suo prototipo è:
 %   Ritorna lo stato delle pagine di memoria occupate da un processo.
   
 %   \bodydesc{La funzione ritorna 0 in caso di successo e $-1$ in caso di
-%     errore, nel qual caso \var{errno} assumerà uno dei valori seguenti:
+%     errore, nel qual caso \var{errno} assumerà uno dei valori:
 %   \begin{errlist}
 %   \item[\errcode{ENOMEM}] o \param{addr} + \param{length} eccede la dimensione
 %     della memoria usata dal processo o l'intervallo di indirizzi specificato
@@ -1228,7 +1278,7 @@ il suo prototipo è:
 \fdesc{Ritorna lo stato delle pagine di memoria occupate da un processo.}
 }
 {La funzione ritorna 0 in caso di successo e $-1$ in caso di errore, nel qual
-caso \var{errno} assumerà uno dei valori seguenti:
+caso \var{errno} assumerà uno dei valori:
 \begin{errlist}
    \item[\errcode{ENOMEM}] o \param{addr} + \param{length} eccede la dimensione
      della memoria usata dal processo o l'intervallo di indirizzi specificato
@@ -1243,8 +1293,8 @@ caso \var{errno} assumerà uno dei valori seguenti:
 
 La funzione permette di ottenere le informazioni sullo stato della mappatura
 della memoria per il processo chiamante, specificando l'intervallo da
-esaminare con l'indirizzo iniziale (indicato con l'argomento \param{addr}) e
-la lunghezza (indicata con l'argomento \param{length}). L'indirizzo iniziale
+esaminare con l'indirizzo iniziale, indicato con l'argomento \param{addr}, e
+la lunghezza, indicata con l'argomento \param{length}. L'indirizzo iniziale
 deve essere un multiplo delle dimensioni di una pagina, mentre la lunghezza
 può essere qualunque, fintanto che si resta nello spazio di indirizzi del
 processo,\footnote{in caso contrario si avrà un errore di \errcode{ENOMEM};
@@ -1258,15 +1308,15 @@ l'intervallo compreso fino al multiplo successivo.
 I risultati della funzione vengono forniti nel vettore puntato da \param{vec},
 che deve essere allocato preventivamente e deve essere di dimensione
 sufficiente a contenere tanti byte quante sono le pagine contenute
-nell'intervallo di indirizzi specificato.\footnote{la dimensione cioè deve
-  essere almeno pari a \code{(length+PAGE\_SIZE-1)/PAGE\_SIZE}. } Al ritorno
-della funzione il bit meno significativo di ciascun byte del vettore sarà
-acceso se la pagina di memoria corrispondente è al momento residente in
-memoria, o cancellato altrimenti. Il comportamento sugli altri bit è
-indefinito, essendo questi al momento riservati per usi futuri. Per questo
-motivo in genere è comunque opportuno inizializzare a zero il contenuto del
-vettore, così che le pagine attualmente residenti in memoria saranno indicata
-da un valore non nullo del byte corrispondente.
+nell'intervallo di indirizzi specificato, la dimensione cioè deve essere
+almeno pari a \code{(length+PAGE\_SIZE-1)/PAGE\_SIZE}.  Al ritorno della
+funzione il bit meno significativo di ciascun byte del vettore sarà acceso se
+la pagina di memoria corrispondente è al momento residente in memoria, o
+cancellato altrimenti. Il comportamento sugli altri bit è indefinito, essendo
+questi al momento riservati per usi futuri. Per questo motivo in genere è
+comunque opportuno inizializzare a zero il contenuto del vettore, così che le
+pagine attualmente residenti in memoria saranno indicata da un valore non
+nullo del byte corrispondente.
 
 Dato che lo stato della memoria di un processo può cambiare continuamente, il
 risultato di \func{mincore} è assolutamente provvisorio e lo stato delle
@@ -1289,30 +1339,28 @@ bloccata oppure no.
 Il \textit{memory lock} persiste fintanto che il processo che detiene la
 memoria bloccata non la sblocca. Chiaramente la terminazione del processo
 comporta anche la fine dell'uso della sua memoria virtuale, e quindi anche di
-tutti i suoi \textit{memory lock}.  Infine i \textit{memory lock} non sono
-ereditati dai processi figli,\footnote{ma siccome Linux usa il
-  \itindex{copy~on~write} \textit{copy on write} (vedi
-  sez.~\ref{sec:proc_fork}) gli indirizzi virtuali del figlio sono mantenuti
-  sullo stesso segmento di RAM del padre, quindi fintanto che un figlio non
-  scrive su un segmento, può usufruire del \textit{memory lock} del padre.} e
-vengono automaticamente rimossi se si pone in esecuzione un altro programma
-con \func{exec} (vedi sez.~\ref{sec:proc_exec}).
-
-Siccome la richiesta di un \textit{memory lock} da parte di un processo riduce
-la memoria fisica disponibile nel sistema, questo ha un evidente impatto su
-tutti gli altri processi, per cui fino al kernel 2.6.9 solo un processo con i
-privilegi opportuni (la \itindex{capabilities} \textit{capability}
-\const{CAP\_IPC\_LOCK}, vedi sez.~\ref{sec:proc_capabilities}) aveva la
-capacità di bloccare una pagina.
+tutti i suoi \textit{memory lock}.  Inoltre i \textit{memory lock} non sono
+ereditati dai processi figli, ma siccome Linux usa il \itindex{copy~on~write}
+\textit{copy on write} (vedi sez.~\ref{sec:proc_fork}) gli indirizzi virtuali
+del figlio sono mantenuti sullo stesso segmento di RAM del padre, e quindi
+fintanto che un figlio non scrive su un segmento bloccato, può usufruire del
+\textit{memory lock} del padre. Infine i \textit{memory lock} vengono
+automaticamente rimossi se si pone in esecuzione un altro programma con
+\func{exec} (vedi sez.~\ref{sec:proc_exec}).
 
 Il sistema pone dei limiti all'ammontare di memoria di un processo che può
 essere bloccata e al totale di memoria fisica che si può dedicare a questo, lo
 standard POSIX.1 richiede che sia definita in \file{unistd.h} la macro
 \macro{\_POSIX\_MEMLOCK\_RANGE} per indicare la capacità di eseguire il
-\textit{memory locking}. Inoltre in alcuni sistemi è definita la costante
-\const{PAGE\_SIZE} in \file{limits.h} per indicare la dimensione di una pagina
-in byte.\footnote{con Linux questo non avviene e si deve ricorrere alla
-  funzione \func{getpagesize}, vedi sez.~\ref{sec:sys_memory_res}.} 
+\textit{memory locking}.
+
+Siccome la richiesta di un \textit{memory lock} da parte di un processo riduce
+la memoria fisica disponibile nel sistema per gli altri processi, questo ha un
+evidente impatto su tutti gli altri processi, per cui fino al kernel 2.6.9
+solo un processo dotato di privilegi amministrativi (la \itindex{capabilities}
+\textit{capability} \const{CAP\_IPC\_LOCK}, vedi
+sez.~\ref{sec:proc_capabilities}) aveva la capacità di bloccare una pagina di
+memoria.
 
 A partire dal kernel 2.6.9 anche un processo normale può bloccare la propria
 memoria\footnote{la funzionalità è stata introdotta per non essere costretti a
@@ -1326,8 +1374,8 @@ però diversi processi bloccano la stessa pagina questa resterà bloccata
 fintanto che ci sarà almeno un processo che la blocca.
 
 Le funzioni per bloccare e sbloccare la \index{paginazione} paginazione di
-singole sezioni di memoria sono \funcd{mlock} e \funcd{munlock}; i loro
-prototipi sono:
+singole sezioni di memoria sono rispettivamente \funcd{mlock} e
+\funcd{munlock}; i loro prototipi sono:
 % \begin{functions}
 %   \headdecl{sys/mman.h} 
 
@@ -1339,7 +1387,7 @@ prototipi sono:
   
 %   \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e $-1$ in
 %     caso di errore, nel qual caso \var{errno} assumerà uno dei
-%     valori seguenti:
+%     valori:
 %   \begin{errlist}
 %   \item[\errcode{ENOMEM}] alcuni indirizzi dell'intervallo specificato non
 %     corrispondono allo spazio di indirizzi del processo o si è ecceduto
@@ -1360,66 +1408,77 @@ prototipi sono:
   \fdecl{int munlock(const void *addr, size\_t len)}
   \fdesc{Rimuove il blocco della paginazione su un intervallo di memoria.}
   }
-{Entrambe le funzioni ritornano 0 in caso di successo e $-1$ in
-    caso di errore, nel qual caso \var{errno} assumerà uno dei
-    valori seguenti:
+{Entrambe le funzioni ritornano $0$ in caso di successo e $-1$ in caso di
+  errore, nel qual caso \var{errno} assumerà uno dei valori:
   \begin{errlist}
-  \item[\errcode{ENOMEM}] alcuni indirizzi dell'intervallo specificato non
-    corrispondono allo spazio di indirizzi del processo o si è ecceduto
-    il numero massimo consentito di pagine bloccate.
+  \item[\errcode{ENOMEM}] alcuni indirizzi dell’intervallo specificato non
+    corrispondono allo spazio di indirizzi del processo o si è superato il
+    limite di \const{RLIMIT\_MEMLOCK} per un processo non privilegiato (solo
+    per kernel a partire dal 2.6.9). 
   \item[\errcode{EINVAL}] \param{len} non è un valore positivo.
-  \item[\errcode{EPERM}] con un kernel successivo al 2.6.9 il processo non è
-    privilegiato e si un limite nullo per \const{RLIMIT\_MEMLOCK}.
-  \end{errlist}
-  e, per \func{mlock}, anche \errval{EPERM} quando il processo non ha i
-  privilegi richiesti per l'operazione.}
+  \item[\errcode{EPERM}] il processo non è privilegiato (per kernel precedenti
+    il 2.6.9) o si ha un limite nullo per \const{RLIMIT\_MEMLOCK} e
+    il processo non è privilegiato (per kernel a partire dal 2.6.9).
+  \end{errlist}}
 \end{funcproto}
 
-
 Le due funzioni permettono rispettivamente di bloccare e sbloccare la
-\index{paginazione} paginazione per l'intervallo di memoria specificato dagli
-argomenti, che ne indicano nell'ordine l'indirizzo iniziale e la lunghezza.
-Tutte le pagine che contengono una parte dell'intervallo bloccato sono
-mantenute in RAM per tutta la durata del blocco.\footnote{con altri kernel si
-  può ottenere un errore di \errcode{EINVAL} se \param{addr} non è un multiplo
-  della dimensione delle pagine di memoria.}
+\index{paginazione} paginazione per l'intervallo di memoria iniziante
+all'indirizzo \param{addr} e lungo \param{len} byte.  Tutte le pagine che
+contengono una parte dell'intervallo bloccato sono mantenute in RAM per tutta
+la durata del blocco. Con kernel diversi da Linux si può ottenere un errore di
+\errcode{EINVAL} se \param{addr} non è un multiplo della dimensione delle
+pagine di memoria, pertanto se si ha a cuore la portabilità si deve avere cura
+di allinearne correttamente il valore.
 
 Altre due funzioni, \funcd{mlockall} e \funcd{munlockall}, consentono di
 bloccare genericamente la \index{paginazione} paginazione per l'intero spazio
 di indirizzi di un processo.  I prototipi di queste funzioni sono:
-\begin{functions}
-  \headdecl{sys/mman.h} 
 
-  \funcdecl{int mlockall(int flags)}
-  Blocca la paginazione per lo spazio di indirizzi del processo corrente. 
-  
-  \funcdecl{int munlockall(void)}
-  Sblocca la paginazione per lo spazio di indirizzi del processo corrente. 
-  
-  \bodydesc{Codici di ritorno ed errori sono gli stessi di \func{mlock} e
-    \func{munlock}, con un kernel successivo al 2.6.9 l'uso di
-    \func{munlockall} senza la \itindex{capabilities} \textit{capability}
-\const{CAP\_IPC\_LOCK} genera un errore di \errcode{EPERM}.}
-\end{functions}
+\begin{funcproto}{ 
+\fhead{sys/mman.h} 
+\fdecl{int mlockall(int flags)}
+\fdesc{Blocca la paginazione per lo spazio di indirizzi del processo corrente.} 
+\fdecl{int munlockall(void)}
+\fdesc{Sblocca la paginazione per lo spazio di indirizzi del processo corrente.}
+}
+{Codici di ritorno ed errori sono gli stessi di \func{mlock} e \func{munlock},
+  tranne per \errcode{EINVAL} che viene restituito solo se si è specificato
+  con \func{mlockall} un valore sconosciuto per \param{flags}.}
+\end{funcproto}
 
 L'argomento \param{flags} di \func{mlockall} permette di controllarne il
-comportamento; esso può essere specificato come l'OR aritmetico delle due
-costanti: 
-\begin{basedescript}{\desclabelwidth{2.5cm}}
-\item[\const{MCL\_CURRENT}] blocca tutte le pagine correntemente mappate nello
-  spazio di indirizzi del processo.
-\item[\const{MCL\_FUTURE}] blocca tutte le pagine che verranno mappate nello
-  spazio di indirizzi del processo.
-\end{basedescript}
+comportamento; esso deve essere specificato come maschera binaria dei valori
+espressi dalle costanti riportate in tab.~\ref{tab:mlockall_flags}.
+
+\begin{table}[htb]
+  \footnotesize
+  \centering
+  \begin{tabular}[c]{|l|p{8cm}|}
+    \hline
+    \textbf{Valore} & \textbf{Significato} \\
+    \hline
+    \hline
+    \const{MCL\_CURRENT}& blocca tutte le pagine correntemente mappate nello
+                          spazio di indirizzi del processo.\\
+    \const{MCL\_FUTURE} & blocca tutte le pagine che verranno mappate nello
+                          spazio di indirizzi del processo.\\
+   \hline
+  \end{tabular}
+  \caption{Valori e significato dell'argomento \param{flags} della funzione
+    \func{mlockall}.}
+  \label{tab:mlockall_flags}
+\end{table}
 
 Con \func{mlockall} si possono bloccare tutte le pagine mappate nello spazio
 di indirizzi del processo, sia che comprendano il \index{segmento!dati}
 \index{segmento!testo} segmento di testo, di dati, lo \itindex{stack}
 \textit{stack}, lo \itindex{heap} \textit{heap} e pure le funzioni di libreria
 chiamate, i file mappati in memoria, i dati del kernel mappati in user space,
-la memoria condivisa.  L'uso dei flag permette di selezionare con maggior
-finezza le pagine da bloccare, ad esempio limitandosi a tutte le pagine
-allocate a partire da un certo momento.
+la memoria condivisa.  L'uso dell'argomento \param{flags} permette di
+selezionare con maggior finezza le pagine da bloccare, ad esempio usando
+\const{MCL\_FUTURE} ci si può limitare a tutte le pagine allocate a partire
+dalla chiamata della funzione.
 
 In ogni caso un processo real-time che deve entrare in una
 \index{sezione~critica} sezione critica deve provvedere a riservare memoria
@@ -1432,10 +1491,10 @@ ancora stata riportata in RAM si potrebbe avere un \itindex{page~fault}
 rallentamento (probabilmente inaccettabile) dei tempi di esecuzione.
 
 In genere si ovvia a questa problematica chiamando una funzione che ha
-allocato una quantità sufficientemente ampia di variabili automatiche, in modo
-che esse vengano mappate in RAM dallo \itindex{stack} \textit{stack}, dopo di
-che, per essere sicuri che esse siano state effettivamente portate in memoria,
-ci si scrive sopra.
+allocato una quantità sufficientemente ampia di \index{variabili!automatiche}
+variabili automatiche, in modo che esse vengano mappate in RAM dallo
+\itindex{stack} \textit{stack}, dopo di che, per essere sicuri che esse siano
+state effettivamente portate in memoria, ci si scrive sopra.
 
 \itindend{memory~locking}
 
@@ -1466,34 +1525,34 @@ funzione specifica.
 Tradizionalmente per rispondere a questa esigenza sono state create due
 funzioni diverse, \funcd{memalign} e \funcd{valloc}, oggi obsolete; i
 rispettivi prototipi sono:
-\begin{functions}
-  \headdecl{malloc.h} 
-
-  \funcdecl{void *valloc(size\_t size)} Alloca un blocco di memoria allineato
-  alla dimensione di una pagina di memoria.
 
-  \funcdecl{void *memalign(size\_t boundary, size\_t size)}
-  Alloca un blocco di memoria allineato ad un multiplo di \param{boundary}.
-  
-  \bodydesc{Entrambe le funzioni ritornano un puntatore al blocco di memoria
-    allocato in caso di successo e \val{NULL} in caso di errore, nel qual
-    caso \var{errno} assumerà uno dei valori seguenti:
+\begin{funcproto}{ 
+\fhead{malloc.h} 
+\fdecl{void *valloc(size\_t size)}
+\fdesc{Alloca un blocco di memoria allineato alla dimensione di una pagina di
+  memoria.}  
+\fdecl{void *memalign(size\_t boundary, size\_t size)}
+\fdesc{Alloca un blocco di memoria allineato ad un multiplo
+  di \param{boundary}.} 
+}
+{Entrambe le funzioni ritornano un puntatore al blocco di memoria allocato in
+  caso di successo e \val{NULL} in caso di errore, nel qual caso \var{errno}
+  assumerà uno dei valori:
   \begin{errlist}
   \item[\errcode{ENOMEM}] non c'è memoria sufficiente per l'allocazione.
-  \item[\errcode{EINVAL}] \param{boundary} non è multiplo di due.
-  \end{errlist}
-}
-\end{functions}
+  \item[\errcode{EINVAL}] \param{boundary} non è una potenza di due.
+  \end{errlist}}
+\end{funcproto}
 
-Le funzioni restituiscono il puntatore al buffer di memoria allocata, che per
-\func{memalign} sarà un multiplo di \param{boundary} mentre per \func{valloc}
-un multiplo della dimensione di una pagina di memoria. Nel caso della versione
-fornita dalle \acr{glibc} la memoria allocata con queste funzioni deve essere
-liberata con \func{free}, cosa che non è detto accada con altre
-implementazioni.
+Le funzioni restituiscono il puntatore al buffer di memoria allocata di
+dimensioni pari a \param{size}, che per \func{memalign} sarà un multiplo
+di \param{boundary} mentre per \func{valloc} un multiplo della dimensione di
+una pagina di memoria. Nel caso della versione fornita dalla \acr{glibc} la
+memoria allocata con queste funzioni deve essere liberata con \func{free},
+cosa che non è detto accada con altre implementazioni.
 
-Nessuna delle due funzioni ha una chiara standardizzazione (nessuna delle due
-compare in POSIX.1), ed inoltre ci sono indicazioni discordi sui file che ne
+Nessuna delle due funzioni ha una chiara standardizzazione nessuna delle due
+compare in POSIX.1, inoltre ci sono indicazioni discordi sui file che ne
 contengono la definizione;\footnote{secondo SUSv2 \func{valloc} è definita in
   \texttt{stdlib.h}, mentre sia le \acr{glibc} che le precedenti \acr{libc4} e
   \acr{libc5} la dichiarano in \texttt{malloc.h}, lo stesso vale per
@@ -1501,82 +1560,82 @@ contengono la definizione;\footnote{secondo SUSv2 \func{valloc} è definita in
 per questo motivo il loro uso è sconsigliato, essendo state sostituite dalla
 nuova \funcd{posix\_memalign}, che è stata standardizzata in POSIX.1d; il suo
 prototipo è:
-\begin{prototype}{stdlib.h}{posix\_memalign(void **memptr, size\_t alignment,
-    size\_t size) } 
-  Alloca un buffer di memoria allineato ad un multiplo di \param{alignment}.
-  
-  \bodydesc{La funzione restituisce 0 in caso di successo e \val{NULL} in caso
-    di fallimento, o uno dei due codici di errore \errcode{ENOMEM} o
-    \errcode{EINVAL}; \var{errno} non viene impostata.}
-\end{prototype}
-
-La funzione restituisce il puntatore al buffer allocato all'indirizzo indicato
-da \param{memptr}. La funzione fallisce nelle stesse condizioni delle due
-funzioni precedenti, ma a differenza di \func{memalign} restituisce un codice
-di errore \errcode{EINVAL} anche se \param{alignment} non è un multiplo della
-la dimensione di \code{sizeof(void *)}. Come per le precedenti la memoria
-allocata con \func{posix\_memalign} può essere disallocata con
-\func{free}.\footnote{che in questo caso è quanto richiesto dallo standard.}
+
+\begin{funcproto}{ 
+\fhead{stdlib.h} 
+\fdecl{posix\_memalign(void **memptr, size\_t alignment, size\_t size)}
+\fdesc{Alloca un buffer di memoria allineato ad un multiplo
+  di \param{alignment}.}   
+}
+{Entrambe le funzioni ritornano un puntatore al blocco di memoria allocato in
+  caso di successo e \val{NULL} in caso di errore, nel qual caso \var{errno}
+  assumerà uno dei valori:
+  \begin{errlist}
+  \item[\errcode{ENOMEM}] non c'è memoria sufficiente per l'allocazione.
+  \item[\errcode{EINVAL}] \param{alignment} non è potenza di due e multiplo
+    di \code{sizeof(void *)}.
+  \end{errlist}}
+\end{funcproto}
+
+La funzione restituisce il puntatore al buffer allocato di dimensioni pari
+a \param{size} nella variabile (di tipo \texttt{void *}) posta all'indirizzo
+indicato da \param{memptr}. La funzione fallisce nelle stesse condizioni delle
+due funzioni precedenti, ma a loro differenza restituisce direttamente come
+valore di ritorno il codice di errore.  Come per le precedenti la memoria
+allocata con \func{posix\_memalign} deve essere disallocata con \func{free},
+che in questo caso però è quanto richiesto dallo standard.  Si tenga presente
+infine che nessuna di queste funzioni inizializza il buffer di memoria
+allocato, il loro comportamento cioè è analogo, allineamento a parte, a quello
+di \func{malloc}.
 
 Un secondo caso in cui risulta estremamente utile poter avere un maggior
 controllo delle modalità di allocazione della memoria è quello in cui cercano
-errori di programmazione. Esempi di questi errori sono chiamate doppie alla
-funzione \func{free} con lo stesso puntatore, o i cosiddetti
-\itindex{buffer~overrun} \textit{buffer overrun}, cioè le scritture su un buffer
-oltre le dimensioni della sua allocazione,\footnote{entrambe queste operazioni
-  causano in genere la corruzione dei dati di controllo delle funzioni di
-  allocazione, che vengono anch'essi mantenuti nello \itindex{heap}
-  \textit{heap} per tenere traccia delle zone di memoria allocata.} o i
-classici \itindex{memory~leak} \textit{memory leak}.
-
-Una prima funzionalità di ausilio nella ricerca di questi errori viene fornita
-dalla \acr{glibc} tramite l'uso della variabile di ambiente
-\var{MALLOC\_CHECK\_}. Quando questa viene definita al posto della versione
-ordinaria delle funzioni di allocazione (\func{malloc}, \func{calloc},
-\func{realloc}, e \func{free}) viene usata una versione meno efficiente ma in
-grado di rilevare (e tollerare) alcuni degli errori più semplici, come le
-doppie chiamate a \func{free} o i \itindex{buffer~overrun} \textit{buffer
-  overrun} di un byte.\footnote{uno degli errori più comuni, causato ad
-  esempio dalla scrittura di una stringa di dimensione pari a quella del
-  buffer, in cui ci si dimentica dello zero di terminazione finale.}
-
-In questo caso a seconda del valore assegnato a \var{MALLOC\_CHECK\_} si
-avranno diversi comportamenti: con 0 l'errore sarà ignorato, con 1 verrà
-stampato un messaggio sullo \textit{standard error} (vedi
-sez.~\ref{sec:file_std_stream}), con 2 verrà invocata la funzione \func{abort}
-(vedi sez.~\ref{sec:sig_alarm_abort}) che termina il programma, con 3 viene
-sia stampato il messaggio d'errore che abortito il programma. In genere è
-opportuno definire la variabile ad un valore diverso da zero che consente di
-rilevare un errore nel momento in cui avviene.
-
-Una modalità alternativa per effettuare dei controlli di consistenza sullo
-stato delle allocazioni di memoria eseguite con \func{malloc}, anche questa
-fornita come estensione specifica (e non standard) delle \acr{glibc}, è quella
-di utilizzare la funzione \funcd{mcheck}, che deve essere chiamata prima di
-eseguire qualunque allocazione con \func{malloc}; il suo prototipo è:
-\begin{prototype}{mcheck.h}{mcheck(void (*abortfn) (enum mcheck\_status
-    status))} 
-  Attiva i controlli di consistenza delle allocazioni eseguite da \func{malloc}.
-  
-  \bodydesc{La funzione restituisce 0 in caso di successo e $-1$ in caso di
-    fallimento; \var{errno} non viene impostata.}
-\end{prototype}
-
-La funzione consente di registrare una funzione di emergenza, da passare come
-argomento, che verrà eseguita tutte le volte che, in una successiva esecuzione
-di \func{malloc}, venissero trovate delle inconsistenze, come delle operazioni
-di scrittura oltre i limiti dei buffer allocati. Per questo motivo la funzione
-deve essere chiamata prima di qualunque allocazione di memoria, altrimenti
-fallirà con un valore di ritorno pari a $-1$.
-
-Se come argomento di \func{mcheck} si passa \val{NULL} verrà utilizzata una
-funzione predefinita che stampa un messaggio di errore ed invoca la funzione
-\func{abort} (vedi sez.~\ref{sec:sig_alarm_abort}), altrimenti si dovrà create
-una funzione personalizzata che verrà eseguita ricevendo un unico argomento di
-tipo \type{mcheck\_status},\footnote{trattasi in sostanza di un codice di
-  errore che la funzione di emergenza potrà utilizzare per prendere le
-  opportune azioni.} un tipo enumerato che può assumere soltanto i valori di
-tab.~\ref{tab:mcheck_status_value}.
+errori di programmazione. Esempi di questi errori sono i \itindex{double~free}
+\textit{double free}, o i cosiddetti \itindex{buffer~overrun} \textit{buffer
+  overrun}, cioè le scritture su un buffer oltre le dimensioni della sua
+allocazione,\footnote{entrambe queste operazioni causano in genere la
+  corruzione dei dati di controllo delle funzioni di allocazione, che vengono
+  anch'essi mantenuti nello \itindex{heap} \textit{heap} per tenere traccia
+  delle zone di memoria allocata.} o i classici \itindex{memory~leak}
+\textit{memory leak}.
+
+Abbiamo visto in sez.~\ref{sec:proc_mem_lock} come una prima funzionalità di
+ausilio nella ricerca di questi errori sia l'uso della variabile di ambiente
+\var{MALLOC\_CHECK\_}.  Una modalità alternativa per effettuare dei controlli
+di consistenza sullo stato delle allocazioni di memoria eseguite con
+\func{malloc}, anche questa fornita come estensione specifica (e non standard)
+della \acr{glibc}, è quella di utilizzare la funzione \funcd{mcheck}, che deve
+essere chiamata prima di eseguire qualunque allocazione con \func{malloc}; il
+suo prototipo è:
+
+\begin{funcproto}{ 
+\fhead{mcheck.h} 
+\fdecl{int mcheck(void (*abortfn) (enum mcheck\_status status))}
+\fdesc{Attiva i controlli di consistenza delle allocazioni di memoria.}   
+}
+{La funzione restituisce $0$ in caso di successo e $-1$ in caso di fallimento;
+  \var{errno} non viene impostata.} 
+\end{funcproto}
+
+La funzione consente di registrare una funzione di emergenza che verrà
+eseguita tutte le volte che, in una successiva esecuzione di \func{malloc},
+venissero trovate delle inconsistenze, come delle operazioni di scrittura
+oltre i limiti dei buffer allocati. Per questo motivo la funzione deve essere
+chiamata prima di qualunque allocazione di memoria, altrimenti fallirà.
+
+Se come primo argomento di \func{mcheck} si passa \val{NULL} verrà utilizzata
+una funzione predefinita che stampa un messaggio di errore ed invoca la
+funzione \func{abort} (vedi sez.~\ref{sec:sig_alarm_abort}), altrimenti si
+dovrà creare una funzione personalizzata in grado di ricevere il tipo di
+errore ed agire di conseguenza.
+
+Nonostante la scarsa leggibilità del prototipo si tratta semplicemente di
+definire una funzione di tipo \code{void abortfn(enum mcheck\_status status)},
+che non deve restituire nulla e che deve avere un unico argomento di tipo
+\type{mcheck\_status}. In caso di errore la funzione verrà eseguita ricevendo
+un opportuno valore di \param{status} che è un tipo enumerato che può assumere
+soltanto i valori di tab.~\ref{tab:mcheck_status_value} che indicano la
+tipologia di errore riscontrata.
 
 \begin{table}[htb]
   \centering
@@ -1586,9 +1645,9 @@ tab.~\ref{tab:mcheck_status_value}.
     \textbf{Valore} & \textbf{Significato} \\
     \hline
     \hline
-    \macro{MCHECK\_OK}      & riportato (a \func{mprobe}) se nessuna
+    \macro{MCHECK\_OK}      & riportato a \func{mprobe} se nessuna
                               inconsistenza è presente.\\
-    \macro{MCHECK\_DISABLED}& riportato (a \func{mprobe}) se si è chiamata
+    \macro{MCHECK\_DISABLED}& riportato a \func{mprobe} se si è chiamata
                               \func{mcheck} dopo aver già usato
                               \func{malloc}.\\
     \macro{MCHECK\_HEAD}    & i dati immediatamente precedenti il buffer sono
@@ -1608,22 +1667,25 @@ tab.~\ref{tab:mcheck_status_value}.
 \end{table}
 
 Una volta che si sia chiamata \func{mcheck} con successo si può anche
-controllare esplicitamente lo stato delle allocazioni (senza aspettare un
-errore nelle relative funzioni) utilizzando la funzione \funcd{mprobe}, il cui
+controllare esplicitamente lo stato delle allocazioni senza aspettare un
+errore nelle relative funzioni utilizzando la funzione \funcd{mprobe}, il cui
 prototipo è:
-\begin{prototype}{mcheck.h}{enum mcheck\_status mprobe(ptr)} 
-  Esegue un controllo di consistenza delle allocazioni.
-  
-  \bodydesc{La funzione restituisce un codice fra quelli riportati in
-    tab.\ref{tab:mcheck_status_value}.}
-\end{prototype}
+
+\begin{funcproto}{ 
+\fhead{mcheck.h} 
+\fdecl{enum mcheck\_status mprobe(ptr)}
+\fdesc{Esegue un controllo di consistenza delle allocazioni.}   
+}
+{La funzione restituisce un codice fra quelli riportati in
+   tab.\ref{tab:mcheck_status_value} e non ha errori.} 
+\end{funcproto}
 
 La funzione richiede che si passi come argomento un puntatore ad un blocco di
 memoria precedentemente allocato con \func{malloc} o \func{realloc}, e
 restituisce lo stesso codice di errore che si avrebbe per la funzione di
 emergenza ad una successiva chiamata di una funzione di allocazione, e poi i
 primi due codici che indicano rispettivamente quando tutto è a posto o il
-controllo non è possibile per non aver chiamato \func{mcheck} in tempo. 
+controllo non è possibile per non aver chiamato \func{mcheck} in tempo.
 
 % TODO: trattare le altre funzionalità avanzate di \func{malloc}, mallopt,
 % mtrace, muntrace, mallinfo e gli hook con le glibc 2.10 c'è pure malloc_info
@@ -1633,7 +1695,6 @@ controllo non è possibile per non aver chiamato \func{mcheck} in tempo.
 \section{Argomenti, ambiente ed altre proprietà di un processo}
 \label{sec:proc_options}
 
-
 In questa sezione esamineremo le funzioni che permettono di gestire gli
 argomenti e le opzioni, e quelle che consentono di manipolare ed utilizzare le
 variabili di ambiente. Accenneremo infine alle modalità con cui si può gestire
@@ -1645,20 +1706,25 @@ operazioni.
 \label{sec:proc_par_format}
 
 Tutti i programmi hanno la possibilità di ricevere argomenti e opzioni quando
-vengono lanciati. Il passaggio degli argomenti e delle opzioni è effettuato
-attraverso gli argomenti \param{argc} e \param{argv} della funzione
-\func{main}, che vengono passati al programma dalla shell (o dal processo che
-esegue la \func{exec}, secondo le modalità che vedremo in
-sez.~\ref{sec:proc_exec}) quando questo viene messo in esecuzione.
-
-In genere il passaggio di argomenti ed opzioni ad un programma viene
-effettuato dalla shell, che si incarica di leggere la linea di comando e di
-effettuarne la scansione (il cosiddetto \textit{parsing}) per individuare le
-parole che la compongono, ciascuna delle quali potrà essere considerata un
-argomento o un'opzione. Di norma per individuare le parole che andranno a
-costituire la lista degli argomenti viene usato come carattere di separazione
-lo spazio o il tabulatore, ma la cosa dipende ovviamente dalle modalità con
-cui si effettua la scansione.
+vengono lanciati e come accennato in sez.~\ref{sec:proc_main} questo viene
+effettuato attraverso gli argomenti \param{argc} e \param{argv} ricevuti nella
+funzione \func{main} all'avvio del programma. Questi argomenti vengono passati
+al programma dalla shell o dal processo che esegue la \func{exec} (secondo le
+modalità che vedremo in sez.~\ref{sec:proc_exec}) quando questo viene messo in
+esecuzione.
+
+Nel caso più comune il passaggio di argomenti ed opzioni viene effettuato
+dalla shell, che si incarica di leggere la linea di comando con cui si lancia
+il programma e di effettuarne la scansione (il cosiddetto \textit{parsing})
+per individuare le parole che la compongono, ciascuna delle quali potrà essere
+considerata un argomento o un'opzione. 
+
+Di norma per individuare le parole che andranno a costituire la lista degli
+argomenti viene usato come carattere di separazione lo spazio o il tabulatore,
+ma la cosa dipende ovviamente dalle modalità con cui si effettua la scansione
+e dalle convenzioni adottate dal programma che la esegue: ad esempio la shell
+consente di proteggere con opportuni caratteri di controllo argomenti che
+contengono degli spazi evitando di spezzarli in parole diverse.
 
 \begin{figure}[htb]
   \centering
@@ -1695,13 +1761,15 @@ cui si effettua la scansione.
   \label{fig:proc_argv_argc}
 \end{figure}
 
-Indipendentemente da come viene eseguita, il risultato della scansione deve
-essere la costruzione del vettore di puntatori \param{argv} in cui si devono
-inserire in successione i puntatori alle stringhe costituenti i vari argomenti
-ed opzioni, e della variabile \param{argc} che deve essere inizializzata al
-numero di stringhe passate. Nel caso della shell questo comporta che il primo
-argomento sia sempre il nome del programma; un esempio di questo meccanismo è
-mostrato in fig.~\ref{fig:proc_argv_argc}.
+Indipendentemente da come viene eseguita, il risultato finale della scansione
+dovrà comunque essere la costruzione del vettore di puntatori \param{argv} in
+cui si devono inserire in successione i puntatori alle stringhe costituenti i
+vari argomenti ed opzioni da passare al programma, e della
+variabile \param{argc} che deve essere inizializzata al numero di stringhe
+contenute in \param{argv}. Nel caso della shell questo comporta ad esempio che
+il primo argomento sia sempre il nome del programma. Un esempio di questo
+meccanismo è mostrato in fig.~\ref{fig:proc_argv_argc}, che illustra il
+risultato della scansione di una riga di comando.
 
 
 \subsection{La gestione delle opzioni}
@@ -1709,50 +1777,54 @@ mostrato in fig.~\ref{fig:proc_argv_argc}.
 
 In generale un programma Unix riceve da linea di comando sia gli argomenti che
 le opzioni, queste ultime sono standardizzate per essere riconosciute come
-tali: un elemento di \param{argv} che inizia con il carattere \texttt{'-'} e
-che non sia un singolo \texttt{'-'} o un \texttt{'-{}-'} viene considerato
-un'opzione.  In genere le opzioni sono costituite da una lettera singola
-(preceduta dal carattere \cmd{'-'}) e possono avere o no un parametro
-associato; un comando tipico può essere quello mostrato in
-fig.~\ref{fig:proc_argv_argc}. In quel caso le opzioni sono \cmd{-r} e \cmd{-m}
-e la prima vuole un parametro mentre la seconda no (\cmd{questofile.txt} è un
-argomento del programma, non un parametro di \cmd{-m}).
-
-Per gestire le opzioni all'interno dei argomenti a linea di comando passati in
-\param{argv} le librerie standard del C forniscono la funzione \funcd{getopt},
-che ha il seguente prototipo:
-\begin{prototype}{unistd.h}
-{int getopt(int argc, char *const argv[], const char *optstring)}
-Esegue il parsing degli argomenti passati da linea di comando
-riconoscendo le possibili opzioni segnalate con \param{optstring}.
-
-\bodydesc{Ritorna il carattere che segue l'opzione, \cmd{':'} se manca un
-  parametro all'opzione, \cmd{'?'} se l'opzione è sconosciuta, e $-1$ se non
-  esistono altre opzioni.}
-\end{prototype}
+tali: un elemento di \param{argv} successivo al primo che inizia con il
+carattere ``\texttt{-}'' e che non sia un singolo ``\texttt{-}'' o un
+``\texttt{-{}-}'' viene considerato un'opzione.  In genere le opzioni sono
+costituite da una lettera singola (preceduta dal carattere ``\texttt{-}'') e
+possono avere o no un parametro associato. Un esempio tipico può essere quello
+mostrato in fig.~\ref{fig:proc_argv_argc}. In quel caso le opzioni sono
+\cmd{-r} e \cmd{-m} e la prima vuole un parametro mentre la seconda no
+(\cmd{questofile.txt} è un argomento del programma, non un parametro di
+\cmd{-m}).
+
+Per gestire le opzioni all'interno degli argomenti a linea di comando passati
+in \param{argv} la libreria standard del C fornisce la funzione
+\funcd{getopt}, che ha il seguente prototipo:
+
+\begin{funcproto}{ 
+\fhead{unistd.h} 
+\fdecl{int getopt(int argc, char * const argv[], const char *optstring)}
+\fdesc{Esegue la scansione delle opzioni negli argomenti della funzione
+  \func{main}.} 
+}
+{Ritorna il carattere che segue l'opzione, ``\texttt{:}'' se manca un
+  parametro all'opzione, ``\texttt{?}'' se l'opzione è sconosciuta, e $-1$ se
+  non esistono altre opzioni.} 
+\end{funcproto}
 
 Questa funzione prende come argomenti le due variabili \param{argc} e
-\param{argv} passate a \func{main} ed una stringa che indica quali sono le
-opzioni valide; la funzione effettua la scansione della lista degli argomenti
-ricercando ogni stringa che comincia con \cmd{-} e ritorna ogni volta che
-trova un'opzione valida.
+\param{argv} che devono essere quelle passate come argomenti di \func{main}
+all'esecuzione del programma, ed una stringa \param{optstring} che indica
+quali sono le opzioni valide. La funzione effettua la scansione della lista
+degli argomenti ricercando ogni stringa che comincia con il carattere
+``\texttt{-}'' e ritorna ogni volta che trova un'opzione valida.
 
 La stringa \param{optstring} indica quali sono le opzioni riconosciute ed è
 costituita da tutti i caratteri usati per identificare le singole opzioni, se
-l'opzione ha un parametro al carattere deve essere fatto seguire un segno di
-due punti \texttt{':'}; nel caso di fig.~\ref{fig:proc_argv_argc} ad esempio la
-stringa di opzioni avrebbe dovuto contenere \texttt{"r:m"}.
+l'opzione ha un parametro al carattere deve essere fatto seguire il carattere
+di due punti (``\texttt{:}''); nel caso di fig.~\ref{fig:proc_argv_argc} ad
+esempio la stringa di opzioni avrebbe dovuto contenere \texttt{"r:m"}.
 
 La modalità di uso di \func{getopt} è pertanto quella di chiamare più volte la
 funzione all'interno di un ciclo, fintanto che essa non ritorna il valore $-1$
 che indica che non ci sono più opzioni. Nel caso si incontri un'opzione non
-dichiarata in \param{optstring} viene ritornato il carattere \texttt{'?'}
+dichiarata in \param{optstring} viene ritornato il carattere ``\texttt{?}''
 mentre se un'opzione che lo richiede non è seguita da un parametro viene
-ritornato il carattere \texttt{':'}, infine se viene incontrato il valore
-\texttt{'-{}-'} la scansione viene considerata conclusa, anche se vi sono altri
-elementi di \param{argv} che cominciano con il carattere \texttt{'-'}.
+ritornato il carattere ``\texttt{:}'', infine se viene incontrato il valore
+``\texttt{-{}-}'' la scansione viene considerata conclusa, anche se vi sono
+altri elementi di \param{argv} che cominciano con il carattere ``\texttt{-}''.
 
-\begin{figure}[!htbp]
+\begin{figure}[!htb]
   \footnotesize \centering
   \begin{minipage}[c]{\codesamplewidth}
   \includecodesample{listati/option_code.c}
@@ -1762,9 +1834,10 @@ elementi di \param{argv} che cominciano con il carattere \texttt{'-'}.
   \label{fig:proc_options_code}
 \end{figure}
 
-Quando la funzione trova un'opzione essa ritorna il valore numerico del
-carattere, in questo modo si possono eseguire azioni specifiche usando uno
-\code{switch}; \func{getopt} inoltre inizializza alcune variabili globali:
+Quando \func{getopt} trova un'opzione fra quelle indicate in \param{optstring}
+essa ritorna il valore numerico del carattere, in questo modo si possono
+eseguire azioni specifiche usando uno \instruction{switch}; la funzione
+inoltre inizializza alcune \index{variabili!globali} variabili globali:
 \begin{itemize*}
 \item \var{char *optarg} contiene il puntatore alla stringa parametro
   dell'opzione.
@@ -1775,17 +1848,17 @@ carattere, in questo modo si possono eseguire azioni specifiche usando uno
 \item \var{int optopt} contiene il carattere dell'opzione non riconosciuta.
 \end{itemize*}
 
-In fig.~\ref{fig:proc_options_code} è mostrata la sezione del programma
-\file{ForkTest.c} (che useremo nel prossimo capitolo per effettuare dei test
-sulla creazione dei processi) deputata alla decodifica delle opzioni a riga di
-comando
+In fig.~\ref{fig:proc_options_code} si è mostrata la sezione del programma
+\file{ForkTest.c}che useremo nel prossimo capitolo per effettuare dei test
+sulla creazione dei processi, deputata alla decodifica delle opzioni a riga di
+comando da esso supportate.
 
 Si può notare che si è anzitutto (\texttt{\small 1}) disabilitata la stampa di
 messaggi di errore per opzioni non riconosciute, per poi passare al ciclo per
 la verifica delle opzioni (\texttt{\small 2-27}); per ciascuna delle opzioni
 possibili si è poi provveduto ad un'azione opportuna, ad esempio per le tre
-opzioni che prevedono un parametro si è effettuata la decodifica del medesimo
-(il cui indirizzo è contenuto nella variabile \var{optarg}) avvalorando la
+opzioni che prevedono un parametro si è effettuata la decodifica del medesimo,
+il cui indirizzo è contenuto nella variabile \var{optarg}), avvalorando la
 relativa variabile (\texttt{\small 12-14}, \texttt{\small 15-17} e
 \texttt{\small 18-20}). Completato il ciclo troveremo in \var{optind} l'indice
 in \code{argv[]} del primo degli argomenti rimanenti nella linea di comando.
@@ -1794,13 +1867,13 @@ Normalmente \func{getopt} compie una permutazione degli elementi di
 \param{argv} cosicché alla fine della scansione gli elementi che non sono
 opzioni sono spostati in coda al vettore. Oltre a questa esistono altre due
 modalità di gestire gli elementi di \param{argv}; se \param{optstring} inizia
-con il carattere \texttt{'+'} (o è impostata la variabile di ambiente
+con il carattere ``\texttt{+}'' (o è impostata la variabile di ambiente
 \macro{POSIXLY\_CORRECT}) la scansione viene fermata non appena si incontra un
-elemento che non è un'opzione. 
+elemento che non è un'opzione.
 
 L'ultima modalità, usata quando un programma può gestire la mescolanza fra
 opzioni e argomenti, ma se li aspetta in un ordine definito, si attiva
-quando \param{optstring} inizia con il carattere \texttt{'-'}. In questo caso
+quando \param{optstring} inizia con il carattere ``\texttt{-}''. In questo caso
 ogni elemento che non è un'opzione viene considerato comunque un'opzione e
 associato ad un valore di ritorno pari ad 1, questo permette di identificare
 gli elementi che non sono opzioni, ma non effettua il riordinamento del
@@ -1829,9 +1902,9 @@ lunghezza del vettore data da un equivalente di \param{argc}, ma la lista è
 terminata da un puntatore nullo.
 
 L'indirizzo della lista delle variabili di ambiente è passato attraverso la
-variabile globale \var{environ}, che viene definita automaticamente per
-ciascun processo, e a cui si può accedere attraverso una semplice
-dichiarazione del tipo:
+\index{variabili!globali} variabile globale \var{environ}, che viene definita
+automaticamente per ciascun processo, e a cui si può accedere attraverso una
+semplice dichiarazione del tipo:
 \includecodesnip{listati/env_ptr.c}
 un esempio della struttura di questa lista, contenente alcune delle variabili
 più comuni che normalmente sono definite dal sistema, è riportato in
@@ -1878,7 +1951,8 @@ Inoltre alcune variabili, come quelle elencate in
 fig.~\ref{fig:proc_envirno_list}, sono definite dal sistema per essere usate
 da diversi programmi e funzioni: per queste c'è l'ulteriore convenzione di
 usare nomi espressi in caratteri maiuscoli.\footnote{ma si tratta solo di una
-  convenzione, niente vieta di usare caratteri minuscoli.}
+  convenzione, niente vieta di usare caratteri minuscoli, come avviene in vari
+  casi.}
 
 Il kernel non usa mai queste variabili, il loro uso e la loro interpretazione è
 riservata alle applicazioni e ad alcune funzioni di libreria; in genere esse
@@ -1913,7 +1987,7 @@ queste ed ulteriori variabili si può ottenere con il comando \cmd{man 7
 \begin{table}[htb]
   \centering
   \footnotesize
-  \begin{tabular}[c]{|l|c|c|c|p{7cm}|}
+  \begin{tabular}[c]{|l|c|c|c|l|}
     \hline
     \textbf{Variabile} & \textbf{POSIX} & \textbf{XPG3} 
     & \textbf{Linux} & \textbf{Descrizione} \\
@@ -1946,20 +2020,20 @@ Lo standard ANSI C prevede l'esistenza di un ambiente, e pur non entrando
 nelle specifiche di come sono strutturati i contenuti, definisce la funzione
 \funcd{getenv} che permette di ottenere i valori delle variabili di ambiente;
 il suo prototipo è:
-\begin{prototype}{stdlib.h}{char *getenv(const char *name)}
-  Esamina l'ambiente del processo cercando una stringa che corrisponda a
-  quella specificata da \param{name}. 
-  
-  \bodydesc{La funzione ritorna \val{NULL} se non trova nulla, o il
-    puntatore alla stringa che corrisponde (di solito nella forma
-    \cmd{NOME=valore}).}
-\end{prototype}
 
-Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI
-C, nell'evoluzione dei sistemi Unix ne sono state proposte altre, da
-utilizzare per impostare e per cancellare le variabili di ambiente. Uno schema
-delle funzioni previste nei vari standard e disponibili in Linux è riportato
-in tab.~\ref{tab:proc_env_func}.
+\begin{funcproto}{ 
+\fhead{stdlib.h}
+\fdecl{char *getenv(const char *name)}
+\fdesc{Cerca una variabile di ambiente del processo.} 
+}
+{La funzione ritorna il puntatore alla stringa contenente il valore della
+  variabile di ambiente in caso di successo e \val{NULL} in caso di errore.} 
+\end{funcproto}
+
+La funzione effettua una ricerca nell'ambiente del processo cercando una
+variabile il cui nome corrisponda a quanto indicato con
+l'argomento \param{name}, ed in caso di successo ritorna il puntatore alla
+stringa che ne contiene il valore, nella forma ``\texttt{NOME=valore}''.
 
 \begin{table}[htb]
   \centering
@@ -1986,68 +2060,55 @@ in tab.~\ref{tab:proc_env_func}.
   \label{tab:proc_env_func}
 \end{table}
 
-In Linux\footnote{in realtà nelle libc4 e libc5 sono definite solo le prime
-  quattro, \func{clearenv} è stata introdotta con le \acr{glibc} 2.0.} sono
-definite tutte le funzioni elencate in tab.~\ref{tab:proc_env_func}. La prima,
-\func{getenv}, l'abbiamo appena esaminata; delle restanti le prime due,
-\funcd{putenv} e \funcd{setenv}, servono per assegnare nuove variabili di
-ambiente, i loro prototipi sono i seguenti:
-\begin{functions}
-  \headdecl{stdlib.h} 
-  
-  \funcdecl{int setenv(const char *name, const char *value, int overwrite)}
-  Imposta la variabile di ambiente \param{name} al valore \param{value}.
-  
-  \funcdecl{int putenv(char *string)} Aggiunge la stringa \param{string}
-  all'ambiente.
-  
-  \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e $-1$ per un
-    errore, che è sempre \errval{ENOMEM}.}
-\end{functions}
-
-La terza funzione della lista, \funcd{unsetenv}, serve a cancellare una
-variabile dall'ambiente, il suo prototipo è:
-\begin{functions}
-  \headdecl{stdlib.h}
-  
-  \funcdecl{void unsetenv(const char *name)} Rimuove la variabile di ambiente
-  \param{name}.
-\end{functions}
-
-\noindent la funzione elimina ogni occorrenza della variabile specificata; se la
-variabile non esiste non succede nulla. Non è prevista (dato che la funzione è
-\ctyp{void}) nessuna segnalazione di errore.
+Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI
+C, nell'evoluzione dei sistemi Unix ne sono state proposte altre, da
+utilizzare per impostare, modificare e per cancellare le variabili di
+ambiente. Uno schema delle funzioni previste nei vari standard e disponibili
+in Linux è riportato in tab.~\ref{tab:proc_env_func}. Tutte le funzioni sono
+state comunque inserite nello standard POSIX.1-2001, ad eccetto di
+\func{clearenv} che è stata rigettata.
+
+In Linux sono definite tutte le funzioni elencate in
+tab.~\ref{tab:proc_env_func},\footnote{in realtà nelle libc4 e libc5 sono
+  definite solo le prime quattro, \func{clearenv} è stata introdotta con la
+  \acr{glibc} 2.0.} anche se parte delle funzionalità sono ridondanti. La
+prima funzione di manipolazione che prenderemo in considerazione è
+\funcd{putenv}, che consente di aggiungere, modificare e cancellare una
+variabile di ambiente; il suo prototipo è:
 
-Per modificare o aggiungere una variabile di ambiente si possono usare sia
-\func{setenv} che \func{putenv}. La prima permette di specificare
-separatamente nome e valore della variabile di ambiente, inoltre il valore di
-\param{overwrite} specifica il comportamento della funzione nel caso la
-variabile esista già, sovrascrivendola se diverso da zero, lasciandola
-immutata se uguale a zero.
+\begin{funcproto}{ 
+\fdecl{int putenv(char *string)}
+\fdesc{Inserisce, modifica o rimuove una variabile d'ambiente.} 
+}
+{La funzione ritorna 0 in caso di successo e $-1$ in caso di errore, che può
+  essere solo \errval{ENOMEM}.}
+\end{funcproto}
 
-La seconda funzione prende come argomento una stringa analoga a quella
-restituita da \func{getenv}, e sempre nella forma \code{NOME=valore}. Se la
-variabile specificata non esiste la stringa sarà aggiunta all'ambiente, se
-invece esiste il suo valore sarà impostato a quello specificato da
-\param{string}. 
+La funzione prende come argomento una stringa analoga a quella restituita da
+\func{getenv} e sempre nella forma ``\texttt{NOME=valore}''. Se la variabile
+specificata (nel caso \texttt{NOME}) non esiste la stringa sarà aggiunta
+all'ambiente, se invece esiste il suo valore sarà impostato a quello
+specificato dal contenuto di \param{string} (nel caso \texttt{valore}).  Se
+invece si passa come argomento solo il nome di una variabile di ambiente
+(cioè \param{string} è nella forma ``\texttt{NAME}'' e non contiene il
+carattere ``\texttt{=}'') allora questa, se presente nell'ambiente, verrà
+cancellata.
 
 Si tenga presente che, seguendo lo standard SUSv2, le \acr{glibc} successive
-alla versione 2.1.2 aggiungono \param{string} alla lista delle variabili di
-ambiente;\footnote{il comportamento è lo stesso delle vecchie \acr{libc4} e
-  \acr{libc5}; nelle \acr{glibc}, dalla versione 2.0 alla 2.1.1, veniva invece
-  fatta una copia, seguendo il comportamento di BSD4.4; dato che questo può
-  dar luogo a perdite di memoria e non rispetta lo standard. Il comportamento
-  è stato modificato a partire dalle 2.1.2, eliminando anche, sempre in
-  conformità a SUSv2, l'attributo \direct{const} dal prototipo.} pertanto ogni
-cambiamento alla stringa in questione si riflette automaticamente
-sull'ambiente, e quindi si deve evitare di passare a questa funzione una
-variabile automatica (per evitare i problemi esposti in
-sez.~\ref{sec:proc_auto_var}). Si tenga infine presente che se si passa a
-\func{putenv} solo il nome di una variabile (cioè \param{string} è nella forma
-\texttt{NAME} e non contiene un carattere \texttt{'='}) allora questa viene
-cancellata dall'ambiente.
-
-Infine quando chiamata a \func{putenv} comporta la necessità di creare una
+alla versione 2.1.2 aggiungono direttamente \param{string} nella lista delle
+variabili di ambiente illustrata in fig.~\ref{fig:proc_envirno_list}
+sostituendo il relativo puntatore;\footnote{il comportamento è lo stesso delle
+  vecchie \acr{libc4} e \acr{libc5}; nella \acr{glibc}, dalla versione 2.0
+  alla 2.1.1, veniva invece fatta una copia, seguendo il comportamento di
+  BSD4.4; dato che questo può dar luogo a perdite di memoria e non rispetta lo
+  standard il comportamento è stato modificato a partire dalle 2.1.2,
+  eliminando anche, sempre in conformità a SUSv2, l'attributo \direct{const}
+  dal prototipo.}  pertanto ogni cambiamento alla stringa in questione si
+riflette automaticamente sull'ambiente, e quindi si deve evitare di passare a
+questa funzione una \index{variabili!automatiche} variabile automatica (per
+evitare i problemi esposti in sez.~\ref{sec:proc_var_passing}).
+
+Infine quando una chiamata a \func{putenv} comporta la necessità di creare una
 nuova versione del vettore \var{environ} questo sarà allocato automaticamente,
 ma la versione corrente sarà deallocata solo se anch'essa è risultante da
 un'allocazione fatta in precedenza da un'altra \func{putenv}. Questo avviene
@@ -2058,17 +2119,59 @@ nello \itindex{heap} \textit{heap} e quindi non può essere deallocato.
 Inoltre la memoria associata alle variabili di ambiente eliminate non viene
 liberata.
 
+Come alternativa a \func{putenv} si può usare la funzione \funcd{setenv} che
+però consente solo di aggiungere o modificare una variabile di ambiente; il
+suo prototipo è:
+
+\begin{funcproto}{ 
+\fhead{stdlib.h}
+\fdecl{int setenv(const char *name, const char *value, int overwrite)}
+\fdesc{Inserisce o modifica una variabile di ambiente.} 
+}
+{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{ENOMEM}] non c'è memoria sufficiente per aggiungere una nuova
+    variabile all'ambiente.
+  \item[\errcode{EINVAL}] \param{name} è \val{NULL} o una stringa di lunghezza
+  nulla o che contiene il carattere ``\texttt{=}''.
+\end{errlist}}
+\end{funcproto}
+
+La funzione consente di specificare separatamente nome e valore della
+variabile di ambiente da aggiungere negli argomenti \param{name}
+e \param{value}. Se la variabile è già presente nell'ambiente
+l'argomento \param{overwrite} specifica il comportamento della funzione, se
+diverso da zero sarà sovrascritta, se uguale a zero sarà lasciata immutata.  A
+differenza di \func{putenv} la funzione esegue delle copie del contenuto degli
+argomenti \param{name} e \param{value} e non è necessario preoccuparsi di
+allocarli in maniera permanente.
+
+La cancellazione di una variabile di ambiente viene invece gestita
+esplicitamente con \funcd{unsetenv}, il cui prototipo è:
+
+\begin{funcproto}{ 
+\fhead{stdlib.h}
+\fdecl{int unsetenv(const char *name)}
+\fdesc{Rimuove una variabile di ambiente.} 
+}
+{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{name} è \val{NULL} o una stringa di lunghezza
+  nulla o che contiene il carattere ``\texttt{=}''.
+  \end{errlist}}  
+\end{funcproto}
+
+La funzione richiede soltanto il nome della variabile di ambiente
+nell'argomento \param{name}, se la variabile non esiste la funzione ritorna
+comunque con un valore di successo.\footnote{questo con le versioni della
+  \acr{glibc} successive la 2.2.2, per le precedenti \func{unsetenv} era
+  definita come \texttt{void} e non restituiva nessuna informazione.}
+
 L'ultima funzione per la gestione dell'ambiente è \funcd{clearenv}, che viene
 usata per cancellare completamente tutto l'ambiente; il suo prototipo è:
-\begin{functions}
-  \headdecl{stdlib.h}
-  
-  \funcdecl{int clearenv(void)} 
-  Cancella tutto l'ambiente.
-  
-  \bodydesc{la funzione restituisce 0 in caso di successo e un valore diverso
-    da zero per un errore.}
-\end{functions}
+
 
 In genere si usa questa funzione in maniera precauzionale per evitare i
 problemi di sicurezza connessi nel trasmettere ai programmi che si invocano un
@@ -2076,23 +2179,25 @@ ambiente che può contenere dei dati non controllati. In tal caso si provvede
 alla cancellazione di tutto l'ambiente per costruirne una versione
 ``\textsl{sicura}'' da zero.
 
+
 \subsection{La localizzazione}
 \label{sec:proc_localization}
 
 Abbiamo accennato in sez.~\ref{sec:proc_environ} come la variabile di ambiente
 \texttt{LANG} sia usata per indicare ai processi il valore della cosiddetta
 \textsl{localizzazione}. Si tratta di una funzionalità fornita dalle librerie
-di sistema\footnote{prenderemo in esame soltanto il caso delle \acr{glibc}.}
+di sistema\footnote{prenderemo in esame soltanto il caso della \acr{glibc}.}
 che consente di gestire in maniera automatica sia la lingua in cui vengono
 stampati i vari messaggi (come i messaggi associati agli errori che vedremo in
 sez.~\ref{sec:sys_strerror}) che le convenzioni usate nei vari paesi per una
 serie di aspetti come il formato dell'ora, quello delle date, gli ordinamenti
 alfabetici, le espressioni della valute, ecc.
 
-La localizzazione di un programma si può selezionare con la 
+Da finire.
 
+% La localizzazione di un programma si può selezionare con la 
 
-In realtà perché un programma sia effettivamente localizzato non è sufficiente 
+In realtà perché un programma sia effettivamente localizzato non è sufficiente 
 
 % TODO trattare, quando ci sarà tempo, setlocale ed il resto
 
@@ -2113,53 +2218,85 @@ In realtà perché un programma sia effettivamente localizzato non è sufficient
 \section{Problematiche di programmazione generica}
 \label{sec:proc_gen_prog}
 
-Benché questo non sia un libro di C, è opportuno affrontare alcune delle
-problematiche generali che possono emergere nella programmazione e di quali
-precauzioni o accorgimenti occorre prendere per risolverle. Queste
-problematiche non sono specifiche di sistemi unix-like o multitasking, ma
-avendo trattato in questo capitolo il comportamento dei processi visti come
-entità a sé stanti, le riportiamo qui.
+Benché questo non sia un libro sul linguaggio C, è opportuno affrontare alcune
+delle problematiche generali che possono emergere nella programmazione con
+questo linguaggio e di quali precauzioni o accorgimenti occorre prendere per
+risolverle. Queste problematiche non sono specifiche di sistemi unix-like o
+multitasking, ma avendo trattato in questo capitolo il comportamento dei
+processi visti come entità a sé stanti, le riportiamo qui.
 
 
-\subsection{Il passaggio delle variabili e dei valori di ritorno}
+\subsection{Il passaggio di variabili e valori di ritorno nelle funzioni}
 \label{sec:proc_var_passing}
 
 Una delle caratteristiche standard del C è che le variabili vengono passate
-alle subroutine attraverso un meccanismo che viene chiamato \textit{by value}
-(diverso ad esempio da quanto avviene con il Fortran, dove le variabili sono
-passate, come suol dirsi, \textit{by reference}, o dal C++ dove la modalità
-del passaggio può essere controllata con l'operatore \cmd{\&}).
+alle funzioni che si invocano in un programma attraverso un meccanismo che
+viene chiamato \textit{by value}, diverso ad esempio da quanto avviene con il
+Fortran, dove le variabili sono passate, come suol dirsi, \textit{by
+  reference}, o dal C++ dove la modalità del passaggio può essere controllata
+con l'operatore \cmd{\&}.
 
 Il passaggio di una variabile \textit{by value} significa che in realtà quello
-che viene passato alla subroutine è una copia del valore attuale di quella
-variabile, copia che la subroutine potrà modificare a piacere, senza che il
+che viene passato alla funzione è una copia del valore attuale di quella
+variabile, copia che la funzione potrà modificare a piacere, senza che il
 valore originale nella funzione chiamante venga toccato. In questo modo non
-occorre preoccuparsi di eventuali effetti delle operazioni della subroutine
-sulla variabile passata come argomento.
+occorre preoccuparsi di eventuali effetti delle operazioni svolte nella
+funzione stessa sulla variabile passata come argomento.
 
 Questo però va inteso nella maniera corretta. Il passaggio \textit{by value}
-vale per qualunque variabile, puntatori compresi; quando però in una
-subroutine si usano dei puntatori (ad esempio per scrivere in un buffer) in
-realtà si va a modificare la zona di memoria a cui essi puntano, per cui anche
-se i puntatori sono copie, i dati a cui essi puntano sono sempre gli stessi, e
+vale per qualunque variabile, puntatori compresi; quando però in una funzione
+si usano dei puntatori (ad esempio per scrivere in un buffer) in realtà si va
+a modificare la zona di memoria a cui essi puntano, per cui anche se i
+puntatori sono copie, i dati a cui essi puntano saranno sempre gli stessi, e
 le eventuali modifiche avranno effetto e saranno visibili anche nella funzione
 chiamante.
 
-Nella maggior parte delle funzioni di libreria e delle system call i puntatori
-vengono usati per scambiare dati (attraverso buffer o strutture) e le
-variabili semplici vengono usate per specificare argomenti; in genere le
-informazioni a riguardo dei risultati vengono passate alla funzione chiamante
-attraverso il valore di ritorno.  È buona norma seguire questa pratica anche
-nella programmazione normale.
+Nella maggior parte delle funzioni di libreria e delle \textit{system call} i
+puntatori vengono usati per scambiare dati (attraverso i buffer o le strutture
+a cui fanno riferimento) e le variabili normali vengono usate per specificare
+argomenti; in genere le informazioni a riguardo dei risultati vengono passate
+alla funzione chiamante attraverso il valore di ritorno.  È buona norma
+seguire questa pratica anche nella programmazione normale.
 
 Talvolta però è necessario che la funzione possa restituire indietro alla
-funzione chiamante un valore relativo ad uno dei suoi argomenti.  Per far
-questo si usa il cosiddetto \itindex{value~result~argument} \textit{value
-  result argument}, si passa cioè, invece di una normale variabile, un
-puntatore alla stessa; vedremo alcuni esempi di questa modalità nelle funzioni
-che gestiscono i socket (in sez.~\ref{sec:TCP_functions}), in cui, per
-permettere al kernel di restituire informazioni sulle dimensioni delle
-strutture degli indirizzi utilizzate, viene usato questo meccanismo.
+funzione chiamante un valore relativo ad uno dei suoi argomenti usato anche in
+ingresso.  Per far questo si usa il cosiddetto \itindex{value~result~argument}
+\textit{value result argument}, si passa cioè, invece di una normale
+variabile, un puntatore alla stessa. Gli esempi di questa modalità di
+passaggio sono moltissimi, ad esempio essa viene usata nelle funzioni che
+gestiscono i socket (in sez.~\ref{sec:TCP_functions}), in cui, per permettere
+al kernel di restituire informazioni sulle dimensioni delle strutture degli
+indirizzi utilizzate, viene usato proprio questo meccanismo.
+
+Occorre tenere ben presente questa differenza, perché le variabili passate in
+maniera ordinaria, che vengono inserite nello \textit{stack}, cessano di
+esistere al ritorno di una funzione, ed ogni loro eventuale modifica
+all'interno della stessa sparisce con la conclusione della stessa, per poter
+passare delle informazioni occorre quindi usare un puntatore che faccia
+riferimento ad un indirizzo accessibile alla funzione chiamante.
+
+Questo requisito di accessibilità è fondamentale, infatti dei possibili
+problemi che si possono avere con il passaggio dei dati è quello di restituire
+alla funzione chiamante dei dati che sono contenuti in una
+\index{variabili!automatiche} variabile automatica.  Ovviamente quando la
+funzione ritorna la sezione dello \itindex{stack} \textit{stack} che conteneva
+la \index{variabili!automatiche} variabile automatica (si ricordi quanto detto
+in sez.~\ref{sec:proc_mem_alloc}) verrà liberata automaticamente e potrà
+essere riutilizzata all'invocazione di un'altra funzione, con le immaginabili
+conseguenze, quasi invariabilmente catastrofiche, di sovrapposizione e
+sovrascrittura dei dati.
+
+Per questo una delle regole fondamentali della programmazione in C è che
+all'uscita di una funzione non deve restare nessun riferimento alle sue
+\index{variabili!automatiche} variabili locali. Qualora sia necessario
+utilizzare delle variabili che devono essere viste anche dalla funzione
+chiamante queste devono essere allocate esplicitamente, o in maniera statica
+usando variabili globali o dichiarate come \direct{extern},\footnote{la
+  direttiva \direct{extern} informa il compilatore che la variabile che si è
+  dichiarata in una funzione non è da considerarsi locale, ma globale, e per
+  questo allocata staticamente e visibile da tutte le funzioni dello stesso
+  programma.} o dinamicamente con una delle funzioni della famiglia
+\func{malloc}, passando opportunamente il relativo puntatore fra le funzioni.
 
 
 \subsection{Il passaggio di un numero variabile di argomenti}
@@ -2170,33 +2307,32 @@ numero fisso di argomenti per una funzione.  Lo standard ISO C prevede nella
 sua sintassi la possibilità di definire delle \index{variadic}
 \textit{variadic function} che abbiano un numero variabile di argomenti,
 attraverso l'uso nella dichiarazione della funzione dello speciale costrutto
-``\texttt{\textellipsis}'', che viene chiamato \textit{ellipsis}.
+``\texttt{...}'', che viene chiamato \textit{ellipsis}.
 
 Lo standard però non provvede a livello di linguaggio alcun meccanismo con cui
 dette funzioni possono accedere ai loro argomenti.  L'accesso viene pertanto
-realizzato a livello delle librerie standard del C che provvedono gli
-strumenti adeguati.  L'uso di una \textit{variadic function} prevede quindi
-tre punti:
+realizzato a livello della libreria standard del C che fornisce gli strumenti
+adeguati.  L'uso di una \textit{variadic function} prevede quindi tre punti:
 \begin{itemize*}
-\item \textsl{Dichiarare} la funzione come \textit{variadic} usando un
-  prototipo che contenga una \textit{ellipsis}.
-\item \textsl{Definire} la funzione come \textit{variadic} usando la stessa
+\item \textsl{dichiarare} la funzione come \textit{variadic} usando un
+  prototipo che contenga una \textit{ellipsis};
+\item \textsl{definire} la funzione come \textit{variadic} usando la stessa
   \textit{ellipsis}, ed utilizzare le apposite macro che consentono la
-  gestione di un numero variabile di argomenti.
-\item \textsl{Invocare} la funzione specificando prima gli argomenti fissi, ed
+  gestione di un numero variabile di argomenti;
+\item \textsl{invocare} la funzione specificando prima gli argomenti fissi, ed
   a seguire quelli addizionali.
 \end{itemize*}
 
 Lo standard ISO C prevede che una \index{variadic} \textit{variadic function}
-abbia sempre almeno un argomento fisso; prima di effettuare la dichiarazione
-deve essere incluso l'apposito header file \file{stdarg.h}; un esempio di
-dichiarazione è il prototipo della funzione \func{execl} che vedremo in
-sez.~\ref{sec:proc_exec}:
+abbia sempre almeno un argomento fisso. Prima di effettuare la dichiarazione
+deve essere incluso l'apposito \textit{header file} \file{stdarg.h}; un
+esempio di dichiarazione è il prototipo della funzione \func{execl} che
+vedremo in sez.~\ref{sec:proc_exec}:
 \includecodesnip{listati/exec_sample.c}
 in questo caso la funzione prende due argomenti fissi ed un numero variabile
-di altri argomenti (che verranno a costituire gli elementi successivi al primo
-del vettore \param{argv} passato al nuovo processo). Lo standard ISO C
-richiede inoltre che l'ultimo degli argomenti fissi sia di tipo
+di altri argomenti, che andranno a costituire gli elementi successivi al primo
+del vettore \param{argv} passato al nuovo processo. Lo standard ISO C richiede
+inoltre che l'ultimo degli argomenti fissi sia di tipo
 \textit{self-promoting}\footnote{il linguaggio C prevede che quando si
   mescolano vari tipi di dati, alcuni di essi possano essere \textsl{promossi}
   per compatibilità; ad esempio i tipi \ctyp{float} vengono convertiti
@@ -2205,87 +2341,148 @@ richiede inoltre che l'ultimo degli argomenti fissi sia di tipo
   a sé stesso.} il che esclude vettori, puntatori a funzioni e interi di tipo
 \ctyp{char} o \ctyp{short} (con segno o meno). Una restrizione ulteriore di
 alcuni compilatori è di non dichiarare l'ultimo argomento fisso come
-\direct{register}.
+\direct{register}.\footnote{la direttiva \direct{register} del compilatore
+  chiede che la variabile dichiarata tale sia mantenuta, nei limiti del
+  possibile, all'interno di un registro del processore; questa direttiva è
+  originaria dell'epoca dai primi compilatori, quando stava al programmatore
+  scrivere codice ottimizzato, riservando esplicitamente alle variabili più
+  usate l'uso dei registri del processore, oggi questa direttiva è in disuso
+  dato che tutti i compilatori sono normalmente in grado di valutare con
+  maggior efficacia degli stessi programmatori quando sia il caso di eseguire
+  questa ottimizzazione.}
 
 Una volta dichiarata la funzione il secondo passo è accedere ai vari argomenti
 quando la si va a definire. Gli argomenti fissi infatti hanno un loro nome, ma
-quelli variabili vengono indicati in maniera generica dalla \textit{ellipsis}.
-
-L'unica modalità in cui essi possono essere recuperati è pertanto quella
-sequenziale; essi verranno estratti dallo \itindex{stack} \textit{stack}
-secondo l'ordine in cui sono stati scritti. Per fare questo in \file{stdarg.h}
-sono definite delle apposite macro; la procedura da seguire è la seguente:
-\begin{enumerate*}
-\item Inizializzare un puntatore alla lista degli argomenti di tipo
-  \macro{va\_list} attraverso la macro \macro{va\_start}.
-\item Accedere ai vari argomenti opzionali con chiamate successive alla macro
-  \macro{va\_arg}, la prima chiamata restituirà il primo argomento, la seconda
-  il secondo e così via.
-\item Dichiarare la conclusione dell'estrazione degli argomenti invocando la
-  macro \macro{va\_end}.
-\end{enumerate*}
+quelli variabili vengono indicati in maniera generica dalla
+\textit{ellipsis}. L'unica modalità in cui essi possono essere recuperati è
+pertanto quella sequenziale, in cui vengono estratti dallo \itindex{stack}
+\textit{stack} secondo l'ordine in cui sono stati scritti nel prototipo della
+funzione. 
+
+Per fare questo in \file{stdarg.h} sono definite delle macro specifiche,
+previste dallo standard ISO C89, che consentono di eseguire questa operazione.
+La prima di queste macro è \macro{va\_start}, che inizializza opportunamente
+una lista degli argomenti, la sua definizione è:
+
+{\centering
+\begin{funcbox}{ 
+\fhead{stdarg.h}
+\fdecl{void va\_start(va\_list ap, last)}
+\fdesc{Inizializza una lista degli argomenti di una funzione
+  \textit{variadic}.} 
+}
+\end{funcbox}}
+
+La macro inizializza il puntatore alla lista di argomenti \param{ap} che
+deve essere una apposita variabile di tipo \type{va\_list}; il
+parametro \param{last} deve indicare il nome dell'ultimo degli argomenti fissi
+dichiarati nel prototipo della funzione \textit{variadic}. 
+
+La seconda macro di gestione delle liste di argomenti di una funzione
+\textit{variadic} è \macro{va\_arg}, che restituisce in successione un
+argomento della lista; la sua definizione è:
+
+{\centering
+\begin{funcbox}{ 
+\fhead{stdarg.h}
+\fdecl{type va\_arg(va\_list ap, type)}
+\fdesc{Restituisce il valore del successivo argomento opzionale.} 
+}
+\end{funcbox}}
+La macro restituisce il valore di un argomento, modificando opportunamente la
+lista \param{ap} perché una chiamata successiva restituisca l'argomento
+seguente. La macro richiede che si specifichi il tipo dell'argomento che si
+andrà ad estrarre attraverso il parametro \param{type} che sarà anche il tipo
+del valore da essa restituito. Si ricordi che il tipo deve essere
+\textit{self-promoting}.
 
 In generale è perfettamente legittimo richiedere meno argomenti di quelli che
 potrebbero essere stati effettivamente forniti, e nella esecuzione delle
 \macro{va\_arg} ci si può fermare in qualunque momento ed i restanti argomenti
-saranno ignorati; se invece si richiedono più argomenti di quelli forniti si
-otterranno dei valori indefiniti. Nel caso del \cmd{gcc} l'uso di
-\macro{va\_end} è inutile, ma si consiglia di usarla ugualmente per
-compatibilità. Le definizioni delle macro citate sono le seguenti:
-\begin{functions}
-  \headdecl{stdarg.h}
-  
-  \funcdecl{void va\_start(va\_list ap, last)} Inizializza il puntatore alla
-  lista di argomenti \param{ap}; il parametro \param{last} \emph{deve} essere
-  l'ultimo degli argomenti fissi.
-  
-  \funcdecl{type va\_arg(va\_list ap, type)} Restituisce il valore del
-  successivo argomento opzionale, modificando opportunamente \param{ap}; la
-  macro richiede che si specifichi il tipo dell'argomento attraverso il
-  parametro \param{type} che deve essere il nome del tipo dell'argomento in
-  questione. Il tipo deve essere \textit{self-promoting}.
-
-  \funcdecl{void va\_end(va\_list ap)} Conclude l'uso di \param{ap}.
-\end{functions}
+saranno ignorati. Se invece si richiedono più argomenti di quelli forniti si
+otterranno dei valori indefiniti, si avranno risultati indefiniti anche quando
+si chiama \macro{va\_arg} specificando un tipo che non corrisponde a quello
+usato per il corrispondente argomento.
+
+Infine una volta completata l'estrazione occorre indicare che si sono concluse
+le operazioni con la macro \macro{va\_end}, la cui definizione è:
+
+{\centering
+\begin{funcbox}{ 
+\fhead{stdarg.h}
+\fdecl{void va\_end(va\_list ap)}
+\fdesc{Conclude l'estrazione degli argomenti di una funzione
+  \textit{variadic}.} 
+}
+\end{funcbox}}
+Dopo l'uso di \macro{va\_end} la variabile \param{ap} diventa indefinita e
+successive chiamate a \macro{va\_arg} non funzioneranno.  Nel caso del
+\cmd{gcc} l'uso di \macro{va\_end} può risultare inutile, ma è comunque
+necessario usarla per chiarezza del codice, per compatibilità con diverse
+implementazioni e per eventuali eventuali modifiche future a questo
+comportamento.
+
+Riassumendo la procedura da seguire per effettuare l'estrazione degli
+argomenti di una funzione \textit{variadic} è la seguente:
+\begin{enumerate*}
+\item inizializzare una lista degli argomenti attraverso la macro
+  \macro{va\_start};
+\item accedere agli argomenti con chiamate successive alla macro
+  \macro{va\_arg}: la prima chiamata restituirà il primo argomento, la seconda
+  il secondo e così via;
+\item dichiarare la conclusione dell'estrazione degli argomenti invocando la
+  macro \macro{va\_end}.
+\end{enumerate*}
 
-In generale si possono avere più puntatori alla lista degli argomenti,
-ciascuno andrà inizializzato con \macro{va\_start} e letto con \macro{va\_arg}
-e ciascuno potrà scandire la lista degli argomenti per conto suo. Dopo l'uso
-di \macro{va\_end} la variabile \param{ap} diventa indefinita e successive
-chiamate a \macro{va\_arg} non funzioneranno. Si avranno risultati indefiniti
-anche chiamando \macro{va\_arg} specificando un tipo che non corrisponde a
-quello dell'argomento.
+Si tenga presente che si possono usare anche più liste degli argomenti,
+ciascuna di esse andrà inizializzata con \macro{va\_start} e letta con
+\macro{va\_arg}, e ciascuna potrà essere usata per scandire la lista degli
+argomenti in modo indipendente. Infine ciascuna scansione dovrà essere
+terminata con \macro{va\_end}.
 
-Un altro limite delle macro è che i passi 1) e 3) devono essere eseguiti nel
+Un limite di queste macro è che i passi 1) e 3) devono essere eseguiti nel
 corpo principale della funzione, il passo 2) invece può essere eseguito anche
-in una subroutine passandole il puntatore alla lista di argomenti; in questo
-caso però si richiede che al ritorno della funzione il puntatore non venga più
-usato (lo standard richiederebbe la chiamata esplicita di \macro{va\_end}),
-dato che il valore di \param{ap} risulterebbe indefinito.
+in un'altra funzione, passandole lista degli argomenti \param{ap}. In questo
+caso però al ritorno della funzione \macro{va\_arg} non può più essere usata
+(anche se non si era completata l'estrazione) dato che il valore di \param{ap}
+risulterebbe indefinito.
 
 Esistono dei casi in cui è necessario eseguire più volte la scansione degli
 argomenti e poter memorizzare una posizione durante la stessa. In questo caso
-sembrerebbe naturale copiarsi il puntatore alla lista degli argomenti con una
-semplice assegnazione. Dato che una delle realizzazioni più comuni di
-\macro{va\_list} è quella di un puntatore nello \itindex{stack} \textit{stack}
-all'indirizzo dove sono stati salvati gli argomenti, è assolutamente normale
-pensare di poter effettuare questa operazione.
-
-In generale però possono esistere anche realizzazioni diverse, per questo
-motivo \macro{va\_list} è definito come \index{tipo!opaco} \textsl{tipo opaco}
-e non può essere assegnato direttamente ad un'altra variabile dello stesso
-tipo. Per risolvere questo problema lo standard ISO C99\footnote{alcuni
-  sistemi che non hanno questa macro provvedono al suo posto
+sembrerebbe naturale copiarsi la lista degli argomenti \param{ap} con una
+semplice assegnazione ad un'altra variabile dello stesso tipo. Dato che una
+delle realizzazioni più comuni di \type{va\_list} è quella di un puntatore
+nello \itindex{stack} \textit{stack} all'indirizzo dove sono stati salvati gli
+argomenti, è assolutamente normale pensare di poter effettuare questa
+operazione.
+
+In generale però possono esistere anche realizzazioni diverse, ed è per questo
+motivo che invece che di un semplice puntatore viene \type{va\_list} è quello
+che viene chiamato un \index{tipo!opaco} \textsl{tipo opaco}. Si chiamano così
+quei tipi di dati, in genere usati da una libreria, la cui struttura interna
+non deve essere vista dal programma chiamante (da cui deriva il nome opaco)
+che li devono utilizzare solo attraverso dalle opportune funzioni di
+gestione. Per questo motivo non può essere assegnata direttamente ad un'altra
+variabile dello stesso tipo. Per risolvere questo problema lo standard ISO
+C99\footnote{alcuni sistemi che non hanno questa macro provvedono al suo posto
   \macro{\_\_va\_copy} che era il nome proposto in una bozza dello standard.}
-ha previsto una macro ulteriore che permette di eseguire la copia di un
-puntatore alla lista degli argomenti:
-\begin{prototype}{stdarg.h}{void va\_copy(va\_list dest, va\_list src)}
-  Copia l'attuale valore \param{src} del puntatore alla lista degli argomenti
-  su \param{dest}.
-\end{prototype}
-\noindent anche in questo caso è buona norma chiudere ogni esecuzione di una
-\macro{va\_copy} con una corrispondente \macro{va\_end} sul nuovo puntatore
-alla lista degli argomenti.
+ha previsto una macro ulteriore che permette di eseguire la copia di una lista
+degli argomenti:
+
+{\centering
+\begin{funcbox}{ 
+\fhead{stdarg.h}
+\fdecl{void va\_copy(va\_list dest, va\_list src)}
+\fdesc{Copia la lista degli argomenti di una funzione \textit{variadic}.} 
+}
+\end{funcbox}}
+
+La macro copia l'attuale della lista degli argomenti \param{src} su una nuova
+lista \param{dest}. Anche in questo caso è buona norma chiudere ogni
+esecuzione di una \macro{va\_copy} con una corrispondente \macro{va\_end} sul
+nuovo puntatore alla lista degli argomenti.
 
 La chiamata di una funzione con un numero variabile di argomenti, posto che la
 si sia dichiarata e definita come tale, non prevede nulla di particolare;
@@ -2316,24 +2513,6 @@ come ultimo argomento (come fa ad esempio \func{execl} che usa un puntatore
 \val{NULL} per indicare la fine della lista degli argomenti).
 
 
-\subsection{Potenziali problemi con le variabili automatiche}
-\label{sec:proc_auto_var}
-
-Uno dei possibili problemi che si possono avere con le subroutine è quello di
-restituire alla funzione chiamante dei dati che sono contenuti in una
-variabile automatica.  Ovviamente quando la subroutine ritorna la sezione
-dello \itindex{stack} \textit{stack} che conteneva la variabile automatica
-potrà essere riutilizzata da una nuova funzione, con le immaginabili
-conseguenze di sovrapposizione e sovrascrittura dei dati.
-
-Per questo una delle regole fondamentali della programmazione in C è che
-all'uscita di una funzione non deve restare nessun riferimento alle variabili
-locali; qualora sia necessario utilizzare variabili che possano essere viste
-anche dalla funzione chiamante queste devono essere allocate esplicitamente, o
-in maniera statica (usando variabili di tipo \ctyp{static} o \ctyp{extern}), o
-dinamicamente con una delle funzioni della famiglia \func{malloc}.
-
-
 \subsection{Il controllo di flusso non locale}
 \label{sec:proc_longjmp}
 
@@ -2388,14 +2567,11 @@ quando serve.  La funzione che permette di salvare il contesto dello
   
 Quando si esegue la funzione il contesto corrente dello \itindex{stack}
 \textit{stack} viene salvato nell'argomento \param{env}, una variabile di tipo
-\type{jmp\_buf}\footnote{questo è un classico esempio di variabile di
-  \index{tipo!opaco} \textsl{tipo opaco}. Si definiscono così strutture ed
-  altri oggetti usati da una libreria, la cui struttura interna non deve
-  essere vista dal programma chiamante (da cui il nome) che li devono
-  utilizzare solo attraverso dalle opportune funzioni di gestione.}  che deve
-essere stata definita in precedenza. In genere le variabili di tipo
-\type{jmp\_buf} vengono definite come variabili globali in modo da poter
-essere viste in tutte le funzioni del programma.
+\type{jmp\_buf}\footnote{anche questo è un classico esempio di variabile di
+  \index{tipo!opaco} \textsl{tipo opaco}.}  che deve essere stata definita in
+precedenza. In genere le variabili di tipo \type{jmp\_buf} vengono definite
+come \index{variabili!globali} variabili globali in modo da poter essere viste
+in tutte le funzioni del programma.
 
 Quando viene eseguita direttamente la funzione ritorna sempre zero, un valore
 diverso da zero viene restituito solo quando il ritorno è dovuto ad una
@@ -2456,19 +2632,13 @@ di \func{setjmp}, quest'ultima usualmente viene chiamata all'interno di un
 comando \code{if}.
 
 Uno dei punti critici dei salti non-locali è quello del valore delle
-variabili, ed in particolare quello delle variabili automatiche della funzione
-a cui si ritorna. In generale le variabili globali e statiche mantengono i
-valori che avevano al momento della chiamata di \func{longjmp}, ma quelli
-delle variabili automatiche (o di quelle dichiarate
-\direct{register}\footnote{la direttiva \direct{register} del compilatore
-  chiede che la variabile dichiarata tale sia mantenuta, nei limiti del
-  possibile, all'interno di un registro del processore. Questa direttiva è
-  originaria dell'epoca dai primi compilatori, quando stava al programmatore
-  scrivere codice ottimizzato, riservando esplicitamente alle variabili più
-  usate l'uso dei registri del processore. Oggi questa direttiva è in disuso
-  dato che tutti i compilatori sono normalmente in grado di valutare con
-  maggior efficacia degli stessi programmatori quando sia il caso di eseguire
-  questa ottimizzazione.}) sono in genere indeterminati.
+variabili, ed in particolare quello delle \index{variabili!automatiche}
+variabili automatiche della funzione a cui si ritorna. In generale le
+\index{variabili!globali} variabili globali e \index{variabili!statiche}
+statiche mantengono i valori che avevano al momento della chiamata di
+\func{longjmp}, ma quelli delle \index{variabili!automatiche} variabili
+automatiche (o di quelle dichiarate \direct{register}) sono in genere
+indeterminati.
 
 Quello che succede infatti è che i valori delle variabili che sono tenute in
 memoria manterranno il valore avuto al momento della chiamata di
@@ -2628,9 +2798,10 @@ il valore del confronto delle due variabili.
 % LocalWords:  Sun order VME  loader Windows DLL shared objects PRELOAD termios
 % LocalWords:  is to LC SIG str mem wcs assert ctype dirent fcntl signal stdio
 % LocalWords:  times library utmp syscall number Filesystem Hierarchy pathname
+% LocalWords:  context assembler sysconf fork Dinamic huge segmentation program
+% LocalWords:  break  store
 
 %%% Local Variables: 
 %%% mode: latex
 %%% TeX-master: "gapil"
 %%% End: 
-% LocalWords:  context assembler sysconf fork
index 7e882ab..5c526df 100644 (file)
@@ -671,7 +671,7 @@ Le differenze fra padre e figlio dopo la \func{fork} invece sono:\footnote{a
   sez.~\ref{sec:file_memory_map}) che non vengono ereditate dal figlio;
 \item l'impostazione con \func{prctl} (vedi sez.~\ref{sec:process_prctl}) che
   notifica al figlio la terminazione del padre viene cancellata;
-\item il segnale di terminazione del figlio è sempre \const{SIGCHLD} anche
+\item il segnale di terminazione del figlio è sempre \signal{SIGCHLD} anche
   qualora nel padre fosse stato modificato (vedi sez.~\ref{sec:process_clone}). 
 \end{itemize*}
 
@@ -717,7 +717,7 @@ modalità di conclusione anomala; queste sono in sostanza due: il programma può
 chiamare la funzione \func{abort} per invocare una chiusura anomala, o essere
 terminato da un segnale (torneremo sui segnali in cap.~\ref{cha:signals}).  In
 realtà anche la prima modalità si riconduce alla seconda, dato che
-\func{abort} si limita a generare il segnale \const{SIGABRT}.
+\func{abort} si limita a generare il segnale \signal{SIGABRT}.
 
 Qualunque sia la modalità di conclusione di un processo, il kernel esegue
 comunque una serie di operazioni: chiude tutti i file aperti, rilascia la
@@ -728,15 +728,15 @@ eseguite alla chiusura di un processo è il seguente:
 \item viene memorizzato lo stato di terminazione del processo;
 \item ad ogni processo figlio viene assegnato un nuovo padre (in genere
   \cmd{init});
-\item viene inviato il segnale \const{SIGCHLD} al processo padre (vedi
+\item viene inviato il segnale \signal{SIGCHLD} al processo padre (vedi
   sez.~\ref{sec:sig_sigchld});
 \item se il processo è un leader di sessione ed il suo terminale di controllo
-  è quello della sessione viene mandato un segnale di \const{SIGHUP} a tutti i
+  è quello della sessione viene mandato un segnale di \signal{SIGHUP} a tutti i
   processi del gruppo di \textit{foreground} e il terminale di controllo viene
   disconnesso (vedi sez.~\ref{sec:sess_ctrl_term});
 \item se la conclusione di un processo rende orfano un \textit{process
     group} ciascun membro del gruppo viene bloccato, e poi gli vengono
-  inviati in successione i segnali \const{SIGHUP} e \const{SIGCONT}
+  inviati in successione i segnali \signal{SIGHUP} e \signal{SIGCONT}
   (vedi ancora sez.~\ref{sec:sess_ctrl_term}).
 \end{itemize*}
 
@@ -1004,7 +1004,7 @@ sez.~\ref{sec:thread_xxx}).
     \const{\_\_WCLONE}& Attende solo per i figli creati con \func{clone} 
                         (vedi sez.~\ref{sec:process_clone}), vale a dire
                         processi che non emettono nessun segnale 
-                        o emettono un segnale diverso da \const{SIGCHLD} alla
+                        o emettono un segnale diverso da \signal{SIGCHLD} alla
                         terminazione. \\
     \const{\_\_WALL}  & Attende per qualunque processo figlio. \\
     \const{\_\_WNOTHREAD}& Non attende per i figli di altri \textit{thread}
@@ -1038,7 +1038,7 @@ quando un processo figlio entra nello stato \textit{stopped}\footnote{in
   sez.~\ref{sec:process_ptrace}).} (vedi tab.~\ref{tab:proc_proc_states}),
 mentre con \const{WCONTINUED} la funzione ritorna quando un processo in stato
 \textit{stopped} riprende l'esecuzione per la ricezione del segnale
-\const{SIGCONT} (l'uso di questi segnali per il controllo di sessione è
+\signal{SIGCONT} (l'uso di questi segnali per il controllo di sessione è
 dettagliato in sez.~\ref{sec:sess_ctrl_term}).
 
 La terminazione di un processo figlio (così come gli altri eventi osservabili
@@ -1046,7 +1046,7 @@ con \func{waitpid}) è chiaramente un evento asincrono rispetto all'esecuzione
 di un programma e può avvenire in un qualunque momento. Per questo motivo,
 come accennato nella sezione precedente, una delle azioni prese dal kernel
 alla conclusione di un processo è quella di mandare un segnale di
-\const{SIGCHLD} al padre. L'azione predefinita (si veda
+\signal{SIGCHLD} al padre. L'azione predefinita (si veda
 sez.~\ref{sec:sig_base}) per questo segnale è di essere ignorato, ma la sua
 generazione costituisce il meccanismo di comunicazione asincrona con cui il
 kernel avverte il processo padre che uno dei suoi figli è terminato.
@@ -1055,7 +1055,7 @@ Il comportamento delle funzioni è però cambiato nel passaggio dal kernel 2.4
 al kernel 2.6, quest'ultimo infatti si è adeguato alle prescrizioni dello
 standard POSIX.1-2001,\footnote{una revisione del 2001 dello standard POSIX.1
   che ha aggiunto dei requisiti e delle nuove funzioni, come \func{waitid}.}
-e come da esso richiesto se \const{SIGCHLD} viene ignorato, o se si imposta il
+e come da esso richiesto se \signal{SIGCHLD} viene ignorato, o se si imposta il
 flag di \const{SA\_NOCLDSTOP} nella ricezione dello stesso (si veda
 sez.~\ref{sec:sig_sigaction}) i processi figli che terminano non diventano
 \textit{zombie} e sia \func{wait} che \func{waitpid} si bloccano fintanto che
@@ -1063,13 +1063,13 @@ tutti i processi figli non sono terminati, dopo di che falliscono con un
 errore di \errcode{ENOCHLD}.\footnote{questo è anche il motivo per cui le
   opzioni \const{WUNTRACED} e \const{WCONTINUED} sono utilizzabili soltanto
   qualora non si sia impostato il flag di \const{SA\_NOCLDSTOP} per il segnale
-  \const{SIGCHLD}.}
+  \signal{SIGCHLD}.}
 
 Con i kernel della serie 2.4 e tutti i kernel delle serie precedenti entrambe
 le funzioni di attesa ignorano questa prescrizione\footnote{lo standard POSIX.1
   originale infatti lascia indefinito il comportamento di queste funzioni
-  quando \const{SIGCHLD} viene ignorato.} e si comportano sempre nello stesso
-modo, indipendentemente dal fatto \const{SIGCHLD} sia ignorato o meno:
+  quando \signal{SIGCHLD} viene ignorato.} e si comportano sempre nello stesso
+modo, indipendentemente dal fatto \signal{SIGCHLD} sia ignorato o meno:
 attendono la terminazione di un processo figlio e ritornano il relativo
 \acr{pid} e lo stato di terminazione nell'argomento \param{status}.
 
@@ -1112,7 +1112,7 @@ attendono la terminazione di un processo figlio e ritornano il relativo
                              nullo. \\ 
     \macro{WIFCONTINUED(s)}& Vera se il processo che ha causato il ritorno è
                              stato riavviato da un
-                             \const{SIGCONT}.\footnotemark  \\ 
+                             \signal{SIGCONT}.\footnotemark  \\ 
     \hline
   \end{tabular}
   \caption{Descrizione delle varie macro di preprocessore utilizzabili per 
@@ -1134,7 +1134,7 @@ la presenza di \index{zombie} \textit{zombie}).
 
 Per questo la modalità più comune di chiamare queste funzioni è quella di
 utilizzarle all'interno di un \textit{signal handler} (vedremo un esempio di
-come gestire \const{SIGCHLD} con i segnali in sez.~\ref{sec:sig_example}). In
+come gestire \signal{SIGCHLD} con i segnali in sez.~\ref{sec:sig_example}). In
 questo caso infatti, dato che il segnale è generato dalla terminazione di un
 figlio, avremo la certezza che la chiamata a \func{waitpid} non si bloccherà.
 
@@ -1276,7 +1276,7 @@ campi:
 \item[\var{si\_pid}] con il \acr{pid} del figlio.
 \item[\var{si\_uid}] con l'user-ID reale (vedi sez.~\ref{sec:proc_perms}) del
   figlio.
-\item[\var{si\_signo}] con \const{SIGCHLD}.
+\item[\var{si\_signo}] con \signal{SIGCHLD}.
 \item[\var{si\_status}] con lo stato di uscita del figlio o con il segnale che
   lo ha terminato, fermato o riavviato.
 \item[\var{si\_code}] con uno fra \const{CLD\_EXITED}, \const{CLD\_KILLED},
@@ -1521,7 +1521,7 @@ I segnali che sono stati impostati per essere ignorati nel processo chiamante
 mantengono la stessa impostazione pure nel nuovo programma, ma tutti gli altri
 segnali, ed in particolare quelli per i quali è stato installato un gestore
 vengono impostati alla loro azione predefinita (vedi
-sez.~\ref{sec:sig_gen_beha}). Un caso speciale è il segnale \const{SIGCHLD}
+sez.~\ref{sec:sig_gen_beha}). Un caso speciale è il segnale \signal{SIGCHLD}
 che, quando impostato a \const{SIG\_IGN}, potrebbe anche essere reimpostato a
 \const{SIG\_DFL}, anche se questo con Linux non avviene.\footnote{lo standard
   POSIX.1-2001 prevede che questo comportamento sia deciso dalla singola
@@ -1548,7 +1548,7 @@ nell'esecuzione della funzione \func{exec}, queste sono:
   sez.~\ref{sec:process_prctl}) viene cancellato;
 \item il nome del processo viene impostato al nome del file contenente il
   programma messo in esecuzione;
-\item il segnale di terminazione viene reimpostato a \const{SIGCHLD};
+\item il segnale di terminazione viene reimpostato a \signal{SIGCHLD};
 \item l'ambiente viene reinizializzato impostando le variabili attinenti alla
   localizzazione al valore di default POSIX. 
 \end{itemize*}
@@ -2260,7 +2260,7 @@ fintanto che esso si trova in uno qualunque degli altri stati.
                                     genere per I/O), e non può essere
                                     interrotto in nessuna circostanza.\\
     \textbf{Stopped} & \texttt{T} & Il processo è stato fermato con un
-                                    \const{SIGSTOP}, o è tracciato.\\
+                                    \signal{SIGSTOP}, o è tracciato.\\
     \textbf{Zombie}\index{zombie} & \texttt{Z} & Il processo è terminato ma il
                                     suo stato di terminazione non è ancora
                                     stato letto dal padre.\\
@@ -2268,7 +2268,7 @@ fintanto che esso si trova in uno qualunque degli altri stati.
                                     2.6.25, sostanzialmente identico
                                     all'\textbf{Uninterrutible Sleep} con la
                                     sola differenza che il processo può
-                                    terminato con \const{SIGKILL} (usato per
+                                    terminato con \signal{SIGKILL} (usato per
                                     lo più per NFS).\\ 
     \hline
   \end{tabular}
@@ -3002,7 +3002,7 @@ nell'evitare la perdita della cache da rendere conveniente l'uso dell'affinità
 di processore.
 
 Per facilitare l'uso dell'argomento \param{cpuset} le \acr{glibc} hanno
-introdotto un apposito dato di tipo, \ctyp{cpu\_set\_t},\footnote{questa è una
+introdotto un apposito dato di tipo, \type{cpu\_set\_t},\footnote{questa è una
   estensione specifica delle \acr{glibc}, da attivare definendo la macro
   \macro{\_GNU\_SOURCE}, non esiste infatti una standardizzazione per
   questo tipo di interfaccia e POSIX al momento non prevede nulla al
@@ -3361,7 +3361,7 @@ vedremo a breve, consente anche di passare per \param{child\_stack} il valore
 \val{NULL}, che non imposta un nuovo \textit{stack}. Se infatti si crea un
 processo, questo ottiene un suo nuovo spazio degli indirizzi,\footnote{è
   sottinteso cioè che non si stia usando il flag \const{CLONE\_VM}.} ed in
-questo caso si applica la semantica del \itindex{copy-on-write} \textit{copy
+questo caso si applica la semantica del \itindex{copy~on~write} \textit{copy
   on write} illustrata in sez.~\ref{sec:proc_fork}, per cui le pagine dello
 \textit{stack} verranno automaticamente copiate come le altre e il nuovo
 processo avrà un suo \textit{stack} totalmente indipendente da quello del
@@ -3531,14 +3531,14 @@ predefinite del seguente elenco, che illustra quelle disponibili al momento:
   PowerPC.
 \item[\const{PR\_GET\_ENDIAN}] Ottiene il valore della \textit{endianess} del
   processo chiamante, salvato sulla variabile puntata da \param{arg2} che deve
-  essere passata come di tipo \type{(int *)}. Introdotta a partire dal kernel
+  essere passata come di tipo \ctyp{(int *)}. Introdotta a partire dal kernel
   2.6.18, solo su PowerPC.
 \item[\const{PR\_SET\_FPEMU}] Imposta i bit di controllo per l'emulazione
   della virgola mobile su architettura ia64, secondo il valore
   di \param{arg2}, si deve passare \const{PR\_FPEMU\_NOPRINT} per emulare in
   maniera trasparente l'accesso alle operazioni in virgola mobile, o
   \const{PR\_FPEMU\_SIGFPE} per non emularle ed inviare il segnale
-  \const{SIGFPE} (vedi sez.~\ref{sec:sig_prog_error}). Introdotta a partire
+  \signal{SIGFPE} (vedi sez.~\ref{sec:sig_prog_error}). Introdotta a partire
   dal kernel 2.4.18, solo su ia64.
 \item[\const{PR\_GET\_FPEMU}] Ottiene il valore dei flag di controllo
   dell'emulazione della virgola mobile, salvato all'indirizzo puntato
@@ -3588,7 +3588,7 @@ predefinite del seguente elenco, che illustra quelle disponibili al momento:
 \item[\const{PR\_SET\_PDEATHSIG}] Consente di richiedere l'emissione di un
   segnale, che sarà ricevuto dal processo chiamante, in occorrenza della
   terminazione del proprio processo padre; in sostanza consente di invertire
-  il ruolo di \const{SIGCHLD}. Il valore di \param{arg2} deve indicare il
+  il ruolo di \signal{SIGCHLD}. Il valore di \param{arg2} deve indicare il
   numero del segnale, o 0 per disabilitare l'emissione. Il valore viene
   automaticamente cancellato per un processo figlio creato con \func{fork}.
   Introdotta a partire dal kernel 2.1.57.
@@ -3646,7 +3646,7 @@ predefinite del seguente elenco, che illustra quelle disponibili al momento:
   \textit{timestamp} (TSC, o \textit{Time Stamp Counter}) da indicare con il
   valore di \param{arg2}. Si deve specificare \const{PR\_TSC\_ENABLE} per
   abilitare la lettura o \const{PR\_TSC\_SIGSEGV} per disabilitarla con la
-  generazione di un segnale di \const{SIGSEGV} (vedi
+  generazione di un segnale di \signal{SIGSEGV} (vedi
   sez.~\ref{sec:sig_prog_error}). La lettura viene automaticamente
   disabilitata se si attiva il \textit{secure computing mode}.  Introdotta a
   partire dal kernel 2.6.26, solo su x86.
@@ -3662,7 +3662,7 @@ predefinite del seguente elenco, che illustra quelle disponibili al momento:
   illegali, da indicare con il valore di \param{arg2}. Si deve specificare il
   valore \const{PR\_UNALIGN\_NOPRINT} per ignorare gli accessi non allineati,
   ed il valore \const{PR\_UNALIGN\_SIGBUS} per generare un segnale di
-  \const{SIGBUS} (vedi sez.~\ref{sec:sig_prog_error}) in caso di accesso non
+  \signal{SIGBUS} (vedi sez.~\ref{sec:sig_prog_error}) in caso di accesso non
   allineato.  Introdotta con diverse versioni su diverse architetture.
 \item[\const{PR\_GET\_UNALIGN}] Ottiene il valore della modalità di controllo
   per l'accesso a indirizzi di memoria non allineati, salvato all'indirizzo
@@ -3675,7 +3675,7 @@ predefinite del seguente elenco, che illustra quelle disponibili al momento:
     piattaforme più avanzate che hanno il supporto hardware per questo tipo di
     controlli.} ma devono essere opportunamente riportati ai processi che
   usano quella parte di RAM che presenta errori; nel caso specifico questo
-  avviene attraverso l'emissione di un segnale di \const{SIGBUS} (vedi
+  avviene attraverso l'emissione di un segnale di \signal{SIGBUS} (vedi
   sez.~\ref{sec:sig_prog_error}).\footnote{in particolare viene anche
     impostato il valore di \var{si\_code} in \struct{siginfo\_t} a
     \const{BUS\_MCEERR\_AO}; per il significato di tutto questo si faccia
@@ -3697,7 +3697,7 @@ predefinite del seguente elenco, che illustra quelle disponibili al momento:
   due, che corrispondono anche al valore che si trova nell'impostazione
   generale di sistema di \texttt{memory\_failure\_early\_kill}, con
   \const{PR\_MCE\_KILL\_EARLY} si richiede l'emissione immediata di
-  \const{SIGBUS} non appena viene rilevato un errore, mentre con
+  \signal{SIGBUS} non appena viene rilevato un errore, mentre con
   \const{PR\_MCE\_KILL\_LATE} il segnale verrà inviato solo quando il processo
   tenterà un accesso alla memoria corrotta. Questi due valori corrispondono
   rispettivamente ai valori 1 e 0 di
@@ -3881,7 +3881,8 @@ queste infatti vengono allocate nello \itindex{stack} \textit{stack}, ed
 un'altra invocazione non fa altro che allocarne un'altra copia. Una funzione
 può non essere rientrante quando opera su memoria che non è nello
 \itindex{stack} \textit{stack}.  Ad esempio una funzione non è mai rientrante
-se usa una variabile globale o statica.
+se usa una \index{variabili!globali} variabile globale o
+\index{variabili!statiche} statica.
 
 Nel caso invece la funzione operi su un oggetto allocato dinamicamente, la
 cosa viene a dipendere da come avvengono le operazioni: se l'oggetto è creato
@@ -3894,12 +3895,12 @@ se viene passato lo stesso oggetto; in tutti questi casi occorre molta cura da
 parte del programmatore.
 
 In genere le funzioni di libreria non sono rientranti, molte di esse ad
-esempio utilizzano variabili statiche, le \acr{glibc} però mettono a
-disposizione due macro di compilatore,\footnote{si ricordi quanto illustrato
-  in sez.~\ref{sec:intro_gcc_glibc_std}.} \macro{\_REENTRANT} e
-\macro{\_THREAD\_SAFE}, la cui definizione attiva le versioni rientranti di
-varie funzioni di libreria, che sono identificate aggiungendo il suffisso
-\code{\_r} al nome della versione normale.
+esempio utilizzano \index{variabili!statiche} variabili statiche, le
+\acr{glibc} però mettono a disposizione due macro di compilatore,\footnote{si
+  ricordi quanto illustrato in sez.~\ref{sec:intro_gcc_glibc_std}.}
+\macro{\_REENTRANT} e \macro{\_THREAD\_SAFE}, la cui definizione attiva le
+versioni rientranti di varie funzioni di libreria, che sono identificate
+aggiungendo il suffisso \code{\_r} al nome della versione normale.
 
 \index{funzioni!rientranti|)}
 
index 0cb02ef..a1bbe4e 100644 (file)
@@ -377,7 +377,7 @@ Come accennato in sez.~\ref{sec:sess_job_control_overview}, tutti i processi
 (e relativi raggruppamenti) che non fanno parte del gruppo di
 \textit{foreground} sono detti in \textit{background}; se uno si essi cerca di
 accedere al terminale di controllo provocherà l'invio da parte del kernel di
-uno dei due segnali \const{SIGTTIN} o \const{SIGTTOU} (a seconda che l'accesso
+uno dei due segnali \signal{SIGTTIN} o \signal{SIGTTOU} (a seconda che l'accesso
 sia stato in lettura o scrittura) a tutto il suo \itindex{process~group}
 \textit{process group}; dato che il comportamento di default di questi segnali
 (si riveda quanto esposto in sez.~\ref{sec:sig_job_control}) è di fermare il
@@ -420,8 +420,8 @@ decifrare, ma deve poi leggere la password dal terminale.
 Un'altra caratteristica del terminale di controllo usata nel job control è che
 utilizzando su di esso le combinazioni di tasti speciali (\texttt{C-z},
 \texttt{C-c}, \texttt{C-y} e \texttt{C-|}) si farà sì che il kernel invii i
-corrispondenti segnali (rispettivamente \const{SIGTSTP}, \const{SIGINT},
-\const{SIGQUIT} e \const{SIGTERM}, trattati in sez.~\ref{sec:sig_job_control})
+corrispondenti segnali (rispettivamente \signal{SIGTSTP}, \signal{SIGINT},
+\signal{SIGQUIT} e \signal{SIGTERM}, trattati in sez.~\ref{sec:sig_job_control})
 a tutti i processi del raggruppamento di \textit{foreground}; in questo modo
 la shell può gestire il blocco e l'interruzione dei vari comandi.
 
@@ -429,14 +429,14 @@ la shell può gestire il blocco e l'interruzione dei vari comandi.
 Per completare la trattazione delle caratteristiche del job control legate al
 terminale di controllo, occorre prendere in considerazione i vari casi legati
 alla terminazione anomala dei processi, che sono di norma gestite attraverso
-il segnale \const{SIGHUP}. Il nome del segnale deriva da \textit{hungup},
+il segnale \signal{SIGHUP}. Il nome del segnale deriva da \textit{hungup},
 termine che viene usato per indicare la condizione in cui il terminale diventa
 inutilizzabile, (letteralmente sarebbe \textsl{impiccagione}).
 
 Quando si verifica questa condizione, ad esempio se si interrompe la linea, o
 va giù la rete o più semplicemente si chiude forzatamente la finestra di
 terminale su cui si stava lavorando, il kernel provvederà ad inviare il
-segnale di \const{SIGHUP} al processo di controllo. L'azione preimpostata in
+segnale di \signal{SIGHUP} al processo di controllo. L'azione preimpostata in
 questo caso è la terminazione del processo, il problema che si pone è cosa
 accade agli altri processi nella sessione, che non han più un processo di
 controllo che possa gestire l'accesso al terminale, che potrebbe essere
@@ -445,7 +445,7 @@ riutilizzato per qualche altra sessione.
 Lo standard POSIX.1 prevede che quando il processo di controllo termina, che
 ciò avvenga o meno per un \textit{hungup} del terminale (ad esempio si
 potrebbe terminare direttamente la shell con \cmd{kill}) venga inviato un
-segnale di \const{SIGHUP} ai processi del raggruppamento di foreground. In
+segnale di \signal{SIGHUP} ai processi del raggruppamento di foreground. In
 questo modo essi potranno essere avvisati che non esiste più un processo in
 grado di gestire il terminale (di norma tutto ciò comporta la terminazione
 anche di questi ultimi).
@@ -464,7 +464,7 @@ cui processi hanno come padri esclusivamente o altri processi nel
 raggruppamento, o processi fuori della sessione.  Lo standard prevede inoltre
 che se la terminazione di un processo fa sì che un raggruppamento di processi
 diventi orfano e se i suoi membri sono bloccati, ad essi vengano inviati in
-sequenza i segnali di \const{SIGHUP} e \const{SIGCONT}.
+sequenza i segnali di \signal{SIGHUP} e \signal{SIGCONT}.
 
 La definizione può sembrare complicata, e a prima vista non è chiaro cosa
 tutto ciò abbia a che fare con il problema della terminazione del processo di
@@ -490,8 +490,8 @@ sez.~\ref{sec:proc_termination}, tutti i suoi figli vengono adottati da
 group creati direttamente dal leader di sessione (a meno di non aver spostato
 con \func{setpgid} un processo da un gruppo ad un altro, cosa che di norma non
 viene fatta) i quali riceveranno, nel caso siano bloccati, i due segnali;
-\const{SIGCONT} ne farà proseguire l'esecuzione, ed essendo stato nel
-frattempo inviato anche \const{SIGHUP}, se non c'è un gestore per
+\signal{SIGCONT} ne farà proseguire l'esecuzione, ed essendo stato nel
+frattempo inviato anche \signal{SIGHUP}, se non c'è un gestore per
 quest'ultimo, i processi bloccati verranno automaticamente terminati.
 
 
@@ -614,7 +614,7 @@ controllo per il terminale, a gestire l'esecuzione dei comandi come illustrato
 in sez.~\ref{sec:sess_job_control_overview}. 
 
 Dato che il processo padre resta sempre \cmd{init} quest'ultimo potrà
-provvedere, ricevendo un \const{SIGCHLD} all'uscita della shell quando la
+provvedere, ricevendo un \signal{SIGCHLD} all'uscita della shell quando la
 sessione di lavoro è terminata, a rilanciare \cmd{getty} sul terminale per
 ripetere da capo tutto il procedimento.
 
@@ -1432,7 +1432,7 @@ modificare i bit su cui non si interviene.
                      \const{IGNBRK} non è impostato. Se \const{BRKINT} è
                      impostato il BREAK causa lo scarico delle code, 
                      e se il terminale è il terminale di controllo per un 
-                     gruppo in foreground anche l'invio di \const{SIGINT} ai
+                     gruppo in foreground anche l'invio di \signal{SIGINT} ai
                      processi di quest'ultimo. Se invece \const{BRKINT} non è
                      impostato un BREAK viene letto come un carattere
                      NUL, a meno che non sia impostato \const{PARMRK}
@@ -1643,7 +1643,7 @@ valore.
                      \const{O\_NOBLOCK} si bloccherà il processo finché 
                      non si è stabilita una connessione con il modem; inoltre 
                      se viene rilevata una disconnessione viene inviato un
-                     segnale di \const{SIGHUP} al processo di controllo del
+                     segnale di \signal{SIGHUP} al processo di controllo del
                      terminale. La lettura su un terminale sconnesso comporta
                      una condizione di \textit{end of file} e la scrittura un
                      errore di \errcode{EIO}.\\
@@ -1758,10 +1758,10 @@ terminali.
                      attivato dal carattere DISCARD. Non è presente in POSIX e
                      non è supportato da Linux.\\
     \const{NOFLSH} & Se impostato disabilita lo scarico delle code di ingresso
-                     e uscita quando vengono emessi i segnali \const{SIGINT}, 
-                     \const{SIGQUIT} e \const{SIGSUSP}.\\
+                     e uscita quando vengono emessi i segnali \signal{SIGINT}, 
+                     \signal{SIGQUIT} e \signal{SIGSUSP}.\\
     \const{TOSTOP} & Se abilitato, con il supporto per il job control presente,
-                     genera il segnale \const{SIGTTOU} per un processo in
+                     genera il segnale \signal{SIGTTOU} per un processo in
                      background che cerca di scrivere sul terminale.\\
     \const{PENDIN} & Indica che la linea deve essere ristampata, viene
                      attivato dal carattere REPRINT e resta attivo fino alla
@@ -1803,10 +1803,10 @@ altri.\footnote{in Linux il valore della costante è 32, anche se i caratteri
     \hline
     \const{VINTR} &\texttt{0x03}&(\texttt{C-c})& Carattere di interrupt, 
                                                  provoca l'emissione di 
-                                                 \const{SIGINT}.\\
+                                                 \signal{SIGINT}.\\
     \const{VQUIT} &\texttt{0x1C}&(\texttt{C-\bslash})& Carattere di uscita,  
                                                  provoca l'emissione di 
-                                                 \const{SIGQUIT}.\\
+                                                 \signal{SIGQUIT}.\\
     \const{VERASE}&\texttt{0x7f}&DEL,\texttt{C-?}& Carattere di ERASE, cancella
                                                  l'ultimo carattere
                                                  precedente nella linea.\\
@@ -1846,10 +1846,10 @@ altri.\footnote{in Linux il valore della costante è 32, anche se i caratteri
                                                  START.\\
     \const{VSUSP} &\texttt{0x1A}&(\texttt{C-z})& Carattere di
                                                  sospensione. Invia il segnale
-                                                 \const{SIGTSTP}.\\
+                                                 \signal{SIGTSTP}.\\
     \const{VDSUSP}&\texttt{0x19}&(\texttt{C-y})& Carattere di sospensione
                                                  ritardata. Invia il segnale 
-                                                 \const{SIGTSTP} quando il
+                                                 \signal{SIGTSTP} quando il
                                                  carattere viene letto dal
                                                  programma, (non presente in
                                                  POSIX e non riconosciuto in
@@ -1938,9 +1938,9 @@ terminale qualunque nella struttura puntata da \param{termios\_p};
 \func{tcsetattr} invece effettua la scrittura delle impostazioni e quando
 viene invocata sul proprio terminale di controllo può essere eseguita con
 successo solo da un processo in foreground.  Se invocata da un processo in
-background infatti tutto il gruppo riceverà un segnale di \const{SIGTTOU} come
+background infatti tutto il gruppo riceverà un segnale di \signal{SIGTTOU} come
 se si fosse tentata una scrittura, a meno che il processo chiamante non abbia
-\const{SIGTTOU} ignorato o bloccato, nel qual caso l'operazione sarà eseguita.
+\signal{SIGTTOU} ignorato o bloccato, nel qual caso l'operazione sarà eseguita.
 
 La funzione \func{tcsetattr} prevede tre diverse modalità di funzionamento,
 specificabili attraverso l'argomento \param{optional\_actions}, che permette
@@ -2153,7 +2153,7 @@ direttamente sulla gestione di quest'ultime e sull'interazione fra i dati in
 ingresso ed uscita e le relative code. In generale tutte queste funzioni
 vengono considerate, dal punto di vista dell'accesso al terminale, come delle
 funzioni di scrittura, pertanto se usate da processi in background sul loro
-terminale di controllo provocano l'emissione di \const{SIGTTOU} come
+terminale di controllo provocano l'emissione di \signal{SIGTTOU} come
 illustrato in sez.~\ref{sec:sess_ctrl_term}.\footnote{con la stessa eccezione,
   già vista per \func{tcsetattr}, che quest'ultimo sia bloccato o ignorato dal
   processo chiamante.}
index 8caa480..b4e869f 100644 (file)
@@ -230,7 +230,7 @@ i segnali successivi alla nuova specificazione saranno notificati).
 
 Una volta che un segnale viene notificato (che questo avvenga subito o dopo
 una attesa più o meno lunga) viene eseguita l'azione specificata per il
-segnale. Per alcuni segnali (\const{SIGKILL} e \const{SIGSTOP}) questa azione
+segnale. Per alcuni segnali (\signal{SIGKILL} e \signal{SIGSTOP}) questa azione
 è fissa e non può essere cambiata, ma per tutti gli altri si può selezionare
 una  delle tre possibilità seguenti:
 
@@ -360,51 +360,51 @@ al momento della ricezione del segnale.
     \textbf{Segnale} &\textbf{Standard}&\textbf{Azione}&\textbf{Descrizione} \\
     \hline
     \hline
-    \const{SIGHUP}   &PL & A & Hangup o terminazione del processo di 
+    \signal{SIGHUP}  &PL & A & Hangup o terminazione del processo di 
                                controllo.                                    \\
-    \const{SIGINT}   &PL & A & Interrupt da tastiera (\cmd{C-c}).            \\
-    \const{SIGQUIT}  &PL & C & Quit da tastiera (\cmd{C-y}).                 \\
-    \const{SIGILL}   &PL & C & Istruzione illecita.                          \\
-    \const{SIGABRT}  &PL & C & Segnale di abort da \func{abort}.             \\
-    \const{SIGFPE}   &PL & C & Errore aritmetico.                            \\
-    \const{SIGKILL}  &PL &AEF& Segnale di terminazione forzata.              \\
-    \const{SIGSEGV}  &PL & C & Errore di accesso in memoria.                 \\
-    \const{SIGPIPE}  &PL & A & Pipe spezzata.                                \\
-    \const{SIGALRM}  &PL & A & Segnale del timer da \func{alarm}.            \\
-    \const{SIGTERM}  &PL & A & Segnale di terminazione \texttt{C-\bslash}.   \\
-    \const{SIGUSR1}  &PL & A & Segnale utente numero 1.                      \\
-    \const{SIGUSR2}  &PL & A & Segnale utente numero 2.                      \\
-    \const{SIGCHLD}  &PL & B & Figlio terminato o fermato.                   \\
-    \const{SIGCONT}  &PL &   & Continua se fermato.                          \\
-    \const{SIGSTOP}  &PL &DEF& Ferma il processo.                            \\
-    \const{SIGTSTP}  &PL & D & Pressione del tasto di stop sul terminale.    \\
-    \const{SIGTTIN}  &PL & D & Input sul terminale per un processo 
+    \signal{SIGINT}  &PL & A & Interrupt da tastiera (\cmd{C-c}).            \\
+    \signal{SIGQUIT} &PL & C & Quit da tastiera (\cmd{C-y}).                 \\
+    \signal{SIGILL}  &PL & C & Istruzione illecita.                          \\
+    \signal{SIGABRT} &PL & C & Segnale di abort da \func{abort}.             \\
+    \signal{SIGFPE}  &PL & C & Errore aritmetico.                            \\
+    \signal{SIGKILL} &PL &AEF& Segnale di terminazione forzata.              \\
+    \signal{SIGSEGV} &PL & C & Errore di accesso in memoria.                 \\
+    \signal{SIGPIPE} &PL & A & Pipe spezzata.                                \\
+    \signal{SIGALRM} &PL & A & Segnale del timer da \func{alarm}.            \\
+    \signal{SIGTERM} &PL & A & Segnale di terminazione \texttt{C-\bslash}.   \\
+    \signal{SIGUSR1} &PL & A & Segnale utente numero 1.                      \\
+    \signal{SIGUSR2} &PL & A & Segnale utente numero 2.                      \\
+    \signal{SIGCHLD} &PL & B & Figlio terminato o fermato.                   \\
+    \signal{SIGCONT} &PL &   & Continua se fermato.                          \\
+    \signal{SIGSTOP} &PL &DEF& Ferma il processo.                            \\
+    \signal{SIGTSTP} &PL & D & Pressione del tasto di stop sul terminale.    \\
+    \signal{SIGTTIN} &PL & D & Input sul terminale per un processo 
                                in background.                                \\
-    \const{SIGTTOU}  &PL & D & Output sul terminale per un processo          
+    \signal{SIGTTOU} &PL & D & Output sul terminale per un processo          
                                in background.                                \\
-    \const{SIGBUS}   &SL & C & Errore sul bus (bad memory access).           \\
-    \const{SIGPOLL}  &SL & A & \textit{Pollable event} (Sys V);  
-                               Sinonimo di \const{SIGIO}.                    \\
-    \const{SIGPROF}  &SL & A & Timer del profiling scaduto.                  \\
-    \const{SIGSYS}   &SL & C & Argomento sbagliato per una subroutine (SVID).\\
-    \const{SIGTRAP}  &SL & C & Trappole per un Trace/breakpoint.             \\
-    \const{SIGURG}   &SLB& B & Ricezione di una \textit{urgent condition} su 
+    \signal{SIGBUS}  &SL & C & Errore sul bus (bad memory access).           \\
+    \signal{SIGPOLL} &SL & A & \textit{Pollable event} (Sys V);  
+                               Sinonimo di \signal{SIGIO}.                   \\
+    \signal{SIGPROF} &SL & A & Timer del profiling scaduto.                  \\
+    \signal{SIGSYS}  &SL & C & Argomento sbagliato per una subroutine (SVID).\\
+    \signal{SIGTRAP} &SL & C & Trappole per un Trace/breakpoint.             \\
+    \signal{SIGURG}  &SLB& B & Ricezione di una \textit{urgent condition} su 
                                un socket. \\
-    \const{SIGVTALRM}&SLB& A & Timer di esecuzione scaduto.                  \\
-    \const{SIGXCPU}  &SLB& C & Ecceduto il limite sul tempo di CPU.          \\
-    \const{SIGXFSZ}  &SLB& C & Ecceduto il limite sulla dimensione dei file. \\
-    \const{SIGIOT}   &L  & C & IOT trap. Sinonimo di \const{SIGABRT}.        \\
-    \const{SIGEMT}   &L  &   &                                               \\
+    \signal{SIGVTALRM}&SLB& A & Timer di esecuzione scaduto.                 \\
+    \signal{SIGXCPU}  &SLB& C & Ecceduto il limite sul tempo di CPU.         \\
+    \signal{SIGXFSZ}  &SLB& C & Ecceduto il limite sulla dimensione dei file.\\
+    \signal{SIGIOT}   &L  & C & IOT trap. Sinonimo di \signal{SIGABRT}.      \\
+    \signal{SIGEMT}   &L  &   &                                              \\
 % TODO che roba e` SIGEMT
-    \const{SIGSTKFLT}&L  & A & Errore sullo stack del coprocessore.          \\
-    \const{SIGIO}    &LB & A & L'I/O è possibile (4.2 BSD).                  \\
-    \const{SIGCLD}   &L  &   & Sinonimo di \const{SIGCHLD}.                  \\
-    \const{SIGPWR}   &L  & A & Fallimento dell'alimentazione.                \\
-    \const{SIGINFO}  &L  &   & Sinonimo di \const{SIGPWR}.                   \\
-    \const{SIGLOST}  &L  & A & Perso un lock sul file (per NFS).             \\
-    \const{SIGWINCH} &LB & B & Finestra ridimensionata (4.3 BSD, Sun).       \\
-    \const{SIGUNUSED}&L  & A & Segnale inutilizzato (diventerà 
-                               \const{SIGSYS}).                              \\
+    \signal{SIGSTKFLT}&L  & A & Errore sullo stack del coprocessore.         \\
+    \signal{SIGIO}    &LB & A & L'I/O è possibile (4.2 BSD).                 \\
+    \signal{SIGCLD}   &L  &   & Sinonimo di \signal{SIGCHLD}.                \\
+    \signal{SIGPWR}   &L  & A & Fallimento dell'alimentazione.               \\
+    \signal{SIGINFO}  &L  &   & Sinonimo di \signal{SIGPWR}.                 \\
+    \signal{SIGLOST}  &L  & A & Perso un lock sul file (per NFS).            \\
+    \signal{SIGWINCH} &LB & B & Finestra ridimensionata (4.3 BSD, Sun).      \\
+    \signal{SIGUNUSED}&L  & A & Segnale inutilizzato (diventerà 
+                               \signal{SIGSYS}).                             \\
     \hline
   \end{tabular}
   \caption{Lista dei segnali in Linux.}
@@ -440,7 +440,7 @@ che viene scritto in un file \file{core} nella directory corrente del processo
 al momento dell'errore, che il debugger può usare per ricostruire lo stato del
 programma al momento della terminazione.  Questi segnali sono:
 \begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\const{SIGFPE}] Riporta un errore aritmetico fatale. Benché il nome
+\item[\signal{SIGFPE}] Riporta un errore aritmetico fatale. Benché il nome
   derivi da \textit{floating point exception} si applica a tutti gli errori
   aritmetici compresa la divisione per zero e l'overflow.  Se il gestore
   ritorna il comportamento del processo è indefinito, ed ignorare questo
@@ -452,7 +452,7 @@ programma al momento della terminazione.  Questi segnali sono:
 %   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},
+\item[\signal{SIGILL}] Il nome deriva da \textit{illegal instruction},
   significa che il programma sta cercando di eseguire una istruzione
   privilegiata o inesistente, in generale del codice illecito. Poiché il
   compilatore del C genera del codice valido si ottiene questo segnale se il
@@ -463,7 +463,7 @@ programma al momento della terminazione.  Questi segnali sono:
   \textit{stack}. Lo stesso segnale viene generato in caso di overflow dello
   \itindex{stack} \textit{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 \itindex{segment~violation}
+\item[\signal{SIGSEGV}] Il nome deriva da \itindex{segment~violation}
   \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 sistema. In genere è il meccanismo della
@@ -472,20 +472,20 @@ programma al momento della terminazione.  Questi segnali sono:
 
   È tipico ottenere questo segnale dereferenziando un puntatore nullo o non
   inizializzato leggendo al di là della fine di un vettore. 
-\item[\const{SIGBUS}] Il nome deriva da \textit{bus error}. Come
-  \const{SIGSEGV} questo è un segnale che viene generato di solito quando si
+\item[\signal{SIGBUS}] Il nome deriva da \textit{bus error}. Come
+  \signal{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
+  \signal{SIGSEGV} indica un accesso non permesso su un indirizzo esistente
   (tipo fuori dallo heap o dallo \itindex{stack} \textit{stack}), mentre
-  \const{SIGBUS} indica l'accesso ad un indirizzo non valido, come nel caso di
+  \signal{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
+\item[\signal{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.
-\item[\const{SIGTRAP}] È il segnale generato da un'istruzione di breakpoint o
+\item[\signal{SIGTRAP}] È il segnale generato da un'istruzione di breakpoint o
   dall'attivazione del tracciamento per il processo. È usato dai programmi per
   il debugging e un programma normale non dovrebbe ricevere questo segnale.
-\item[\const{SIGSYS}] Sta ad indicare che si è eseguita una istruzione che
+\item[\signal{SIGSYS}] Sta ad indicare che si è eseguita una istruzione che
   richiede l'esecuzione di una system call, ma si è fornito un codice
   sbagliato per quest'ultima.
 \end{basedescript}
@@ -508,18 +508,18 @@ periferica).
 L'azione predefinita di questi segnali è di terminare il processo, questi
 segnali sono:
 \begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\const{SIGTERM}] Il nome sta per \textit{terminate}. È un segnale
+\item[\signal{SIGTERM}] Il nome sta per \textit{terminate}. È un segnale
   generico usato per causare la conclusione di un programma. Al contrario di
-  \const{SIGKILL} può essere intercettato, ignorato, bloccato. In genere lo si
+  \signal{SIGKILL} può essere intercettato, ignorato, bloccato. In genere lo si
   usa per chiedere in maniera ``\textsl{educata}'' ad un processo di
   concludersi.
 
-\item[\const{SIGINT}] Il nome sta per \textit{interrupt}. È il segnale di
+\item[\signal{SIGINT}] Il nome sta per \textit{interrupt}. È il segnale di
   interruzione per il programma. È quello che viene generato di default dal
   comando \cmd{kill} o dall'invio sul terminale del carattere di controllo
   INTR (interrupt, generato dalla sequenza \cmd{C-c}).
 
-\item[\const{SIGQUIT}] È analogo a \const{SIGINT} con la differenza che è
+\item[\signal{SIGQUIT}] È analogo a \signal{SIGINT} con la differenza che è
   controllato da un altro carattere di controllo, QUIT, corrispondente alla
   sequenza \texttt{C-\bslash}. A differenza del precedente l'azione
   predefinita, oltre alla terminazione del processo, comporta anche la
@@ -533,22 +533,22 @@ segnali sono:
   \textit{core dump}.
   
 
-\item[\const{SIGKILL}] Il nome è utilizzato per terminare in maniera immediata
+\item[\signal{SIGKILL}] Il nome è utilizzato per terminare in maniera immediata
   qualunque programma. Questo segnale non può essere né intercettato, né
   ignorato, né bloccato, per cui causa comunque la terminazione del processo.
   In genere esso viene generato solo per richiesta esplicita dell'utente dal
   comando (o tramite la funzione) \cmd{kill}. Dato che non lo si può
   intercettare è sempre meglio usarlo come ultima risorsa quando metodi meno
-  brutali, come \const{SIGTERM} o \cmd{C-c} non funzionano. 
+  brutali, come \signal{SIGTERM} o \cmd{C-c} non funzionano. 
 
-  Se un processo non risponde a nessun altro segnale \const{SIGKILL} ne causa
+  Se un processo non risponde a nessun altro segnale \signal{SIGKILL} ne causa
   sempre la terminazione (in effetti il fallimento della terminazione di un
-  processo da parte di \const{SIGKILL} costituirebbe un malfunzionamento del
+  processo da parte di \signal{SIGKILL} costituirebbe un malfunzionamento del
   kernel). Talvolta è il sistema stesso che può generare questo segnale quando
   per condizioni particolari il processo non può più essere eseguito neanche
   per eseguire un gestore.
 
-\item[\const{SIGHUP}] Il nome sta per \textit{hang-up}. Segnala che il
+\item[\signal{SIGHUP}] Il nome sta per \textit{hang-up}. Segnala che il
   terminale dell'utente si è disconnesso (ad esempio perché si è interrotta la
   rete). Viene usato anche per riportare la terminazione del processo di
   controllo di un terminale a tutti i processi della sessione, in modo che
@@ -569,7 +569,7 @@ causare la terminazione del programma, ma con questi segnali la scelta
 predefinita è irrilevante, in quanto il loro uso presuppone sempre la
 necessità di un gestore.  Questi segnali sono:
 \begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\const{SIGALRM}] Il nome sta per \textit{alarm}. Segnale la scadenza di
+\item[\signal{SIGALRM}] Il nome sta per \textit{alarm}. Segnale la scadenza di
   un timer misurato sul tempo reale o sull'orologio di sistema. È normalmente
   usato dalla funzione \func{alarm}.
 
@@ -577,7 +577,7 @@ necessità di un gestore.  Questi segnali sono:
   precedente ma segnala la scadenza di un timer sul tempo di CPU usato dal
   processo. 
 
-\item[\const{SIGPROF}] Il nome sta per \textit{profiling}. Indica la scadenza
+\item[\signal{SIGPROF}] Il nome sta per \textit{profiling}. Indica la scadenza
   di un timer che misura sia il tempo di CPU speso direttamente dal processo
   che quello che il sistema ha speso per conto di quest'ultimo. In genere
   viene usato dagli strumenti che servono a fare la profilazione dell'utilizzo
@@ -593,18 +593,18 @@ questo occorre comunque usare \func{fcntl} per abilitare un file descriptor a
 generare questi segnali.  L'azione predefinita è di essere ignorati. Questi
 segnali sono:
 \begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\const{SIGIO}] Questo segnale viene inviato quando un file descriptor è
+\item[\signal{SIGIO}] Questo segnale viene inviato quando un file descriptor è
   pronto per eseguire dell'input/output. In molti sistemi solo i
   socket e i terminali possono generare questo segnale, in Linux
   questo può essere usato anche per i file, posto che la \func{fcntl} abbia
   avuto successo.
 
-\item[\const{SIGURG}] Questo segnale è inviato quando arrivano dei dati
+\item[\signal{SIGURG}] Questo segnale è inviato quando arrivano dei dati
   urgenti o \itindex{out-of-band} \textit{out-of-band} su di un
   socket; per maggiori dettagli al proposito si veda
   sez.~\ref{sec:TCP_urgent_data}.
 
-\item[\const{SIGPOLL}] Questo segnale è equivalente a \const{SIGIO}, è
+\item[\signal{SIGPOLL}] Questo segnale è equivalente a \signal{SIGIO}, è
   definito solo per compatibilità con i sistemi System V.
 \end{basedescript}
 
@@ -616,16 +616,16 @@ Questi sono i segnali usati dal controllo delle sessioni e dei processi, il
 loro uso è specializzato e viene trattato in maniera specifica nelle sezioni
 in cui si trattano gli argomenti relativi.  Questi segnali sono:
 \begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\const{SIGCHLD}] Questo è il segnale mandato al processo padre quando un
+\item[\signal{SIGCHLD}] Questo è il segnale mandato al processo padre quando un
   figlio termina o viene fermato. L'azione predefinita è di ignorare il
   segnale, la sua gestione è trattata in sez.~\ref{sec:proc_wait}.
 
-\item[\const{SIGCLD}] Per Linux questo è solo un segnale identico al
+\item[\signal{SIGCLD}] Per Linux questo è solo un segnale identico al
   precedente, il nome è obsoleto e andrebbe evitato. 
 
-\item[\const{SIGCONT}] Il nome sta per \textit{continue}. Il segnale viene
+\item[\signal{SIGCONT}] Il nome sta per \textit{continue}. Il segnale viene
   usato per fare ripartire un programma precedentemente fermato da
-  \const{SIGSTOP}. Questo segnale ha un comportamento speciale, e fa sempre
+  \signal{SIGSTOP}. Questo segnale ha un comportamento speciale, e fa sempre
   ripartire il processo prima della sua consegna. Il comportamento predefinito
   è di fare solo questo; il segnale non può essere bloccato. Si può anche
   installare un gestore, ma il segnale provoca comunque il riavvio del
@@ -637,27 +637,27 @@ in cui si trattano gli argomenti relativi.  Questi segnali sono:
   gestori per far si che un programma produca una qualche azione speciale
   se viene fermato e riavviato, come per esempio riscrivere un prompt, o
   inviare un avviso. 
-\item[\const{SIGSTOP}] Il segnale ferma un processo (lo porta cioè in uno
+\item[\signal{SIGSTOP}] Il segnale ferma un processo (lo porta cioè in uno
   stato di sleep, vedi sez.~\ref{sec:proc_sched}); il segnale non può essere né
   intercettato, né ignorato, né bloccato.
 
-\item[\const{SIGTSTP}] Il nome sta per \textit{interactive stop}. Il segnale
+\item[\signal{SIGTSTP}] Il nome sta per \textit{interactive stop}. Il segnale
   ferma il processo interattivamente, ed è generato dal carattere SUSP
   (prodotto dalla combinazione \cmd{C-z}), ed al contrario di
-  \const{SIGSTOP} può essere intercettato e ignorato. In genere un programma
+  \signal{SIGSTOP} può essere intercettato e ignorato. In genere un programma
   installa un gestore per questo segnale quando vuole lasciare il sistema
   o il terminale in uno stato definito prima di fermarsi; se per esempio un
   programma ha disabilitato l'eco sul terminale può installare un gestore
   per riabilitarlo prima di fermarsi.
 
-\item[\const{SIGTTIN}] Un processo non può leggere dal terminale se esegue una
+\item[\signal{SIGTTIN}] Un processo non può leggere dal terminale se esegue una
   sessione di lavoro in \textit{background}. Quando un processo in background
   tenta di leggere da un terminale viene inviato questo segnale a tutti i
   processi della sessione di lavoro. L'azione predefinita è di fermare il
   processo.  L'argomento è trattato in
   sez.~\ref{sec:sess_job_control_overview}.
 
-\item[\const{SIGTTOU}] Segnale analogo al precedente \const{SIGTTIN}, ma
+\item[\signal{SIGTTOU}] Segnale analogo al precedente \signal{SIGTTIN}, ma
   generato quando si tenta di scrivere o modificare uno dei modi del
   terminale. L'azione predefinita è di fermare il processo, l'argomento è
   trattato in sez.~\ref{sec:sess_job_control_overview}.
@@ -673,23 +673,23 @@ che impediscono il completamento dell'esecuzione dovute all'interazione con il
 resto del sistema.  L'azione predefinita di questi segnali è di terminare il
 processo, questi segnali sono:
 \begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\const{SIGPIPE}] Sta per \textit{Broken pipe}. Se si usano delle pipe,
+\item[\signal{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
   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
   lo ha causato fallisce, restituendo l'errore \errcode{EPIPE}.
-\item[\const{SIGLOST}] Sta per \textit{Resource lost}. Tradizionalmente è il
+\item[\signal{SIGLOST}] Sta per \textit{Resource lost}. Tradizionalmente è il
   segnale che viene generato quando si perde un advisory lock su un file su
   NFS perché il server NFS è stato riavviato. Il progetto GNU lo utilizza per
   indicare ad un client il crollo inaspettato di un server. In Linux è
-  definito come sinonimo di \const{SIGIO}.\footnote{ed è segnalato come BUG
+  definito come sinonimo di \signal{SIGIO}.\footnote{ed è segnalato come BUG
     nella pagina di manuale.}
-\item[\const{SIGXCPU}] Sta per \textit{CPU time limit exceeded}. Questo
+\item[\signal{SIGXCPU}] Sta per \textit{CPU time limit exceeded}. Questo
   segnale è generato quando un processo eccede il limite impostato per il
   tempo di CPU disponibile, vedi sez.~\ref{sec:sys_resource_limit}. 
-\item[\const{SIGXFSZ}] Sta per \textit{File size limit exceeded}. Questo
+\item[\signal{SIGXFSZ}] Sta per \textit{File size limit exceeded}. Questo
   segnale è generato quando un processo tenta di estendere un file oltre le
   dimensioni specificate dal limite impostato per le dimensioni massime di un
   file, vedi sez.~\ref{sec:sys_resource_limit}. 
@@ -702,20 +702,20 @@ processo, questi segnali sono:
 Raccogliamo qui infine una serie di segnali che hanno scopi differenti non
 classificabili in maniera omogenea. Questi segnali sono:
 \begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\const{SIGUSR1}] Insieme a \const{SIGUSR2} è un segnale a disposizione
+\item[\signal{SIGUSR1}] Insieme a \signal{SIGUSR2} è un segnale a disposizione
   dell'utente che lo può usare per quello che vuole. Viene generato solo
   attraverso l'invocazione della funzione \func{kill}. Entrambi i segnali
   possono essere utili per implementare una comunicazione elementare fra
   processi diversi, o per eseguire a richiesta una operazione utilizzando un
   gestore. L'azione predefinita è di terminare il processo.
-\item[\const{SIGUSR2}] È il secondo segnale a disposizione degli utenti. Vedi
-  quanto appena detto per \const{SIGUSR1}.
-\item[\const{SIGWINCH}] Il nome sta per \textit{window (size) change} e viene
+\item[\signal{SIGUSR2}] È il secondo segnale a disposizione degli utenti. Vedi
+  quanto appena detto per \signal{SIGUSR1}.
+\item[\signal{SIGWINCH}] Il nome sta per \textit{window (size) change} e viene
   generato in molti sistemi (GNU/Linux compreso) quando le dimensioni (in
   righe e colonne) di un terminale vengono cambiate. Viene usato da alcuni
   programmi testuali per riformattare l'uscita su schermo quando si cambia
   dimensione a quest'ultimo. L'azione predefinita è di essere ignorato.
-\item[\const{SIGINFO}] Il segnale indica una richiesta di informazioni. È
+\item[\signal{SIGINFO}] Il segnale indica una richiesta di informazioni. È
   usato con il controllo di sessione, causa la stampa di informazioni da parte
   del processo leader del gruppo associato al terminale di controllo, gli
   altri processi lo ignorano.
@@ -802,7 +802,7 @@ che non sono presenti nello spazio di indirizzi del nuovo programma.
 Si noti che questo vale solo per le azioni per le quali è stato installato un
 gestore; viene mantenuto invece ogni eventuale impostazione dell'azione a
 \const{SIG\_IGN}. Questo permette ad esempio alla shell di impostare ad
-\const{SIG\_IGN} le risposte per \const{SIGINT} e \const{SIGQUIT} per i
+\const{SIG\_IGN} le risposte per \signal{SIGINT} e \signal{SIGQUIT} per i
 programmi eseguiti in background, che altrimenti sarebbero interrotti da una
 successiva pressione di \texttt{C-c} o \texttt{C-y}.
 
@@ -917,7 +917,7 @@ L'argomento \param{handler} che indica il gestore invece, oltre all'indirizzo
 della funzione da chiamare all'occorrenza del segnale, può assumere anche i
 due valori costanti \const{SIG\_IGN} e \const{SIG\_DFL}; il primo indica che
 il segnale deve essere ignorato,\footnote{si ricordi però che i due segnali
-  \const{SIGKILL} e \const{SIGSTOP} non possono essere né ignorati né
+  \signal{SIGKILL} e \signal{SIGSTOP} non possono essere né ignorati né
   intercettati; l'uso di \const{SIG\_IGN} per questi segnali non ha alcun
   effetto.} mentre il secondo ripristina l'azione predefinita.\footnote{e
   serve a tornare al comportamento di default quando non si intende più
@@ -952,8 +952,8 @@ processo \itindex{thread} multi-\textit{thread}, è da evitare; tutti i nuovi
 programmi dovrebbero usare \func{sigaction}.
 
 È da tenere presente che, seguendo lo standard POSIX, il comportamento di un
-processo che ignora i segnali \const{SIGFPE}, \const{SIGILL}, o
-\const{SIGSEGV} (qualora questi non originino da una chiamata ad una
+processo che ignora i segnali \signal{SIGFPE}, \signal{SIGILL}, o
+\signal{SIGSEGV} (qualora questi non originino da una chiamata ad una
 \func{kill} o ad una \func{raise}) è indefinito. Un gestore che ritorna da
 questi segnali può dare luogo ad un ciclo infinito.
 
@@ -1067,7 +1067,7 @@ Solo l'amministratore può inviare un segnale ad un processo qualunque, in
 tutti gli altri casi l'user-ID reale o l'user-ID effettivo del processo
 chiamante devono corrispondere all'user-ID reale o all'user-ID salvato della
 destinazione. Fa eccezione il caso in cui il segnale inviato sia
-\const{SIGCONT}, nel quale occorre che entrambi i processi appartengano alla
+\signal{SIGCONT}, nel quale occorre che entrambi i processi appartengano alla
 stessa sessione. Inoltre, dato il ruolo fondamentale che riveste nel sistema
 (si ricordi quanto visto in sez.~\ref{sec:sig_termination}), non è possibile
 inviare al processo 1 (cioè a \cmd{init}) segnali per i quali esso non abbia
@@ -1085,12 +1085,12 @@ segnale al processo che ha effettuato la chiamata.
 \label{sec:sig_alarm_abort}
 
 Un caso particolare di segnali generati a richiesta è quello che riguarda i
-vari segnali di temporizzazione e \const{SIGABRT}, per ciascuno di questi
+vari segnali di temporizzazione e \signal{SIGABRT}, per ciascuno di questi
 segnali sono previste funzioni specifiche che ne effettuino l'invio. La più
 comune delle funzioni usate per la temporizzazione è \funcd{alarm} il cui
 prototipo è:
 \begin{prototype}{unistd.h}{unsigned int alarm(unsigned int seconds)}
-  Predispone l'invio di \const{SIGALRM} dopo \param{seconds} secondi.
+  Predispone l'invio di \signal{SIGALRM} dopo \param{seconds} secondi.
   
   \bodydesc{La funzione restituisce il numero di secondi rimanenti ad un
     precedente allarme, o zero se non c'erano allarmi pendenti.}
@@ -1099,7 +1099,7 @@ prototipo è:
 La funzione fornisce un meccanismo che consente ad un processo di predisporre
 un'interruzione nel futuro, (ad esempio per effettuare una qualche operazione
 dopo un certo periodo di tempo), programmando l'emissione di un segnale (nel
-caso in questione \const{SIGALRM}) dopo il numero di secondi specificato da
+caso in questione \signal{SIGALRM}) dopo il numero di secondi specificato da
 \param{seconds}.
 
 Se si specifica per \param{seconds} un valore nullo non verrà inviato nessun
@@ -1118,15 +1118,15 @@ processo tre diversi timer:
 \begin{itemize*}
 \item un \textit{real-time timer} che calcola il tempo reale trascorso (che
   corrisponde al \textit{clock time}). La scadenza di questo timer provoca
-  l'emissione di \const{SIGALRM};
+  l'emissione di \signal{SIGALRM};
 \item un \textit{virtual timer} che calcola il tempo di processore usato dal
   processo in user space (che corrisponde all'\textit{user time}). La scadenza
-  di questo timer provoca l'emissione di \const{SIGVTALRM};
+  di questo timer provoca l'emissione di \signal{SIGVTALRM};
 \item un \textit{profiling timer} che calcola la somma dei tempi di processore
   utilizzati direttamente dal processo in user space, e dal kernel nelle
   system call ad esso relative (che corrisponde a quello che in
   sez.~\ref{sec:sys_unix_time} abbiamo chiamato \textit{CPU time}). La scadenza
-  di questo timer provoca l'emissione di \const{SIGPROF}.
+  di questo timer provoca l'emissione di \signal{SIGPROF}.
 \end{itemize*}
 
 Il timer usato da \func{alarm} è il \textit{clock time}, e corrisponde cioè al
@@ -1266,14 +1266,14 @@ valore corrente di un timer senza modificarlo, è possibile usare la funzione
 
 L'ultima funzione che permette l'invio diretto di un segnale è \funcd{abort},
 che, come accennato in sez.~\ref{sec:proc_termination}, permette di abortire
-l'esecuzione di un programma tramite l'invio di \const{SIGABRT}. Il suo
+l'esecuzione di un programma tramite l'invio di \signal{SIGABRT}. Il suo
 prototipo è:
 \begin{prototype}{stdlib.h}{void abort(void)}
   
   Abortisce il processo corrente.
   
   \bodydesc{La funzione non ritorna, il processo è terminato inviando il
-  segnale di \const{SIGABRT}.}
+  segnale di \signal{SIGABRT}.}
 \end{prototype}
 
 La differenza fra questa funzione e l'uso di \func{raise} è che anche se il
@@ -1342,10 +1342,10 @@ termine per l'attesa, e ricalcolare tutte le volte il numero di secondi da
 aspettare.
 
 In alcune implementazioni inoltre l'uso di \func{sleep} può avere conflitti
-con quello di \const{SIGALRM}, dato che la funzione può essere realizzata con
+con quello di \signal{SIGALRM}, dato che la funzione può essere realizzata con
 l'uso di \func{pause} e \func{alarm} (in maniera analoga all'esempio che
 vedremo in sez.~\ref{sec:sig_example}). In tal caso mescolare chiamata di
-\func{alarm} e \func{sleep} o modificare l'azione di \const{SIGALRM}, può
+\func{alarm} e \func{sleep} o modificare l'azione di \signal{SIGALRM}, può
 causare risultati indefiniti. Nel caso delle \acr{glibc} è stata usata una
 implementazione completamente indipendente e questi problemi non ci sono.
 
@@ -1366,7 +1366,7 @@ seguono quella di SUSv2 che prevede il seguente prototipo:
 \end{prototype}
 
 Anche questa funzione, a seconda delle implementazioni, può presentare
-problemi nell'interazione con \func{alarm} e \const{SIGALRM}. È pertanto
+problemi nell'interazione con \func{alarm} e \signal{SIGALRM}. È pertanto
 deprecata in favore della funzione \funcd{nanosleep}, definita dallo standard
 POSIX1.b, il cui prototipo è:
 \begin{prototype}{unistd.h}{int nanosleep(const struct timespec *req, struct
@@ -1387,7 +1387,7 @@ POSIX1.b, il cui prototipo è:
 Lo standard richiede che la funzione sia implementata in maniera del tutto
 indipendente da \func{alarm}\footnote{nel caso di Linux questo è fatto
   utilizzando direttamente il timer del kernel.} e sia utilizzabile senza
-interferenze con l'uso di \const{SIGALRM}. La funzione prende come argomenti
+interferenze con l'uso di \signal{SIGALRM}. La funzione prende come argomenti
 delle strutture di tipo \struct{timespec}, la cui definizione è riportata in
 fig.~\ref{fig:sys_timespec_struct}, che permette di specificare un tempo con
 una precisione fino al nanosecondo.
@@ -1432,29 +1432,29 @@ precisione disponibile sull'hardware della propria macchina.
 \label{sec:sig_sigchld}
 
 Un semplice esempio per illustrare il funzionamento di un gestore di segnale è
-quello della gestione di \const{SIGCHLD}. Abbiamo visto in
+quello della gestione di \signal{SIGCHLD}. Abbiamo visto in
 sez.~\ref{sec:proc_termination} che una delle azioni eseguite dal kernel alla
 conclusione di un processo è quella di inviare questo segnale al
 padre.\footnote{in realtà in SVr4 eredita la semantica di System V, in cui il
-  segnale si chiama \const{SIGCLD} e viene trattato in maniera speciale; in
+  segnale si chiama \signal{SIGCLD} e viene trattato in maniera speciale; in
   System V infatti se si imposta esplicitamente l'azione a \const{SIG\_IGN} il
   segnale non viene generato ed il sistema non genera \index{zombie} zombie
   (lo stato di terminazione viene scartato senza dover chiamare una
   \func{wait}).  L'azione predefinita è sempre quella di ignorare il segnale,
   ma non attiva questo comportamento. Linux, come BSD e POSIX, non supporta
-  questa semantica ed usa il nome di \const{SIGCLD} come sinonimo di
-  \const{SIGCHLD}.} In generale dunque, quando non interessa elaborare lo
+  questa semantica ed usa il nome di \signal{SIGCLD} come sinonimo di
+  \signal{SIGCHLD}.} In generale dunque, quando non interessa elaborare lo
 stato di uscita di un processo, si può completare la gestione della
-terminazione installando un gestore per \const{SIGCHLD} il cui unico compito
+terminazione installando un gestore per \signal{SIGCHLD} il cui unico compito
 sia quello di chiamare \func{waitpid} per completare la procedura di
 terminazione in modo da evitare la formazione di \index{zombie} zombie.
 
 In fig.~\ref{fig:sig_sigchld_handl} è mostrato il codice contenente una
-implementazione generica di una funzione di gestione per \const{SIGCHLD}, (che
+implementazione generica di una funzione di gestione per \signal{SIGCHLD}, (che
 si trova nei sorgenti allegati nel file \file{SigHand.c}); se ripetiamo i test
 di sez.~\ref{sec:proc_termination}, invocando \cmd{forktest} con l'opzione
 \cmd{-s} (che si limita ad effettuare l'installazione di questa funzione come
-gestore di \const{SIGCHLD}) potremo verificare che non si ha più la creazione
+gestore di \signal{SIGCHLD}) potremo verificare che non si ha più la creazione
 di \index{zombie} zombie.
 
 \begin{figure}[!htbp]
@@ -1464,7 +1464,7 @@ di \index{zombie} zombie.
   \end{minipage}
   \normalsize 
   \caption{Codice di una funzione generica di gestione per il segnale
-    \texttt{SIGCHLD}.}
+    \signal{SIGCHLD}.}
   \label{fig:sig_sigchld_handl}
 \end{figure}
 
@@ -1486,7 +1486,7 @@ generazione di ulteriori segnali dello stesso tipo. In questo caso normalmente
 i segnali successivi vengono ``\textsl{fusi}'' col primo ed al processo ne
 viene recapitato soltanto uno.
 
-Questo può essere un caso comune proprio con \const{SIGCHLD}, qualora capiti
+Questo può essere un caso comune proprio con \signal{SIGCHLD}, qualora capiti
 che molti processi figli terminino in rapida successione. Esso inoltre si
 presenta tutte le volte che un segnale viene bloccato: per quanti siano i
 segnali emessi durante il periodo di blocco, una volta che quest'ultimo sarà
@@ -1541,7 +1541,7 @@ fig.~\ref{fig:sig_sleep_wrong}.
   \label{fig:sig_sleep_wrong}
 \end{figure}
 
-Dato che è nostra intenzione utilizzare \const{SIGALRM} il primo passo della
+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
 \func{alarm} per specificare il tempo d'attesa per l'invio del segnale a cui
@@ -1558,7 +1558,7 @@ presenta una pericolosa \itindex{race~condition} \textit{race condition}.
 Infatti, se il processo viene interrotto fra la chiamata di \func{alarm} e
 \func{pause}, può capitare (ad esempio se il sistema è molto carico) che il
 tempo di attesa scada prima dell'esecuzione di quest'ultima, cosicché essa
-sarebbe eseguita dopo l'arrivo di \const{SIGALRM}. In questo caso ci si
+sarebbe eseguita dopo l'arrivo di \signal{SIGALRM}. In questo caso ci si
 troverebbe di fronte ad un \itindex{deadlock} deadlock, in quanto \func{pause}
 non verrebbe mai più interrotta (se non in caso di un altro segnale).
 
@@ -1598,10 +1598,10 @@ qualche forma di evento; in genere quello che si fa in questo caso è impostare
 nel gestore un opportuno flag da controllare nel corpo principale del
 programma (con un codice del tipo di quello riportato in
 fig.~\ref{fig:sig_event_wrong}). La logica è quella di far impostare al
-gestore (\texttt{\small 14-19}) una variabile globale preventivamente
-inizializzata nel programma principale, il quale potrà determinare,
-osservandone il contenuto, l'occorrenza o meno del segnale, e prendere le
-relative azioni conseguenti (\texttt{\small 6-11}).
+gestore (\texttt{\small 14-19}) una \index{variabili!globali} variabile
+globale preventivamente inizializzata nel programma principale, il quale potrà
+determinare, osservandone il contenuto, l'occorrenza o meno del segnale, e
+prendere le relative azioni conseguenti (\texttt{\small 6-11}).
 
 \begin{figure}[!htbp]
   \footnotesize\centering
@@ -1720,8 +1720,8 @@ da un processo. Il suo prototipo è:
     errore, nel qual caso \var{errno} assumerà i valori:
   \begin{errlist}
   \item[\errcode{EINVAL}] si è specificato un numero di segnale invalido o si è
-    cercato di installare il gestore per \const{SIGKILL} o
-    \const{SIGSTOP}.
+    cercato di installare il gestore per \signal{SIGKILL} o
+    \signal{SIGSTOP}.
   \item[\errcode{EFAULT}] si sono specificati indirizzi non validi.
   \end{errlist}}
 \end{prototype}
@@ -1772,7 +1772,7 @@ dell'implementazione di \code{sleep} mostrata in
 fig.~\ref{fig:sig_sleep_incomplete}. In quel caso infatti se il segnale di
 allarme avesse interrotto un altro gestore questo non sarebbe stato eseguito
 correttamente; la cosa poteva essere prevenuta installando gli altri gestori
-usando \var{sa\_mask} per bloccare \const{SIGALRM} durante la loro esecuzione.
+usando \var{sa\_mask} per bloccare \signal{SIGALRM} durante la loro esecuzione.
 Il valore di \var{sa\_flag} permette di specificare vari aspetti del
 comportamento di \func{sigaction}, e della reazione del processo ai vari
 segnali; i valori possibili ed il relativo significato sono riportati in
@@ -1786,11 +1786,11 @@ tab.~\ref{tab:sig_sa_flag}.
     \textbf{Valore} & \textbf{Significato} \\
     \hline
     \hline
-    \const{SA\_NOCLDSTOP}& Se il segnale è \const{SIGCHLD} allora non deve
+    \const{SA\_NOCLDSTOP}& Se il segnale è \signal{SIGCHLD} allora non deve
                            essere notificato quando il processo figlio viene
-                           fermato da uno dei segnali \const{SIGSTOP},
-                           \const{SIGTSTP}, \const{SIGTTIN} o 
-                           \const{SIGTTOU}.\\
+                           fermato da uno dei segnali \signal{SIGSTOP},
+                           \signal{SIGTSTP}, \signal{SIGTTIN} o 
+                           \signal{SIGTTOU}.\\
     \const{SA\_RESETHAND}& Ristabilisce l'azione per il segnale al valore 
                            predefinito una volta che il gestore è stato
                            lanciato, riproduce cioè il comportamento della
@@ -1813,7 +1813,7 @@ tab.~\ref{tab:sig_sa_flag}.
                            gestore in forma estesa usando
                            \var{sa\_sigaction} al posto di
                            \var{sa\_handler}.\\
-    \const{SA\_NOCLDWAIT}& Se il segnale è \const{SIGCHLD} allora i processi
+    \const{SA\_NOCLDWAIT}& Se il segnale è \signal{SIGCHLD} allora i processi
                            figli non diventano \textit{zombie} quando
                            terminano.\footnotemark \\ 
     \hline
@@ -1836,7 +1836,7 @@ specificare, a seconda dell'uso o meno del flag \const{SA\_SIGINFO},
 rispettivamente attraverso i campi \var{sa\_sigaction} o
 \var{sa\_handler},\footnote{i due campi devono essere usati in maniera
   alternativa, in certe implementazioni questi campi vengono addirittura
-  definiti come \ctyp{union}.}  Quest'ultima è quella classica usata anche con
+  definiti come \direct{union}.}  Quest'ultima è quella classica usata anche con
 \func{signal}, mentre la prima permette di usare un gestore più complesso, in
 grado di ricevere informazioni più dettagliate dal sistema, attraverso la
 struttura \struct{siginfo\_t}, riportata in fig.~\ref{fig:sig_siginfo_t}.
@@ -1869,11 +1869,11 @@ in questo caso sono riportati in tab.~\ref{tab:sig_si_code_generic}.
 
 Nel caso di alcuni segnali però il valore di \var{si\_code} viene usato per
 fornire una informazione specifica relativa alle motivazioni della ricezione
-dello stesso; ad esempio i vari segnali di errore (\const{SIGILL},
-\const{SIGFPE}, \const{SIGSEGV} e \const{SIGBUS}) lo usano per fornire
+dello stesso; ad esempio i vari segnali di errore (\signal{SIGILL},
+\signal{SIGFPE}, \signal{SIGSEGV} e \signal{SIGBUS}) lo usano per fornire
 maggiori dettagli riguardo l'errore, come il tipo di errore aritmetico, di
 istruzione illecita o di violazione di memoria; mentre alcuni segnali di
-controllo (\const{SIGCHLD}, \const{SIGTRAP} e \const{SIGPOLL}) forniscono
+controllo (\signal{SIGCHLD}, \signal{SIGTRAP} e \signal{SIGPOLL}) forniscono
 altre informazioni specifiche.
 
 \begin{table}[!htb]
@@ -1896,7 +1896,7 @@ altre informazioni specifiche.
     \const{SI\_ASYNCIO}& una operazione di I/O asincrono (vedi
                          sez.~\ref{sec:file_asyncronous_access}) è stata
                          completata.\\
-    \const{SI\_SIGIO}  & segnale di \const{SIGIO} da una coda (vedi
+    \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}).\footnotemark\\ 
@@ -1973,22 +1973,22 @@ cui si sono appena citati i rispettivi segnali.\footnote{il prefisso del nome
     \hline
   \end{tabular}
   \caption{Valori del campo \var{si\_code} della struttura \struct{sigaction}
-    impostati rispettivamente dai segnali \const{SIGILL}, \const{SIGFPE},
-    \const{SIGSEGV}, \const{SIGBUS}, \const{SIGCHLD}, \const{SIGTRAP} e
-    \const{SIGPOLL}/\const{SIGIO}.}
+    impostati rispettivamente dai segnali \signal{SIGILL}, \signal{SIGFPE},
+    \signal{SIGSEGV}, \signal{SIGBUS}, \signal{SIGCHLD}, \signal{SIGTRAP} e
+    \signal{SIGPOLL}/\signal{SIGIO}.}
   \label{tab:sig_si_code_special}
 \end{table}
 
-Il resto della struttura \struct{siginfo\_t} è definito come \ctyp{union} ed i
-valori eventualmente presenti dipendono dal segnale, così \const{SIGCHLD} ed i
+Il resto della struttura \struct{siginfo\_t} è definito come \direct{union} ed i
+valori eventualmente presenti dipendono dal segnale, così \signal{SIGCHLD} ed i
 segnali \textit{real-time} (vedi sez.~\ref{sec:sig_real_time}) inviati tramite
 \func{kill} avvalorano \var{si\_pid} e \var{si\_uid} coi valori corrispondenti
-al processo che ha emesso il segnale, \const{SIGCHLD} avvalora anche i campi
+al processo che ha emesso il segnale, \signal{SIGCHLD} avvalora anche i campi
 \var{si\_status}, \var{si\_utime} e \var{si\_stime} che indicano
 rispettivamente lo stato di uscita, l'\textit{user time} e il \textit{system
   time} (vedi sez.~\ref{sec:sys_cpu_times}) usati dal processo;
-\const{SIGILL}, \const{SIGFPE}, \const{SIGSEGV} e \const{SIGBUS} avvalorano
-\var{si\_addr} con l'indirizzo in cui è avvenuto l'errore, \const{SIGIO} (vedi
+\signal{SIGILL}, \signal{SIGFPE}, \signal{SIGSEGV} e \signal{SIGBUS} avvalorano
+\var{si\_addr} con l'indirizzo in cui è avvenuto l'errore, \signal{SIGIO} (vedi
 sez.~\ref{sec:file_asyncronous_io}) avvalora \var{si\_fd} con il numero del
 file descriptor e \var{si\_band} per i \itindex{out-of-band} dati urgenti
 (vedi sez.~\ref{sec:TCP_urgent_data}) su un socket, il segnale inviato alla
@@ -2155,7 +2155,7 @@ sospensione del processo lo standard POSIX ha previsto la funzione
 Come esempio dell'uso di queste funzioni proviamo a riscrivere un'altra volta
 l'esempio di implementazione di \code{sleep}. Abbiamo accennato in
 sez.~\ref{sec:sig_sigaction} come con \func{sigaction} sia possibile bloccare
-\const{SIGALRM} nell'installazione dei gestori degli altri segnali, per poter
+\signal{SIGALRM} nell'installazione dei gestori degli altri segnali, per poter
 usare l'implementazione vista in fig.~\ref{fig:sig_sleep_incomplete} senza
 interferenze.  Questo però comporta una precauzione ulteriore al semplice uso
 della funzione, vediamo allora come usando la nuova interfaccia è possibile
@@ -2179,18 +2179,18 @@ 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
-l'opportuno gestore per \const{SIGALRM}, salvando quello originario, che
+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 \const{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
 fine (\texttt{\small 22}), e al contempo si prepara la maschera dei segnali
-\var{sleep\_mask} per riattivare \const{SIGALRM} all'esecuzione di
+\var{sleep\_mask} per riattivare \signal{SIGALRM} all'esecuzione di
 \func{sigsuspend}.  
 
 In questo modo non sono più possibili \itindex{race~condition} \textit{race
-  condition} dato che \const{SIGALRM} viene disabilitato con
+  condition} dato che \signal{SIGALRM} viene disabilitato con
 \func{sigprocmask} fino alla chiamata di \func{sigsuspend}.  Questo metodo è
 assolutamente generale e può essere applicato a qualunque altra situazione in
 cui si deve attendere per un segnale, i passi sono sempre i seguenti:
@@ -2309,10 +2309,11 @@ ulteriori funzioni in fig.~\ref{fig:sig_safe_functions_posix_2008}.
 Per questo motivo è opportuno mantenere al minimo indispensabile le operazioni
 effettuate all'interno di un gestore di segnali, qualora si debbano compiere
 operazioni complesse è sempre preferibile utilizzare la tecnica in cui si usa
-il gestore per impostare il valore di una qualche variabile globale, e poi si
-eseguono le operazioni complesse nel programma verificando (con tutti gli
-accorgimenti visti in precedenza) il valore di questa variabile tutte le volte
-che si è rilevata una interruzione dovuta ad un segnale.
+il gestore per impostare il valore di una qualche \index{variabili!globali}
+variabile globale, e poi si eseguono le operazioni complesse nel programma
+verificando (con tutti gli accorgimenti visti in precedenza) il valore di
+questa variabile tutte le volte che si è rilevata una interruzione dovuta ad
+un segnale.
 
 
 \section{Funzionalità avanzate}
@@ -2433,7 +2434,7 @@ per la restituzione dei dati viene usato il campo \var{si\_value}.
   \label{fig:sig_sigval}
 \end{figure}
 
-Questo è una \ctyp{union} di tipo \struct{sigval} (la sua definizione è in
+Questo è 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
 \var{sival\_ptr}. L'unione viene usata dai segnali \textit{real-time} e da
@@ -2972,7 +2973,7 @@ effettuata. Diventa così possibile indicare l'uso di un segnale o l'esecuzione
                              segnale è stato installato con
                              \const{SA\_SIGINFO} gli verrà restituito il
                              valore specificato con \var{sigev\_value} (una
-                             \ctyp{union} \texttt{sigval}, la cui definizione
+                             \direct{union} \texttt{sigval}, la cui definizione
                              è in fig.~\ref{fig:sig_sigval}) come valore del
                              campo \var{si\_value} di \struct{siginfo\_t}.\\
     \const{SIGEV\_THREAD}  & La notifica viene effettuata creando un nuovo
@@ -3008,9 +3009,9 @@ 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
 cui si vuole essere notificati della scadenza del timer, se non si specifica
 nulla (passando un valore \val{NULL}) verrà inviato il segnale
-\const{SIGALRM} al processo corrente, o per essere più precisi verrà
+\signal{SIGALRM} al processo corrente, o per essere più precisi verrà
 utilizzato un valore equivalente all'aver specificato \const{SIGEV\_SIGNAL}
-per \var{sigev\_notify}, \const{SIGALRM} per \var{sigev\_signo} e
+per \var{sigev\_notify}, \signal{SIGALRM} per \var{sigev\_signo} e
 l'identificatore del timer come valore per \var{sigev\_value.sival\_int}.
 
 Il terzo argomento deve essere l'indirizzo di una variabile di tipo
@@ -3329,7 +3330,7 @@ segnali quando si teme di avere problemi di esaurimento dello \textit{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
+segnale di \signal{SIGSEGV}, che potrebbe essere gestito soltanto avendo
 abilitato uno \itindex{stack} \textit{stack} alternativo.
 
 Si tenga presente che le funzioni chiamate durante l'esecuzione sullo
index 8d47429..29df12b 100644 (file)
@@ -1947,7 +1947,7 @@ Il quarto argomento, \param{optval} è un puntatore ad una zona di memoria che
 contiene i dati che specificano il valore dell'opzione che si vuole passare al
 socket, mentre l'ultimo argomento \param{optlen},\footnote{questo argomento è
   in realtà sempre di tipo \ctyp{int}, come era nelle \acr{libc4} e
-  \acr{libc5}; l'uso di \ctyp{socklen\_t} è stato introdotto da POSIX (valgono
+  \acr{libc5}; l'uso di \type{socklen\_t} è stato introdotto da POSIX (valgono
   le stesse considerazioni per l'uso di questo tipo di dato fatte in
   sez.~\ref{sec:TCP_func_accept}) ed adottato dalle \acr{glibc}.} è la
 dimensione in byte dei dati presenti all'indirizzo indicato da \param{optval}.
@@ -3581,8 +3581,8 @@ identificano le operazioni sono le seguenti:
     accennato in sez.~\ref{sec:net_tcp}.} dei pacchetti sulla rete.
 
 \item[\const{SIOCSPGRP}] imposta il processo o il \itindex{process~group}
-  \textit{process group} a cui inviare i segnali \const{SIGIO} e
-  \const{SIGURG} quando viene completata una operazione di I/O asincrono o
+  \textit{process group} a cui inviare i segnali \signal{SIGIO} e
+  \signal{SIGURG} quando viene completata una operazione di I/O asincrono o
   arrivano dei dati urgenti \itindex{out-of-band} (\texttt{out-of-band}). Il
   terzo argomento deve essere un puntatore ad una variabile di tipo
   \type{pid\_t}; un valore positivo indica direttamente il \acr{pid} del
@@ -3593,15 +3593,15 @@ identificano le operazioni sono le seguenti:
 
 \item[\const{SIOCGPGRP}] legge le impostazioni presenti sul socket
   relativamente all'eventuale processo o \itindex{process~group}
-  \textit{process group} cui devono essere inviati i segnali \const{SIGIO} e
-  \const{SIGURG}. Come per \const{SIOCSPGRP} l'argomento passato deve un
+  \textit{process group} cui devono essere inviati i segnali \signal{SIGIO} e
+  \signal{SIGURG}. Come per \const{SIOCSPGRP} l'argomento passato deve un
   puntatore ad una variabile di tipo \type{pid\_t}, con lo stesso significato.
   Qualora non sia presente nessuna impostazione verrà restituito un valore
   nullo.
 
 \item[\const{FIOASYNC}] Abilita o disabilita la modalità di I/O asincrono sul
   socket. Questo significa (vedi sez.~\ref{sec:file_asyncronous_operation})
-  che verrà inviato il segnale di \const{SIGIO} (o quanto impostato con
+  che verrà inviato il segnale di \signal{SIGIO} (o quanto impostato con
   \const{F\_SETSIG}, vedi sez.~\ref{sec:file_fcntl}) in caso di eventi di I/O
   sul socket.
 \end{basedescript}
@@ -3643,7 +3643,7 @@ il primo campo della struttura, \var{ifr\_name} per specificare il nome
 dell'interfaccia su cui si vuole operare (ad esempio \texttt{eth0},
 \texttt{ppp0}, ecc.), e si inseriscono (o ricevono) i valori relativi alle
 diversa caratteristiche e funzionalità nel secondo campo, che come si può
-notare è definito come una \ctyp{union} proprio in quanto il suo significato
+notare è definito come una \direct{union} proprio in quanto il suo significato
 varia a secondo dell'operazione scelta.
 
 Si tenga inoltre presente che alcune di queste operazioni (in particolare
@@ -3843,7 +3843,7 @@ questo buffer deve essere specificata nel campo \var{ifc\_len} di
 \var{ifc\_req}. Qualora il buffer sia stato allocato come una stringa, il suo
 indirizzo potrà essere fornito usando il campo \var{ifc\_buf}.\footnote{si
   noti che l'indirizzo del buffer è definito in \struct{ifconf} con una
-  \ctyp{union}, questo consente di utilizzare una delle due forme a piacere.}
+  \direct{union}, questo consente di utilizzare una delle due forme a piacere.}
 
 La funzione restituisce nel buffer indicato una serie di strutture
 \struct{ifreq} contenenti nel campo \var{ifr\_name} il nome dell'interfaccia e
index 70b7f0b..cd62e7c 100644 (file)
@@ -1496,7 +1496,7 @@ fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
                               \errcode{ENOMEM}, mentre se il superamento viene
                               causato dalla crescita dello \itindex{stack}
                               \textit{stack} il processo riceverà un segnale di
-                              \const{SIGSEGV}.\\  
+                              \signal{SIGSEGV}.\\  
     \const{RLIMIT\_CORE}   &  La massima dimensione per di un file di
                               \itindex{core~dump} \textit{core dump} (vedi
                               sez.~\ref{sec:sig_prog_error}) creato nella
@@ -1508,13 +1508,13 @@ fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
                               sez.~\ref{sec:sys_cpu_times}) che il processo può
                               usare. Il superamento del limite corrente
                               comporta l'emissione di un segnale di
-                              \const{SIGXCPU}, la cui azione predefinita (vedi
+                              \signal{SIGXCPU}, la cui azione predefinita (vedi
                               sez.~\ref{sec:sig_classification}) è terminare
                               il processo, una volta al secondo fino al
                               raggiungimento del limite massimo. Il
                               superamento del limite massimo 
                               comporta l'emissione di un segnale di
-                              \const{SIGKILL}.\footnotemark\\
+                              \signal{SIGKILL}.\footnotemark\\
     \const{RLIMIT\_DATA}   &  La massima dimensione del \index{segmento!dati}
                               segmento dati di un 
                               processo (vedi sez.~\ref{sec:proc_mem_layout}).
@@ -1525,7 +1525,7 @@ fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
     \const{RLIMIT\_FSIZE}  &  La massima dimensione di un file che un processo
                               può creare. Se il processo cerca di scrivere
                               oltre questa dimensione riceverà un segnale di
-                              \const{SIGXFSZ}, che di norma termina il
+                              \signal{SIGXFSZ}, che di norma termina il
                               processo; se questo viene intercettato la
                               system call che ha causato l'errore fallirà con
                               un errore di \errcode{EFBIG}.\\
@@ -1568,7 +1568,7 @@ fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
                               \textit{stack} del processo. Se il processo
                               esegue operazioni che estendano lo
                               \textit{stack} oltre questa dimensione 
-                              riceverà un segnale di \const{SIGSEGV}.\\
+                              riceverà un segnale di \signal{SIGSEGV}.\\
     \const{RLIMIT\_RSS}    &  L'ammontare massimo di pagine di memoria dato al
                               \index{segmento!testo} testo del processo. Il
                               limite è solo una indicazione per il kernel,
@@ -1587,7 +1587,7 @@ fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
   oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
   avviene quando viene superato il \textit{soft limit}; perciò per avere
   operazioni portabili è sempre opportuno intercettare il primo
-  \const{SIGXCPU} e terminare in maniera ordinata il processo.}
+  \signal{SIGXCPU} e terminare in maniera ordinata il processo.}
 
 \footnotetext{il limite su questa risorsa è stato introdotto con il kernel
   2.6.8.}
@@ -2326,10 +2326,11 @@ restituita la conversione.
 Come mostrato in fig.~\ref{fig:sys_tm_struct} il \textit{broken-down time}
 permette di tenere conto anche della differenza fra tempo universale e ora
 locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
-variabili globali mostrate in fig.~\ref{fig:sys_tzname}, cui si accede quando
-si include \file{time.h}. Queste variabili vengono impostate quando si chiama
-una delle precedenti funzioni di conversione, oppure invocando direttamente la
-funzione \funcd{tzset}, il cui prototipo è:
+\index{variabili!globali} variabili globali mostrate in
+fig.~\ref{fig:sys_tzname}, cui si accede quando si include
+\file{time.h}. Queste variabili vengono impostate quando si chiama una delle
+precedenti funzioni di conversione, oppure invocando direttamente la funzione
+\funcd{tzset}, il cui prototipo è:
 \begin{prototype}{sys/timex.h}
 {void tzset(void)} 
   
@@ -2349,8 +2350,8 @@ verrà usato il file \conffile{/etc/localtime}.
     \includestruct{listati/time_zone_var.c}
   \end{minipage} 
   \normalsize 
-  \caption{Le variabili globali usate per la gestione delle \textit{time
-      zone}.}  
+  \caption{Le \index{variabili!globali} variabili globali usate per la
+    gestione delle \textit{time zone}.}
   \label{fig:sys_tzname}
 \end{figure}
 
@@ -2465,12 +2466,12 @@ c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
 costante \val{EOF} (a seconda della funzione); ma questo valore segnala solo
 che c'è stato un errore, non il tipo di errore.
 
-Per riportare il tipo di errore il sistema usa la variabile globale
-\var{errno},\footnote{l'uso di una variabile globale può comportare alcuni
-  problemi (ad esempio nel caso dei \itindex{thread} \textit{thread}) ma lo
-  standard ISO C consente anche di definire \var{errno} come un
-  \textit{modifiable lvalue}, quindi si può anche usare una macro, e questo è
-  infatti il modo usato da Linux per renderla locale ai singoli
+Per riportare il tipo di errore il sistema usa \index{variabili!globali} la
+variabile globale \var{errno},\footnote{l'uso di una variabile globale può
+  comportare alcuni problemi (ad esempio nel caso dei \itindex{thread}
+  \textit{thread}) ma lo standard ISO C consente anche di definire \var{errno}
+  come un \textit{modifiable lvalue}, quindi si può anche usare una macro, e
+  questo è infatti il modo usato da Linux per renderla locale ai singoli
   \itindex{thread} \textit{thread}.}  definita nell'header \file{errno.h}; la
 variabile è in genere definita come \direct{volatile} dato che può essere
 cambiata in modo asincrono da un segnale (si veda sez.~\ref{sec:sig_sigchld}
@@ -2579,7 +2580,8 @@ riferiscono all'ultimo errore avvenuto. La stringa specificata con
 \param{message} viene stampato prima del messaggio d'errore, seguita dai due
 punti e da uno spazio, il messaggio è terminato con un a capo.
 
-Il messaggio può essere riportato anche usando le due variabili globali:
+Il messaggio può essere riportato anche usando le due
+\index{variabili!globali} variabili globali:
 \includecodesnip{listati/errlist.c} 
 dichiarate in \file{errno.h}. La prima contiene i puntatori alle stringhe di
 errore indicizzati da \var{errno}; la seconda esprime il valore più alto per
@@ -2648,8 +2650,9 @@ l'argomento \param{format} prende la stessa sintassi di \func{printf}, ed i
 relativi argomenti devono essere forniti allo stesso modo, mentre
 \param{errnum} indica l'errore che si vuole segnalare (non viene quindi usato
 il valore corrente di \var{errno}); la funzione stampa sullo standard error il
-nome del programma, come indicato dalla variabile globale \var{program\_name},
-seguito da due punti ed uno spazio, poi dalla stringa generata da
+nome del programma, come indicato dalla \index{variabili!globali} variabile
+globale \var{program\_name}, seguito da due punti ed uno spazio, poi dalla
+stringa generata da
 \param{format} e dagli argomenti seguenti, seguita da due punti ed uno spazio
 infine il messaggio di errore relativo ad \param{errnum}, il tutto è terminato
 da un a capo.
@@ -2663,8 +2666,8 @@ L'argomento \param{status} può essere usato per terminare direttamente il
 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
-un'altra variabile globale, \var{error\_message\_count}, che tiene conto di
-quanti errori ci sono stati.
+un'altra \index{variabili!globali} variabile globale,
+\var{error\_message\_count}, che tiene conto di quanti errori ci sono stati.
 
 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
@@ -2680,9 +2683,10 @@ Stampa un messaggio di errore formattato.
 \noindent ed il suo comportamento è identico a quello di \func{error} se non
 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
-stampa del nome del programma. Inoltre essa usa un'altra variabile globale,
-\var{error\_one\_per\_line}, che impostata ad un valore diverso da zero fa si
-che errori relativi alla stessa linea non vengano ripetuti.
+stampa del nome del programma. Inoltre essa usa un'altra
+\index{variabili!globali} variabile globale, \var{error\_one\_per\_line}, che
+impostata ad un valore diverso da zero fa si che errori relativi alla stessa
+linea non vengano ripetuti.
 
 
 % LocalWords:  filesystem like kernel saved header limits sysconf sez tab float
index c896d44..695603e 100644 (file)
@@ -2035,7 +2035,7 @@ quando affronteremo il comportamento in caso di conclusioni anomale:
 Tutto questo riguarda la connessione, c'è però da tenere conto dell'effetto
 del procedimento di chiusura del processo figlio nel server (si veda quanto
 esaminato in sez.~\ref{sec:proc_termination}). In questo caso avremo l'invio
-del segnale \const{SIGCHLD} al padre, ma dato che non si è installato un
+del segnale \signal{SIGCHLD} al padre, ma dato che non si è installato un
 gestore e che l'azione predefinita per questo segnale è quella di essere
 ignorato, non avendo predisposto la ricezione dello stato di terminazione,
 otterremo che il processo figlio entrerà nello stato di \index{zombie} zombie
@@ -2048,7 +2048,7 @@ ripetendo il comando \cmd{ps}:
 
 Dato che non è il caso di lasciare processi \index{zombie} zombie, occorrerà
 ricevere opportunamente lo stato di terminazione del processo (si veda
-sez.~\ref{sec:proc_wait}), cosa che faremo utilizzando \const{SIGCHLD} secondo
+sez.~\ref{sec:proc_wait}), cosa che faremo utilizzando \signal{SIGCHLD} secondo
 quanto illustrato in sez.~\ref{sec:sig_sigchld}. Una prima modifica al nostro
 server è pertanto quella di inserire la gestione della terminazione dei
 processi figli attraverso l'uso di un gestore.  Per questo useremo la funzione
@@ -2069,7 +2069,7 @@ di \errcode{EINTR}.
 
 Vediamo allora cosa comporta tutto questo nel nostro caso: quando si chiude il
 client, il processo figlio che gestisce la connessione terminerà, ed il padre,
-per evitare la creazione di zombie, riceverà il segnale \const{SIGCHLD}
+per evitare la creazione di zombie, riceverà il segnale \signal{SIGCHLD}
 eseguendo il relativo gestore. Al ritorno del gestore però l'esecuzione nel
 padre ripartirà subito con il ritorno della funzione \func{accept} (a meno di
 un caso fortuito in cui il segnale arriva durante l'esecuzione del programma
@@ -2136,7 +2136,7 @@ codice completo di quest'ultimo si trova nel file
 
 La prima modifica effettuata è stata quella di introdurre una nuova opzione a
 riga di comando, \texttt{-c}, che permette di richiedere il comportamento
-compatibile nella gestione di \const{SIGCHLD} al posto della semantica BSD
+compatibile nella gestione di \signal{SIGCHLD} al posto della semantica BSD
 impostando la variabile \var{compat} ad un valore non nullo. Questa è
 preimpostata al valore nullo, cosicché se non si usa questa opzione il
 comportamento di default del server è di usare la semantica BSD. 
@@ -2165,7 +2165,7 @@ programma.
 
 Vediamo allora come è cambiato il nostro server; una volta definite le
 variabili e trattate le opzioni il primo passo (\texttt{\small 9--13}) è
-verificare la semantica scelta per la gestione di \const{SIGCHLD}, a seconda
+verificare la semantica scelta per la gestione di \signal{SIGCHLD}, a seconda
 del valore di \var{compat} (\texttt{\small 9}) si installa il gestore con la
 funzione \func{Signal} (\texttt{\small 10}) o con \texttt{SignalRestart}
 (\texttt{\small 12}), essendo quest'ultimo il valore di default.
@@ -2182,13 +2182,13 @@ numero di secondi da aspettare (il valore preimpostato è nullo).
 
 Si è potuto lasciare inalterata tutta la sezione di creazione del socket
 perché nel server l'unica chiamata ad una system call lenta, che può essere
-interrotta dall'arrivo di \const{SIGCHLD}, è quella ad \func{accept}, che è
+interrotta dall'arrivo di \signal{SIGCHLD}, è quella ad \func{accept}, che è
 l'unica funzione che può mettere il processo padre in stato di sleep nel
 periodo in cui un figlio può terminare; si noti infatti come le altre
 \index{system~call~lente} \textit{slow system call}\footnote{si ricordi la
   distinzione fatta in sez.~\ref{sec:sig_gen_beha}.} o sono chiamate prima di
 entrare nel ciclo principale, quando ancora non esistono processi figli, o
-sono chiamate dai figli stessi e non risentono di \const{SIGCHLD}.
+sono chiamate dai figli stessi e non risentono di \signal{SIGCHLD}.
 
 Per questo l'unica modifica sostanziale nel ciclo principale (\texttt{\small
   23--42}), rispetto precedente versione di fig.~\ref{fig:TCP_ServEcho_first},
@@ -2291,7 +2291,7 @@ stata accettata dal programma.
 
 Questo significa che, oltre alla interruzione da parte di un segnale, che
 abbiamo trattato in sez.~\ref{sec:TCP_child_hand} nel caso particolare di
-\const{SIGCHLD}, si possono ricevere altri errori non fatali all'uscita di
+\signal{SIGCHLD}, si possono ricevere altri errori non fatali all'uscita di
 \func{accept}, che come nel caso precedente, necessitano semplicemente la
 ripetizione della chiamata senza che si debba uscire dal programma. In questo
 caso anche la versione modificata del nostro server non sarebbe adatta, in
@@ -2420,7 +2420,7 @@ pacchetto.  Questo causerà la ricezione dell'eco nel client che lo stamperà a
 video.
 
 A questo punto noi procediamo ad interrompere l'esecuzione del server con un
-\texttt{C-c} (cioè con l'invio di \const{SIGTERM}): nel momento in cui
+\texttt{C-c} (cioè con l'invio di \signal{SIGTERM}): nel momento in cui
 facciamo questo vengono immediatamente generati altri due pacchetti. La
 terminazione del processo infatti comporta la chiusura di tutti i suoi file
 descriptor, il che comporta, per il socket che avevamo aperto, l'inizio della
@@ -2491,7 +2491,7 @@ flusso dei dati, dal punto di vista del funzionamento nei confronti delle
 funzioni di lettura e scrittura, i socket sono del tutto analoghi a delle
 pipe. Allora, da quanto illustrato in sez.~\ref{sec:ipc_pipes}, sappiamo che
 tutte le volte che si cerca di scrivere su una pipe il cui altro capo non è
-aperto il lettura il processo riceve un segnale di \const{SIGPIPE}, e questo è
+aperto il lettura il processo riceve un segnale di \signal{SIGPIPE}, e questo è
 esattamente quello che avviene in questo caso, e siccome non abbiamo un
 gestore per questo segnale, viene eseguita l'azione preimpostata, che è quella
 di terminare il processo.
@@ -2826,7 +2826,7 @@ pronto per la scrittura sono le seguenti:
   bloccherà e restituirà un valore positivo pari al numero di byte accettati
   dal livello di trasporto.
 \item il lato in scrittura della connessione è stato chiuso. In questo caso
-  una operazione di scrittura sul socket genererà il segnale \const{SIGPIPE}.
+  una operazione di scrittura sul socket genererà il segnale \signal{SIGPIPE}.
 \item c'è stato un errore sul socket. In questo caso una operazione di
   scrittura non si bloccherà ma restituirà una condizione di errore ed
   imposterà opportunamente la variabile \var{errno}. Vedremo in