Correzioni

[gapil.git] / filedir.tex

diff --git a/filedir.tex b/filedir.tex
index f41816316dcb0d8f3c9fe382b267cc1e7e3e3d2f..11a25fc9d650e1cd85d7afe1497dcccd5c1d542f 100644 (file)
--- a/filedir.tex
+++ b/filedir.tex
@@ -5368,7 +5368,7 @@ queste funzioni che prendiamo in esame è \funcd{acl\_init}, il cui prototipo
 \fdesc{Inizializza un'area di lavoro per una ACL.} 
 }
 
 \fdesc{Inizializza un'area di lavoro per una ACL.} 
 }
 

-{La funzione ritorna un puntatore all'area di lavoro in caso di successo e
+{La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo e

   \val{NULL} per un errore, nel qual caso \var{errno} assumerà uno dei valori:
   \begin{errlist}
   \item[\errcode{EINVAL}] il valore di \param{count} è negativo.
   \val{NULL} per un errore, nel qual caso \var{errno} assumerà uno dei valori:
   \begin{errlist}
   \item[\errcode{EINVAL}] il valore di \param{count} è negativo.


@@ -5381,16 +5381,22 @@ La funzione alloca ed inizializza un'area di memoria che verrà usata per
 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
 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 \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}''.
+iniziale e non inserisce nessun valore nella ACL che resta vuota. 
+
+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à, in questa come in tutte le funzioni seguenti che restituiscono un
+oggetto di tipo \type{acl\_t}, confrontare il valore di ritorno della funzione
+con ``\code{(acl\_t) NULL}''.\footnote{dato che il valore \var{NULL} in questo
+  caso viene restituito come oggetto di tipo \type{acl\_t}, un confronto del
+  risultato della funzione con \var{NULL} darebbe un errore di compilazione
+  per la differenza di tipo.}

 
 Una volta che si siano completate le operazioni sui dati di una ACL la memoria
 
 Una volta che si siano completate le operazioni sui dati di una ACL la memoria

-allocata dovrà essere liberata esplicitamente attraverso una chiamata alla
-funzione \funcd{acl\_free}, il cui prototipo è:
+allocata per un oggetto \type{acl\_t} dovrà essere liberata esplicitamente
+attraverso una chiamata alla funzione \funcd{acl\_free}, il cui prototipo è:

 
 \begin{funcproto}{
 \fhead{sys/types.h}
 
 \begin{funcproto}{
 \fhead{sys/types.h}


@@ -5400,20 +5406,25 @@ funzione \funcd{acl\_free}, il cui prototipo è:
 }
 
 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
 }
 
 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual

-  caso \var{errno} assumerà il valore \errcode{EINVAL} se \param{obj\_p} non è
-  valido.}
+  caso \var{errno} può assumere solo il valore:
+  \begin{errlist}
+  \item[\errcode{EINVAL}] \param{obj\_p} non è valido.
+  \end{errlist}
+}

 \end{funcproto}
 
 \end{funcproto}
 

-Si noti come la funzione richieda come argomento un puntatore di tipo
-``\ctyp{void *}'', essa infatti può essere usata non solo per liberare la
-memoria allocata per i dati di una ACL, ma anche per quella usata per creare
-le stringhe di descrizione testuale delle ACL o per ottenere i valori dei
-qualificatori di una voce; pertanto a seconda dei casi occorrerà eseguire un
-\textit{cast} a ``\ctyp{void *}'' del tipo di dato di cui si vuole eseguire la
-disallocazione.  Si tenga presente poi che oltre a \func{acl\_init} esistono
-molte altre funzioni che possono allocare memoria per i dati delle ACL, è
-pertanto opportuno tenere traccia di tutte queste funzioni perché alla fine
-delle operazioni tutta la memoria allocata dovrà essere liberata con
+Si noti come la funzione usi come argomento un puntatore di tipo ``\ctyp{void
+  *}'', essa infatti può essere usata non solo per liberare la memoria
+allocata per i dati di una ACL, ma anche per quella usata per creare le
+stringhe di descrizione testuale delle ACL o per ottenere i valori dei
+qualificatori della una voce di una ACL. 
+
+Pertanto a seconda dei casi occorrerà eseguire un \textit{cast} a ``\ctyp{void
+  *}'' del tipo di dato di cui si vuole eseguire la disallocazione.  Si tenga
+presente poi che oltre a \func{acl\_init} ci sono molte altre funzioni che
+possono allocare memoria per i dati delle ACL, è pertanto opportuno tenere
+traccia di tutte le chiamate a queste funzioni perché alla fine delle
+operazioni tutta la memoria allocata dovrà essere liberata con

 \func{acl\_free}.
 
 Una volta che si abbiano a disposizione i dati di una ACL tramite il
 \func{acl\_free}.
 
 Una volta che si abbiano a disposizione i dati di una ACL tramite il


@@ -5428,8 +5439,8 @@ con la funzione \funcd{acl\_dup}, il cui prototipo è:
 }
 
 {La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo in
 }
 
 {La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo in

-  caso di successo e \code{(acl\_t)NULL} per un errore, nel qual caso
-  \var{errno} assumerà assumerà uno dei valori:
+  caso di successo e \val{NULL} per un errore, nel qual caso \var{errno}
+  assumerà assumerà uno dei valori:

   \begin{errlist}
   \item[\errcode{EINVAL}] l'argomento \param{acl} non è un puntatore valido
     per una ACL.
   \begin{errlist}
   \item[\errcode{EINVAL}] l'argomento \param{acl} non è un puntatore valido
     per una ACL.


@@ -5460,8 +5471,8 @@ di permessi ordinari, il prototipo della funzione è:
 }
 
 {La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo e
 }
 
 {La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo e

-  \code{(acl\_t)NULL} per un errore, nel qual caso \var{errno} potra assumere
-  solo il valore \errval{ENOMEM} nel suo significato generico.}
+  \val{NULL} per un errore, nel qual caso \var{errno} può assumere solo
+  il valore \errval{ENOMEM}.}

 \end{funcproto}
 
 
 \end{funcproto}
 
 


@@ -5486,16 +5497,18 @@ sono:
 }
 
 {La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo e
 }
 
 {La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo e

-  \code{(acl\_t)NULL} per un errore, nel qual caso \var{errno} assumerà uno
+  \val{NULL} per un errore, nel qual caso \var{errno} assumerà uno

   dei valori:
   \begin{errlist}
   \item[\errcode{ENOMEM}] non c'è memoria sufficiente per allocare i dati.
   dei valori:
   \begin{errlist}
   \item[\errcode{ENOMEM}] non c'è memoria sufficiente per allocare i dati.

+  \item[\errcode{EINVAL}] \param{type} non ha un valore valido (solo per
+    \func{acl\_get\_file}).

   \item[\errcode{ENOTSUP}] il filesystem cui fa riferimento il file non
     supporta le ACL.
   \end{errlist}
   \item[\errcode{ENOTSUP}] il filesystem cui fa riferimento il file non
     supporta le ACL.
   \end{errlist}

-  ed inoltre \errval{EBADF} per \func{acl\_get\_fd}, ed \errval{EINVAL} per
-  valori scorretti di \param{type} e tutti i possibili errori per l'accesso ad
-  un file per \func{acl\_get\_file}. }
+  ed inoltre \errval{EBADF} per \func{acl\_get\_fd}, e \errval{EACCES},
+  \errval{ENAMETOOLONG}, \errval{ENOENT}, \errval{ENOTDIR}, per
+  \func{acl\_get\_file}. }

 \end{funcproto}
 
 Le due funzioni ritornano, con un oggetto di tipo \type{acl\_t}, il valore
 \end{funcproto}
 
 Le due funzioni ritornano, con un oggetto di tipo \type{acl\_t}, il valore


@@ -5542,15 +5555,14 @@ testuale con la funzione  \funcd{acl\_from\_text}, il cui prototipo è:
 }
 
 {La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo e
 }
 
 {La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo e

-  \code{(acl\_t)NULL} per un errore, nel qual caso \var{errno} assumerà uno
+  \val{NULL} per un errore, nel qual caso \var{errno} assumerà uno

   dei valori:
   \begin{errlist}
   \item[\errcode{ENOMEM}] non c'è memoria sufficiente per allocare i dati.
   \item[\errcode{EINVAL}] la rappresentazione testuale all'indirizzo
     \param{buf\_p} non è valida.
    \end{errlist}
   dei valori:
   \begin{errlist}
   \item[\errcode{ENOMEM}] non c'è memoria sufficiente per allocare i dati.
   \item[\errcode{EINVAL}] la rappresentazione testuale all'indirizzo
     \param{buf\_p} non è valida.
    \end{errlist}

-  ed inoltre 
-nel loro significato generico.}  
+}

 \end{funcproto}
 
 La funzione prende come argomento il puntatore ad un buffer dove si è inserita
 \end{funcproto}
 
 La funzione prende come argomento il puntatore ad un buffer dove si è inserita


