X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=ipc.tex;h=abe229a50538d4ffb8bd31449eba60c6f15f43a2;hp=2b34ded891023126f13b8cc841b3cb6105af8fd8;hb=8e03e6dab3729b15c924991f2f4a59079d7e53d7;hpb=7f880b411dd147595d2309696cf56f3f7bc37d01

diff --git a/ipc.tex b/ipc.tex
index 2b34ded..abe229a 100644
--- a/ipc.tex
+++ b/ipc.tex
@@ -1,6 +1,6 @@
 %% ipc.tex
 %%
-%% Copyright (C) 2000-2014 Simone Piccardi.  Permission is granted to
+%% Copyright (C) 2000-2015 Simone Piccardi.  Permission is granted to
 %% copy, distribute and/or modify this document under the terms of the GNU Free
 %% Documentation License, Version 1.1 or any later version published by the
 %% Free Software Foundation; with the Invariant Sections being "Un preambolo",
@@ -122,7 +122,7 @@ fra \const{O\_NONBLOCK} o \const{O\_CLOEXEC} che hanno l'effetto di impostare
 su entrambi i file descriptor restituiti dalla funzione i relativi flag, già
 descritti per \func{open} in tab.~\ref{tab:open_operation_flag}, che attivano
 rispettivamente la modalità di accesso \textsl{non-bloccante} ed il
-\textit{close-on-exec} \itindex{close-on-exec}.
+\textit{close-on-exec}.
 
 Chiaramente creare una \textit{pipe} all'interno di un singolo processo non
 serve a niente; se però ricordiamo quanto esposto in
@@ -258,7 +258,7 @@ trova nella directory dei sorgenti.
   \label{fig:ipc_barcodepage_code}
 \end{figure}
 
-La prima operazione del programma (\texttt{\small 4--12}) è quella di creare
+La prima operazione del programma (\texttt{\small 4-12}) è quella di creare
 le due \textit{pipe} che serviranno per la comunicazione fra i due comandi
 utilizzati per produrre il codice a barre; si ha cura di controllare la
 riuscita della chiamata, inviando in caso di errore un messaggio invece
@@ -269,8 +269,8 @@ formattare l'uscita alla maniera dei CGI, aggiungendo l'opportuno
 quest'ultimo possa essere visualizzato correttamente da un browser.
 
 Una volta create le \textit{pipe}, il programma può creare (\texttt{\small
-  13--17}) il primo processo figlio, che si incaricherà (\texttt{\small
-  19--25}) di eseguire \cmd{barcode}. Quest'ultimo legge dallo standard input
+  13-17}) il primo processo figlio, che si incaricherà (\texttt{\small
+  19-25}) di eseguire \cmd{barcode}. Quest'ultimo legge dallo standard input
 una stringa di caratteri, la converte nell'immagine PostScript del codice a
 barre ad essa corrispondente, e poi scrive il risultato direttamente sullo
 standard output.
@@ -306,7 +306,7 @@ Alla conclusione della sua esecuzione \cmd{barcode} avrà inviato l'immagine
 PostScript del codice a barre sul capo in scrittura della seconda
 \textit{pipe}; a questo punto si può eseguire la seconda conversione, da PS a
 JPEG, usando il programma \cmd{gs}. Per questo si crea (\texttt{\small
-  30--34}) un secondo processo figlio, che poi (\texttt{\small 35--42})
+  30-34}) un secondo processo figlio, che poi (\texttt{\small 35-42})
 eseguirà questo programma leggendo l'immagine PostScript creata da
 \cmd{barcode} dallo \textit{standard input}, per convertirla in JPEG.
 
@@ -369,8 +369,8 @@ La funzione restituisce il puntatore ad uno stream associato alla
   input}) in caso di \code{w}. A partire dalla versione 2.9 delle \acr{glibc}
 (questa è una estensione specifica di Linux) all'argomento \param{type} può
 essere aggiunta la lettera ``\texttt{e}'' per impostare automaticamente il
-flag di \textit{close-on-exec} \itindex{close-on-exec} sul file descriptor
-sottostante (si ricordi quanto spiegato in sez.~\ref{sec:file_open_close}).
+flag di \textit{close-on-exec} sul file descriptor sottostante (si ricordi
+quanto spiegato in sez.~\ref{sec:file_open_close}).
 
 Lo \textit{stream} restituito da \func{popen} è identico a tutti gli effetti
 ai \textit{file stream} visti in sez.~\ref{sec:files_std_interface}, anche se
@@ -468,7 +468,7 @@ padre non necessita più di eseguire ulteriori operazioni sullo
 \textit{standard output} e può tranquillamente provvedere alla redirezione.
 
 Dato che i vari programmi devono essere lanciati in successione, si è
-approntato un ciclo (\texttt{\small 15--19}) che esegue le operazioni in
+approntato un ciclo (\texttt{\small 15-19}) che esegue le operazioni in
 sequenza: prima crea una \textit{pipe} (\texttt{\small 17}) per la scrittura
 eseguendo il programma con \func{popen}, in modo che essa sia collegata allo
 \textit{standard input}, e poi redirige (\texttt{\small 18}) lo
@@ -484,7 +484,7 @@ Alla fine tutto quello che resta da fare è lanciare (\texttt{\small 21}) il
 primo processo della catena, che nel caso è \cmd{barcode}, e scrivere
 (\texttt{\small 23}) la stringa del codice a barre sulla \textit{pipe}, che è
 collegata al suo \textit{standard input}, infine si può eseguire
-(\texttt{\small 24--27}) un ciclo che chiuda con \func{pclose}, nell'ordine
+(\texttt{\small 24-27}) un ciclo che chiuda con \func{pclose}, nell'ordine
 inverso rispetto a quello in cui le si sono create, tutte le \textit{pipe}
 create in precedenza.
 
@@ -622,7 +622,7 @@ dell'insieme delle frasi non nulla, dato che l'inizializzazione del vettore
 \var{fortune} avviene solo quando questa dimensione viene specificata, la
 presenza di un valore nullo provoca l'uscita dal programma attraverso la
 funzione (non riportata) che ne stampa le modalità d'uso.  Dopo di che
-installa (\texttt{\small 13--15}) la funzione che gestisce i segnali di
+installa (\texttt{\small 13-15}) la funzione che gestisce i segnali di
 interruzione (anche questa non è riportata in fig.~\ref{fig:ipc_fifo_server})
 che si limita a rimuovere dal filesystem la \textit{fifo} usata dal server per
 comunicare.
@@ -634,7 +634,7 @@ dinamicamente la memoria necessaria) nel vettore di puntatori \var{fortune}.
 Anche il codice della funzione non è riportato, in quanto non direttamente
 attinente allo scopo dell'esempio.
 
-Il passo successivo (\texttt{\small 17--22}) è quello di creare con
+Il passo successivo (\texttt{\small 17-22}) è quello di creare con
 \func{mkfifo} la \textit{fifo} nota sulla quale il server ascolterà le
 richieste, qualora si riscontri un errore il server uscirà (escludendo
 ovviamente il caso in cui la funzione \func{mkfifo} fallisce per la precedente
@@ -644,7 +644,7 @@ Una volta che si è certi che la \textit{fifo} di ascolto esiste la procedura
 di inizializzazione è completata. A questo punto (\texttt{\small 23}) si può
 chiamare la funzione \func{daemon} per far proseguire l'esecuzione del
 programma in background come demone.  Si può quindi procedere (\texttt{\small
-  24--33}) alla apertura della \textit{fifo}: si noti che questo viene fatto
+  24-33}) alla apertura della \textit{fifo}: si noti che questo viene fatto
 due volte, prima in lettura e poi in scrittura, per evitare di dover gestire
 all'interno del ciclo principale il caso in cui il server è in ascolto ma non
 ci sono client che effettuano richieste.  Si ricordi infatti che quando una
