From: Simone Piccardi <piccardi@gnulinux.it>
Date: Sat, 17 Aug 2002 10:13:17 +0000 (+0000)
Subject: Correzione mutiple del tipo effective user id in userid effettivo
X-Git-Url: https://gapil.gnulinux.it/gitweb/?a=commitdiff_plain;h=5099573b0239402d8860e2c0af07c8eb3378b865;p=gapil.git

Correzione mutiple del tipo effective user id in userid effettivo
---

diff --git a/fileadv.tex b/fileadv.tex
index 6095c58..a3118b0 100644
--- a/fileadv.tex
+++ b/fileadv.tex
@@ -1249,14 +1249,14 @@ opportune verifiche nei processi, questo verrebbe comunque rispettato.
 
 Per poter utilizzare il \textit{mandatory locking} è stato introdotto un
 utilizzo particolare del bit \acr{suid}. Se si ricorda quanto esposto in
-\secref{sec:file_suid_sgid}), esso viene di norma utlizzato per cambiare
-l'\textit{effective user ID} con cui viene eseguito un programma, ed è
-pertanto sempre associato alla presenza del permesso di esecuzione. Impostando
-questo bit su un file senza permesso di esecuzione in un sistema che supporta
-il \textit{mandatory locking}, fa sì che quest'ultimo venga attivato per il
-file in questione. In questo modo una combinaizone dei permessi
-originariamente non contemplata, in quanto senza significato, diventa
-l'indicazione della presenza o meno del \textit{mandatory locking}.
+\secref{sec:file_suid_sgid}), esso viene di norma utilizzato per cambiare
+l'userid effettivo con cui viene eseguito un programma, ed è pertanto sempre
+associato alla presenza del permesso di esecuzione. Impostando questo bit su
+un file senza permesso di esecuzione in un sistema che supporta il
+\textit{mandatory locking}, fa sì che quest'ultimo venga attivato per il file
+in questione. In questo modo una combinaizone dei permessi originariamente non
+contemplata, in quanto senza significato, diventa l'indicazione della presenza
+o meno del \textit{mandatory locking}.
 
 
 
diff --git a/filedir.tex b/filedir.tex
index b734c44..c1bb182 100644
--- a/filedir.tex
+++ b/filedir.tex
@@ -480,7 +480,7 @@ suo prototipo 
   \begin{errlist}
   \item[\macro{EPERM}] Il filesystem non supporta la cancellazione di
     directory, oppure la directory che contiene \var{dirname} ha lo sticky bit
-    impostato e l'\textit{effective user id} del processo non corrisponde al
+    impostato e l'userid effettivo del processo non corrisponde al
     proprietario della directory.
   \item[\macro{EACCESS}] Non c'è il permesso di scrittura per la directory che
     contiene la directory che si vuole cancellare, o non c'è il permesso di
@@ -1467,29 +1467,29 @@ in una directory con lo \textsl{sticky bit} impostato (si veda
 La procedura con cui il kernel stabilisce se un processo possiede un certo
 permesso (di lettura, scrittura o esecuzione) si basa sul confronto fra
 l'utente e il gruppo a cui il file appartiene (i valori di \var{st\_uid} e
-\var{st\_gid} accennati in precedenza) e l'\textit{effective user id},
-l'\textit{effective group id} e gli eventuali \textit{supplementary group id}
-del processo.\footnote{in realtà Linux per quanto riguarda l'accesso ai file
-  utilizza al posto degli \textit{effective id} i \textit{filesystem id} (si
-  veda \secref{sec:proc_perms}), ma essendo questi del tutto equivalenti ai
-  primi, eccetto il caso in cui si voglia scrivere un server NFS, ignoreremo
-  questa differenza.}
+\var{st\_gid} accennati in precedenza) e l'userid effettivo, il groupid
+effettivo e gli eventuali groupid supplementari del processo.\footnote{in
+  realtà Linux, per quanto riguarda l'accesso ai file, utilizza gli gli
+  identificatori del gruppo \textit{filesystem} (si ricordi quanto esposto in
+  \secref{sec:proc_perms}), ma essendo questi del tutto equivalenti ai primi,
+  eccetto il caso in cui si voglia scrivere un server NFS, ignoreremo questa
+  differenza.}
 
 Per una spiegazione dettagliata degli identificatori associati ai processi si
 veda \secref{sec:proc_perms}; normalmente, a parte quanto vedremo in
-\secref{sec:file_suid_sgid}, l'\textit{effective user id} e
-l'\textit{effective group id} corrispondono a \acr{uid} e \acr{gid}
-dell'utente che ha lanciato il processo, mentre i \textit{supplementary group
-  id} sono quelli dei gruppi cui l'utente appartiene.
+\secref{sec:file_suid_sgid}, l'userid effettivo e il groupid effectivo
+corrispondono ai valori dell'\acr{uid} e del \acr{gid} dell'utente che ha
+lanciato il processo, mentre i groupid supplementari sono quelli dei gruppi
+cui l'utente appartiene.
 
 I passi attraverso i quali viene stabilito se il processo possiede il diritto
 di accesso sono i seguenti:
 \begin{enumerate}
-\item Se l'\textit{effective user id} del processo è zero (corrispondente
+\item Se l'userid effettivo del processo è zero (corrispondente
   all'amministratore) l'accesso è sempre garantito senza nessun ulteriore
   controllo. Per questo motivo \textsl{root} ha piena libertà di accesso a
   tutti i file.
-\item Se l'\textit{effective user id} del processo è uguale all'\acr{uid} del
+\item Se l'userid effettivo del processo è uguale all'\acr{uid} del
   proprietario del file (nel qual caso si dice che il processo è proprietario
   del file) allora:
   \begin{itemize*}
@@ -1499,9 +1499,8 @@ di accesso sono i seguenti:
     impostato, l'accesso è consentito
   \item altrimenti l'accesso è negato
   \end{itemize*}
-\item Se l'\textit{effective group id} del processo o uno dei
-  \textit{supplementary group id} dei processi corrispondono al \acr{gid} del
-  file allora:
+\item Se il groupid effettivo del processo o uno dei groupid supplementari dei
+  processi corrispondono al \acr{gid} del file allora:
   \begin{itemize*}
   \item se il bit dei permessi d'accesso del gruppo è impostato, l'accesso è
     consentito, 
@@ -1531,18 +1530,17 @@ sono i bit detti \acr{suid} (da \textit{set-user-ID bit}) e \acr{sgid} (da
 \macro{S\_ISUID} e \macro{S\_ISGID}.
 
 Come spiegato in dettaglio in \secref{sec:proc_exec}, quando si lancia un
-programma il comportamento normale del kernel è quello di impostare
-l'\textit{effective user id} e l'\textit{effective group id} del nuovo
-processo all'\acr{uid} e al \acr{gid} del processo corrente, che normalmente
+programma il comportamento normale del kernel è quello di impostare gli
+identificatori del gruppo \textit{effective} del nuovo processo al valore dei
+corrispondenti del gruppo \textit{real} del processo corrente, che normalmente
 corrispondono dell'utente con cui si è entrati nel sistema.
 
 Se però il file del programma\footnote{per motivi di sicurezza il kernel
   ignora i bit \acr{suid} e \acr{sgid} per gli script eseguibili.} (che
 ovviamente deve essere eseguibile) ha il bit \acr{suid} impostato, il kernel
-assegnerà come \textit{effective user id} al nuovo processo l'\acr{uid} del
-proprietario del file al posto dell'\acr{uid} del processo originario.  Avere
-il bit \acr{sgid} impostato ha lo stesso effetto sull'\textit{effective group
-  id} del processo.
+assegnerà come userid effettivo al nuovo processo l'\acr{uid} del proprietario
+del file al posto dell'\acr{uid} del processo originario.  Avere il bit
+\acr{sgid} impostato ha lo stesso effetto sul groupid effettivo del processo.
 
 I bit \acr{suid} e \acr{sgid} vengono usati per permettere agli utenti normali
 di usare programmi che abbisognano di privilegi speciali; l'esempio classico è
@@ -1640,11 +1638,10 @@ per la creazione di nuove directory (procedimento descritto in
 \secref{sec:file_dir_creat_rem}).
 
 Lo standard POSIX prescrive che l'\acr{uid} del nuovo file corrisponda
-all'\textit{effective user id} del processo che lo crea; per il \acr{gid}
-invece prevede due diverse possibilità:
+all'userid effettivo del processo che lo crea; per il \acr{gid} invece prevede
+due diverse possibilità:
 \begin{itemize*}
-\item il \acr{gid} del file corrisponde all'\textit{effective group id} del
-  processo.
+\item il \acr{gid} del file corrisponde al group id effettivo del processo.
 \item il \acr{gid} del file corrisponde al \acr{gid} della directory in cui
   esso è creato.
 \end{itemize*}
@@ -1669,13 +1666,13 @@ stesso.
 \label{sec:file_access}
 
 Come visto in \secref{sec:file_access_control} il controllo di accesso ad un
-file viene fatto usando \textit{effective user id} e \textit{effective group
-  id} del processo; ma ci sono casi in cui è necessario effettuare il
-controllo usando il \textit{real user id} ed il \textit{real group id} (cioè
-\acr{uid} e \acr{gid} dell'utente che ha lanciato il programma, e che, come
-accennato in \secref{sec:file_suid_sgid} e spiegato in
-\secref{sec:proc_perms}, non è detto siano uguali agli \textit{effective id}).
-Per far questo si può usare la funzione \func{access}, il cui prototipo è:
+file viene fatto utilizzando l'userid ed il groupid effettivo del processo; ci
+sono casi però in cui si può voler effettuare il controllo con l'userid reale
+ed il groupid reale, vale a dire usando i valori di \acr{uid} e \acr{gid}
+relativi all'utente che ha lanciato il programma, e che, come accennato in
+\secref{sec:file_suid_sgid} e spiegato in dettaglio in
+\secref{sec:proc_perms}, non è detto siano uguali a quelli effettivi.  Per far
+questo si può usare la funzione \func{access}, il cui prototipo è:
 \begin{prototype}{unistd.h}
 {int access(const char *pathname, int mode)}
 