@@ -5565,17 +5577,27 @@ ordinari per la gestione delle ACL (\texttt{getfacl} e \texttt{setfacl}), che
 prevede due diverse forme, estesa e breve, entrambe supportate da
 \func{acl\_from\_text}. La forma estesa prevede che sia specificata una voce
 per riga, nella forma:
 prevede due diverse forme, estesa e breve, entrambe supportate da
 \func{acl\_from\_text}. La forma estesa prevede che sia specificata una voce
 per riga, nella forma:

-\begin{Verbatim}
-  tipo:qualificatore:permessi
-\end{Verbatim}
+\begin{Example}
+tipo:qualificatore:permessi
+\end{Example}

 dove il tipo può essere uno fra \texttt{user}, \texttt{group}, \texttt{other}
 e \texttt{mask}. Il qualificatore è presente solo per \texttt{user} e
 \texttt{group} e indica l'utente o il gruppo a cui la voce si riferisce; i
 permessi sono espressi con una tripletta di lettere analoga a quella usata per
 dove il tipo può essere uno fra \texttt{user}, \texttt{group}, \texttt{other}
 e \texttt{mask}. Il qualificatore è presente solo per \texttt{user} e
 \texttt{group} e indica l'utente o il gruppo a cui la voce si riferisce; i
 permessi sono espressi con una tripletta di lettere analoga a quella usata per