@@ -667,31 +667,31 @@ una singola apertura con \const{O\_RDWR}; la doppia apertura comunque ha il
 vantaggio che non si può scrivere per errore sul capo aperto in sola lettura.
 
 Per questo motivo, dopo aver eseguito l'apertura in lettura (\texttt{\small
-  24--28}),\footnote{di solito si effettua l'apertura del capo in lettura di
+  24-28}),\footnote{di solito si effettua l'apertura del capo in lettura di
   una \textit{fifo} in modalità non bloccante, per evitare il rischio di uno
   stallo: se infatti nessuno apre la \textit{fifo} in scrittura il processo
   non ritornerà mai dalla \func{open}. Nel nostro caso questo rischio non
   esiste, mentre è necessario potersi bloccare in lettura in attesa di una
   richiesta.}  si esegue una seconda apertura in scrittura (\texttt{\small
-  29--32}), scartando il relativo file descriptor, che non sarà mai usato, in
+  29-32}), scartando il relativo file descriptor, che non sarà mai usato, in
 questo modo però la \textit{fifo} resta comunque aperta anche in scrittura,
 cosicché le successive chiamate a \func{read} possono bloccarsi.
 
 A questo punto si può entrare nel ciclo principale del programma che fornisce
-le risposte ai client (\texttt{\small 34--50}); questo viene eseguito
+le risposte ai client (\texttt{\small 34-50}); questo viene eseguito
 indefinitamente (l'uscita del server viene effettuata inviando un segnale, in
 modo da passare attraverso la funzione di chiusura che cancella la
 \textit{fifo}).
 
 Il server è progettato per accettare come richieste dai client delle stringhe
 che contengono il nome della \textit{fifo} sulla quale deve essere inviata la
-risposta.  Per cui prima (\texttt{\small 35--39}) si esegue la lettura dalla
+risposta.  Per cui prima (\texttt{\small 35-39}) si esegue la lettura dalla
 stringa di richiesta dalla \textit{fifo} nota (che a questo punto si bloccherà
 tutte le volte che non ci sono richieste). Dopo di che, una volta terminata la
 stringa (\texttt{\small 40}) e selezionato (\texttt{\small 41}) un numero
 casuale per ricavare la frase da inviare, si procederà (\texttt{\small
-  42--46}) all'apertura della \textit{fifo} per la risposta, che poi 
-(\texttt{\small 47--48}) vi sarà scritta. Infine (\texttt{\small 49}) si
+  42-46}) all'apertura della \textit{fifo} per la risposta, che poi 
+(\texttt{\small 47-48}) vi sarà scritta. Infine (\texttt{\small 49}) si
 chiude la \textit{fifo} di risposta che non serve più.
 
 Il codice del client è invece riportato in fig.~\ref{fig:ipc_fifo_client},
@@ -714,18 +714,18 @@ principale del programma e le definizioni delle variabili. Il codice completo
 La prima istruzione (\texttt{\small 12}) compone il nome della \textit{fifo}
 che dovrà essere utilizzata per ricevere la risposta dal server.  Si usa il
 \ids{PID} del processo per essere sicuri di avere un nome univoco; dopo di che
-(\texttt{\small 13--18}) si procede alla creazione del relativo file, uscendo
+(\texttt{\small 13-18}) si procede alla creazione del relativo file, uscendo
 in caso di errore (a meno che il file non sia già presente sul filesystem).
 
 A questo punto il client può effettuare l'interrogazione del server, per
-questo prima si apre la \textit{fifo} nota (\texttt{\small 19--23}), e poi ci
+questo prima si apre la \textit{fifo} nota (\texttt{\small 19-23}), e poi ci
 si scrive (\texttt{\small 24}) la stringa composta in precedenza, che contiene
 il nome della \textit{fifo} da utilizzare per la risposta. Infine si richiude
 la \textit{fifo} del server che a questo punto non serve più (\texttt{\small
   25}). 
 
 Inoltrata la richiesta si può passare alla lettura della risposta; anzitutto
-si apre (\texttt{\small 26--30}) la \textit{fifo} appena creata, da cui si
+si apre (\texttt{\small 26-30}) la \textit{fifo} appena creata, da cui si
 deve riceverla, dopo di che si effettua una lettura (\texttt{\small 31})
 nell'apposito buffer; si è supposto, come è ragionevole, che le frasi inviate
 dal server siano sempre di dimensioni inferiori a \const{PIPE\_BUF},
@@ -1075,8 +1075,7 @@ direttamente (in lettura o scrittura) all'oggetto. In tal caso lo schema dei
 controlli è simile a quello dei file, ed avviene secondo questa sequenza:
 \begin{itemize*}
 \item se il processo ha i privilegi di amministratore (più precisamente la
-  capacità \itindex{capability} \const{CAP\_IPC\_OWNER}) l'accesso è sempre
-  consentito.
+  capacità \const{CAP\_IPC\_OWNER}) l'accesso è sempre consentito.
 \item se l'\ids{UID} effettivo del processo corrisponde o al valore del campo
   \var{cuid} o a quello del campo \var{uid} ed il permesso per il proprietario
   in \var{mode} è appropriato\footnote{per appropriato si intende che è
@@ -1171,7 +1170,7 @@ di creazione, stampa, cancellazione.
 
 I valori di default sono per l'uso delle code di messaggi e per 5 ripetizioni
 del ciclo. Per questo motivo se non si utilizzano opzioni verrà eseguito per
-cinque volte il ciclo (\texttt{\small 7--11}), in cui si crea una coda di
+cinque volte il ciclo (\texttt{\small 7-11}), in cui si crea una coda di
 messaggi (\texttt{\small 8}), se ne stampa l'identificativo (\texttt{\small
   9}) e la si rimuove (\texttt{\small 10}). Non stiamo ad approfondire adesso
 il significato delle funzioni utilizzate, che verranno esaminate nelle
@@ -1451,9 +1450,9 @@ per \param{cmd} sono:
   occorre essere il proprietario o il creatore della coda, oppure
   l'amministratore e lo stesso vale per \var{msg\_qbytes}. Infine solo
   l'amministratore (più precisamente un processo con la capacità
-  \itindex{capability} \const{CAP\_IPC\_RESOURCE}) ha la facoltà di
-  incrementarne il valore a limiti superiori a \const{MSGMNB}. Se eseguita con
-  successo la funzione aggiorna anche il campo \var{msg\_ctime}.
+  \const{CAP\_IPC\_RESOURCE}) ha la facoltà di incrementarne il valore a
+  limiti superiori a \const{MSGMNB}. Se eseguita con successo la funzione
+  aggiorna anche il campo \var{msg\_ctime}.
 \end{basedescript}
 
 A questi tre valori, che sono quelli previsti dallo standard, su Linux se ne
@@ -1699,13 +1698,13 @@ messaggi sulla base del loro tipo.
 Il programma, oltre alle solite variabili per il nome del file da cui leggere
 le \textit{fortunes} e per il vettore di stringhe che contiene le frasi,
 definisce due strutture appositamente per la comunicazione; con
-\var{msgbuf\_read} vengono passate (\texttt{\small 8--11}) le richieste mentre
-con \var{msgbuf\_write} vengono restituite (\texttt{\small 12--15}) le frasi.
+\var{msgbuf\_read} vengono passate (\texttt{\small 8-11}) le richieste mentre
+con \var{msgbuf\_write} vengono restituite (\texttt{\small 12-15}) le frasi.
 
 La gestione delle opzioni si è al solito omessa, essa si curerà di impostare
 nella variabile \var{n} il numero di frasi da leggere specificato a linea di
 comando ed in \var{fortunefilename} il file da cui leggerle. Dopo aver
-installato (\texttt{\small 19--21}) i gestori dei segnali per trattare
+installato (\texttt{\small 19-21}) i gestori dei segnali per trattare
 l'uscita dal server, viene prima controllato (\texttt{\small 22}) il numero di
 frasi richieste abbia senso (cioè sia maggiore di zero), le quali poi vengono
 lette (\texttt{\small 23}) nel vettore in memoria con la stessa funzione