@@ -1683,18 +1680,20 @@ Verifica i permessi di accesso, indicati da \var{mode}, per il file indicato
 da \var{pathname}.
   
 \bodydesc{La funzione ritorna 0 se l'accesso è consentito, -1 altrimenti; in
-  quest'ultimo caso la variabile \var{errno} viene impostata secondo i codici di
-  errore: \macro{EACCES}, \macro{EROFS}, \macro{EFAULT}, \macro{EINVAL},
+  quest'ultimo caso la variabile \var{errno} viene impostata secondo i codici
+  di errore: \macro{EACCES}, \macro{EROFS}, \macro{EFAULT}, \macro{EINVAL},
   \macro{ENAMETOOLONG}, \macro{ENOENT}, \macro{ENOTDIR}, \macro{ELOOP},
   \macro{EIO}.}
 \end{prototype}
 
 I valori possibili per l'argomento \param{mode} sono esprimibili come
-combinazione delle costanti numeriche riportate in \ntab\ (attraverso un OR
-binario). I primi tre valori implicano anche la verifica dell'esistenza del
-file, se si vuole verificare solo quest'ultima si può usare \macro{F\_OK}, o
-anche direttamente \func{stat}. In caso \var{pathname} si riferisca ad un link
-simbolico il controllo è fatto sul file a cui esso fa riferimento.
+combinazione delle costanti numeriche riportate in
+\tabref{tab:file_access_mode_val} (attraverso un OR binario delle stesse). I
+primi tre valori implicano anche la verifica dell'esistenza del file, se si
+vuole verificare solo quest'ultima si può usare \macro{F\_OK}, o anche
+direttamente \func{stat}. Nel caso in cui \var{pathname} si riferisca ad un
+link simbolico, questo viene seguito ed il controllo è fatto sul file a cui
+esso fa riferimento.
 
 La funzione controlla solo i bit dei permessi di accesso, si ricordi che il
 fatto che una directory abbia permesso di scrittura non significa che ci si
@@ -1722,7 +1721,7 @@ contrario (o di errore) ritorna -1.
 \end{table}
 
 Un esempio tipico per l'uso di questa funzione è quello di un processo che sta
-eseguendo un programma coi privilegi di un altro utente (ad esmepio attraverso
+eseguendo un programma coi privilegi di un altro utente (ad esempio attraverso
 l'uso del \acr{suid} bit) che vuole controllare se l'utente originale ha i
 permessi per accedere ad un certo file.
 
@@ -1746,8 +1745,8 @@ filename e su un file descriptor, i loro prototipi sono:
   \bodydesc{Le funzioni restituiscono zero in caso di successo e -1 per
     un errore, in caso di errore \var{errno} può assumere i valori:
   \begin{errlist}
-  \item[\macro{EPERM}] L'\textit{effective user id} non corrisponde a quello
-    del proprietario del file o non è zero.
+  \item[\macro{EPERM}] L'userid effettivo non corrisponde a quello del
+    proprietario del file o non è zero.
   \end{errlist}
   ed inoltre \macro{EROFS} e \macro{EIO}; \func{chmod} restituisce anche
   \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT}, \macro{ENOMEM},
@@ -1755,15 +1754,16 @@ filename e su un file descriptor, i loro prototipi sono:
   \macro{EBADF}.}
 \end{functions}
 
-I valori possibili per \var{mode} sono indicati in \ntab. I valori possono
-esser combinati con l'OR binario delle relative costanti simboliche, o
-specificati direttamente, come per l'analogo comando di shell, con il valore
-numerico (la shell lo vuole in ottale, dato che i bit dei permessi sono
-divisibili in gruppi di tre). Ad esempio i permessi standard assegnati ai
-nuovi file (lettura e scrittura per il proprietario, sola lettura per il
-gruppo e gli altri) sono corrispondenti al valore ottale $0644$, un programma
-invece avrebbe anche il bit di esecuzione attivo, con un valore di $0755$, se
-si volesse attivare il bit \acr{suid} il valore da fornire sarebbe $4755$.
+I valori possibili per \var{mode} sono indicati in
+\tabref{tab:file_permission_const}. I valori possono esser combinati con l'OR
+binario delle relative costanti simboliche, o specificati direttamente, come
+per l'analogo comando di shell, con il valore numerico (la shell lo vuole in
+ottale, dato che i bit dei permessi sono divisibili in gruppi di tre). Ad
+esempio i permessi standard assegnati ai nuovi file (lettura e scrittura per
+il proprietario, sola lettura per il gruppo e gli altri) sono corrispondenti
+al valore ottale $0644$, un programma invece avrebbe anche il bit di
+esecuzione attivo, con un valore di $0755$, se si volesse attivare il bit
+\acr{suid} il valore da fornire sarebbe $4755$.
 
 \begin{table}[!htb]
   \centering
@@ -1803,17 +1803,17 @@ anche se si 
 particolare:
 \begin{enumerate}
 \item siccome solo l'amministratore può impostare lo \textit{sticky bit}, se
-  l'\textit{effective user id} del processo non è zero esso viene
-  automaticamente cancellato (senza notifica di errore) qualora sia stato
-  indicato in \var{mode}.
+  l'userid effettivo del processo non è zero esso viene automaticamente
+  cancellato (senza notifica di errore) qualora sia stato indicato in
+  \var{mode}.
 \item per via della semantica SVr4 nella creazione dei nuovi file, si può
   avere il caso in cui il file creato da un processo è assegnato a un gruppo
   per il quale il processo non ha privilegi. Per evitare che si possa