-i permessi dei file.\footnote{vale a dire \texttt{r} per il permesso di
-  lettura, \texttt{w} per il permesso di scrittura, \texttt{x} per il permesso
-  di esecuzione (scritti in quest'ordine) e \texttt{-} per l'assenza del
-  permesso.}
+i permessi dei file.\footnote{vale a dire ``\texttt{r}'' per il permesso di
+  lettura, ``\texttt{w}'' per il permesso di scrittura, ``\texttt{x}'' per il
+  permesso di esecuzione (scritti in quest'ordine) e ``\texttt{-}'' per
+  l'assenza del permesso.} 
+
+Un possibile esempio di rappresentazione della ACL di un file ordinario a cui,
+oltre ai permessi ordinari, si è aggiunto un altro utente con un accesso in
+lettura, è il seguente:
+\begin{Example}
+user::rw-
+group::r--
+other::r--
+user:piccardi:r--
+\end{Example}

 
 Va precisato che i due tipi \texttt{user} e \texttt{group} sono usati
 rispettivamente per indicare delle voci relative ad utenti e
 
 Va precisato che i due tipi \texttt{user} e \texttt{group} sono usati
 rispettivamente per indicare delle voci relative ad utenti e


@@ -5595,8 +5617,8 @@ iniziali dei valori usati nella forma estesa (cioè ``\texttt{u}'',
 voce sono le stesse. In questo caso non sono consentiti permessi.
 
 Per la conversione inversa, che consente di ottenere la rappresentazione
 voce sono le stesse. In questo caso non sono consentiti permessi.
 
 Per la conversione inversa, che consente di ottenere la rappresentazione

-testuale di una ACL, sono invece disponibili due funzioni, la prima delle due,
-di uso più immediato, è \funcd{acl\_to\_text}, il cui prototipo è:
+testuale di una ACL, sono invece disponibili due funzioni. La prima delle due,
+di uso più immediato, è \funcd{acl\_to\_text}, ed il suo prototipo è:

 
 \begin{funcproto}{
 \fhead{sys/types.h}
 
 \begin{funcproto}{
 \fhead{sys/types.h}


@@ -5620,12 +5642,14 @@ contenente la rappresentazione in forma estesa della ACL passata come
 argomento, ed alloca automaticamente la memoria necessaria. Questa dovrà poi
 essere liberata, quando non più necessaria, con \func{acl\_free}. Se
 nell'argomento \param{len\_p} si passa un valore puntatore ad una variabile
 argomento, ed alloca automaticamente la memoria necessaria. Questa dovrà poi
 essere liberata, quando non più necessaria, con \func{acl\_free}. Se
 nell'argomento \param{len\_p} si passa un valore puntatore ad una variabile

-intera in questa verrà restituita la dimensione della stringa con la
-rappresentazione testuale (non comprendente il carattere nullo finale). 
+intera in questa verrà restituita (come \itindex{value~result~argument}
+\textit{value result argument}) la dimensione della stringa con la
+rappresentazione testuale, non comprendente il carattere nullo finale.
+
+La seconda funzione, che permette di controllare con dovizia di dettagli la
+generazione della stringa contenente la rappresentazione testuale della ACL, è
+\funcd{acl\_to\_any\_text}, ed il suo prototipo è:

 
 

-La seconda funzione, \funcd{acl\_to\_any\_text}, permette di controllare con
-dovizia di dettagli la generazione della stringa contenente la
-rappresentazione testuale della ACL, il suo prototipo è:

 \begin{funcproto}{
 \fhead{sys/types.h}
 \fhead{sys/acl.h}
 \begin{funcproto}{
 \fhead{sys/types.h}
 \fhead{sys/acl.h}


@@ -5699,20 +5723,19 @@ disallocato con una chiamata ad \func{acl\_free}. Si tenga presente infine che
 questa funzione è una estensione specifica di Linux, e non è presente nella
 bozza dello standard POSIX.1e.
 
 questa funzione è una estensione specifica di Linux, e non è presente nella
 bozza dello standard POSIX.1e.
 

-Per quanto utile per la visualizzazione o l'impostazione da comando delle ACL,
-la forma testuale non è la più efficiente per poter memorizzare i dati
-relativi ad una ACL, ad esempio quando si vuole eseguirne una copia a scopo di
-archiviazione. Per questo è stata prevista la possibilità di utilizzare una
-rappresentazione delle ACL in una apposita forma binaria contigua e
-persistente. È così possibile copiare il valore di una ACL in un buffer e da
-questa rappresentazione tornare indietro e generare una ACL. 
+Per quanto utile per la visualizzazione o l'impostazione da riga di comando
+delle ACL, la forma testuale non è la più efficiente per poter memorizzare i
+dati relativi ad una ACL, ad esempio quando si vuole eseguirne una copia a
+scopo di archiviazione. Per questo è stata prevista la possibilità di
+utilizzare una rappresentazione delle ACL in una apposita forma binaria
+contigua e persistente. È così possibile copiare il valore di una ACL in un
+buffer e da questa rappresentazione tornare indietro e generare una ACL.

 
 Lo standard POSIX.1e prevede a tale scopo tre funzioni, la prima e più
 semplice è \funcd{acl\_size}, che consente di ottenere la dimensione che avrà
 la citata rappresentazione binaria, in modo da poter allocare per essa un
 buffer di dimensione sufficiente, il suo prototipo è:
 
 
 Lo standard POSIX.1e prevede a tale scopo tre funzioni, la prima e più
 semplice è \funcd{acl\_size}, che consente di ottenere la dimensione che avrà
 la citata rappresentazione binaria, in modo da poter allocare per essa un
 buffer di dimensione sufficiente, il suo prototipo è:
 

-

 \begin{funcproto}{
 \fhead{sys/types.h}
 \fhead{sys/acl.h}
 \begin{funcproto}{
 \fhead{sys/types.h}
 \fhead{sys/acl.h}


@@ -5722,23 +5745,16 @@ buffer di dimensione sufficiente, il suo prototipo è:
 
 {La funzione ritorna la dimensione in byte della rappresentazione binaria
   della ACL in caso di successo e $-1$ per un errore, nel qual caso
 
 {La funzione ritorna la dimensione in byte della rappresentazione binaria
   della ACL in caso di successo e $-1$ per un errore, nel qual caso

-  \var{errno} assumerà uno dei valori:
+  \var{errno} può assumere solo il valore:

   \begin{errlist}
   \item[\errcode{EINVAL}] la ACL indicata da \param{acl} non è valida.
   \end{errlist}
 }  
 \end{funcproto}
 
   \begin{errlist}
   \item[\errcode{EINVAL}] la ACL indicata da \param{acl} non è valida.
   \end{errlist}
 }  
 \end{funcproto}
 

-
-Prima di effettuare la lettura della rappresentazione binaria è sempre
-necessario allocare un buffer di dimensione sufficiente a contenerla, pertanto
-prima si dovrà far ricorso a \funcd{acl\_size} per ottenere tale dimensione e
-poi allocare il buffer con una delle funzioni di
-sez.~\ref{sec:proc_mem_alloc}. Una volta terminato l'uso della
-rappresentazione binaria, il buffer dovrà essere esplicitamente disallocato.
-
-La funzione che consente di leggere la rappresentazione binaria di una ACL è
-\funcd{acl\_copy\_ext}, il cui prototipo è:
+Ottenuta con \func{acl\_size} la dimensione per il buffer lo si potrà allocare
+direttamente con \func{malloc}. La rappresentazione binaria di una ACL si
+potrà poi ottenere con la funzione \funcd{acl\_copy\_ext}, il cui prototipo è:

 
 \begin{funcproto}{
 \fhead{sys/types.h}
 
 \begin{funcproto}{
 \fhead{sys/types.h}


@@ -5759,74 +5775,68 @@ La funzione che consente di leggere la rappresentazione binaria di una ACL è
 }  
 \end{funcproto}
 
 }  
 \end{funcproto}
 

-La funzione salverà la rappresentazione binaria della ACL indicata da
-\param{acl} sul buffer posto all'indirizzo \param{buf\_p} e lungo \param{size}
-byte, restituendo la dimensione della stessa come valore di ritorno. Qualora
-la dimensione della rappresentazione ecceda il valore di \param{size} la
-funzione fallirà con un errore di \errcode{ERANGE}. La funzione non ha nessun
-effetto sulla ACL indicata da \param{acl}.
-
-Viceversa se si vuole ripristinare una ACL a partire dalla rappresentazione
-binaria della stessa disponibile in un buffer si potrà usare la funzione 
-\funcd{acl\_copy\_int}, il cui prototipo è:
-\begin{functions}
-  \headdecl{sys/types.h} 
-  \headdecl{sys/acl.h}
-  
-  \funcdecl{ssize\_t acl\_copy\_int(const void *buf\_p)}
+La funzione scriverà la rappresentazione binaria della ACL indicata da
+\param{acl} sul buffer di dimensione \param{size}
+all'indirizzo \param{buf\_p}, restituendo la dimensione della stessa come
+valore di ritorno. Qualora la dimensione della rappresentazione ecceda il
+valore di \param{size} la funzione fallirà con un errore di
+\errcode{ERANGE}. La funzione non ha nessun effetto sulla ACL indicata
+da \param{acl}.

 
 

-  Ripristina la rappresentazione binaria di una ACL.
+Viceversa se si vuole ripristinare una ACL a partire da una rappresentazione
+binaria si potrà usare la funzione \funcd{acl\_copy\_int}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{sys/types.h} 
+\fhead{sys/acl.h}
+\fdecl{acl\_t acl\_copy\_int(const void *buf\_p)}
+\fdesc{Ripristina la rappresentazione binaria di una ACL.} 
+}

 
 

-  \bodydesc{La funzione restituisce un oggetto di tipo \type{acl\_t} in caso
-    di successo e \code{(acl\_t)NULL} in caso di errore, nel qual caso
-    \var{errno} assumerà uno dei valori:
+{La funzione ritorna un oggetto di tipo \type{acl\_t} in caso di successo e
+  \val{NULL} per un errore, nel qual caso \var{errno} assumerà uno dei valori:

   \begin{errlist}
   \item[\errcode{EINVAL}] il buffer all'indirizzo \param{buf\_p} non contiene
     una rappresentazione corretta di una ACL.
   \item[\errcode{ENOMEM}] non c'è memoria sufficiente per allocare un oggetto
     \type{acl\_t} per la ACL richiesta.
   \end{errlist}
   \begin{errlist}
   \item[\errcode{EINVAL}] il buffer all'indirizzo \param{buf\_p} non contiene
     una rappresentazione corretta di una ACL.
   \item[\errcode{ENOMEM}] non c'è memoria sufficiente per allocare un oggetto
     \type{acl\_t} per la ACL richiesta.
   \end{errlist}

-

 }
 }

-\end{functions}
+\end{funcproto}

 
 

-La funzione in caso di successo alloca autonomamente un oggetto di tipo
-\type{acl\_t} che viene restituito come valore di ritorno con il contenuto
-della ACL rappresentata dai dati contenuti nel buffer puntato da
-\param{buf\_p}. Si ricordi che come per le precedenti funzioni l'oggetto
-\type{acl\_t} dovrà essere disallocato esplicitamente al termine del suo
-utilizzo.
+La funzione alloca autonomamente un oggetto di tipo \type{acl\_t}, restituito
+come valore di ritorno, con il contenuto della ACL rappresentata dai dati del
+buffer puntato da \param{buf\_p}. Al solito l'oggetto \type{acl\_t} dovrà
+essere disallocato esplicitamente al termine del suo utilizzo.

 
 Una volta che si disponga della ACL desiderata, questa potrà essere impostata
 su un file o una directory. Per impostare una ACL sono disponibili due
 funzioni; la prima è \funcd{acl\_set\_file}, che opera sia su file che su
 directory, ed il cui prototipo è:
 
 Una volta che si disponga della ACL desiderata, questa potrà essere impostata
 su un file o una directory. Per impostare una ACL sono disponibili due
 funzioni; la prima è \funcd{acl\_set\_file}, che opera sia su file che su
 directory, ed il cui prototipo è:

-\begin{functions}
-  \headdecl{sys/types.h} 
-  \headdecl{sys/acl.h}
-  
-  \funcdecl{int acl\_set\_file(const char *path, acl\_type\_t type, acl\_t
-    acl)}

 
 

-  Imposta una ACL su un file o una directory.
+\begin{funcproto}{
+\fhead{sys/types.}
+\fhead{sys/acl.h}
+\fdecl{int acl\_set\_file(const char *path, acl\_type\_t type, acl\_t acl)}
+\fdesc{Imposta una ACL su un file o una directory.} 
+}

 
 

-  \bodydesc{La funzione restituisce $0$ in caso di successo e $-1$ in caso di
-    errore, nel qual caso \var{errno} assumerà uno dei valori:
+{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{EACCES}] o un generico errore di accesso a \param{path} o il
     valore di \param{type} specifica una ACL il cui tipo non può essere
     assegnato a \param{path}.
   \item[\errcode{EINVAL}] o \param{acl} non è una ACL valida, o \param{type}
   \begin{errlist}
   \item[\errcode{EACCES}] o un generico errore di accesso a \param{path} o il
     valore di \param{type} specifica una ACL il cui tipo non può essere
     assegnato a \param{path}.
   \item[\errcode{EINVAL}] o \param{acl} non è una ACL valida, o \param{type}

-    ha in valore non corretto.
+    ha un valore non corretto.

   \item[\errcode{ENOSPC}] non c'è spazio disco sufficiente per contenere i
     dati aggiuntivi della ACL.
   \item[\errcode{ENOTSUP}] si è cercato di impostare una ACL su un file
     contenuto in un filesystem che non supporta le ACL.
   \end{errlist}
   \item[\errcode{ENOSPC}] non c'è spazio disco sufficiente per contenere i
     dati aggiuntivi della ACL.
   \item[\errcode{ENOTSUP}] si è cercato di impostare una ACL su un file
     contenuto in un filesystem che non supporta le ACL.
   \end{errlist}

-  ed inoltre \errval{ENOENT}, \errval{ENOTDIR}, \errval{ENAMETOOLONG},
-  \errval{EROFS}, \errval{EPERM}.
-}
-\end{functions}
+  ed inoltre \errval{ENAMETOOLONG}, \errval{ENOENT}, \errval{ENOTDIR},
+  \errval{EPERM}, \errval{EROFS} nel loro significato generico.}
+\end{funcproto}

 
 La funzione consente di assegnare la ACL contenuta in \param{acl} al file o
 alla directory indicate dal \textit{pathname} \param{path}, mentre
 
 La funzione consente di assegnare la ACL contenuta in \param{acl} al file o
 alla directory indicate dal \textit{pathname} \param{path}, mentre


@@ -5843,27 +5853,28 @@ vuota per cancellare la ACL di default associata a
   default, per i dettagli si ricorra alla pagina di manuale.}  La seconda
 funzione che consente di impostare una ACL è \funcd{acl\_set\_fd}, ed il suo
 prototipo è:
   default, per i dettagli si ricorra alla pagina di manuale.}  La seconda
 funzione che consente di impostare una ACL è \funcd{acl\_set\_fd}, ed il suo
 prototipo è:

-\begin{functions}
-  \headdecl{sys/types.h} 
-  \headdecl{sys/acl.h}
-  
-  \funcdecl{int acl\_set\_fd(int fd, acl\_t acl)}

 
 

-  Imposta una ACL su un file descriptor.
+\begin{funcproto}{
+\fhead{sys/types.h} 
+\fhead{sys/acl.h}
+\fdecl{int acl\_set\_fd(int fd, acl\_t acl)}
+\fdesc{Imposta una ACL su un file descriptor.} 
+}

 
 

-  \bodydesc{La funzione restituisce $0$ in caso di successo e $-1$ in caso di
-    errore, nel qual caso \var{errno} assumerà uno dei valori:
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+  caso \var{errno} assumerà uno dei valori: 

   \begin{errlist}
   \begin{errlist}

-  \item[\errcode{EINVAL}] o \param{acl} non è una ACL valida, o \param{type}
-    ha in valore non corretto.
+  \item[\errcode{EINVAL}] o \param{acl} non è una ACL valida, o ha più voci di
+    quante se ne possono assegnare al file indicato da \param{fd}.

   \item[\errcode{ENOSPC}] non c'è spazio disco sufficiente per contenere i
     dati aggiuntivi della ACL.
   \item[\errcode{ENOTSUP}] si è cercato di impostare una ACL su un file
     contenuto in un filesystem che non supporta le ACL.
   \end{errlist}
   \item[\errcode{ENOSPC}] non c'è spazio disco sufficiente per contenere i
     dati aggiuntivi della ACL.
   \item[\errcode{ENOTSUP}] si è cercato di impostare una ACL su un file
     contenuto in un filesystem che non supporta le ACL.
   \end{errlist}

-  ed inoltre \errval{EBADF}, \errval{EROFS}, \errval{EPERM}.
+  ed inoltre \errval{EBADF}, \errval{EPERM}, \errval{EROFS} nel loro
+  significato generico.

 }
 }

-\end{functions}
+\end{funcproto}

 
 La funzione è del tutto è analoga a \funcd{acl\_set\_file} ma opera
 esclusivamente sui file identificati tramite un file descriptor. Non dovendo
 
 La funzione è del tutto è analoga a \funcd{acl\_set\_file} ma opera
 esclusivamente sui file identificati tramite un file descriptor. Non dovendo


@@ -5879,27 +5890,27 @@ voce direttamente con le funzioni previste dallo standard POSIX.1e.  Queste
 funzioni però sono alquanto macchinose da utilizzare per cui è molto più
 semplice operare direttamente sulla rappresentazione testuale. Questo è il
 motivo per non tratteremo nei dettagli dette funzioni, fornendone solo una
 funzioni però sono alquanto macchinose da utilizzare per cui è molto più
 semplice operare direttamente sulla rappresentazione testuale. Questo è il
 motivo per non tratteremo nei dettagli dette funzioni, fornendone solo una

-descrizione sommaria; chi fosse interessato potrà ricorrere alle pagina di
+descrizione sommaria; chi fosse interessato potrà ricorrere alle pagine di

 manuale.
 
 Se si vuole operare direttamente sui contenuti di un oggetto di tipo
 \type{acl\_t} infatti occorre fare riferimento alle singole voci tramite gli
 opportuni puntatori di tipo \type{acl\_entry\_t}, che possono essere ottenuti
 manuale.
 
 Se si vuole operare direttamente sui contenuti di un oggetto di tipo
 \type{acl\_t} infatti occorre fare riferimento alle singole voci tramite gli
 opportuni puntatori di tipo \type{acl\_entry\_t}, che possono essere ottenuti

-dalla funzione \funcd{acl\_get\_entry} (per una voce esistente) o dalla
-funzione \funcd{acl\_create\_entry} per una voce da aggiungere. Nel caso della
+dalla funzione \funcm{acl\_get\_entry} (per una voce esistente) o dalla
+funzione \funcm{acl\_create\_entry} per una voce da aggiungere. Nel caso della

 prima funzione si potrà poi ripetere la lettura per ottenere i puntatori alle
 singole voci successive alla prima.
 
 Una volta ottenuti detti puntatori si potrà operare sui contenuti delle singole
 prima funzione si potrà poi ripetere la lettura per ottenere i puntatori alle
 singole voci successive alla prima.
 
 Una volta ottenuti detti puntatori si potrà operare sui contenuti delle singole

-voci; con le funzioni \funcd{acl\_get\_tag\_type}, \funcd{acl\_get\_qualifier},
-\funcd{acl\_get\_permset} si potranno leggere rispettivamente tipo,
+voci; con le funzioni \funcm{acl\_get\_tag\_type}, \funcm{acl\_get\_qualifier},
+\funcm{acl\_get\_permset} si potranno leggere rispettivamente tipo,

 qualificatore e permessi mentre con le corrispondente funzioni
 qualificatore e permessi mentre con le corrispondente funzioni

-\funcd{acl\_set\_tag\_type}, \funcd{acl\_set\_qualifier},
-\funcd{acl\_set\_permset} si possono impostare i valori; in entrambi i casi
+\funcm{acl\_set\_tag\_type}, \funcm{acl\_set\_qualifier},
+\funcm{acl\_set\_permset} si possono impostare i valori; in entrambi i casi

 vengono utilizzati tipi di dato ad hoc.\footnote{descritti nelle singole
   pagine di manuale.} Si possono poi copiare i valori di una voce da una ACL
 vengono utilizzati tipi di dato ad hoc.\footnote{descritti nelle singole
   pagine di manuale.} Si possono poi copiare i valori di una voce da una ACL

-ad un altra con \funcd{acl\_copy\_entry} o eliminare una voce da una ACL con
-\funcd{acl\_delete\_entry}.
+ad un altra con \funcm{acl\_copy\_entry} o eliminare una voce da una ACL con
+\funcm{acl\_delete\_entry}.

 
 \itindend{Access~Control~List~(ACL)}
 
 
 \itindend{Access~Control~List~(ACL)}
 


@@ -5915,10 +5926,11 @@ funzionalità ha senso solo per i filesystem su cui si mantengono i dati degli
 utenti\footnote{in genere la si attiva sul filesystem che contiene le
   \textit{home} degli utenti, dato che non avrebbe senso per i file di sistema
   che in genere appartengono all'amministratore.} essa deve essere
 utenti\footnote{in genere la si attiva sul filesystem che contiene le
   \textit{home} degli utenti, dato che non avrebbe senso per i file di sistema
   che in genere appartengono all'amministratore.} essa deve essere

-esplicitamente richiesta; questo si fa tramite due distinte opzioni di
-montaggio, \texttt{usrquota} e \texttt{grpquota} che abilitano le quote
-rispettivamente per gli utenti e per i gruppi. Grazie a questo è possibile
-usare le limitazioni sulle quote solo sugli utenti o solo sui gruppi.
+esplicitamente richiesta. Questo si fa, per tutti i filesystem che le
+supportano, tramite due distinte opzioni di montaggio, \texttt{usrquota} e
+\texttt{grpquota} che abilitano le quote rispettivamente per gli utenti e per
+i gruppi. Così è possibile usare le limitazioni sulle quote o sugli utenti o
+sui gruppi o su entrambi.

 
 Il meccanismo prevede che per ciascun filesystem che supporta le quote disco
 (i vari \textit{extN}, \textit{btrfs}, \textit{XFS}, \textit{JFS},
 
 Il meccanismo prevede che per ciascun filesystem che supporta le quote disco
 (i vari \textit{extN}, \textit{btrfs}, \textit{XFS}, \textit{JFS},


@@ -5936,14 +5948,15 @@ directory radice del filesystem su cui si sono attivate le quote;\footnote{la
   cosa vale per tutti i filesystem tranne \textit{XFS} che mantiene i dati
   internamente.} con la versione 2 del supporto delle quote, l'unica rimasta
 in uso, questi file sono \texttt{aquota.user} e \texttt{aquota.group}, in
   cosa vale per tutti i filesystem tranne \textit{XFS} che mantiene i dati
   internamente.} con la versione 2 del supporto delle quote, l'unica rimasta
 in uso, questi file sono \texttt{aquota.user} e \texttt{aquota.group}, in

-precedenza erano \texttt{quota.user} e \texttt{quota.group}. Dato che i file
-vengono aggiornati soltanto se il filesystem è stato montato con il supporto
-delle quote, se si abilita questo in un secondo tempo (o se si eseguono
-operazioni sul filesystem senza averlo abilitato) i dati contenuti possono non
-corrispondere esattamente allo stato corrente del consumo delle risorse; per
-questo in genere prima di montare in scrittura un filesystem su cui sono
-abilitate le quote in genere viene utilizzato il comando \cmd{quotacheck} per
-verificare e aggiornare i dati.
+precedenza erano \texttt{quota.user} e \texttt{quota.group}. 
+
+Dato che i file vengono aggiornati soltanto se il filesystem è stato montato
+con il supporto delle quote, se si abilita questo in un secondo tempo, o se si
+eseguono operazioni sul filesystem senza averlo abilitato, i dati contenuti
+possono non corrispondere esattamente allo stato corrente del consumo delle
+risorse. Per questo in genere prima di montare in scrittura un filesystem su
+cui sono abilitate le quote in genere viene utilizzato il comando
+\cmd{quotacheck} per verificare e aggiornare i dati.

 
 Le restrizioni sul consumo delle risorse prevedono due limiti, il primo viene
 detto \textit{soft limit} e può essere superato per brevi periodi di tempo, il
 
 Le restrizioni sul consumo delle risorse prevedono due limiti, il primo viene
 detto \textit{soft limit} e può essere superato per brevi periodi di tempo, il


@@ -5955,30 +5968,30 @@ dell'\textit{hard limit}.  Questi limiti riguardano separatamente sia lo
 spazio disco (i blocchi) che il numero di file (gli \itindex{inode}
 \textit{inode}) e devono pertanto essere specificati per entrambe le risorse.
 
 spazio disco (i blocchi) che il numero di file (gli \itindex{inode}
 \textit{inode}) e devono pertanto essere specificati per entrambe le risorse.
 

-La funzione che consente di controllare tutti i vari aspetti della gestione
-delle quote è \funcd{quotactl}, ed il suo prototipo è:
-\begin{functions}
-  \headdecl{sys/types.h} 
-  \headdecl{sys/quota.h}
-  
-  \funcdecl{quotactl(int cmd, const char *dev, int id, caddr\_t addr)}
+La funzione di sistema che consente di controllare tutti i vari aspetti della
+gestione delle quote è \funcd{quotactl}, ed il suo prototipo è:

 
 

-  Esegue una operazione di controllo sulle quote disco.
+\begin{funcproto}{
+\fhead{sys/types.h}
+\fhead{sys/quota.h}
+\fdecl{int quotactl(int cmd, const char *dev, int id, caddr\_t addr)}
+\fdesc{Esegue una operazione di controllo sulle quote disco.} 
+}

 
 

-  \bodydesc{La funzione restituisce $0$ in caso di successo e $-1$ in caso di
-    errore, nel qual caso \var{errno} assumerà uno dei valori:
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+  caso \var{errno} assumerà uno dei valori: 

   \begin{errlist}
   \begin{errlist}

-  \item[\errcode{EACCES}] il file delle quote non è un file ordinario.
-  \item[\errcode{EBUSY}] si è richiesto \const{Q\_QUOTAON} ma le quote sono
+  \item[\errcode{EACCES}] si è richiesto \const{Q\_QUOTAON}, ma il file delle
+    quote indicato da \param{addr} non esiste o non è un file ordinario.
+  \item[\errcode{EBUSY}] si è richiesto \const{Q\_QUOTAON}, ma le quote sono

     già attive.
     già attive.

-  \item[\errcode{EFAULT}] l'indirizzo \param{addr} non è valido.
+  \item[\errcode{EINVAL}] o \param{cmd} non è un comando valido,
+    o il dispositivo \param{dev} non esiste.

   \item[\errcode{EIO}] errore di lettura/scrittura sul file delle quote.
   \item[\errcode{EMFILE}] non si può aprire il file delle quote avendo
     superato il limite sul numero di file aperti nel sistema. 
   \item[\errcode{EIO}] errore di lettura/scrittura sul file delle quote.
   \item[\errcode{EMFILE}] non si può aprire il file delle quote avendo
     superato il limite sul numero di file aperti nel sistema. 

-  \item[\errcode{EINVAL}] o \param{cmd} non è un comando valido,
-    o il dispositivo \param{dev} non esiste.
-  \item[\errcode{ENODEV}] \param{dev} non corrisponde ad un \textit{mount
-      point} attivo.
+  \item[\errcode{ENODEV}] \param{dev} non corrisponde ad un
+    \itindex{mount~point} \textit{mount point} attivo.

   \item[\errcode{ENOPKG}] il kernel è stato compilato senza supporto per le
     quote. 
   \item[\errcode{ENOTBLK}] \param{dev} non è un dispositivo a blocchi.
   \item[\errcode{ENOPKG}] il kernel è stato compilato senza supporto per le
     quote. 
   \item[\errcode{ENOTBLK}] \param{dev} non è un dispositivo a blocchi.


@@ -5987,8 +6000,11 @@ delle quote è \funcd{quotactl}, ed il suo prototipo è:
     \const{Q\_SETQUOTA}, \const{Q\_SETUSE}, \const{Q\_SETQLIM} per un
     filesystem senza quote attivate.
   \end{errlist}
     \const{Q\_SETQUOTA}, \const{Q\_SETUSE}, \const{Q\_SETQLIM} per un
     filesystem senza quote attivate.
   \end{errlist}

+  ed inoltre \errval{EFAULT} e nel suo significato generico.

 }
 }

-\end{functions}
+\end{funcproto}
+
+% TODO rivedere gli errori

 
 La funzione richiede che il filesystem sul quale si vuole operare sia montato
 con il supporto delle quote abilitato; esso deve essere specificato con il
 
 La funzione richiede che il filesystem sul quale si vuole operare sia montato
 con il supporto delle quote abilitato; esso deve essere specificato con il


@@ -6002,10 +6018,18 @@ stessa.
 Il tipo di operazione che si intende effettuare deve essere indicato tramite
 il primo argomento \param{cmd}, questo in genere viene specificato con
 l'ausilio della macro \macro{QCMD}:
 Il tipo di operazione che si intende effettuare deve essere indicato tramite
 il primo argomento \param{cmd}, questo in genere viene specificato con
 l'ausilio della macro \macro{QCMD}:

-\begin{functions}
-  \funcdecl{int QCMD(subcmd,type)} Imposta il comando \param{subcmd} per il
-  tipo di quote (utente o gruppo) \param{type}.
-\end{functions}
+
+{\centering
+\vspace{3pt}
+\begin{funcbox}{
+\fhead{sys/quota.h}
+\fdecl{int \macro{QCMD}(subcmd,type)}
+\fdesc{Imposta il comando \param{subcmd} per il tipo di quote (utente o
+  gruppo) \param{type}.}
+} 
+\end{funcbox}
+}
+

 \noindent che consente di specificare, oltre al tipo di operazione, se questa
 deve applicarsi alle quote utente o alle quote gruppo, nel qual
 caso \param{type} deve essere rispettivamente \const{USRQUOTA} o
 \noindent che consente di specificare, oltre al tipo di operazione, se questa
 deve applicarsi alle quote utente o alle quote gruppo, nel qual
 caso \param{type} deve essere rispettivamente \const{USRQUOTA} o


@@ -6401,7 +6425,7 @@ in forma di tre diverse maschere binarie,\footnote{il kernel li mantiene, come
   \texttt{kernel\_cap\_t}; questo era, fino al kernel 2.6.25 definito come
   intero a 32 bit per un massimo di 32 \textit{capabilities} distinte,
   attualmente è stato aggiornato ad un vettore in grado di mantenerne fino a
   \texttt{kernel\_cap\_t}; questo era, fino al kernel 2.6.25 definito come
   intero a 32 bit per un massimo di 32 \textit{capabilities} distinte,
   attualmente è stato aggiornato ad un vettore in grado di mantenerne fino a

-  64.}  in cui ciascun bit corrisponde ad una capacità diversa. 
+  64.} in cui ciascun bit corrisponde ad una capacità diversa.

 
 L'utilizzo di tre distinti insiemi serve a fornire una interfaccia flessibile
 per l'uso delle \textit{capabilities}, con scopi analoghi a quelli per cui
 
 L'utilizzo di tre distinti insiemi serve a fornire una interfaccia flessibile
 per l'uso delle \textit{capabilities}, con scopi analoghi a quelli per cui


@@ -6967,20 +6991,18 @@ funzioni che permettono rispettivamente di leggere ed impostare i valori dei
 tre insiemi illustrati in precedenza. Queste due funzioni sono \funcd{capget}
 e \funcd{capset} e costituiscono l'interfaccia di gestione basso livello; i
 loro rispettivi prototipi sono:
 tre insiemi illustrati in precedenza. Queste due funzioni sono \funcd{capget}
 e \funcd{capset} e costituiscono l'interfaccia di gestione basso livello; i
 loro rispettivi prototipi sono:

-\begin{functions}
-  \headdecl{sys/capability.h}
-
-  \funcdecl{int capget(cap\_user\_header\_t hdrp, cap\_user\_data\_t datap)}
-  Legge le \textit{capabilities}.

 
 

-  \funcdecl{int capset(cap\_user\_header\_t hdrp, const cap\_user\_data\_t
-    datap)} 
-  Imposta le \textit{capabilities}.
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{int capget(cap\_user\_header\_t hdrp, cap\_user\_data\_t datap)}
+\fdesc{Legge le \textit{capabilities}.} 
+\fdecl{int capset(cap\_user\_header\_t hdrp, const cap\_user\_data\_t datap)} 
+\fdesc{Imposta le \textit{capabilities}.} 
+}

 
 

-  
-  \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 in caso
-    di errore, nel qual caso \var{errno} può assumere i valori:
-    \begin{errlist}
+{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{ESRCH}] si è fatto riferimento ad un processo inesistente.
     \item[\errcode{EPERM}] si è tentato di aggiungere una capacità
       nell'insieme delle \textit{capabilities} permesse, o di impostare una
     \item[\errcode{ESRCH}] si è fatto riferimento ad un processo inesistente.
     \item[\errcode{EPERM}] si è tentato di aggiungere una capacità
       nell'insieme delle \textit{capabilities} permesse, o di impostare una


@@ -6989,9 +7011,10 @@ loro rispettivi prototipi sono:
       \textit{capability} di un altro processo senza avare
       \const{CAP\_SETPCAP}. 
   \end{errlist}
       \textit{capability} di un altro processo senza avare
       \const{CAP\_SETPCAP}. 
   \end{errlist}

-  ed inoltre \errval{EFAULT} ed \errval{EINVAL}.
-}
-\end{functions}
+  ed inoltre  \errval{EFAULT} ed \errval{EINVAL}
+ nel loro significato generico.}
+\end{funcproto}
+

 
 Queste due funzioni prendono come argomenti due tipi di dati dedicati,
 definiti come puntatori a due strutture specifiche di Linux, illustrate in
 
 Queste due funzioni prendono come argomenti due tipi di dati dedicati,
 definiti come puntatori a due strutture specifiche di Linux, illustrate in


@@ -7075,17 +7098,18 @@ pertanto non soltanto fornisce le funzioni per modificare e leggere le
 La prima funzione dell'interfaccia è quella che permette di inizializzare un
 \textit{capability state}, allocando al contempo la memoria necessaria per i
 relativi dati. La funzione è \funcd{cap\_init} ed il suo prototipo è:
 La prima funzione dell'interfaccia è quella che permette di inizializzare un
 \textit{capability state}, allocando al contempo la memoria necessaria per i
 relativi dati. La funzione è \funcd{cap\_init} ed il suo prototipo è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{cap\_t cap\_init(void)} 
-  Crea ed inizializza un \textit{capability state}.
-  
-  \bodydesc{La funzione ritorna un valore non nullo in caso di successo e
-    \val{NULL} in caso di errore, nel qual caso \var{errno} assumerà il
-    valore \errval{ENOMEM}.
-  }
-\end{functions}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{cap\_t cap\_init(void)}
+\fdesc{Crea ed inizializza un \textit{capability state}.} 
+}
+
+{La funzione ritorna un valore non nullo in caso di successo e\val{NULL} per
+  un errore, nel qual caso \var{errno} potrà assumere solo il valore
+  \errval{ENOMEM}.
+}
+\end{funcproto}

 
 La funzione restituisce il puntatore \type{cap\_t} ad uno stato inizializzato
 con tutte le \textit{capabilities} azzerate. In caso di errore (cioè quando
 
 La funzione restituisce il puntatore \type{cap\_t} ad uno stato inizializzato
 con tutte le \textit{capabilities} azzerate. In caso di errore (cioè quando


@@ -7095,16 +7119,18 @@ mantenere i dati viene automaticamente allocata da \func{cap\_init}, ma dovrà
 essere disallocata esplicitamente quando non è più necessaria utilizzando, per
 questo l'interfaccia fornisce una apposita funzione, \funcd{cap\_free}, il cui
 prototipo è:
 essere disallocata esplicitamente quando non è più necessaria utilizzando, per
 questo l'interfaccia fornisce una apposita funzione, \funcd{cap\_free}, il cui
 prototipo è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{int cap\_free(void *obj\_d)} 
-  Disalloca la memoria allocata per i dati delle \textit{capabilities}.
-  
-  \bodydesc{La funzione ritorna 0 in caso di successo e $-1$ in caso di
-    errore, nel qual caso \var{errno} assumerà il valore \errval{EINVAL}.
-  }
-\end{functions}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{int cap\_free(void *obj\_d)}
+\fdesc{Disalloca la memoria allocata per i dati delle \textit{capabilities}..} 
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+  caso \var{errno} potrà assumere solo il valore \errval{EINVAL}.
+}
+\end{funcproto}
+

 
 La funzione permette di liberare la memoria allocata dalle altre funzioni
 della libreria sia per un \textit{capability state}, nel qual caso l'argomento
 
 La funzione permette di liberare la memoria allocata dalle altre funzioni
 della libreria sia per un \textit{capability state}, nel qual caso l'argomento


@@ -7118,17 +7144,18 @@ fallirà con un errore di \errval{EINVAL}.
 
 Infine si può creare una copia di un \textit{capability state} ottenuto in
 precedenza tramite la funzione \funcd{cap\_dup}, il cui prototipo è:
 
 Infine si può creare una copia di un \textit{capability state} ottenuto in
 precedenza tramite la funzione \funcd{cap\_dup}, il cui prototipo è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{cap\_t cap\_dup(cap\_t cap\_p)} 
-  Duplica un \textit{capability state} restituendone una copia.
-  
-  \bodydesc{La funzione ritorna un valore non nullo in caso di successo e
-    \val{NULL} in caso di errore, nel qual caso \var{errno} potrà assumere i
-    valori \errval{ENOMEM} o \errval{EINVAL}.  
-  }
-\end{functions}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{cap\_t cap\_dup(cap\_t cap\_p)}
+\fdesc{Duplica un \textit{capability state} restituendone una copia.} 
+}
+
+{La funzione ritorna un valore non nullo in caso di successo e \val{NULL} per
+  un errore, nel qual caso \var{errno} assumerà valori \errval{ENOMEM} o
+  \errval{EINVAL} nel loro significato generico.}
+\end{funcproto}
+

 
 La funzione crea una copia del \textit{capability state} posto all'indirizzo
 \param{cap\_p} che si è passato come argomento, restituendo il puntatore alla
 
 La funzione crea una copia del \textit{capability state} posto all'indirizzo
 \param{cap\_p} che si è passato come argomento, restituendo il puntatore alla


@@ -7142,17 +7169,18 @@ indipendente.\footnote{alla fine delle operazioni si ricordi però di
 Una seconda classe di funzioni di servizio previste dall'interfaccia sono
 quelle per la gestione dei dati contenuti all'interno di un \textit{capability
   state}; la prima di queste è \funcd{cap\_clear}, il cui prototipo è:
 Una seconda classe di funzioni di servizio previste dall'interfaccia sono
 quelle per la gestione dei dati contenuti all'interno di un \textit{capability
   state}; la prima di queste è \funcd{cap\_clear}, il cui prototipo è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{int cap\_clear(cap\_t cap\_p)} 
-  Inizializza un \textit{capability state} cancellando tutte le
-  \textit{capabilities}.
-  
-  \bodydesc{La funzione ritorna 0 in caso di successo e $-1$ in caso di
-    errore, nel qual caso \var{errno} assumerà il valore \errval{EINVAL}.
-  }
-\end{functions}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{int cap\_clear(cap\_t cap\_p)}
+\fdesc{Inizializza un \textit{capability state} cancellando tutte le
+  \textit{capabilities}.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+  caso \var{errno} potrà assumere solo il valore \errval{EINVAL}.
+}
+\end{funcproto}

 
 La funzione si limita ad azzerare tutte le \textit{capabilities} presenti nel
 \textit{capability state} all'indirizzo \param{cap\_p} passato come argomento,
 
 La funzione si limita ad azzerare tutte le \textit{capabilities} presenti nel
 \textit{capability state} all'indirizzo \param{cap\_p} passato come argomento,


@@ -7181,17 +7209,18 @@ Una variante di \func{cap\_clear} è \funcd{cap\_clear\_flag} che cancella da
 un \textit{capability state} tutte le \textit{capabilities} di un certo
 insieme fra quelli di pag.~\pageref{sec:capabilities_set}, il suo prototipo
 è:
 un \textit{capability state} tutte le \textit{capabilities} di un certo
 insieme fra quelli di pag.~\pageref{sec:capabilities_set}, il suo prototipo
 è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{int cap\_clear\_flag(cap\_t cap\_p, cap\_flag\_t flag)} 
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{int cap\_clear\_flag(cap\_t cap\_p, cap\_flag\_t flag)} 
+\fdesc{ncella dal \textit{capability state} \param{cap\_p} tutte le
+  \textit{capabilities} dell'insieme \param{flag}.} 
+}

 
 

-  Cancella dal \textit{capability state} \param{cap\_p} tutte le
-  \textit{capabilities} dell'insieme \param{flag}.
-  
-  \bodydesc{La funzione ritorna 0 in caso di successo e $-1$ in caso di
-    errore, nel qual caso \var{errno} assumerà il valore \errval{EINVAL}.  }
-\end{functions}
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+  caso \var{errno}  potrà assumere solo il valore \errval{EINVAL}.
+}
+\end{funcproto}

 
 La funzione richiede che si indichi quale degli insiemi si intente cancellare
 con l'argomento \param{flag}. Questo deve essere specificato con una variabile
 
 La funzione richiede che si indichi quale degli insiemi si intente cancellare
 con l'argomento \param{flag}. Questo deve essere specificato con una variabile