@@ -1717,11 +1716,11 @@ una chiave per identificare la coda di messaggi (si usa il nome del file dei
 sorgenti del server) con la quale poi si esegue (\texttt{\small 26}) la
 creazione della stessa (si noti come si sia chiamata \func{msgget} con un
 valore opportuno per l'argomento \param{flag}), avendo cura di abortire il
-programma (\texttt{\small 27--29}) in caso di errore.
+programma (\texttt{\small 27-29}) in caso di errore.
 
 Finita la fase di inizializzazione il server prima (\texttt{\small 32}) chiama
 la funzione \func{daemon} per andare in background e poi esegue in permanenza
-il ciclo principale (\texttt{\small 33--40}). Questo inizia (\texttt{\small
+il ciclo principale (\texttt{\small 33-40}). Questo inizia (\texttt{\small
   34}) con il porsi in attesa di un messaggio di richiesta da parte di un
 client. Si noti infatti come \func{msgrcv} richieda un messaggio con
 \var{mtype} uguale a 1, questo è il valore usato per le richieste dato che
@@ -1745,7 +1744,7 @@ messaggio di risposta. Si tenga conto che se la coda è piena anche questa
 funzione potrà bloccarsi fintanto che non venga liberato dello spazio.
 
 Si noti che il programma può terminare solo grazie ad una interruzione da
-parte di un segnale; in tal caso verrà eseguito (\texttt{\small 45--48}) il
+parte di un segnale; in tal caso verrà eseguito (\texttt{\small 45-48}) il
 gestore \code{HandSIGTERM}, che semplicemente si limita a cancellare la coda
 (\texttt{\small 46}) ed ad uscire (\texttt{\small 47}).
 
@@ -1769,14 +1768,14 @@ per la comunicazione tramite le code, sono le stesse viste in
 fig.~\ref{fig:ipc_mq_fortune_server}.
 
 Il client in questo caso è molto semplice; la prima parte del programma
-(\texttt{\small 4--9}) si occupa di accedere alla coda di messaggi, ed è
+(\texttt{\small 4-9}) si occupa di accedere alla coda di messaggi, ed è
 identica a quanto visto per il server, solo che in questo caso \func{msgget}
 non viene chiamata con il flag di creazione in quanto la coda deve essere
 preesistente. In caso di errore (ad esempio se il server non è stato avviato)
 il programma termina immediatamente. 
 
 Una volta acquisito l'identificatore della coda il client compone
-(\texttt{\small 12--13}) il messaggio di richiesta in \var{msg\_read}, usando
+(\texttt{\small 12-13}) il messaggio di richiesta in \var{msg\_read}, usando
 1 per il tipo ed inserendo il proprio \ids{PID} come dato da passare al
 server.  Calcolata (\texttt{\small 14}) la dimensione, provvede
 (\texttt{\small 15}) ad immettere la richiesta sulla coda.
@@ -2423,8 +2422,7 @@ referenziata tramite i campi \var{sem\_pending} e \var{sem\_pending\_last} di
 operazioni richieste (nel campo \var{sops}, che è un puntatore ad una
 struttura \struct{sembuf}) e al processo corrente (nel campo \var{sleeper})
 poi quest'ultimo viene messo stato di attesa e viene invocato lo
-\itindex{scheduler} \textit{scheduler} per passare all'esecuzione di un altro
-processo.
+\textit{scheduler} per passare all'esecuzione di un altro processo.
 
 Se invece tutte le operazioni possono avere successo queste vengono eseguite
 immediatamente, dopo di che il kernel esegue una scansione della coda di
@@ -2482,20 +2480,20 @@ nullo per segnalarne l'indisponibilità.
   \label{fig:ipc_mutex_create}
 \end{figure}
 
-La prima funzione (\texttt{\small 2--15}) è \func{MutexCreate} che data una
+La prima funzione (\texttt{\small 2-15}) è \func{MutexCreate} che data una
 chiave crea il semaforo usato per il mutex e lo inizializza, restituendone
 l'identificatore. Il primo passo (\texttt{\small 6}) è chiamare \func{semget}
 con \const{IPC\_CREATE} per creare il semaforo qualora non esista,
 assegnandogli i privilegi di lettura e scrittura per tutti. In caso di errore
-(\texttt{\small 7--9}) si ritorna subito il risultato di \func{semget},
+(\texttt{\small 7-9}) si ritorna subito il risultato di \func{semget},
 altrimenti (\texttt{\small 10}) si inizializza il semaforo chiamando
 \func{semctl} con il comando \const{SETVAL}, utilizzando l'unione
 \struct{semunion} dichiarata ed avvalorata in precedenza (\texttt{\small 4})
 ad 1 per significare che risorsa è libera. In caso di errore (\texttt{\small
-  11--13}) si restituisce il valore di ritorno di \func{semctl}, altrimenti
+  11-13}) si restituisce il valore di ritorno di \func{semctl}, altrimenti
 (\texttt{\small 14}) si ritorna l'identificatore del semaforo.
 
-La seconda funzione (\texttt{\small 17--20}) è \func{MutexFind}, che, data una
+La seconda funzione (\texttt{\small 17-20}) è \func{MutexFind}, che, data una
 chiave, restituisce l'identificatore del semaforo ad essa associato. La
 comprensione del suo funzionamento è immediata in quanto essa è soltanto un
 \textit{wrapper}\footnote{si chiama così una funzione usata per fare da
@@ -2506,21 +2504,21 @@ comprensione del suo funzionamento è immediata in quanto essa è soltanto un
 l'identificatore associato alla chiave, il valore di ritorno di quest'ultima
 viene passato all'indietro al chiamante.
 
-La terza funzione (\texttt{\small 22--25}) è \func{MutexRead} che, dato un
+La terza funzione (\texttt{\small 22-25}) è \func{MutexRead} che, dato un
 identificatore, restituisce il valore del semaforo associato al mutex. Anche
 in questo caso la funzione è un \textit{wrapper} per una chiamata a
 \func{semctl} con il comando \const{GETVAL}, che permette di restituire il
 valore del semaforo.
 
-La quarta e la quinta funzione (\texttt{\small 36--44}) sono \func{MutexLock},
+La quarta e la quinta funzione (\texttt{\small 36-44}) sono \func{MutexLock},
 e \func{MutexUnlock}, che permettono rispettivamente di bloccare e sbloccare
 il mutex. Entrambe fanno da wrapper per \func{semop}, utilizzando le due
 strutture \var{sem\_lock} e \var{sem\_unlock} definite in precedenza
-(\texttt{\small 27--34}). Si noti come per queste ultime si sia fatto uso
+(\texttt{\small 27-34}). Si noti come per queste ultime si sia fatto uso
 dell'opzione \const{SEM\_UNDO} per evitare che il semaforo resti bloccato in
 caso di terminazione imprevista del processo.
 
-L'ultima funzione (\texttt{\small 46--49}) della serie, è \func{MutexRemove},
+L'ultima funzione (\texttt{\small 46-49}) della serie, è \func{MutexRemove},
 che rimuove il mutex. Anche in questo caso si ha un wrapper per una chiamata a
 \func{semctl} con il comando \const{IPC\_RMID}, che permette di cancellare il
 semaforo; il valore di ritorno di quest'ultima viene passato all'indietro.
@@ -2591,8 +2589,8 @@ creazione del segmento usando una \itindex{huge~page} \textit{huge page}, le
 pagine di memoria di grandi dimensioni introdotte con il kernel 2.6 per
 ottimizzare le prestazioni nei sistemi più recenti che hanno grandi quantità
 di memoria. L'operazione è privilegiata e richiede che il processo abbia la
-\itindex{capability} \textit{capability} \const{CAP\_IPC\_LOCK}. Questa
-funzionalità è specifica di Linux e non è portabile.
+\textit{capability} \const{CAP\_IPC\_LOCK}. Questa funzionalità è specifica di
+Linux e non è portabile.
 
 Il secondo flag aggiuntivo, introdotto a partire dal kernel 2.6.15, è
 \const{SHM\_NORESERVE}, ed ha lo stesso scopo del flag \const{MAP\_NORESERVE}
@@ -2776,13 +2774,12 @@ si ha a cuore la portabilità. Questi comandi aggiuntivi sono:
 \begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
 \item[\const{SHM\_LOCK}] Abilita il \itindex{memory~locking} \textit{memory
     locking} sul segmento di memoria condivisa, impedendo che la memoria usata
-  per il segmento venga salvata su disco dal meccanismo della
-  \index{memoria~virtuale} memoria virtuale. Come illustrato in
-  sez.~\ref{sec:proc_mem_lock} fino al kernel 2.6.9 solo l'amministratore
-  poteva utilizzare questa capacità,\footnote{che richiedeva la
-    \textit{capability} \const{CAP\_IPC\_LOCK}.} a partire dal dal kernel
-  2.6.10 anche gli utenti normali possono farlo fino al limite massimo
-  determinato da \const{RLIMIT\_MEMLOCK} (vedi
+  per il segmento venga salvata su disco dal meccanismo della memoria
+  virtuale. Come illustrato in sez.~\ref{sec:proc_mem_lock} fino al kernel
+  2.6.9 solo l'amministratore poteva utilizzare questa capacità,\footnote{che
+    richiedeva la \textit{capability} \const{CAP\_IPC\_LOCK}.} a partire dal
+  dal kernel 2.6.10 anche gli utenti normali possono farlo fino al limite
+  massimo determinato da \const{RLIMIT\_MEMLOCK} (vedi
   sez.~\ref{sec:sys_resource_limit}).
 \item[\const{SHM\_UNLOCK}] Disabilita il \itindex{memory~locking}
   \textit{memory locking} sul segmento di memoria condivisa.  Fino al kernel
@@ -2971,37 +2968,37 @@ funzioni di libreria che ne semplifichino l'uso, automatizzando le operazioni
 più comuni; il codice, contenuto nel file \file{SharedMem.c}, è riportato in
 fig.~\ref{fig:ipc_sysv_shm_func}.
 
-La prima funzione (\texttt{\small 3--16}) è \func{ShmCreate} che, data una
+La prima funzione (\texttt{\small 1-16}) è \func{ShmCreate} che, data una
 chiave, crea il segmento di memoria condivisa restituendo il puntatore allo
 stesso. La funzione comincia (\texttt{\small 6}) con il chiamare
 \func{shmget}, usando il flag \const{IPC\_CREATE} per creare il segmento
 qualora non esista, ed assegnandogli i privilegi specificati dall'argomento
 \var{perm} e la dimensione specificata dall'argomento \var{shm\_size}.  In
-caso di errore (\texttt{\small 7--9}) si ritorna immediatamente un puntatore
+caso di errore (\texttt{\small 7-9}) si ritorna immediatamente un puntatore
 nullo, altrimenti (\texttt{\small 10}) si prosegue agganciando il segmento di
 memoria condivisa al processo con \func{shmat}. In caso di errore
-(\texttt{\small 11--13}) si restituisce di nuovo un puntatore nullo, infine
+(\texttt{\small 11-13}) si restituisce di nuovo un puntatore nullo, infine
 (\texttt{\small 14}) si inizializza con \func{memset} il contenuto del
 segmento al valore costante specificato dall'argomento \var{fill}, e poi si
 ritorna il puntatore al segmento stesso.
 
-La seconda funzione (\texttt{\small 17--31}) è \func{ShmFind}, che, data una
+La seconda funzione (\texttt{\small 17-31}) è \func{ShmFind}, che, data una
 chiave, restituisce l'indirizzo del segmento ad essa associato. Anzitutto
 (\texttt{\small 22}) si richiede l'identificatore del segmento con
-\func{shmget}, ritornando (\texttt{\small 23--25}) un puntatore nullo in caso
+\func{shmget}, ritornando (\texttt{\small 23-25}) un puntatore nullo in caso
 di errore. Poi si prosegue (\texttt{\small 26}) agganciando il segmento al
-processo con \func{shmat}, restituendo (\texttt{\small 27--29}) di nuovo un
+processo con \func{shmat}, restituendo (\texttt{\small 27-29}) di nuovo un
 puntatore nullo in caso di errore, se invece non ci sono errori si restituisce
 il puntatore ottenuto da \func{shmat}.
 
-La terza funzione (\texttt{\small 32--51}) è \func{ShmRemove} che, data la
+La terza funzione (\texttt{\small 32-51}) è \func{ShmRemove} che, data la
 chiave ed il puntatore associati al segmento di memoria condivisa, prima lo
 sgancia dal processo e poi lo rimuove. Il primo passo (\texttt{\small 37}) è
 la chiamata a \func{shmdt} per sganciare il segmento, restituendo
-(\texttt{\small 38--39}) un valore -1 in caso di errore. Il passo successivo
+(\texttt{\small 38-39}) un valore -1 in caso di errore. Il passo successivo
 (\texttt{\small 41}) è utilizzare \func{shmget} per ottenere l'identificatore
 associato al segmento data la chiave \var{key}. Al solito si restituisce un
-valore di -1 (\texttt{\small 42--45}) in caso di errore, mentre se tutto va
+valore di -1 (\texttt{\small 42-45}) in caso di errore, mentre se tutto va
 bene si conclude restituendo un valore nullo.
 
 Benché la memoria condivisa costituisca il meccanismo di intercomunicazione
@@ -3053,7 +3050,7 @@ sorgenti allegati nel file \file{DirMonitor.c}.
 \end{figure}
 
 Il programma usa delle \index{variabili!globali} variabili globali
-(\texttt{\small 2--14}) per mantenere i valori relativi agli oggetti usati per
+(\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.
@@ -3062,12 +3059,12 @@ 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
 aiuto a video ed all'impostazione della durata dell'intervallo con cui viene
 ripetuto il calcolo delle proprietà della directory) controlla (\texttt{\small
-  20--23}) che sia stato specificato l'argomento necessario contenente il nome
+  20-23}) che sia stato specificato l'argomento necessario contenente il nome
 della directory da tenere sotto controllo, senza il quale esce immediatamente
 con un messaggio di errore.
 
 Poi, per verificare che l'argomento specifichi effettivamente una directory,