-  assegnare il bit \acr{sgid} ad un file appartenente a un gruppo per cui
-  non si hanno diritti, questo viene automaticamente cancellato (senza
-  notifica di errore) da \var{mode} qualora il gruppo del file non corrisponda
-  a quelli associati al processo (la cosa non avviene quando
-  l'\textit{effective user id} del processo è zero).
+  assegnare il bit \acr{sgid} ad un file appartenente a un gruppo per cui non
+  si hanno diritti, questo viene automaticamente cancellato (senza notifica di
+  errore) da \var{mode} qualora il gruppo del file non corrisponda a quelli
+  associati al processo (la cosa non avviene quando l'userid effettivo del
+  processo è zero).
 \end{enumerate}
 
 Per alcuni filesystem\footnote{il filesystem \acr{ext2} supporta questa
@@ -1884,8 +1884,8 @@ sono tre e i loro prototipi sono i seguenti:
   \bodydesc{Le funzioni restituiscono zero in caso di successo e -1 per
     un errore, in caso di errore \var{errno} viene impostata ai valori:
   \begin{errlist}
-  \item[\macro{EPERM}] L'\textit{effective user id} non corrisponde a quello
-    del proprietario del file o non è zero, o utente e gruppo non sono validi
+  \item[\macro{EPERM}] L'userid effettivo non corrisponde a quello del
+    proprietario del file o non è zero, o utente e gruppo non sono validi
   \end{errlist}
   Oltre a questi entrambe restituiscono gli errori \macro{EROFS} e
   \macro{EIO}; \func{chown} restituisce anche \macro{EFAULT},
@@ -1949,7 +1949,7 @@ radice con la funzione \func{chroot}, il cui prototipo 
 \bodydesc{La funzione restituisce zero in caso di successo e -1 per
     un errore, in caso di errore \var{errno} viene impostata ai valori:
   \begin{errlist}
-  \item[\macro{EPERM}] L'\textit{effective user id} non è zero.
+  \item[\macro{EPERM}] L'userid effettivo del processo non è zero.
   \end{errlist}
   ed inoltre \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT},
   \macro{ENOMEM}, \macro{ENOTDIR}, \macro{EACCES}, \macro{ELOOP};
diff --git a/intro.tex b/intro.tex
index b648bd0..5ea4f9a 100644
--- a/intro.tex
+++ b/intro.tex
@@ -226,8 +226,10 @@ definendo gruppi di lavoro, di accesso a determinate risorse, etc.
 L'utente e il gruppo sono identificati da due numeri (la cui corrispondenza ad
 un nome espresso in caratteri è inserita nei due file \file{/etc/passwd} e
 \file{/etc/groups}). Questi numeri sono l'\textit{user identifier}, detto in
-breve \acr{uid}, e il \textit{group identifier}, detto in breve \acr{gid}, che
-sono quelli che poi vengono usati dal kernel per identificare l'utente.
+breve \textsl{userid}, ed indicato dall'acronimo \acr{uid}, e il \textit{group
+  identifier}, detto in breve \textsl{groupid}, ed identificato dall'acronimo
+\acr{gid}, e sono quelli che vengono usati dal kernel per identificare
+l'utente.
  
 In questo modo il sistema è in grado di tenere traccia per ogni processo
 dell'utente a cui appartiene ed impedire ad altri utenti di interferire con
diff --git a/prochand.tex b/prochand.tex
index e8f68a8..181b1bd 100644
--- a/prochand.tex
+++ b/prochand.tex
@@ -231,11 +231,9 @@ sono stati creati, questo viene chiamato in genere \acr{ppid} (da
 \textit{parent process id}).  Questi due identificativi possono essere
 ottenuti da programma usando le funzioni:
 \begin{functions}
-\headdecl{sys/types.h}
-\headdecl{unistd.h}
-\funcdecl{pid\_t getpid(void)} Restituisce il pid del processo corrente.
-\funcdecl{pid\_t getppid(void)} Restituisce il pid del padre del processo
-    corrente.
+  \headdecl{sys/types.h} \headdecl{unistd.h} \funcdecl{pid\_t getpid(void)}
+  Restituisce il \acr{pid} del processo corrente.  \funcdecl{pid\_t
+    getppid(void)} Restituisce il \acr{pid} del padre del processo corrente.
 
 \bodydesc{Entrambe le funzioni non riportano condizioni di errore.}
 \end{functions}
@@ -405,20 +403,20 @@ d'uso, esistono numerosi scenari in cui si pu
 aver bisogno di eseguire una \func{exec}. Inoltre, anche nel caso della
 seconda modalità d'uso, avere le due funzioni separate permette al figlio di
 cambiare gli attributi del processo (maschera dei segnali, redirezione
-dell'output, \textit{user id}) prima della \func{exec}, rendendo così
+dell'output, identificatori) prima della \func{exec}, rendendo così
 relativamente facile intervenire sulle le modalità di esecuzione del nuovo
 programma.
 
-In \curfig\ si è riportato il corpo del codice del programma di esempio
-\cmd{forktest}, che ci permette di illustrare molte caratteristiche dell'uso
-della funzione \func{fork}. Il programma permette di creare un numero di figli
-specificato da linea di comando, e prende anche alcune opzioni per indicare
-degli eventuali tempi di attesa in secondi (eseguiti tramite la funzione
-\func{sleep}) per il padre ed il figlio (con \cmd{forktest -h} si ottiene la
-descrizione delle opzioni); il codice completo, compresa la parte che gestisce
-le opzioni a riga di comando, è disponibile nel file \file{ForkTest.c},
-distribuito insieme agli altri sorgenti degli esempi su
-\href{http://gapil.firenze.linux.it/gapil_source.tgz}
+In \figref{fig:proc_fork_code} si è riportato il corpo del codice del
+programma di esempio \cmd{forktest}, che ci permette di illustrare molte
+caratteristiche dell'uso della funzione \func{fork}. Il programma permette di
+creare un numero di figli specificato da linea di comando, e prende anche
+alcune opzioni per indicare degli eventuali tempi di attesa in secondi
+(eseguiti tramite la funzione \func{sleep}) per il padre ed il figlio (con
+\cmd{forktest -h} si ottiene la descrizione delle opzioni); il codice
+completo, compresa la parte che gestisce le opzioni a riga di comando, è
+disponibile nel file \file{ForkTest.c}, distribuito insieme agli altri
+sorgenti degli esempi su \href{http://gapil.firenze.linux.it/gapil_source.tgz}
 {\texttt{http://gapil.firenze.linux.it/gapil\_source.tgz}}.
 
 Decifrato il numero di figli da creare, il ciclo principale del programma
@@ -603,12 +601,12 @@ comune dopo l'esecuzione di una \func{fork} 
 \begin{itemize*}
 \item i file aperti e gli eventuali flag di \textit{close-on-exec} impostati
   (vedi \secref{sec:proc_exec} e \secref{sec:file_fcntl}).
-\item gli identificatori per il controllo di accesso: il \textit{real user
-    id}, il \textit{real group id}, l'\textit{effective user id},
-  l'\textit{effective group id} ed i \textit{supplementary group id} (vedi
+\item gli identificatori per il controllo di accesso: l'\textsl{userid reale},
+  il \textsl{groupid reale}, l'\textsl{userid effettivo}, il \textsl{groupid
+    effettivo} ed i \textit{groupid supplementari} (vedi
   \secref{sec:proc_access_id}).
 \item gli identificatori per il controllo di sessione: il \textit{process
-    group id} e il \textit{session id} ed il terminale di controllo (vedi
+    groupid} e il \textit{session id} ed il terminale di controllo (vedi
   \secref{sec:sess_xxx} e \secref{sec:sess_xxx}).
 \item la directory di lavoro e la directory radice (vedi
   \secref{sec:file_work_dir} e \secref{sec:file_chroot}).
@@ -623,9 +621,9 @@ comune dopo l'esecuzione di una \func{fork} 
 le differenze fra padre e figlio dopo la \func{fork} invece sono:
 \begin{itemize*}
 \item il valore di ritorno di \func{fork}.
-\item il \textit{process id}. 
-\item il \textit{parent process id} (quello del figlio viene impostato al
-  \acr{pid} del padre).
+\item il \acr{pid} (\textit{process id}). 
+\item il \acr{ppid} (\textit{parent process id}), quello del figlio viene
+  impostato al \acr{pid} del padre.
 \item i valori dei tempi di esecuzione della struttura \var{tms} (vedi
   \secref{sec:sys_cpu_times}) che nel figlio sono posti a zero.
 \item i \textit{file lock} (vedi \secref{sec:file_locking}), che non
@@ -1202,10 +1200,9 @@ la lista completa 
 \begin{itemize*}
 \item il \textit{process id} (\acr{pid}) ed il \textit{parent process id}
   (\acr{ppid}).
-\item il \textit{real user id} ed il \textit{real group id} (vedi
-  \secref{sec:proc_access_id}).
-\item i \textit{supplementary group id} (vedi \secref{sec:proc_access_id}).
-\item il \textit{session id} ed il \textit{process group id} (vedi
+\item l'\textsl{userid reale}, il \textit{groupid reale} ed i \textsl{groupid
+    supplementari} (vedi \secref{sec:proc_access_id}).
+\item il \textit{session id} ed il \textit{process groupid} (vedi
   \secref{sec:sess_xxx}).
 \item il terminale di controllo (vedi \secref{sec:sess_xxx}).
 \item il tempo restante ad un allarme (vedi \secref{sec:sig_alarm_abort}).
@@ -1241,13 +1238,14 @@ attraverso una \func{exec}, in genere questo 
 l'impostazione del flag di \textit{close-on-exec} sulle directory che apre, in
 maniera trasparente all'utente.
 
-Abbiamo detto che il \textit{real user id} ed il \textit{real group id}
-restano gli stessi all'esecuzione di \func{exec}; lo stesso vale per
-l'\textit{effective user id} ed l'\textit{effective group id}, tranne quando
-il file che si va ad eseguire abbia o il \acr{suid} bit o lo \acr{sgid} bit
-impostato, in questo caso l'\textit{effective user id} e l'\textit{effective
-  group id} vengono impostati rispettivamente all'utente o al gruppo cui il file
-appartiene (per i dettagli vedi \secref{sec:proc_perms}).
+Abbiamo detto che l'\textsl{userid reale} ed il \textsl{groupid reale} restano
+gli stessi all'esecuzione di \func{exec}; lo stesso vale per l'\textsl{userid
+  effettivo} ed il \textsl{groupid effettivo} (il significato di questi
+identificatori è trattato in \secref{sec:proc_access_id}), tranne quando il
+file che si va ad eseguire abbia o il \acr{suid} bit o lo \acr{sgid} bit
+impostato, in questo caso l'\textsl{userid effettivo} ed il \textsl{groupid
+  effettivo} vengono impostati rispettivamente all'utente o al gruppo cui il
+file appartiene (per i dettagli vedi \secref{sec:proc_perms}).
 
 Se il file da eseguire è in formato \emph{a.out} e necessita di librerie
 condivise, viene lanciato il \textit{linker} dinamico \cmd{ld.so} prima del
@@ -1255,8 +1253,8 @@ programma per caricare le librerie necessarie ed effettuare il link
 dell'eseguibile. Se il programma è in formato ELF per caricare le librerie
 dinamiche viene usato l'interprete indicato nel segmento \macro{PT\_INTERP},
 in genere questo è \file{/lib/ld-linux.so.1} per programmi linkati con le
-\emph{libc5}, e \file{/lib/ld-linux.so.2} per programmi linkati con le
-\emph{glibc}. Infine nel caso il file sia uno script esso deve iniziare con
+\acr{libc5}, e \file{/lib/ld-linux.so.2} per programmi linkati con le
+\acr{glibc}. Infine nel caso il file sia uno script esso deve iniziare con
 una linea nella forma \cmd{\#!/path/to/interpreter} dove l'interprete indicato
 deve esse un valido programma (binario, non un altro script) che verrà
 chiamato come se si fosse eseguito il comando \cmd{interpreter [arg]
@@ -1298,8 +1296,8 @@ utenti, per i quali invece vengono effettuati i vari controlli di accesso.
 %notevole flessibilità, 
 
 Abbiamo già accennato come il sistema associ ad ogni utente e gruppo due
-identificatori univoci, lo \acr{uid} e il \acr{gid}; questi servono al kernel
-per identificare uno specifico utente o un gruppo di utenti, per poi poter
+identificatori univoci, lo userid ed il groupid; questi servono al kernel per
+identificare uno specifico utente o un gruppo di utenti, per poi poter
 controllare che essi siano autorizzati a compiere le operazioni richieste.  Ad
 esempio in \secref{sec:file_access_control} vedremo come ad ogni file vengano
 associati un utente ed un gruppo (i suoi \textsl{proprietari}, indicati
@@ -1309,42 +1307,49 @@ kernel nella gestione dei permessi di accesso.
 Dato che tutte le operazioni del sistema vengono compiute dai processi, è
 evidente che per poter implementare un controllo sulle operazioni occorre
 anche poter identificare chi è che ha lanciato un certo programma, e pertanto
-anche a ciascun processo è associato un utente e a un gruppo.
+anche a ciascun processo dovrà essere associato ad un utente e ad un gruppo.
 
 Un semplice controllo di una corrispondenza fra identificativi non garantisce
 però sufficiente flessibilità per tutti quei casi in cui è necessario poter
 disporre di privilegi diversi, o dover impersonare un altro utente per un
 limitato insieme di operazioni. Per questo motivo in generale tutti gli Unix
 prevedono che i processi abbiano almeno due gruppi di identificatori, chiamati
-rispettivamente \textit{real} ed \textit{effective}.
+rispettivamente \textit{real} ed \textit{effective} (cioè \textsl{reali} ed
+\textsl{effettivi}). Nel caso di Linux si aggiungono poi altri due gruppi, il
+\textit{saved} (\textsl{salvati}) ed il \textit{filesystem} (\textsl{di
+  filesystem}), secondo la situazione illustrata in \tabref{tab:proc_uid_gid}.
 
 \begin{table}[htb]
   \footnotesize
   \centering
-  \begin{tabular}[c]{|c|l|p{6.5cm}|}
+  \begin{tabular}[c]{|c|c|l|p{7.3cm}|}
     \hline
-    \textbf{Suffisso} & \textbf{Significato} & \textbf{Utilizzo} \\ 
+    \textbf{Suffisso} & \textbf{Gruppo} & \textbf{Denominazione} 
+                                        & \textbf{Significato} \\ 
     \hline
     \hline
-    \acr{uid}   & \textit{real user id} & indica l'utente che ha lanciato
-    il programma\\ 
-    \acr{gid}   & \textit{real group id} & indica il gruppo dell'utente 
-    che ha lanciato il programma \\ 
+    \acr{uid}   & \textit{real} & \textsl{userid reale} 
+                & indica l'utente che ha lanciato il programma\\ 
+    \acr{gid}   & '' &\textsl{groupid reale} 
+                & indica il gruppo principale dell'utente che ha lanciato 
+                  il programma \\ 
     \hline
-    \acr{euid}  & \textit{effective user id} & indica l'utente usato
-    dal programma nel controllo di accesso \\ 
-    \acr{egid}  & \textit{effective group id} & indica il gruppo 
-    usato dal programma  nel controllo di accesso \\ 
-    --          & \textit{supplementary group id} & indica i gruppi cui
-    l'utente appartiene  \\ 
+    \acr{euid}  & \textit{effective} &\textsl{userid effettivo} 
+                & indica l'utente usato nel controllo di accesso \\ 
+    \acr{egid}  & '' & \textsl{groupid effettivo} 
+                & indica il gruppo usato nel controllo di accesso \\ 
+    --          & -- & \textsl{groupid supplementari} 
+                & indicano gli ulteriori gruppi cui l'utente appartiene \\ 
     \hline
-    --          & \textit{saved user id} &  copia dell'\acr{euid} iniziale\\ 
-    --          & \textit{saved group id} &  copia dell'\acr{egid} iniziale \\ 
+    --          & \textit{saved} & \textsl{userid salvato} 
+                & è una copia dell'\acr{euid} iniziale\\ 
+    --          & '' & \textsl{groupid salvato} 
+                & è una copia dell'\acr{egid} iniziale \\ 
     \hline
-    \acr{fsuid} & \textit{filesystem user id} & indica l'utente effettivo per
-    il filesystem \\ 
-    \acr{fsgid} & \textit{filesystem group id} & indica il gruppo effettivo
-    per il filesystem  \\ 
+    \acr{fsuid} & \textit{filesystem} &\textsl{userid di filesystem} 
+                & indica l'utente effettivo per l'accesso al filesystem \\ 
+    \acr{fsgid} & '' & \textsl{groupid di filesystem} 
+                & indica il gruppo effettivo per l'accesso al filesystem  \\ 
     \hline
   \end{tabular}
   \caption{Identificatori di utente e gruppo associati a ciascun processo con
@@ -1352,31 +1357,32 @@ rispettivamente \textit{real} ed \textit{effective}.
   \label{tab:proc_uid_gid}
 \end{table}
 
-Al primo gruppo appartengono il \textit{real user id} e il \textit{real group
-  id}: questi vengono impostati al login ai valori corrispondenti all'utente
-con cui si accede al sistema (e relativo gruppo principale). Servono per
-l'identificazione dell'utente e normalmente non vengono mai cambiati. In
-realtà vedremo (in \secref{sec:proc_setuid}) che è possibile modificarli, ma
-solo ad un processo che abbia i privilegi di amministratore; questa
-possibilità è usata ad esempio da \cmd{login} che, una volta completata la
-procedura di autenticazione, lancia una shell per la quale imposta questi
-identificatori ai valori corrispondenti all'utente che entra nel sistema.
-
-Al secondo gruppo appartengono l'\textit{effective user id} e
-l'\textit{effective group id} (a cui si aggiungono gli eventuali
-\textit{supplementary group id} dei gruppi dei quali l'utente fa parte).
-Questi sono invece gli identificatori usati nella verifiche dei permessi del
-processo e per il controllo di accesso ai file (argomento affrontato in
-dettaglio in \secref{sec:file_perm_overview}). 
+Al primo gruppo appartengono l'\textsl{userid reale} ed il \textsl{groupid
+  reale}: questi vengono impostati al login ai valori corrispondenti
+all'utente con cui si accede al sistema (e relativo gruppo principale).
+Servono per l'identificazione dell'utente e normalmente non vengono mai
+cambiati. In realtà vedremo (in \secref{sec:proc_setuid}) che è possibile
+modificarli, ma solo ad un processo che abbia i privilegi di amministratore;
+questa possibilità è usata proprio dal programma \cmd{login} che, una volta
+completata la procedura di autenticazione, lancia una shell per la quale
+imposta questi identificatori ai valori corrispondenti all'utente che entra
+nel sistema.
+
+Al secondo gruppo appartengono l'\textsl{userid effettivo} e l'\textsl{groupid
+  effettivo} (a cui si aggiungono gli eventuali \textsl{groupid supplementari}
+dei gruppi dei quali l'utente fa parte).  Questi sono invece gli
+identificatori usati nella verifiche dei permessi del processo e per il
+controllo di accesso ai file (argomento affrontato in dettaglio in
+\secref{sec:file_perm_overview}).
 
 Questi identificatori normalmente sono identici ai corrispondenti del gruppo
 \textit{real} tranne nel caso in cui, come accennato in
 \secref{sec:proc_exec}, il programma che si è posto in esecuzione abbia i bit
-\acr{suid} o \acr{sgid} impostati (il significato di questi bit è affrontato in
-dettaglio in \secref{sec:file_suid_sgid}). In questo caso essi saranno impostati
-all'utente e al gruppo proprietari del file. Questo consente, per programmi in
-cui ci sia necessità, di dare a qualunque utente normale privilegi o permessi
-di un'altro (o dell'amministratore).
+\acr{suid} o \acr{sgid} impostati (il significato di questi bit è affrontato
+in dettaglio in \secref{sec:file_suid_sgid}). In questo caso essi saranno
+impostati all'utente e al gruppo proprietari del file. Questo consente, per
+programmi in cui ci sia necessità, di dare a qualunque utente normale
+privilegi o permessi di un'altro (o dell'amministratore).
 
 Come nel caso del \acr{pid} e del \acr{ppid} tutti questi identificatori
 possono essere letti dal processo attraverso delle opportune funzioni, i cui
@@ -1384,18 +1390,18 @@ prototipi sono i seguenti:
 \begin{functions}
   \headdecl{unistd.h}
   \headdecl{sys/types.h}  
-  \funcdecl{uid\_t getuid(void)} Restituisce il \textit{real user id} del
+  \funcdecl{uid\_t getuid(void)} Restituisce l'\textsl{userid reale} del
   processo corrente.
 
-  \funcdecl{uid\_t geteuid(void)} Restituisce l'\textit{effective user id} del
+  \funcdecl{uid\_t geteuid(void)} Restituisce l'\textsl{userid effettivo} del
   processo corrente.
 
-  \funcdecl{gid\_t getgid(void)} Restituisce il \textit{real group id} del
-  processo corrente.
-
-  \funcdecl{gid\_t getegid(void)} Restituisce l'\textit{effective group id} del
+  \funcdecl{gid\_t getgid(void)} Restituisce il \textsl{groupid reale} del
   processo corrente.
   
+  \funcdecl{gid\_t getegid(void)} Restituisce il \textsl{groupid effettivo}
+  del processo corrente.
+  
   \bodydesc{Queste funzioni non riportano condizioni di errore.}
 \end{functions}
 
@@ -1406,37 +1412,32 @@ maggiori privilegi necessari, una volta che si siano effettuate le operazioni
 per i quali erano richiesti, e a poterli eventualmente recuperare in caso
 servano di nuovo.
 
-Questo in Linux viene fatto usando altri due gruppi di identificatori, il
-\textit{saved} ed il \textit{filesystem}, analoghi ai precedenti. Il primo
-gruppo è lo stesso usato in SVr4, e previsto dallo standard POSIX quando è
-definita la costante \macro{\_POSIX\_SAVED\_IDS},\footnote{in caso si abbia a
-  cuore la portabilità del programma su altri Unix è buona norma controllare
-  sempre la disponibilità di queste funzioni controllando se questa costante è
+Questo in Linux viene fatto usando altri gli altri due gruppi di
+identificatori, il \textit{saved} ed il \textit{filesystem}. Il primo gruppo è
+lo stesso usato in SVr4, e previsto dallo standard POSIX quando è definita la
+costante \macro{\_POSIX\_SAVED\_IDS},\footnote{in caso si abbia a cuore la
+  portabilità del programma su altri Unix è buona norma controllare sempre la
+  disponibilità di queste funzioni controllando se questa costante è
   definita.} il secondo gruppo è specifico di Linux e viene usato per
 migliorare la sicurezza con NFS.
 
-Il \textit{saved user id} e il \textit{saved group id} sono copie
-dell'\textit{effective user id} e dell'\textit{effective group id} del
-processo padre, e vengono impostati dalla funzione \func{exec} all'avvio del
-processo, come copie dell'\textit{effective user id} e dell'\textit{effective
-  group id} dopo che questo sono stati impostati tenendo conto di eventuali
-\acr{suid} o \acr{sgid}.  Essi quindi consentono di tenere traccia di quale
-fossero utente e gruppo effettivi all'inizio dell'esecuzione di un nuovo
-programma.
+L'\textsl{userid salvato} ed il \textsl{groupid salvato} sono copie
+dell'\textsl{userid effettivo} e del \textsl{groupid effettivo} del processo
+padre, e vengono impostati dalla funzione \func{exec} all'avvio del processo,
+come copie dell'\textsl{userid effettivo} e del \textsl{groupid effettivo}
+dopo che questo sono stati impostati tenendo conto di eventuali \acr{suid} o
+\acr{sgid}.  Essi quindi consentono di tenere traccia di quale fossero utente
+e gruppo effettivi all'inizio dell'esecuzione di un nuovo programma.
 
-Il \textit{filesystem user id} e il \textit{filesystem group id} sono
+L'\textsl{userid di filesystem} e il \textsl{groupid di filesystem} sono
 un'estensione introdotta in Linux per rendere più sicuro l'uso di NFS
 (torneremo sull'argomento in \secref{sec:proc_setfsuid}). Essi sono una
-replica dei corrispondenti \textit{effective id}, ai quali si sostituiscono
-per tutte le operazioni di verifica dei permessi relativi ai file (trattate in
-\secref{sec:file_perm_overview}).  Ogni cambiamento effettuato sugli
-\textit{effective id} viene automaticamente riportato su di essi, per cui in
-condizioni normali se ne può tranquillamente ignorare l'esistenza, in quanto
-saranno del tutto equivalenti ai precedenti.
-
-Uno specchietto riassuntivo, contenente l'elenco completo degli identificatori
-di utente e gruppo associati dal kernel ad ogni processo, è riportato in
-\tabref{tab:proc_uid_gid}.
+replica dei corrispondenti identificatori del gruppo \textit{effective}, ai
+quali si sostituiscono per tutte le operazioni di verifica dei permessi
+relativi ai file (trattate in \secref{sec:file_perm_overview}).  Ogni
+cambiamento effettuato sugli identificatori effettivi viene automaticamente
+riportato su di essi, per cui in condizioni normali si può tranquillamente
+ignorarne l'esistenza, in quanto saranno del tutto equivalenti ai precedenti.
 
 
 \subsection{Le funzioni \func{setuid} e \func{setgid}}
@@ -1445,16 +1446,16 @@ di utente e gruppo associati dal kernel ad ogni processo, 
 Le due funzioni che vengono usate per cambiare identità (cioè utente e gruppo
 di appartenenza) ad un processo sono rispettivamente \func{setuid} e
 \func{setgid}; come accennato in \secref{sec:proc_access_id} in Linux esse
-seguono la semantica POSIX che prevede l'esistenza del \textit{saved user id}
-e del \textit{saved group id}; i loro prototipi sono:
+seguono la semantica POSIX che prevede l'esistenza dell'\textit{userid
+  salvato} e del \textit{groupid salvato}; i loro prototipi sono:
 \begin{functions}
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setuid(uid\_t uid)} Imposta l'\textit{user id} del processo
+\funcdecl{int setuid(uid\_t uid)} Imposta l'\textsl{userid} del processo
 corrente.
 
-\funcdecl{int setgid(gid\_t gid)} Imposta il \textit{group id} del processo
+\funcdecl{int setgid(gid\_t gid)} Imposta il \textsl{groupid} del processo
 corrente.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1463,21 +1464,21 @@ corrente.
 
 Il funzionamento di queste due funzioni è analogo, per cui considereremo solo
 la prima; la seconda si comporta esattamente allo stesso modo facendo
-riferimento al \textit{group id} invece che all'\textit{user id}.  Gli
-eventuali \textit{supplementary group id} non vengono modificati.
-
+riferimento al \textsl{groupid} invece che all'\textsl{userid}.  Gli
+eventuali \textsl{groupid supplementari} non vengono modificati.
 
 L'effetto della chiamata è diverso a seconda dei privilegi del processo; se
-l'\textit{effective user id} è zero (cioè è quello dell'amministratore di
-sistema) allora tutti gli identificatori (\textit{real}, \textit{effective}
-e \textit{saved}) vengono impostati al valore specificato da \var{uid},
-altrimenti viene impostato solo l'\textit{effective user id}, e soltanto se il
-valore specificato corrisponde o al \textit{real user id} o al \textit{saved
-  user id}. Negli altri casi viene segnalato un errore (con \macro{EPERM}).
+l'\textsl{userid effettivo} è zero (cioè è quello dell'amministratore di
+sistema) allora tutti gli identificatori (\textit{real}, \textit{effective} e
+\textit{saved}) vengono impostati al valore specificato da \var{uid},
+altrimenti viene impostato solo l'\textsl{userid effettivo}, e soltanto se il
+valore specificato corrisponde o all'\textsl{userid reale} o
+all'\textsl{userid salvato}. Negli altri casi viene segnalato un errore (con
+\macro{EPERM}).
 
 Come accennato l'uso principale di queste funzioni è quello di poter
 consentire ad un programma con i bit \acr{suid} o \acr{sgid} impostati di
-riportare l'\textit{effective user id} a quello dell'utente che ha lanciato il
+riportare l'\textsl{userid effettivo} a quello dell'utente che ha lanciato il
 programma, effettuare il lavoro che non necessita di privilegi aggiuntivi, ed
 eventualmente tornare indietro.
 
@@ -1496,35 +1497,35 @@ Quando uno di questi programmi (ad esempio \cmd{xterm}) viene lanciato, la
 situazione degli identificatori è la seguente:
 \begin{eqnarray*}
   \label{eq:1}
-  \textit{real group id}      &=& \textrm{\acr{gid} (del chiamante)} \\
-  \textit{effective group id} &=& \textrm{\acr{utmp}} \\
-  \textit{saved group id}     &=& \textrm{\acr{utmp}}
+  \textsl{groupid reale}      &=& \textrm{\acr{gid} (del chiamante)} \\
+  \textsl{groupid effettivo}  &=& \textrm{\acr{utmp}} \\
+  \textsl{groupid salvato}    &=& \textrm{\acr{utmp}}
 \end{eqnarray*}
-in questo modo, dato che l'\textit{effective group id} è quello giusto, il
+in questo modo, dato che il \textsl{groupid effettivo} è quello giusto, il
 programma può accedere a \file{/var/log/utmp} in scrittura ed aggiornarlo. A
-questo punto il programma può eseguire una \code{setgid(getgid())} per impostare
-l'\textit{effective group id} a quello dell'utente (e dato che il \textit{real
-  group id} corrisponde la funzione avrà successo), in questo modo non sarà
-possibile lanciare dal terminale programmi che modificano detto file, in tal
-caso infatti la situazione degli identificatori sarebbe:
+questo punto il programma può eseguire una \code{setgid(getgid())} per
+impostare il \textsl{groupid effettivo} a quello dell'utente (e dato che il
+\textsl{groupid reale} corrisponde la funzione avrà successo), in questo modo
+non sarà possibile lanciare dal terminale programmi che modificano detto file,
+in tal caso infatti la situazione degli identificatori sarebbe:
 \begin{eqnarray*}
   \label{eq:2}
-  \textit{real group id}      &=& \textrm{\acr{gid} (invariato)}  \\
-  \textit{effective group id} &=& \textrm{\acr{gid}} \\
-  \textit{saved group id}     &=& \textrm{\acr{utmp} (invariato)}
+  \textsl{groupid reale}      &=& \textrm{\acr{gid} (invariato)}  \\
+  \textsl{groupid effettivo}  &=& \textrm{\acr{gid}} \\
+  \textsl{groupid salvato}    &=& \textrm{\acr{utmp} (invariato)}
 \end{eqnarray*}
 e ogni processo lanciato dal terminale avrebbe comunque \acr{gid} come
-\textit{effective group id}. All'uscita dal terminale, per poter di nuovo
+\textsl{groupid effettivo}. All'uscita dal terminale, per poter di nuovo
 aggiornare lo stato di \file{/var/log/utmp} il programma eseguirà una
 \code{setgid(utmp)} (dove \var{utmp} è il valore numerico associato al gruppo
 \acr{utmp}, ottenuto ad esempio con una precedente \func{getegid}), dato che
-in questo caso il valore richiesto corrisponde al \textit{saved group id} la
+in questo caso il valore richiesto corrisponde al \textsl{groupid salvato} la
 funzione avrà successo e riporterà la situazione a:
 \begin{eqnarray*}
   \label{eq:3}
-  \textit{real group id}      &=& \textrm{\acr{gid} (invariato)}  \\
-  \textit{effective group id} &=& \textrm{\acr{utmp}} \\
-  \textit{saved group id}     &=& \textrm{\acr{utmp} (invariato)}
+  \textsl{groupid reale}      &=& \textrm{\acr{gid} (invariato)}  \\
+  \textsl{groupid effettivo}  &=& \textrm{\acr{utmp}} \\
+  \textsl{groupid salvato}    &=& \textrm{\acr{utmp} (invariato)}
 \end{eqnarray*}
 consentendo l'accesso a \file{/var/log/utmp}.
 
@@ -1534,7 +1535,7 @@ comporta il cambiamento di tutti gli identificatori associati al processo,
 rendendo impossibile riguadagnare i privilegi di amministratore.  Questo
 comportamento è corretto per l'uso che ne fa \cmd{login} una volta che crea
 una nuova shell per l'utente; ma quando si vuole cambiare soltanto
-l'\textit{effective user id} del processo per cedere i privilegi occorre
+l'\textsl{userid effettivo} del processo per cedere i privilegi occorre
 ricorrere ad altre funzioni (si veda ad esempio \secref{sec:proc_seteuid}).
 
 
@@ -1542,84 +1543,83 @@ ricorrere ad altre funzioni (si veda ad esempio \secref{sec:proc_seteuid}).
 \label{sec:proc_setreuid}
 
 Queste due funzioni derivano da BSD che, non supportando\footnote{almeno fino
-  alla versione 4.3+BSD TODO, FIXME verificare e aggiornare la nota.} i
-\textit{saved id}, le usava per poter scambiare fra di loro \textit{effective}
-e \textit{real id}. I loro prototipi sono:
+  alla versione 4.3+BSD TODO, FIXME verificare e aggiornare la nota.} gli
+identificatori del gruppo \textit{saved}, le usa per poter scambiare fra di
+loro \textit{effective} e \textit{real}. I loro prototipi sono:
 \begin{functions}
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Imposta il \textit{real user
-  id} e l'\textit{effective user id} del processo corrente ai valori
+\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Imposta l'\textsl{userid
+  reale} e l'\textsl{userid effettivo} del processo corrente ai valori
 specificati da \var{ruid} e \var{euid}.
   
-\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Imposta il \textit{real group
-  id} e l'\textit{effective group id} del processo corrente ai valori
+\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Imposta il \textsl{groupid
+  reale} ed il \textsl{groupid effettivo} del processo corrente ai valori
 specificati da \var{rgid} e \var{egid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
   di fallimento: l'unico errore possibile è \macro{EPERM}.}
 \end{functions}
 
-I processi non privilegiati possono impostare i \textit{real id} soltanto ai
-valori dei loro \textit{effective id} o \textit{real id} e gli
-\textit{effective id} ai valori dei loro \textit{real id}, \textit{effective
-  id} o \textit{saved id}; valori diversi comportano il fallimento della
-chiamata; l'amministratore invece può specificare un valore qualunque.
-Specificando un valore di -1 l'identificatore corrispondente viene lasciato
-inalterato.
+La due funzioni sono analoghe ed il loro comportamento è identico; quanto
+detto per la prima prima riguardo l'userid, si applica immediatamente alla
+seconda per il groupid. I processi non privilegiati possono impostare solo i
+valori del loro userid effettivo o reale; valori diversi comportano il
+fallimento della chiamata; l'amministratore invece può specificare un valore
+qualunque.  Specificando un argomento di valore -1 l'identificatore
+corrispondente verrà lasciato inalterato.
 
-Con queste funzione si possono scambiare fra loro \textit{real id} e
-\textit{effective id}, e pertanto è possibile implementare un comportamento
-simile a quello visto in precedenza per \func{setgid}, cedendo i privilegi con
-un primo scambio, e recuperandoli, eseguito il lavoro non privilegiato, con un
-secondo scambio.
+Con queste funzione si possono scambiare fra loro gli userid reale e
+effettivo, e pertanto è possibile implementare un comportamento simile a
+quello visto in precedenza per \func{setgid}, cedendo i privilegi con un primo
+scambio, e recuperandoli, eseguito il lavoro non privilegiato, con un secondo
+scambio.
 
 In questo caso però occorre porre molta attenzione quando si creano nuovi
 processi nella fase intermedia in cui si sono scambiati gli identificatori, in
-questo caso infatti essi avranno un \textit{real id} privilegiato, che dovrà
+questo caso infatti essi avranno un userid reale privilegiato, che dovrà
 essere esplicitamente eliminato prima di porre in esecuzione un nuovo
-programma (occorrerà cioè eseguire un'altra chiamata dopo la \func{fork}, e
-prima della \func{exec} per uniformare i \textit{real id} agli
-\textit{effective id}) in caso contrario quest'ultimo potrebbe a sua volta
-effettuare uno scambio e riottenere privilegi non previsti.
+programma (occorrerà cioè eseguire un'altra chiamata dopo la \func{fork} e
+prima della \func{exec} per uniformare l'userid reale a quello effettivo) in
+caso contrario il nuovo programma potrebbe a sua volta effettuare uno scambio
+e riottenere privilegi non previsti.
 
 Lo stesso problema di propagazione dei privilegi ad eventuali processi figli
-si porrebbe per i \textit{saved id}: queste funzioni derivano da
-un'implementazione che non ne prevede la presenza, e quindi non è possibile
-usarle per correggere la situazione come nel caso precedente. Per questo
-motivo in Linux tutte le volte che tali funzioni vengono usate per modificare
-uno degli identificatori ad un valore diverso dal \textit{real id} precedente,
-il \textit{saved id} viene sempre impostato al valore dell'\textit{effective
-  id}.
-
+si pone per l'userid salvato: questa funzione deriva da un'implementazione che
+non ne prevede la presenza, e quindi non è possibile usarla per correggere la
+situazione come nel caso precedente. Per questo motivo in Linux tutte le volte
+che si imposta un qualunque valore diverso da quello dall'userid reale
+corrente, l'userid salvato viene automaticamente uniformato al valore
+dell'userid effettivo.
 
 
 \subsection{Le funzioni \func{seteuid} e \func{setegid}}
 \label{sec:proc_seteuid}
 
 Queste funzioni sono un'estensione allo standard POSIX.1 (ma sono comunque
-supportate dalla maggior parte degli Unix) e usate per cambiare gli
-\textit{effective id}; i loro prototipi sono:
+supportate dalla maggior parte degli Unix) e vengono usate per cambiare gli
+identificatori del gruppo \textit{effective}; i loro prototipi sono:
 \begin{functions}
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int seteuid(uid\_t uid)} Imposta l'\textit{effective user id} del
-processo corrente a \var{uid}.
+\funcdecl{int seteuid(uid\_t uid)} Imposta l'userid effettivo del processo
+corrente a \var{uid}.
 