@@ -7203,15 +7232,17 @@ illustrati in tab.~\ref{tab:cap_set_identifier}.
 Si possono inoltre confrontare in maniera diretta due diversi
 \textit{capability state} con la funzione \funcd{cap\_compare}; il suo
 prototipo è:
 Si possono inoltre confrontare in maniera diretta due diversi
 \textit{capability state} con la funzione \funcd{cap\_compare}; il suo
 prototipo è:

-\begin{functions}
-  \headdecl{sys/capability.h}
-  \funcdecl{int cap\_compare(cap\_t cap\_a, cap\_t cap\_b)}

 
 

-  Confronta due \textit{capability state}.
-  
-  \bodydesc{La funzione ritorna 0 se i \textit{capability state} sono identici
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{int cap\_compare(cap\_t cap\_a, cap\_t cap\_b)}
+\fdesc{Confronta due \textit{capability state}.} 
+}
+
+{La funzione ritorna $0$ se i \textit{capability state} sono identici

     ed un valore positivo se differiscono, non sono previsti errori.}
     ed un valore positivo se differiscono, non sono previsti errori.}

-\end{functions}
+\end{funcproto}
+

 
 La funzione esegue un confronto fra i due \textit{capability state} passati
 come argomenti e ritorna in un valore intero il risultato, questo è nullo se
 
 La funzione esegue un confronto fra i due \textit{capability state} passati
 come argomenti e ritorna in un valore intero il risultato, questo è nullo se