-si esegue (\texttt{\small 24--26}) su di esso una \func{chdir}, uscendo
+si esegue (\texttt{\small 24-26}) su di esso una \func{chdir}, uscendo
 immediatamente in caso di errore.  Questa funzione serve anche per impostare
 la \index{directory~di~lavoro} directory di lavoro del programma nella
 directory da tenere sotto controllo, in vista del successivo uso della
@@ -3076,46 +3073,36 @@ nonostante le indicazioni illustrate in sez.~\ref{sec:sess_daemon}, per il
 particolare scopo del programma, che necessita comunque di restare all'interno
 di una directory.
 
-Infine (\texttt{\small 27--29}) si installano i gestori per i vari segnali di
+Infine (\texttt{\small 27-29}) si installano i gestori per i vari segnali di
 terminazione che, avendo a che fare con un programma che deve essere eseguito
 come server, sono il solo strumento disponibile per concluderne l'esecuzione.
 
-Il passo successivo (\texttt{\small 30--39}) è quello di creare gli oggetti di
+Il passo successivo (\texttt{\small 30-39}) è quello di creare gli oggetti di
 intercomunicazione necessari. Si inizia costruendo (\texttt{\small 30}) la
 chiave da usare come riferimento con il nome del programma,\footnote{si è
   usato un riferimento relativo alla home dell'utente, supposto che i sorgenti
-  di GaPiL siano stati installati direttamente in essa. Qualora si effettui
+  di GaPiL siano stati installati direttamente in essa; qualora si effettui
   una installazione diversa si dovrà correggere il programma.} dopo di che si
 richiede (\texttt{\small 31}) la creazione di un segmento di memoria condivisa
 con usando la funzione \func{ShmCreate} illustrata in precedenza (una pagina
 di memoria è sufficiente per i dati che useremo), uscendo (\texttt{\small
-  32--35}) qualora la creazione ed il successivo agganciamento al processo non
+  32-35}) qualora la creazione ed il successivo agganciamento al processo non
 abbia successo. Con l'indirizzo \var{shmptr} così ottenuto potremo poi
 accedere alla memoria condivisa, che, per come abbiamo lo abbiamo definito,
 sarà vista nella forma data da \struct{DirProp}. Infine (\texttt{\small
-  36--39}) utilizzando sempre la stessa chiave, si crea, tramite le funzioni
+  36-39}) utilizzando sempre la stessa chiave, si crea, tramite le funzioni
 di interfaccia già descritte in sez.~\ref{sec:ipc_sysv_sem}, anche un mutex,
 che utilizzeremo per regolare l'accesso alla memoria condivisa.
 