-\funcdecl{int setegid(gid\_t gid)} Imposta l'\textit{effective group id} del
-processo corrente a \var{gid}.
+\funcdecl{int setegid(gid\_t gid)} Imposta il groupid effettivo del processo
+corrente a \var{gid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
   di fallimento: l'unico errore possibile è \macro{EPERM}.}
 \end{functions}
 
-Gli utenti normali possono impostare l'\textit{effective id} solo al valore del
-\textit{real id} o del \textit{saved id}, l'amministratore può specificare
-qualunque valore. Queste funzioni sono usate per permettere a root di impostare
-solo l'\textit{effective id}, dato che l'uso normale di \func{setuid} comporta
-l'impostazione di tutti gli identificatori.
+Come per le precedenti le due funzioni sono identiche, per cui tratteremo solo
+la prima. Gli utenti normali possono impostare l'userid effettivo solo al
+valore dell'userid reale o dell'userid salvato, l'amministratore può
+specificare qualunque valore. Queste funzioni sono usate per permettere
+all'amministratore di impostare solo l'userid effettivo, dato che l'uso
+normale di \func{setuid} comporta l'impostazione di tutti gli identificatori.
  
 
 \subsection{Le funzioni \func{setresuid} e \func{setresgid}}
@@ -1632,25 +1632,25 @@ e permettono un completo controllo su tutti gli identificatori (\textit{real},
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setresuid(uid\_t ruid, uid\_t euid, uid\_t suid)} Imposta il
-\textit{real user id}, l'\textit{effective user id} e il \textit{saved user
-  id} del processo corrente ai valori specificati rispettivamente da
-\var{ruid}, \var{euid} e \var{suid}.
+\funcdecl{int setresuid(uid\_t ruid, uid\_t euid, uid\_t suid)} Imposta
+l'userid reale, l'userid effettivo e l'userid salvato del processo corrente
+ai valori specificati rispettivamente da \var{ruid}, \var{euid} e \var{suid}.
   
 \funcdecl{int setresgid(gid\_t rgid, gid\_t egid, gid\_t sgid)} Imposta il