@@ -7219,10 +7250,17 @@ sono identici o positivo se vi sono delle differenze. Il valore di ritorno
 della funzione consente inoltre di per ottenere ulteriori informazioni su
 quali sono gli insiemi di \textit{capabilities} che risultano differenti.  Per
 questo si può infatti usare la apposita macro \macro{CAP\_DIFFERS}:
 della funzione consente inoltre di per ottenere ulteriori informazioni su
 quali sono gli insiemi di \textit{capabilities} che risultano differenti.  Per
 questo si può infatti usare la apposita macro \macro{CAP\_DIFFERS}:

-\begin{functions}
-  \funcdecl{int CAP\_DIFFERS(value, flag)} Controlla lo stato di eventuali
-  differenze delle \textit{capabilities} nell'insieme \texttt{flag}.
-\end{functions}
+
+{\centering
+\vspace{3pt}
+\begin{funcbox}{
+\fhead{sys/capability.h}
+\fdecl{int \macro{CAP\_DIFFERS}(value, flag)}
+\fdesc{Controlla lo stato di eventuali differenze delle \textit{capabilities}
+  nell'insieme \texttt{flag}.}
+}
+\end{funcbox}
+}

 
 La macro che richiede si passi nell'argomento \texttt{value} il risultato
 della funzione \func{cap\_compare} e in \texttt{flag} l'indicazione (coi
 
 La macro che richiede si passi nell'argomento \texttt{value} il risultato
 della funzione \func{cap\_compare} e in \texttt{flag} l'indicazione (coi


@@ -7235,21 +7273,21 @@ Per la gestione dei singoli valori delle \textit{capabilities} presenti in un
 \funcd{cap\_get\_flag} e \funcd{cap\_set\_flag}, che permettono
 rispettivamente di leggere o impostare il valore di una capacità all'interno
 in uno dei tre insiemi già citati; i rispettivi prototipi sono:
 \funcd{cap\_get\_flag} e \funcd{cap\_set\_flag}, che permettono
 rispettivamente di leggere o impostare il valore di una capacità all'interno
 in uno dei tre insiemi già citati; i rispettivi prototipi sono:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{int cap\_get\_flag(cap\_t cap\_p, cap\_value\_t cap, cap\_flag\_t
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{int cap\_get\_flag(cap\_t cap\_p, cap\_value\_t cap, cap\_flag\_t

     flag, cap\_flag\_value\_t *value\_p)}
     flag, cap\_flag\_value\_t *value\_p)}

-  Legge il valore di una \textit{capability}.
+\fdesc{Legge il valore di una \textit{capability}.}
+\fdecl{int cap\_set\_flag(cap\_t cap\_p, cap\_flag\_t flag, int ncap,
+  cap\_value\_t *caps, cap\_flag\_value\_t value)} 
+\fdesc{Imposta il valore di una \textit{capability}.} 
+}

 
 