-\begin{figure}[!htbp]
-  \footnotesize \centering
-  \begin{minipage}[c]{\codesamplewidth}
-    \includecodesample{listati/ComputeValues.c}
-  \end{minipage} 
-  \normalsize 
-  \caption{Codice delle funzioni ausiliarie usate da \file{DirMonitor.c}.}
-  \label{fig:ipc_dirmonitor_sub}
-\end{figure}
-
 Completata l'inizializzazione e la creazione degli oggetti di
 intercomunicazione il programma entra nel ciclo principale (\texttt{\small
-  40--49}) dove vengono eseguite indefinitamente le attività di monitoraggio.
+  40-49}) dove vengono eseguite indefinitamente le attività di monitoraggio.
 Il primo passo (\texttt{\small 41}) è eseguire \func{daemon} per proseguire
 con l'esecuzione in background come si conviene ad un programma demone; si
 noti che si è mantenuta, usando un valore non nullo del primo argomento, la
 \index{directory~di~lavoro} directory di lavoro corrente.  Una volta che il
 programma è andato in background l'esecuzione prosegue all'interno di un ciclo
-infinito (\texttt{\small 42--48}).
+infinito (\texttt{\small 42-48}).
 
 Si inizia (\texttt{\small 43}) bloccando il mutex con \func{MutexLock} per
 poter accedere alla memoria condivisa (la funzione si bloccherà
@@ -3133,8 +3120,19 @@ descritta in dettaglio) in sez.~\ref{sec:file_dir_read}, che ci permette di
 effettuare la scansione delle voci della directory, chiamando per ciascuna di
 esse la funzione \func{ComputeValues}, che esegue tutti i calcoli necessari.
 
+\begin{figure}[!htbp]
+  \footnotesize \centering
+  \begin{minipage}[c]{\codesamplewidth}
+    \includecodesample{listati/ComputeValues.c}
+  \end{minipage} 
+  \normalsize 
+  \caption{Codice delle funzioni ausiliarie usate da \file{DirMonitor.c}.}
+  \label{fig:ipc_dirmonitor_sub}
+\end{figure}
+
+
 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
+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
@@ -3144,13 +3142,13 @@ Dato che la funzione è chiamata da \myfunc{dir\_scan}, si è all'interno del
 ciclo principale del programma, con un mutex acquisito, perciò non è
 necessario effettuare nessun controllo e si può accedere direttamente alla
 memoria condivisa usando \var{shmptr} per riempire i campi della struttura
-\struct{DirProp}; così prima (\texttt{\small 6--7}) si sommano le dimensioni
+\struct{DirProp}; così prima (\texttt{\small 6-7}) si sommano le dimensioni
 dei file ed il loro numero, poi, utilizzando le macro di
-tab.~\ref{tab:file_type_macro}, si contano (\texttt{\small 8--14}) quanti ce
+tab.~\ref{tab:file_type_macro}, si contano (\texttt{\small 8-14}) quanti ce
 ne sono per ciascun tipo.
 
 In fig.~\ref{fig:ipc_dirmonitor_sub} è riportato anche il codice
-(\texttt{\small 17--23}) del gestore dei segnali di terminazione, usato per
+(\texttt{\small 17-23}) del gestore dei segnali di terminazione, usato per
 chiudere il programma. Esso, oltre a provocare l'uscita del programma, si
 incarica anche di cancellare tutti gli oggetti di intercomunicazione non più
 necessari.  Per questo anzitutto (\texttt{\small 19}) acquisisce il mutex con
@@ -3181,12 +3179,12 @@ rigenera (\texttt{\small 7}) con \func{ftok} la stessa chiave usata dal server
 per identificare il segmento di memoria condivisa ed il mutex, poi
 (\texttt{\small 8}) richiede con \func{ShmFind} l'indirizzo della memoria
 condivisa agganciando al contempo il segmento al processo, Infine
-(\texttt{\small 17--20}) con \func{MutexFind} si richiede l'identificatore del
+(\texttt{\small 17-20}) con \func{MutexFind} si richiede l'identificatore del
 mutex.  Completata l'inizializzazione ed ottenuti i riferimenti agli oggetti
 di intercomunicazione necessari viene eseguito il corpo principale del
-programma (\texttt{\small 21--33}); si comincia (\texttt{\small 22})
+programma (\texttt{\small 21-33}); si comincia (\texttt{\small 22})
 acquisendo il mutex con \func{MutexLock}; qui avviene il blocco del processo
-se la memoria condivisa non è disponibile.  Poi (\texttt{\small 23--31}) si
+se la memoria condivisa non è disponibile.  Poi (\texttt{\small 23-31}) si
 stampano i vari valori mantenuti nella memoria condivisa attraverso l'uso di
 \var{shmptr}.  Infine (\texttt{\small 41}) con \func{MutexUnlock} si rilascia
 il mutex, prima di uscire.
@@ -3358,8 +3356,8 @@ Un esempio dell'uso di questa funzione è mostrato dalle funzioni
 (sono contenute in \file{LockFile.c}, un altro dei sorgenti allegati alla
 guida) che permettono rispettivamente di creare e rimuovere un \textsl{file di
   lock}. Come si può notare entrambe le funzioni sono elementari; la prima
-(\texttt{\small 4--10}) si limita ad aprire il file di lock (\texttt{\small
-  9}) nella modalità descritta, mentre la seconda (\texttt{\small 11--17}) lo
+(\texttt{\small 4-10}) si limita ad aprire il file di lock (\texttt{\small
+  9}) nella modalità descritta, mentre la seconda (\texttt{\small 11-17}) lo
 cancella con \func{unlink}.
 
 \begin{figure}[!htbp]
@@ -3444,7 +3442,7 @@ analoga alle precedenti funzioni che usano i semafori, anche se le due
 interfacce non possono essere completamente equivalenti, specie per quanto
 riguarda la rimozione del mutex.
 
-La prima funzione (\texttt{\small 1--5}) è \func{CreateMutex}, e serve a
+La prima funzione (\texttt{\small 1-5}) è \func{CreateMutex}, e serve a
 creare il mutex; la funzione è estremamente semplice, e si limita
 (\texttt{\small 4}) a creare, con una opportuna chiamata ad \func{open}, il
 file che sarà usato per il successivo \textit{file locking}, assicurandosi che
@@ -3452,32 +3450,32 @@ non esista già (nel qual caso segnala un errore); poi restituisce il file
 descriptor che sarà usato dalle altre funzioni per acquisire e rilasciare il
 mutex.
 
-La seconda funzione (\texttt{\small 6--10}) è \func{FindMutex}, che, come la
+La seconda funzione (\texttt{\small 6-10}) è \func{FindMutex}, che, come la
 precedente, è stata definita per mantenere una analogia con la corrispondente
 funzione basata sui semafori. Anch'essa si limita (\texttt{\small 9}) ad
 aprire il file da usare per il \itindex{file~locking} \textit{file locking},
 solo che in questo caso le opzioni di \func{open} sono tali che il file in
 questione deve esistere di già.
 