-\textit{real group id}, l'\textit{effective group id} e il \textit{saved group
-  id} del processo corrente ai valori specificati rispettivamente da
-\var{rgid}, \var{egid} e \var{sgid}.
+groupid reale, il groupid effettivo ed il groupid salvato del processo
+corrente ai valori specificati rispettivamente da \var{rgid}, \var{egid} e
+\var{sgid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
   di fallimento: l'unico errore possibile è \macro{EPERM}.}
 \end{functions}
 
-I processi non privilegiati possono cambiare uno qualunque degli
-identificatori usando uno qualunque dei valori correnti di \textit{real id},
-\textit{effective id} o \textit{saved id}, l'amministratore può specificare i
-valori che vuole; un valore di -1 per un qualunque parametro lascia inalterato
-l'identificatore corrispondente.
+Le due funzioni sono identiche, quanto detto per la prima riguardo gli userid
+si applica alla seconda per i groupid. I processi non privilegiati possono
+cambiare uno qualunque degli userid solo ad un valore corripondente o
+all'userid reale, o a quello effettivo o a quello salvato, l'amministratore
+può specificare i valori che vuole; un valore di -1 per un qualunque parametro
+lascia inalterato l'identificatore corrispondente.
 
 Per queste funzioni esistono anche due controparti che permettono di leggere
 in blocco i vari identificatori: \func{getresuid} e \func{getresgid}; i loro
@@ -1659,13 +1659,12 @@ prototipi sono:
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int getresuid(uid\_t *ruid, uid\_t *euid, uid\_t *suid)} Legge il
-\textit{real user id}, l'\textit{effective user id} e il \textit{saved user
-  id} del processo corrente.
+\funcdecl{int getresuid(uid\_t *ruid, uid\_t *euid, uid\_t *suid)} Legge
+l'userid reale, l'userid effettivo e l'userid salvato del processo corrente.
   
 \funcdecl{int getresgid(gid\_t *rgid, gid\_t *egid, gid\_t *sgid)} Legge il