-  \funcdecl{int cap\_set\_flag(cap\_t cap\_p, cap\_flag\_t flag, int ncap,
-    cap\_value\_t *caps, cap\_flag\_value\_t value)} 
-  Imposta il valore di una \textit{capability}.
-  
-  \bodydesc{Le funzioni ritornano 0 in caso di successo e $-1$ in caso di
-    errore, nel qual caso \var{errno} assumerà il valore \errval{EINVAL}.
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+  caso \var{errno} potrà assumere solo il valore \errval{EINVAL}.  

 }
 }

-\end{functions}
+\end{funcproto}

 
 In entrambe le funzioni l'argomento \param{cap\_p} indica il puntatore al
 \textit{capability state} su cui operare, mentre l'argomento \param{flag}
 
 In entrambe le funzioni l'argomento \param{cap\_p} indica il puntatore al
 \textit{capability state} su cui operare, mentre l'argomento \param{flag}


@@ -7311,19 +7349,18 @@ di un \textit{capability state} e fornisce le opportune funzioni di
 gestione;\footnote{entrambe erano previste dalla bozza dello standard
   POSIX.1e.} la prima di queste, che consente di ottenere la rappresentazione
 testuale, è \funcd{cap\_to\_text}, il cui prototipo è:
 gestione;\footnote{entrambe erano previste dalla bozza dello standard
   POSIX.1e.} la prima di queste, che consente di ottenere la rappresentazione
 testuale, è \funcd{cap\_to\_text}, il cui prototipo è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{char * cap\_to\_text(cap\_t caps, ssize\_t * length\_p)}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{char * cap\_to\_text(cap\_t caps, ssize\_t * length\_p)}
+\fdesc{Genera una visualizzazione testuale delle \textit{capabilities}.} 
+}

 
 

-  Genera una visualizzazione testuale delle \textit{capabilities}.
-  
-  \bodydesc{La funzione ritorna un puntatore alla stringa con la descrizione
-    delle \textit{capabilities} in caso di successo e \val{NULL} in caso di
-    errore, nel qual caso \var{errno} può assumere i valori \errval{EINVAL} o
-    \errval{ENOMEM}.
-  }
-\end{functions}
+{La funzione ritorna un puntatore alla stringa con la descrizione delle
+  \textit{capabilities} in caso di successo e \val{NULL} per un errore, nel
+  qual caso \var{errno} assumerà i valori \errval{EINVAL} o \errval{ENOMEM}
+  nel loro significato generico.}
+\end{funcproto}

 
 La funzione ritorna l'indirizzo di una stringa contente la descrizione
 testuale del contenuto del \textit{capability state} \param{caps} passato come
 
 La funzione ritorna l'indirizzo di una stringa contente la descrizione
 testuale del contenuto del \textit{capability state} \param{caps} passato come


@@ -7383,17 +7420,18 @@ detto processo.
 Viceversa per passare ottenere un \textit{capability state} dalla sua
 rappresentazione testuale si può usare \funcd{cap\_from\_text}, il cui
 prototipo è:
 Viceversa per passare ottenere un \textit{capability state} dalla sua
 rappresentazione testuale si può usare \funcd{cap\_from\_text}, il cui
 prototipo è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{cap\_t cap\_from\_text(const char *string)}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{cap\_t cap\_from\_text(const char *string)}
+\fdesc{Crea un \textit{capability state} dalla sua rappresentazione testuale.} 
+}

 
 

-  Crea un \textit{capability state} dalla sua rappresentazione testuale.
+{La funzione ritorna un puntatore valid in caso di successo e \val{NULL} per
+  un errore, nel qual caso \var{errno} assumerà i valori \errval{EINVAL} o
+  \errval{ENOMEM} nel loro significato generico.}
+\end{funcproto}

 
 

-  \bodydesc{La funzione ritorna un puntatore valido in caso di successo e
-    \val{NULL} in caso di errore, nel qual caso \var{errno} può assumere i
-    valori \errval{EINVAL} o \errval{ENOMEM}.}
-\end{functions}

 
 La funzione restituisce il puntatore ad un \textit{capability state}
 inizializzato con i valori indicati nella stringa \param{string} che ne
 
 La funzione restituisce il puntatore ad un \textit{capability state}
 inizializzato con i valori indicati nella stringa \param{string} che ne


@@ -7406,20 +7444,22 @@ convertire i valori delle costanti di tab.~\ref{tab:proc_capabilities} nelle
 stringhe usate nelle rispettive rappresentazioni e viceversa. Le due funzioni,
 \funcd{cap\_to\_name} e \funcd{cap\_from\_name}, sono estensioni specifiche di
 Linux ed i rispettivi prototipi sono:
 stringhe usate nelle rispettive rappresentazioni e viceversa. Le due funzioni,
 \funcd{cap\_to\_name} e \funcd{cap\_from\_name}, sono estensioni specifiche di
 Linux ed i rispettivi prototipi sono:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{char * cap\_to\_name(cap\_value\_t cap)}
-  \funcdecl{int cap\_from\_name(const char *name, cap\_value\_t *cap\_p)}
-  Convertono le \textit{capabilities} dalle costanti alla rappresentazione
-  testuale e viceversa.
-  
-  \bodydesc{La funzione \func{cap\_to\_name} ritorna un valore diverso da
-    \val{NULL} in caso di successo e \val{NULL} in caso di errore, mentre
-    \func{cap\_to\_name} ritorna rispettivamente 0 e $-1$; per entrambe in
-    caso di errore \var{errno} può assumere i valori \errval{EINVAL} o
-    \errval{ENOMEM}.  }
-\end{functions}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{char * cap\_to\_name(cap\_value\_t cap)}
+\fdecl{int cap\_from\_name(const char *name, cap\_value\_t *cap\_p)}
+
+\fdesc{Convertono le \textit{capabilities} dalle costanti alla rappresentazione
+  testuale e viceversa.} 
+}
+
+{La funzione \func{cap\_to\_name} ritorna un puntatore ad una stringa in caso
+  di successo e \val{NULL} per un errore, mentre \func{cap\_to\_name} ritorna
+  $0$ in caso di successo e $-1$ nel qual caso di errore, per entrambe
+  \var{errno}può assumere i valori \errval{EINVAL} o \errval{ENOMEM}.
+}
+\end{funcproto}

 
 La prima funzione restituisce la stringa (allocata automaticamente e che dovrà
 essere liberata con \func{cap\_free}) che corrisponde al valore della
 
 La prima funzione restituisce la stringa (allocata automaticamente e che dovrà
 essere liberata con \func{cap\_free}) che corrisponde al valore della


@@ -7433,16 +7473,18 @@ l'interfaccia di gestione prevede però anche le funzioni per trattare le
 \textit{capabilities} presenti nei processi. La prima di queste funzioni è
 \funcd{cap\_get\_proc} che consente la lettura delle \textit{capabilities} del
 processo corrente, il suo prototipo è:
 \textit{capabilities} presenti nei processi. La prima di queste funzioni è
 \funcd{cap\_get\_proc} che consente la lettura delle \textit{capabilities} del
 processo corrente, il suo prototipo è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{cap\_t cap\_get\_proc(void)}
-  Legge le \textit{capabilities} del processo corrente.
-  
-  \bodydesc{La funzione ritorna un valore diverso da \val{NULL} in caso di
-    successo e \val{NULL} in caso di errore, nel qual caso \var{errno} può
-    assumere i valori \errval{EINVAL}, \errval{EPERM} o \errval{ENOMEM}.  }
-\end{functions}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{cap\_t cap\_get\_proc(void)}
+\fdesc{Legge le \textit{capabilities} del processo corrente.} 
+}
+
+{La funzione ritorna un valore diverso da \val{NULL} in caso di successo e
+  \val{NULL} per un errore, nel qual caso \var{errno} assumerà i valori
+  \errval{EINVAL}, \errval{EPERM} o \errval{ENOMEM} nel loro significato
+  generico.}
+\end{funcproto}

 
 La funzione legge il valore delle \textit{capabilities} associate al processo
 da cui viene invocata, restituendo il risultato tramite il puntatore ad un
 
 La funzione legge il valore delle \textit{capabilities} associate al processo
 da cui viene invocata, restituendo il risultato tramite il puntatore ad un


@@ -7456,17 +7498,18 @@ prototipo\footnote{su alcune pagine di manuale la funzione è descritta con un
   prototipo sbagliato, che prevede un valore di ritorno di tipo \type{cap\_t},
   ma il valore di ritorno è intero, come si può verificare anche dalla
   dichiarazione della stessa in \headfile{sys/capability.h}.} è:
   prototipo sbagliato, che prevede un valore di ritorno di tipo \type{cap\_t},
   ma il valore di ritorno è intero, come si può verificare anche dalla
   dichiarazione della stessa in \headfile{sys/capability.h}.} è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{int capgetp(pid\_t pid, cap\_t cap\_d)}
-  Legge le \textit{capabilities} del processo indicato da \param{pid}.
-  
-  \bodydesc{La funzione ritorna 0 in caso di successo e $-1$ in caso di
-    errore, nel qual caso \var{errno} può assumere i valori \errval{EINVAL},
-    \errval{EPERM} o \errval{ENOMEM}.  
-  }
-\end{functions}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{int capgetp(pid\_t pid, cap\_t cap\_d)}
+\fdesc{Legge le \textit{capabilities} di un processo.} 
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+  caso \var{errno} assumerà i valori \errval{EINVAL}, \errval{EPERM} o
+  \errval{ENOMEM} nel loro significato generico.}
+\end{funcproto}
+

 %TODO controllare e correggere i codici di errore!!!
 
 La funzione legge il valore delle \textit{capabilities} del processo indicato
 %TODO controllare e correggere i codici di errore!!!
 
 La funzione legge il valore delle \textit{capabilities} del processo indicato


@@ -7490,17 +7533,17 @@ Infine per impostare le \textit{capabilities} del processo corrente (non
 esiste una funzione che permetta di cambiare le \textit{capabilities} di un
 altro processo) si deve usare la funzione \funcd{cap\_set\_proc}, il cui
 prototipo è:
 esiste una funzione che permetta di cambiare le \textit{capabilities} di un
 altro processo) si deve usare la funzione \funcd{cap\_set\_proc}, il cui
 prototipo è:

-\begin{functions}
-  \headdecl{sys/capability.h}

 
 

-  \funcdecl{int cap\_set\_proc(cap\_t cap\_p)}
-  Imposta le \textit{capabilities} del processo corrente.
-  
-  \bodydesc{La funzione ritorna 0 in caso di successo e $-1$ in caso di
-    errore, nel qual caso \var{errno} può assumere i valori \errval{EINVAL},
-    \errval{EPERM} o \errval{ENOMEM}.  
-  }
-\end{functions}
+\begin{funcproto}{
+\fhead{sys/capability.h}
+\fdecl{int cap\_set\_proc(cap\_t cap\_p)}
+\fdesc{Imposta le \textit{capabilities} del processo corrente.} 
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+  caso \var{errno} assumerà i valori \errval{EINVAL}, \errval{EPERM} o
+  \errval{ENOMEM} nel loro significato generico.}
+\end{funcproto}

 
 La funzione modifica le \textit{capabilities} del processo corrente secondo
 quanto specificato con l'argomento \param{cap\_p}, posto che questo sia
 
 La funzione modifica le \textit{capabilities} del processo corrente secondo
 quanto specificato con l'argomento \param{cap\_p}, posto che questo sia


@@ -7597,27 +7640,31 @@ dalla stessa directory, che corrisponde alla radice del sistema.
 In certe situazioni però è utile poter impedire che un processo possa accedere
 a tutto il filesystem; per far questo si può cambiare la sua directory radice
 con la funzione \funcd{chroot}, il cui prototipo è:
 In certe situazioni però è utile poter impedire che un processo possa accedere
 a tutto il filesystem; per far questo si può cambiare la sua directory radice
 con la funzione \funcd{chroot}, il cui prototipo è:

-\begin{prototype}{unistd.h}{int chroot(const char *path)}
-  Cambia la directory radice del processo a quella specificata da
-  \param{path}.
-  
-\bodydesc{La funzione restituisce zero in caso di successo e -1 per
-    un errore, in caso di errore \var{errno} può assumere i valori:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{int chroot(const char *path)}
+\fdesc{Cambia la directory radice del processo.} 
+}
+
+{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{EPERM}] l'\ids{UID} effettivo del processo non è zero.
   \end{errlist}
   \begin{errlist}
   \item[\errcode{EPERM}] l'\ids{UID} effettivo del processo non è zero.
   \end{errlist}

-  ed inoltre \errval{EFAULT}, \errval{ENAMETOOLONG}, \errval{ENOENT},
+  ed inoltre errval{EFAULT}, \errval{ENAMETOOLONG}, \errval{ENOENT},

   \errval{ENOMEM}, \errval{ENOTDIR}, \errval{EACCES}, \errval{ELOOP};
   \errval{ENOMEM}, \errval{ENOTDIR}, \errval{EACCES}, \errval{ELOOP};

-  \errval{EROFS} e \errval{EIO}.}
-\end{prototype}
-\noindent in questo modo la directory radice del processo diventerà
+  \errval{EROFS} e \errval{EIO} nel loro significato generico.}
+\end{funcproto}
+
+La funzione  la directory radice del processo a quella specificata da

 \param{path} (che ovviamente deve esistere) ed ogni
 \param{path} (che ovviamente deve esistere) ed ogni

-\itindsub{pathname}{assoluto}\textit{pathname} assoluto usato dalle funzioni
+\itindsub{pathname}{assoluto} \textit{pathname} assoluto usato dalle funzioni

 chiamate nel processo sarà risolto a partire da essa, rendendo impossibile
 accedere alla parte di albero sovrastante.  Si ha così quella che viene
 chiamata una \textit{chroot jail}, in quanto il processo non può più accedere
 a file al di fuori della sezione di albero in cui è stato
 chiamate nel processo sarà risolto a partire da essa, rendendo impossibile
 accedere alla parte di albero sovrastante.  Si ha così quella che viene
 chiamata una \textit{chroot jail}, in quanto il processo non può più accedere
 a file al di fuori della sezione di albero in cui è stato

-\textsl{imprigionato}. 
+\textsl{imprigionato}.

 
 Solo un processo con i privilegi di amministratore può usare questa funzione,
 e la nuova radice, per quanto detto in sez.~\ref{sec:proc_fork}, sarà ereditata
 
 Solo un processo con i privilegi di amministratore può usare questa funzione,
 e la nuova radice, per quanto detto in sez.~\ref{sec:proc_fork}, sarà ereditata