-La terza funzione (\texttt{\small 11--22}) è \func{LockMutex} e serve per
+La terza funzione (\texttt{\small 11-22}) è \func{LockMutex} e serve per
 acquisire il mutex. La funzione definisce (\texttt{\small 14}) e inizializza
-(\texttt{\small 16--19}) la struttura \var{lock} da usare per acquisire un
+(\texttt{\small 16-19}) la struttura \var{lock} da usare per acquisire un
 write lock sul file, che poi (\texttt{\small 21}) viene richiesto con
 \func{fcntl}, restituendo il valore di ritorno di quest'ultima. Se il file è
 libero il lock viene acquisito e la funzione ritorna immediatamente;
 altrimenti \func{fcntl} si bloccherà (si noti che la si è chiamata con
 \const{F\_SETLKW}) fino al rilascio del lock.
 
-La quarta funzione (\texttt{\small 24--34}) è \func{UnlockMutex} e serve a
+La quarta funzione (\texttt{\small 24-34}) è \func{UnlockMutex} e serve a
 rilasciare il mutex. La funzione è analoga alla precedente, solo che in questo
-caso si inizializza (\texttt{\small 28--31}) la struttura \var{lock} per il
+caso si inizializza (\texttt{\small 28-31}) la struttura \var{lock} per il
 rilascio del lock, che viene effettuato (\texttt{\small 33}) con la opportuna
 chiamata a \func{fcntl}. Avendo usato il \itindex{file~locking} \textit{file
   locking} in semantica POSIX (si riveda quanto detto
 sez.~\ref{sec:file_posix_lock}) solo il processo che ha precedentemente
 eseguito il lock può sbloccare il mutex.
 
-La quinta funzione (\texttt{\small 36--39}) è \func{RemoveMutex} e serve a
+La quinta funzione (\texttt{\small 36-39}) è \func{RemoveMutex} e serve a
 cancellare il mutex. Anche questa funzione è stata definita per mantenere una
 analogia con le funzioni basate sui semafori, e si limita a cancellare
 (\texttt{\small 38}) il file con una chiamata ad \func{unlink}. Si noti che in
@@ -3487,8 +3485,8 @@ disponibili fintanto che i relativi file descriptor restano aperti. Pertanto
 per rilasciare un mutex occorrerà prima chiamare \func{UnlockMutex} oppure
 chiudere il file usato per il lock.
 
-La sesta funzione (\texttt{\small 41--55}) è \func{ReadMutex} e serve a
-leggere lo stato del mutex. In questo caso si prepara (\texttt{\small 46--49})
+La sesta funzione (\texttt{\small 41-55}) è \func{ReadMutex} e serve a
+leggere lo stato del mutex. In questo caso si prepara (\texttt{\small 46-49})
 la solita struttura \var{lock} come l'acquisizione del lock, ma si effettua
 (\texttt{\small 51}) la chiamata a \func{fcntl} usando il comando
 \const{F\_GETLK} per ottenere lo stato del lock, e si restituisce
@@ -3552,6 +3550,11 @@ sez.~\ref{sec:ipc_sysv_shm} che possa restituisca i risultati via rete.
 % trattarlo qui, vedi http://lwn.net/Articles/405346/
 % https://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commitdiff;h=fcf634098c00dd9cd247447368495f0b79be12d1
 
+% TODO: con il kernel 3.17 è stata introdotta una fuunzionalità di
+% sigillatura dei file mappati in memoria e la system call memfd
+% (capire se va messo qui o altrove) vedi: http://lwn.net/Articles/593918/
+
+
 \section{L'intercomunicazione fra processi di POSIX}
 \label{sec:ipc_posix}
 
@@ -3616,7 +3619,7 @@ non è detto che altrettanto valga per altri kernel. In particolare, come si
 può facilmente verificare con il comando \cmd{strace}, sia per la memoria
 condivisa che per le code di messaggi varie \textit{system call} utilizzate da
 Linux corrispondono in realtà a quelle ordinarie dei file, essendo detti
-oggetti realizzati come tali in appositi filesystem.
+oggetti realizzati come tali usando degli specifici filesystem.
 
 In particolare i permessi associati agli oggetti di IPC POSIX sono identici ai
 permessi dei file, ed il controllo di accesso segue esattamente la stessa
@@ -3785,9 +3788,8 @@ dei limiti sono:
   valore massimo è \const{HARD\_MAX} che vale \code{(131072/sizeof(void *))},
   ed il valore minimo 1 (ma era 10 per i kernel precedenti il 2.6.28). Questo
   limite viene ignorato per i processi con privilegi amministrativi (più
-  precisamente con la \itindex{capability} \textit{capability}
-  \const{CAP\_SYS\_RESOURCE}) ma \const{HARD\_MAX} resta comunque non
-  superabile.
+  precisamente con la \textit{capability} \const{CAP\_SYS\_RESOURCE}) ma
+  \const{HARD\_MAX} resta comunque non superabile.
 
 \item[\sysctlfile{fs/mqueue/msgsize\_max}] Indica il valore massimo della
   dimensione in byte di un messaggio sulla coda ed agisce come limite
@@ -3795,14 +3797,14 @@ dei limiti sono:
   suo valore di default è 8192.  Il valore massimo è 1048576 ed il valore
   minimo 128 (ma per i kernel precedenti il 2.6.28 detti limiti erano
   rispettivamente \const{INT\_MAX} e 8192). Questo limite viene ignorato dai
-  processi con privilegi amministrativi (con la \itindex{capability}
-  \textit{capability} \const{CAP\_SYS\_RESOURCE}).
+  processi con privilegi amministrativi (con la \textit{capability}
+  \const{CAP\_SYS\_RESOURCE}).
 
 \item[\sysctlfile{fs/mqueue/queues\_max}] Indica il numero massimo di code di
   messaggi creabili in totale sul sistema, il valore di default è 256 ma si
   può usare un valore qualunque fra $0$ e \const{INT\_MAX}. Il limite non
   viene applicato ai processi con privilegi amministrativi (cioè con la
-  \itindex{capability} \textit{capability} \const{CAP\_SYS\_RESOURCE}).
+  \textit{capability} \const{CAP\_SYS\_RESOURCE}).
 
 \end{basedescript}
 
@@ -3935,8 +3937,8 @@ I rispettivi prototipi sono:
 \fhead{mqueue.h}
 \fhead{time.h}
 \fdecl{int mq\_timedsend(mqd\_t mqdes, const char *msg\_ptr, size\_t
-    msg\_len, unsigned int msg\_prio,\\ 
-\phantom{int mq\_timedsend(}const struct timespec *abs\_timeout)}
+    msg\_len, \\ 
+\phantom{int mq\_timedsend(}unsigned int msg\_prio, const struct timespec *abs\_timeout)}
 \fdesc{Esegue l'inserimento di un messaggio su una coda entro un tempo
   specificato}
 }
@@ -3981,13 +3983,12 @@ descriptor della coda, nel qual caso entrambe ritornano con un codice di
 errore di \errcode{EAGAIN}.
 
 La sola differenza fra le due funzioni è che \func{mq\_timedsend}, passato il
-tempo massimo impostato con l'argomento \param{abs\_timeout}, ritorna comunque
-con un errore di \errcode{ETIMEDOUT}, se invece il tempo è già scaduto al
-momento della chiamata e la coda è piena la funzione ritorna
-immediatamente. Il valore di \param{abs\_timeout} deve essere specificato come
-tempo assoluto tramite una struttura \struct{timespec} (vedi
-fig.~\ref{fig:sys_timespec_struct}) indicato in numero di secondi e
-nanosecondi a partire dal 1 gennaio 1970.
+tempo massimo impostato con l'argomento \param{abs\_timeout}, ritorna con un
+errore di \errcode{ETIMEDOUT}, se invece il tempo è già scaduto al momento
+della chiamata e la coda è piena la funzione ritorna immediatamente. Il valore
+di \param{abs\_timeout} deve essere specificato come tempo assoluto tramite
+una struttura \struct{timespec} (vedi fig.~\ref{fig:sys_timespec_struct})
+indicato in numero di secondi e nanosecondi a partire dal 1 gennaio 1970.
 
 Come per l'inserimento, anche per l'estrazione dei messaggi da una coda sono
 previste due funzioni di sistema, \funcd{mq\_receive} e