-\textit{real group id}, l'\textit{effective group id} e il \textit{saved group
-  id} del processo corrente.
+groupid reale, il groupid effettivo e il groupid salvato del processo
+corrente.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso di
   fallimento: l'unico errore possibile è \macro{EFAULT} se gli indirizzi delle
@@ -1675,31 +1674,32 @@ prototipi sono:
 Anche queste funzioni sono un'estensione specifica di Linux, e non richiedono
 nessun privilegio. I valori sono restituiti negli argomenti, che vanno
 specificati come puntatori (è un'altro esempio di \textit{value result
-  argument}). Si noti che queste funzioni sono le uniche in grado di leggere i
-\textit{saved id}.
+  argument}). Si noti che queste funzioni sono le uniche in grado di leggere
+gli identificatori del gruppo \textit{saved}.
 
 
 \subsection{Le funzioni \func{setfsuid} e \func{setfsgid}}
 \label{sec:proc_setfsuid}
 
-Queste funzioni sono usate per impostare gli identificatori usati da Linux per
-il controllo dell'accesso ai file. Come già accennato in
-\secref{sec:proc_access_id} in Linux è definito questo ulteriore gruppo di
-identificatori, che di norma sono assolutamente equivalenti agli
-\textit{effective id}, dato che ogni cambiamento di questi ultimi viene
-immediatamente riportato sui \textit{filesystem id}.
-
-C'è un solo caso in cui si ha necessità di introdurre una differenza fra
-\textit{effective id} e \textit{filesystem id}, ed è per ovviare ad un
-problema di sicurezza che si presenta quando si deve implementare un server
-NFS. Il server NFS infatti deve poter cambiare l'identificatore con cui accede
-ai file per assumere l'identità del singolo utente remoto, ma se questo viene
-fatto cambiando l'\textit{effective id} o il \textit{real id} il server si
-espone alla ricezione di eventuali segnali ostili da parte dell'utente di cui
-ha temporaneamente assunto l'identità.  Cambiando solo il \textit{filesystem
-  id} si ottengono i privilegi necessari per accedere ai file, mantenendo
-quelli originari per quanto riguarda tutti gli altri controlli di accesso,
-così che l'utente non possa inviare segnali al server NFS.
+Queste funzioni sono usate per impostare gli identificatori del gruppo
+\textit{filesystem} che usati da Linux per il controllo dell'accesso ai file.
+Come già accennato in \secref{sec:proc_access_id} Linux definisce questo
+ulteriore gruppo di identificatori, che di norma sono assolutamente
+equivalenti a quelli del gruppo \textit{effective}, dato che ogni cambiamento
+di questi ultimi viene immediatamente riportato su di essi.
+
+C'è un solo caso in cui si ha necessità di introdurre una differenza fra gli
+identificatori dei gruppi \textit{effective} e \textit{filesystem}, ed è per
+ovviare ad un problema di sicurezza che si presenta quando si deve
+implementare un server NFS. Il server NFS infatti deve poter cambiare
+l'identificatore con cui accede ai file per assumere l'identità del singolo
+utente remoto, ma se questo viene fatto cambiando l'userid effettivo o
+l'userid reale il server si espone alla ricezione di eventuali segnali ostili
+da parte dell'utente di cui ha temporaneamente assunto l'identità.  Cambiando
+solo l'userid di filesystem si ottengono i privilegi necessari per accedere ai
+file, mantenendo quelli originari per quanto riguarda tutti gli altri
+controlli di accesso, così che l'utente non possa inviare segnali al server
+NFS.
 
 Le due funzioni usate per cambiare questi identificatori sono \func{setfsuid}
 e \func{setfsgid}, ovviamente sono specifiche di Linux e non devono essere
@@ -1707,10 +1707,10 @@ usate se si intendono scrivere programmi portabili; i loro prototipi sono:
 \begin{functions}
 \headdecl{sys/fsuid.h}
 
-\funcdecl{int setfsuid(uid\_t fsuid)} Imposta il \textit{filesystem user id} del
+\funcdecl{int setfsuid(uid\_t fsuid)} Imposta l'userid di filesystem del
 processo corrente a \var{fsuid}.
 
-\funcdecl{int setfsgid(gid\_t fsgid)} Imposta l'\textit{filesystem group id} del
+\funcdecl{int setfsgid(gid\_t fsgid)} Imposta il groupid di filesystem del
 processo corrente a \var{fsgid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1718,7 +1718,8 @@ processo corrente a \var{fsgid}.
 \end{functions}
 \noindent queste funzioni hanno successo solo se il processo chiamante ha i
 privilegi di amministratore o, per gli altri utenti, se il valore specificato
-coincide con uno dei \textit{real}, \textit{effective} o \textit{saved id}.
+coincide con uno dei di quelli del gruppo \textit{real}, \textit{effective} o
+\textit{saved}.
 
 
 \subsection{Le funzioni \func{setgroups} e \func{getgroups}}
@@ -1749,9 +1750,9 @@ questa funzione 
     \end{errlist}}
 \end{functions}
 \noindent non è specificato se la funzione inserisca o meno nella lista
-l'\textit{effective user id} del processo. Se si specifica un valore di
-\param{size} uguale a 0 \param{list} non viene modificato, ma si ottiene il
-numero di gruppi supplementari.
+il groupid effettivo del processo. Se si specifica un valore di \param{size}
+uguale a 0 \param{list} non viene modificato, ma si ottiene il numero di
+gruppi supplementari.
 
 Una seconda funzione, \func{getgrouplist}, può invece essere usata per
 ottenere tutti i gruppi a cui appartiene un utente; il suo prototipo è:
@@ -1811,7 +1812,6 @@ La funzione esegue la scansione del database dei gruppi (usualmente
 \file{/etc/groups}) cercando i gruppi di cui è membro \param{user} e
 costruendo una lista di gruppi supplementari a cui aggiunge \param{group}, che
 poi imposta usando \func{setgroups}.
-
 Si tenga presente che sia \func{setgroups} che \func{initgroups} non sono
 definite nello standard POSIX.1 e che pertanto non è possibile utilizzarle
 quando si definisce \macro{\_POSIX\_SOURCE} o si compila con il flag
@@ -1873,7 +1873,7 @@ fintanto che esso si trova in uno qualunque degli altri stati.
 
 \begin{table}[htb]
   \centering
-  \begin{tabular}[c]{|p{3cm}|c|p{8cm}|}
+  \begin{tabular}[c]{|p{2.8cm}|c|p{10cm}|}
     \hline
     \textbf{Stato} & \texttt{STAT} & \textbf{Descrizione} \\
     \hline
@@ -1987,7 +1987,6 @@ meccanismo appena descritto infatti un valore pi
 maggiore attribuzione di CPU.  L'origine del nome di questo parametro sta nel
 fatto che in genere esso viene generalmente usato per diminuire la priorità di
 un processo, come misura di cortesia nei confronti degli altri.
-
 I processi infatti vengono creati dal sistema con lo stesso valore di
 \var{nice} (nullo) e nessuno è privilegiato rispetto agli altri; il valore può
 essere modificato solo attraverso la funzione \func{nice}, il cui prototipo è:
@@ -2083,14 +2082,14 @@ impostare la priorit
   \end{errlist}}
 \end{prototype}
 
-La funzione imposta la priorità al valore specificato da \param{prio} per tutti
-i processi indicati dagli argomenti \param{which} e \param{who}.  La gestione
-dei permessi dipende dalle varie implementazioni; in Linux, secondo le
-specifiche dello standard SUSv3, e come avviene per tutti i sistemi che
-derivano da SYSV, è richiesto che il real o l'effective user id del processo
+La funzione imposta la priorità al valore specificato da \param{prio} per
+tutti i processi indicati dagli argomenti \param{which} e \param{who}.  La
+gestione dei permessi dipende dalle varie implementazioni; in Linux, secondo
+le specifiche dello standard SUSv3, e come avviene per tutti i sistemi che
+derivano da SYSV, è richiesto che l'userid reale o effettivo del processo
 chiamante corrispondano al real user id (e solo quello) del processo di cui si
 vuole cambiare la priorità; per i sistemi derivati da BSD invece (SunOS,
-Ultrix, *BSD) la corrispondenza può essere anche con l'effective user id.
+Ultrix, *BSD) la corrispondenza può essere anche con l'userid effettivo.
 
 
 
@@ -2190,11 +2189,30 @@ la politica di scheduling corrente.
 Il valore della priorità è passato attraverso la struttura \var{sched\_param}
 (riportata in \figref{fig:sig_sched_param}), il cui solo campo attualmente
 definito è \var{sched\_priority}, che nel caso delle priorità assolute deve
-essere specificato nell'intervallo fra 1 e 99 (il valore zero è legale, ma
-indica i processi normali). Lo standard POSIX.1b prevede comunque che questi
-due valori possano essere ottenuti per ciascuna politica di scheduling dalle
-funzioni \func{sched\_get\_priority\_max} e \func{sched\_get\_priority\_min},
-i cui prototipi sono:
+essere specificato nell'intervallo fra un valore massimo ed uno minimo, che
+nel caso sono rispettivamente 1 e 99 (il valore zero è legale, ma indica i
+processi normali).
+
+\begin{figure}[!htb]
+  \footnotesize \centering
+  \begin{minipage}[c]{15cm}
+    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
+struct sched_param {
+    int sched_priority;
+};
+    \end{lstlisting}
+  \end{minipage} 
+  \normalsize 
+  \caption{La struttura \var{sched\_param}.} 
+  \label{fig:sig_sched_param}
+\end{figure}
+
+
+
+Lo standard POSIX.1b prevede comunque che i due valori della massima e minima
+priorità statica possano essere ottenuti, per ciascuna delle politiche di
+scheduling realtime, tramite le due funzioni \func{sched\_get\_priority\_max}
+e \func{sched\_get\_priority\_min}, i cui prototipi sono:
 \begin{functions}
   \headdecl{sched.h}
   
@@ -2219,20 +2237,6 @@ infatti non ha niente a che vedere con la priorit
 valore di \var{nice}, che deve essere impostato con le funzioni viste in
 precedenza.
 
-\begin{figure}[!htb]
-  \footnotesize \centering
-  \begin{minipage}[c]{15cm}
-    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct sched_param {
-    int sched_priority;
-};
-    \end{lstlisting}
-  \end{minipage} 
-  \normalsize 
-  \caption{La struttura \var{sched\_param}.} 
-  \label{fig:sig_sched_param}
-\end{figure}
-
 Il kernel mantiene i processi con la stessa priorità assoluta in una lista, ed
 esegue sempre il primo della lista, mentre un nuovo processo che torna in
 stato \textit{runnable} viene sempre inserito in coda alla lista. Se la
diff --git a/signal.tex b/signal.tex
index c737f57..860a1f5 100644
--- a/signal.tex
+++ b/signal.tex
@@ -1011,14 +1011,14 @@ e che permette di inviare un segnale a tutto un \textit{process group} (vedi
 \secref{sec:sess_xxx}).
 
 Solo l'amministratore può inviare un segnale ad un processo qualunque, in
-tutti gli altri casi il \textit{real user id} o l'\textit{effective user id}
-del processo chiamante devono corrispondere al \textit{real user id} o al
-\textit{saved user id} della destinazione. Fa eccezione il caso in cui il
-segnale inviato sia \macro{SIGCONT}, nel quale occorre che entrambi i processi
-appartengano alla stessa sessione. Inoltre, dato il ruolo fondamentale che
-riveste nel sistema (si ricordi quanto visto in \secref{sec:sig_termination}),
-non è possibile inviare al processo 1 (cioè a \cmd{init}) segnali per i quali
-esso non abbia un gestore installato.
+tutti gli altri casi l'userid reale o l'userid effettivo del processo
+chiamante devono corrispondere all'userid reale o all'userid salvato della
+destinazione. Fa eccezione il caso in cui il segnale inviato sia
+\macro{SIGCONT}, nel quale occorre che entrambi i processi appartengano alla
+stessa sessione. Inoltre, dato il ruolo fondamentale che riveste nel sistema
+(si ricordi quanto visto in \secref{sec:sig_termination}), non è possibile
+inviare al processo 1 (cioè a \cmd{init}) segnali per i quali esso non abbia
+un gestore installato.
 
 Infine, seguendo le specifiche POSIX 1003.1-2001, l'uso della chiamata
 \code{kill(-1, sig)} comporta che il segnale sia inviato (con la solita
diff --git a/socket.tex b/socket.tex
index 8511778..a5af5da 100644
--- a/socket.tex
+++ b/socket.tex
@@ -193,9 +193,8 @@ protocolli disponibili sono riportate in \tabref{tab:net_pf_names}.
 
 Non tutte le famiglie di protocolli sono accessibili dall'utente generico, ad
 esempio in generale tutti i socket di tipo \macro{SOCK\_RAW} possono essere
-creati solo da processi che hanno i privilegi di root (cioè con
-\textit{effective user id} uguale a zero) o con la capability
-\macro{CAP\_NET\_RAW}.
+creati solo da processi che hanno i privilegi di root (cioè con userid
+effettivo uguale a zero) o con la capability \macro{CAP\_NET\_RAW}.
 
 
 \subsection{Il tipo, o stile}
@@ -416,9 +415,9 @@ porta viene impostato al numero di protocollo.
 Il membro \var{sin\_family} deve essere sempre impostato; \var{sin\_port}
 specifica il numero di porta (vedi \secref{sec:TCPel_port_num}; i numeri di
 porta sotto il 1024 sono chiamati \textsl{riservati} in quanto utilizzati da
-servizi standard. Soltanto processi con i privilegi di root (effective uid
-uguale a zero) o con la capability \macro{CAP\_NET\_BIND\_SERVICE} possono
-usare la funzione \func{bind} su queste porte.
+servizi standard. Soltanto processi con i privilegi di root (con userid
+effettivo uguale a zero) o con la capability \macro{CAP\_NET\_BIND\_SERVICE}
+possono usare la funzione \func{bind} su queste porte.
 
 Il membro \var{sin\_addr} contiene l'indirizzo internet dell'altro capo
 della comunicazione, e viene acceduto sia come struttura (un resto di una
diff --git a/system.tex b/system.tex
index bc7cac5..2422abd 100644
--- a/system.tex
+++ b/system.tex
@@ -35,11 +35,11 @@ quelle della gestione dei file.
 Quando si devono determinare le le caratteristiche generali del sistema ci si
 trova di fronte a diverse possibilità; alcune di queste infatti possono
 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
-interi), o dal sistema operativo (come la presenza o meno dei \textit{saved
-  id}), altre invece possono dipendere dalle opzioni con cui si è costruito
-il sistema (ad esempio da come si è compilato il kernel), o dalla
-configurazione del medesimo; per questo motivo in generale sono necessari due
-tipi diversi di funzionalità:
+interi), o dal sistema operativo (come la presenza o meno del gruppo degli
+identificatori \textit{saved}), altre invece possono dipendere dalle opzioni
+con cui si è costruito il sistema (ad esempio da come si è compilato il
+kernel), o dalla configurazione del medesimo; per questo motivo in generale
+sono necessari due tipi diversi di funzionalità:
 \begin{itemize*}
 \item la possibilità di determinare limiti ed opzioni al momento della
   compilazione.
@@ -242,8 +242,9 @@ valori ottenuti da \func{sysconf}.
     \macro{\_POSIX\_JOB\_CONTROL}& il sistema supporta il 
                                    \textit{job control} (vedi 
                                    \secref{sec:sess_xxx}).\\
-    \macro{\_POSIX\_SAVED\_IDS}  & il sistema supporta i \textit{saved id} 
-                                   (vedi \secref{sec:proc_access_id}). 
+    \macro{\_POSIX\_SAVED\_IDS}  & il sistema supporta gli identificatori del 
+                                   gruppo \textit{saved} (vedi 
+                                   \secref{sec:proc_access_id})
                                    per il controllo di accesso dei processi\\
     \macro{\_POSIX\_VERSION}     & fornisce la versione dello standard POSIX.1
                                    supportata nel formato YYYYMML (ad esempio 
@@ -263,7 +264,7 @@ incluso automaticamente all'interno di \file{limits.h}). Di questi vale la
 pena menzionare alcune macro di uso comune, (riportate in
 \tabref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
 denotano la presenza di alcune funzionalità nel sistema (come il supporto del
-\textit{job control} o dei \textit{saved id}).
+\textit{job control} o degli identificatori del gruppo \textit{saved}).
 
 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
@@ -504,7 +505,7 @@ indicano rispettivamente:
 \item il nome del domino.
 \end{itemize*}
 l'ultima informazione è stata aggiunta di recente e non è prevista dallo
-standard POSIX, essa è accessibile, come mostrato in \figref{fig:sig_stack_t},
+standard POSIX, essa è accessibile, come mostrato in \figref{fig:sys_utsname},
 solo definendo \macro{\_GNU\_SOURCE}.
 
 \begin{figure}[!htb]
@@ -534,11 +535,11 @@ In generale si tenga presente che le dimensioni delle stringe di una
 \macro{\_UTSNAME\_LENGTH} per i campi standard e
 \macro{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
 altri sistemi usano nomi diversi come \macro{SYS\_NMLN} o \macro{\_SYS\_NMLN}
-o \macro{UTSLEN} che possono avere valori diversi. Nel caso di Linux
+o \macro{UTSLEN} che possono avere valori diversi.\footnote{Nel caso di Linux
 \func{uname} corrisponde in realtà a 3 system call diverse, le prime due usano
 rispettivamente delle lunghezze delle stringhe di 9 e 65 byte; la terza usa
 anch'essa 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con
-una lunghezza di 257 byte.
+una lunghezza di 257 byte.}
 
 
 \section{Opzioni e configurazione del sistema}
@@ -555,11 +556,9 @@ da uno standard, ogni sistema pu
 configurazione, che, non essendo mai fissi e variando da sistema a sistema,
 non sono stati inclusi nella standardizzazione della sezione precedente. Per
 questi occorre, oltre al meccanismo di impostazione, pure un meccanismo di
-lettura.
-
-Affronteremo questi argomenti in questa sezione, insieme alle funzioni che si
-usano per il controllo di altre caratteristiche generali del sistema, come
-quelle per la gestione dei filesystem e di utenti e gruppi.
+lettura.  Affronteremo questi argomenti in questa sezione, insieme alle
+funzioni che si usano per il controllo di altre caratteristiche generali del
+sistema, come quelle per la gestione dei filesystem e di utenti e gruppi.
 
 
 \subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}