@@ -4272,11 +4273,11 @@ lunghezza nulla. Il nuovo segmento verrà creato con i permessi indicati
 da \param{mode} (di cui vengono usati solo i 9 bit meno significativi, non si
 applicano pertanto i permessi speciali di sez.~\ref{sec:file_special_perm})
 filtrati dal valore dell'\textit{umask} del processo. Come gruppo ed utente
-propritario del segmento saranno presi quelli facenti parte del gruppo
+proprietario del segmento saranno presi quelli facenti parte del gruppo
 \textit{effective} del processo chiamante.
 
 Dato che un segmento di lunghezza nulla è di scarsa utilità, una vola che lo
-si è creato per impostarne la dimensione si devrà poi usare \func{ftruncate}
+si è creato per impostarne la dimensione si dovrà poi usare \func{ftruncate}
 (vedi sez.~\ref{sec:file_file_size}) prima di mapparlo in memoria con
 \func{mmap}.  Si tenga presente che una volta chiamata \func{mmap} si può
 chiudere il file descriptor ad esso associato (semplicemente con
@@ -4325,7 +4326,7 @@ Come esempio dell'uso delle funzioni attinenti ai segmenti di memoria
 condivisa POSIX, vediamo come è possibile riscrivere una interfaccia
 semplificata analoga a quella vista in fig.~\ref{fig:ipc_sysv_shm_func} per la
 memoria condivisa in stile SysV. Il codice completo, di cui si sono riportate
-le parti esseziali in fig.~\ref{fig:ipc_posix_shmmem}, è contenuto nel file
+le parti essenziali in fig.~\ref{fig:ipc_posix_shmmem}, è contenuto nel file
 \file{SharedMem.c} dei sorgenti allegati.
 
 \begin{figure}[!htb]
@@ -4339,7 +4340,7 @@ le parti esseziali in fig.~\ref{fig:ipc_posix_shmmem}, è contenuto nel file
   \label{fig:ipc_posix_shmmem}
 \end{figure}
 
-La prima funzione (\texttt{\small 1--24}) è \func{CreateShm} che, dato un nome
+La prima funzione (\texttt{\small 1-24}) è \func{CreateShm} che, dato un nome
 nell'argomento \var{name} crea un nuovo segmento di memoria condivisa,
 accessibile in lettura e scrittura, e ne restituisce l'indirizzo. Anzitutto si
 definiscono (\texttt{\small 8}) i flag per la successiva (\texttt{\small 9})
@@ -4347,27 +4348,27 @@ chiamata a \func{shm\_open}, che apre il segmento in lettura e scrittura
 (creandolo se non esiste, ed uscendo in caso contrario) assegnandogli sul
 filesystem i permessi specificati dall'argomento \var{perm}. 
 
-In caso di errore (\texttt{\small 10--12}) si restituisce un puntatore nullo,
+In caso di errore (\texttt{\small 10-12}) si restituisce un puntatore nullo,
 altrimenti si prosegue impostando (\texttt{\small 14}) la dimensione del
-segmento con \func{ftruncate}. Di nuovo (\texttt{\small 15--16}) si esce
+segmento con \func{ftruncate}. Di nuovo (\texttt{\small 15-16}) si esce
 immediatamente restituendo un puntatore nullo in caso di errore. Poi si passa
 (\texttt{\small 18}) a mappare in memoria il segmento con \func{mmap}
 specificando dei diritti di accesso corrispondenti alla modalità di apertura.
-Di nuovo si restituisce (\texttt{\small 19--21}) un puntatore nullo in caso di
+Di nuovo si restituisce (\texttt{\small 19-21}) un puntatore nullo in caso di
 errore, altrimenti si inizializza (\texttt{\small 22}) il contenuto del
 segmento al valore specificato dall'argomento \var{fill} con \func{memset}, e
 se ne restituisce (\texttt{\small 23}) l'indirizzo.
 
-La seconda funzione (\texttt{\small 25--40}) è \func{FindShm} che trova un
+La seconda funzione (\texttt{\small 25-40}) è \func{FindShm} che trova un
 segmento di memoria condiviso esistente, restituendone l'indirizzo. In questo
 caso si apre (\texttt{\small 31}) il segmento con \func{shm\_open} richiedendo
-che il segmento sia già esistente, in caso di errore (\texttt{\small 31--33})
+che il segmento sia già esistente, in caso di errore (\texttt{\small 31-33})
 si ritorna immediatamente un puntatore nullo.  Ottenuto il file descriptor del
 segmento lo si mappa (\texttt{\small 35}) in memoria con \func{mmap},
-restituendo (\texttt{\small 36--38}) un puntatore nullo in caso di errore, o
+restituendo (\texttt{\small 36-38}) un puntatore nullo in caso di errore, o
 l'indirizzo (\texttt{\small 39}) dello stesso in caso di successo.
 
-La terza funzione (\texttt{\small 40--45}) è \func{RemoveShm}, e serve a
+La terza funzione (\texttt{\small 40-45}) è \func{RemoveShm}, e serve a
 cancellare un segmento di memoria condivisa. Dato che al contrario di quanto
 avveniva con i segmenti del \textit{SysV-IPC} gli oggetti allocati nel kernel
 vengono rilasciati automaticamente quando nessuna li usa più, tutto quello che
@@ -4447,15 +4448,15 @@ utilizzare, ed è quello che permette a processi diversi di accedere allo
 stesso semaforo. Questo deve essere specificato nella stessa forma utilizzata
 per i segmenti di memoria condivisa, con un nome che inizia con ``\texttt{/}''
 e senza ulteriori ``\texttt{/}'', vale a dire nella forma
-\texttt{/nomesemaforo}.
+\texttt{/nome-semaforo}.
 
 Con Linux i file associati ai semafori sono mantenuti nel filesystem virtuale
 \texttt{/dev/shm}, e gli viene assegnato automaticamente un nome nella forma
-\texttt{sem.nomesemaforo}, si ha cioè una corrispondenza per cui
-\texttt{/nomesemaforo} viene rimappato, nella creazione tramite
-\func{sem\_open}, su \texttt{/dev/shm/sem.nomesemaforo}. Per questo motivo la
+\texttt{sem.nome-semaforo}, si ha cioè una corrispondenza per cui
+\texttt{/nome-semaforo} viene rimappato, nella creazione tramite
+\func{sem\_open}, su \texttt{/dev/shm/sem.nome-semaforo}. Per questo motivo la
 dimensione massima per il nome di un semaforo, a differenza di quanto avviene
-per i segmenti di memoria confivisa, è pari a \const{NAME\_MAX}$ - 4$.
+per i segmenti di memoria condivisa, è pari a \const{NAME\_MAX}$ - 4$.
 
 L'argomento \param{oflag} è quello che controlla le modalità con cui opera la
 funzione, ed è passato come maschera binaria; i bit corrispondono a quelli
@@ -4528,7 +4529,7 @@ decrementarlo con successo e proseguire.
 
 Si tenga presente che la funzione può sempre essere interrotta da un segnale,
 nel qual caso si avrà un errore di \const{EINTR}; inoltre questo avverrà
-comunque, anche qualora si fosse richiesta la gesione con la semantica BSD,
+comunque, anche qualora si fosse richiesta la gestione con la semantica BSD,
 installando il gestore del suddetto segnale con l'opzione \const{SA\_RESTART}
 (vedi sez.~\ref{sec:sig_sigaction}) per riavviare le \textit{system call}
 interrotte.
@@ -4592,7 +4593,7 @@ Anche in questo caso il comportamento della funzione è identico a quello di
 \func{sem\_wait}, ma è possibile impostare un tempo limite per l'attesa
 tramite la struttura \struct{timespec} (vedi
 fig.~\ref{fig:sys_timespec_struct}) puntata
-dall'argomento \param{abs\_timeout}, indicato in secondi e nonosecondi a
+dall'argomento \param{abs\_timeout}, indicato in secondi e nanosecondi a
 partire dalla cosiddetta \textit{Epoch} (00:00:00, 1 January 1970
 UTC). Scaduto il limite la funzione ritorna anche se non è possibile acquisire
 il semaforo fallendo con un errore di \errval{ETIMEDOUT}.
@@ -4845,7 +4846,7 @@ una volta al secondo. Si utilizzerà un semaforo per proteggere l'accesso in
 lettura alla stringa, in modo che questa non possa essere modificata
 dall'altro programma prima di averla finita di stampare.
 
-La parte iniziale del programma contiene le definizioni (\texttt{\small 1--8})
+La parte iniziale del programma contiene le definizioni (\texttt{\small 1-8})
 del gestore del segnale usato per liberare le risorse utilizzate, delle
 \index{variabili!globali} variabili globali contenenti i nomi di default del
 segmento di memoria condivisa e del semaforo (il default scelto è
@@ -4854,7 +4855,7 @@ segmento di memoria condivisa e del semaforo (il default scelto è
 Come prima istruzione (\texttt{\small 10}) si è provveduto ad installare un
 gestore di segnale che consentirà di effettuare le operazioni di pulizia
 (usando la funzione \func{Signal} illustrata in
-fig.~\ref{fig:sig_Signal_code}), dopo di che (\texttt{\small 12--16}) si è
+fig.~\ref{fig:sig_Signal_code}), dopo di che (\texttt{\small 12-16}) si è
 creato il segmento di memoria condivisa con la funzione \func{CreateShm} che
 abbiamo appena trattato in sez.~\ref{sec:ipc_posix_shm}, uscendo con un
 messaggio in caso di errore. 
@@ -4865,7 +4866,7 @@ abbia già allocato un segmento con quello stesso nome. Per semplicità di
 gestione si è usata una dimensione fissa pari a 256 byte, definita tramite la
 costante \texttt{MSGMAXSIZE}.
 
-Il passo successivo (\texttt{\small 17--21}) è quello della creazione del
+Il passo successivo (\texttt{\small 17-21}) è quello della creazione del
 semaforo che regola l'accesso al segmento di memoria condivisa con
 \func{sem\_open}; anche in questo caso si gestisce l'uscita con stampa di un
 messaggio in caso di errore. Anche per il semaforo, avendo specificato la
@@ -4881,16 +4882,16 @@ programma. Essendo il semaforo stato creato già bloccato non ci si dovrà
 preoccupare di eventuali \itindex{race~condition} \textit{race condition}
 qualora il programma di modifica del messaggio venisse lanciato proprio in
 questo momento.  Una volta inizializzato il messaggio occorrerà però
-rilasciare il semaforo (\texttt{\small 24--27}) per consentirne l'uso; in
+rilasciare il semaforo (\texttt{\small 24-27}) per consentirne l'uso; in
 tutte queste operazioni si provvederà ad uscire dal programma con un opportuno
 messaggio in caso di errore.
 
 Una volta completate le inizializzazioni il ciclo principale del programma
-(\texttt{\small 29--47}) viene ripetuto indefinitamente (\texttt{\small 29})
+(\texttt{\small 29-47}) viene ripetuto indefinitamente (\texttt{\small 29})
 per stampare sia il contenuto del messaggio che una serie di informazioni di
-controllo. Il primo passo (\texttt{\small 30--34}) è quello di acquisire (con
+controllo. Il primo passo (\texttt{\small 30-34}) è quello di acquisire (con
 \func{sem\_getvalue}, con uscita in caso di errore) e stampare il valore del
-semaforo ad inizio del ciclo; seguito (\texttt{\small 35--36}) dal tempo
+semaforo ad inizio del ciclo; seguito (\texttt{\small 35-36}) dal tempo
 corrente.
 
 \begin{figure}[!htb]
@@ -4905,9 +4906,9 @@ corrente.
 \end{figure}
 
 Prima della stampa del messaggio invece si deve acquisire il semaforo
-(\texttt{\small 30--33}) per evitare accessi concorrenti alla stringa da parte
+(\texttt{\small 30-33}) per evitare accessi concorrenti alla stringa da parte
 del programma di modifica. Una volta eseguita la stampa (\texttt{\small 41})
-il semaforo dovrà essere rilasciato (\texttt{\small 42--45}). Il passo finale
+il semaforo dovrà essere rilasciato (\texttt{\small 42-45}). Il passo finale
 (\texttt{\small 46}) è attendere per un secondo prima di eseguire da capo il
 ciclo. 
 
@@ -4943,16 +4944,16 @@ cui il programma si ferma tenendo bloccato il semaforo.
 
 Una volta completata la gestione delle opzioni e degli argomenti (ne deve
 essere presente uno solo, contenente la nuova stringa da usare come
-messaggio), il programma procede (\texttt{\small 10--14}) con l'acquisizione
+messaggio), il programma procede (\texttt{\small 10-14}) con l'acquisizione
 del segmento di memoria condivisa usando la funzione \func{FindShm} (trattata
 in sez.~\ref{sec:ipc_posix_shm}) che stavolta deve già esistere.  Il passo
-successivo (\texttt{\small 16--19}) è quello di aprire il semaforo, e a
+successivo (\texttt{\small 16-19}) è quello di aprire il semaforo, e a
 differenza di \file{message\_getter}, in questo caso si richiede a
 \func{sem\_open} che questo esista, passando uno zero come secondo ed unico
 argomento.
 
 Una volta completate con successo le precedenti inizializzazioni, il passo
-seguente (\texttt{\small 21--24}) è quello di acquisire il semaforo, dopo di
+seguente (\texttt{\small 21-24}) è quello di acquisire il semaforo, dopo di
 che sarà possibile eseguire la sostituzione del messaggio (\texttt{\small 25})
 senza incorrere in possibili \itindex{race~condition} \textit{race condition}
 con la stampa dello stesso da parte di \file{message\_getter}.
@@ -4962,7 +4963,7 @@ di attesa impostato con l'opzione ``\texttt{-t}'' dopo di che (\texttt{\small
   27}) viene eseguita la stessa, senza rilasciare il semaforo che resterà
 quindi bloccato (causando a questo punto una interruzione delle stampe
 eseguite da \file{message\_getter}). Terminato il tempo di attesa si rilascerà
-(\texttt{\small 29--32}) il semaforo per poi uscire.
+(\texttt{\small 29-32}) il semaforo per poi uscire.
 
 Per verificare il funzionamento dei programmi occorrerà lanciare per primo
 \file{message\_getter}\footnote{lanciare per primo \file{message\_setter} darà
@@ -5080,8 +5081,9 @@ testo alla terminazione di quest'ultimo.
 % LocalWords:  Larry Wall Escape the Hell William ipctestid Identifier segment
 % LocalWords:  violation dell'I SIGINT setter Fri Dec Sleeping seconds ECHILD
 % LocalWords:  SysV capability short RESOURCE INFO UNDEFINED EFBIG semtimedop
-% LocalWords:  scan HUGETLB huge page NORESERVE copy RLIMIT MEMLOCK REMAP
-% LocalWords:  readmon Hierarchy defaults queues MSGQUEUE
+% LocalWords:  scan HUGETLB huge page NORESERVE copy RLIMIT MEMLOCK REMAP UTC
+% LocalWords:  readmon Hierarchy defaults queues MSGQUEUE effective fstat
+% LocalWords:  fchown fchmod Epoch January
 
 
 %%% Local Variables: