X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=prochand.tex;h=1e3b69e106f0bc133269877ebda5682c024c9d08;hp=93212327f92db341aa265bbc8164802ecd006a5c;hb=1bdb3c6f5316edaf8e9943a99c210ecc0ec70751;hpb=da0899b61653d07d75c8df134906261f1afd2485

diff --git a/prochand.tex b/prochand.tex
index 9321232..1e3b69e 100644
--- a/prochand.tex
+++ b/prochand.tex
@@ -43,7 +43,7 @@ caratteristiche di Unix (che esamineremo in dettaglio pi
 qualunque processo può a sua volta generarne altri, detti processi figli
 (\textit{child process}). Ogni processo è identificato presso il sistema da un
 numero univoco, il cosiddetto \textit{process identifier} o, più brevemente,
-\acr{pid}, assengnato in forma progressiva (vedi \secref{sec:proc_pid}) quando
+\acr{pid}, assegnato in forma progressiva (vedi \secref{sec:proc_pid}) quando
 il processo viene creato.
 
 Una seconda caratteristica di un sistema Unix è che la generazione di un
@@ -126,13 +126,14 @@ struttura, alla cui base c'
 processi.
 
 Il kernel mantiene una tabella dei processi attivi, la cosiddetta
-\textit{process table}; per ciascun processo viene mantenuta una voce nella
-tabella dei processi costituita da una struttura \struct{task\_struct}, che
-contiene tutte le informazioni rilevanti per quel processo. Tutte le strutture
-usate a questo scopo sono dichiarate nell'header file \file{linux/sched.h}, ed
-uno schema semplificato, che riporta la struttura delle principali informazioni
-contenute nella \struct{task\_struct} (che in seguito incontreremo a più
-riprese), è mostrato in \figref{fig:proc_task_struct}.
+\textit{process table}; per ciascun processo viene mantenuta una voce,
+costituita da una struttura \struct{task\_struct}, nella tabella dei processi
+che contiene tutte le informazioni rilevanti per quel processo. Tutte le
+strutture usate a questo scopo sono dichiarate nell'header file
+\file{linux/sched.h}, ed uno schema semplificato, che riporta la struttura
+delle principali informazioni contenute nella \struct{task\_struct} (che in
+seguito incontreremo a più riprese), è mostrato in
+\figref{fig:proc_task_struct}.
 
 \begin{figure}[htb]
   \centering
@@ -196,7 +197,7 @@ coi processi che 
 
 Il programma che un processo sta eseguendo si chiama immagine del processo (o
 \textit{process image}), le funzioni della famiglia \func{exec} permettono di
-caricare un'altro programma da disco sostituendo quest'ultimo all'immagine
+caricare un altro programma da disco sostituendo quest'ultimo all'immagine
 corrente; questo fa sì che l'immagine precedente venga completamente
 cancellata. Questo significa che quando il nuovo programma termina, anche il
 processo termina, e non si può tornare alla precedente immagine.
@@ -223,7 +224,7 @@ programmi.
 \label{sec:proc_pid}
 
 Come accennato nell'introduzione, ogni processo viene identificato dal sistema
-da un numero identificativo univoco, il \textit{process id} o \acr{pid};
+da un numero identificativo univoco, il \textit{process ID} o \acr{pid};
 quest'ultimo è un tipo di dato standard, il \type{pid\_t} che in genere è un
 intero con segno (nel caso di Linux e delle \acr{glibc} il tipo usato è
 \ctyp{int}).
@@ -240,13 +241,13 @@ disponibile a partire da un minimo di 300,\footnote{questi valori, fino al
   e direttamente in \file{fork.c}, con il kernel 2.5.x e la nuova interfaccia
   per i thread creata da Ingo Molnar anche il meccanismo di allocazione dei
   \acr{pid} è stato modificato.} che serve a riservare i \acr{pid} più bassi
-ai processi eseguiti dal direttamente dal kernel.  Per questo motivo, come
-visto in \secref{sec:proc_hierarchy}, il processo di avvio (\cmd{init}) ha
-sempre il \acr{pid} uguale a uno.
+ai processi eseguiti direttamente dal kernel.  Per questo motivo, come visto
+in \secref{sec:proc_hierarchy}, il processo di avvio (\cmd{init}) ha sempre il
+\acr{pid} uguale a uno.
 
 Tutti i processi inoltre memorizzano anche il \acr{pid} del genitore da cui
 sono stati creati, questo viene chiamato in genere \acr{ppid} (da
-\textit{parent process id}).  Questi due identificativi possono essere
+\textit{parent process ID}).  Questi due identificativi possono essere
 ottenuti usando le due funzioni \funcd{getpid} e \funcd{getppid}, i cui
 prototipi sono:
 \begin{functions}
@@ -263,13 +264,13 @@ prototipi sono:
 \bodydesc{Entrambe le funzioni non riportano condizioni di errore.}
 \end{functions}
 \noindent esempi dell'uso di queste funzioni sono riportati in
-\figref{fig:proc_fork_code}, nel programma di esempio \file{ForkTest.c}.
+\figref{fig:proc_fork_code}, nel programma \file{ForkTest.c}.
 
 Il fatto che il \acr{pid} sia un numero univoco per il sistema lo rende un
 candidato per generare ulteriori indicatori associati al processo di cui
 diventa possibile garantire l'unicità: ad esempio in alcune implementazioni la
 funzione \func{tmpname} (si veda \secref{sec:file_temp_file}) usa il \acr{pid}
-per generare un pathname univoco, che non potrà essere replicato da un'altro
+per generare un pathname univoco, che non potrà essere replicato da un altro
 processo che usi la stessa funzione.
 
 Tutti i processi figli dello stesso processo padre sono detti
@@ -307,7 +308,7 @@ prototipo della funzione 
     zero al figlio; ritorna -1 al padre (senza creare il figlio) in caso di
     errore; \var{errno} può assumere i valori:
   \begin{errlist}
-  \item[\errcode{EAGAIN}] non ci sono risorse sufficienti per creare un'altro
+  \item[\errcode{EAGAIN}] non ci sono risorse sufficienti per creare un altro
     processo (per allocare la tabella delle pagine e le strutture del task) o
     si è esaurito il numero di processi disponibili.
   \item[\errcode{ENOMEM}] non è stato possibile allocare la memoria per le
@@ -317,7 +318,7 @@ prototipo della funzione 
 
 Dopo il successo dell'esecuzione di una \func{fork} sia il processo padre che
 il processo figlio continuano ad essere eseguiti normalmente a partire
-dall'istruzione seccessiva alla \func{fork}; il processo figlio è però una
+dall'istruzione successiva alla \func{fork}; il processo figlio è però una
 copia del padre, e riceve una copia dei segmenti di testo, stack e dati (vedi
 \secref{sec:proc_mem_layout}), ed esegue esattamente lo stesso codice del
 padre. Si tenga presente però che la memoria è copiata, non condivisa,
@@ -349,53 +350,11 @@ sempre un solo padre (il cui \acr{pid} pu
 che non è il \acr{pid} di nessun processo.
 
 \begin{figure}[!htb]
-  \footnotesize
-  \begin{lstlisting}{}
-#include <errno.h>       /* error definitions and routines */ 
-#include <stdlib.h>      /* C standard library */
-#include <unistd.h>      /* unix standard library */
-#include <stdio.h>       /* standard I/O library */
-#include <string.h>      /* string functions */
-
-/* Help printing routine */
-void usage(void);
-
-int main(int argc, char *argv[])
-{
-/* 
- * Variables definition  
- */
-    int nchild, i;
-    pid_t pid;
-    int wait_child  = 0;
-    int wait_parent = 0;
-    int wait_end    = 0;
-    ...        /* handling options */
-    nchild = atoi(argv[optind]);
-    printf("Test for forking %d child\n", nchild);
-    /* loop to fork children */
-    for (i=0; i<nchild; i++) {
-        if ( (pid = fork()) < 0) { 
-            /* on error exit */ 
-            printf("Error on %d child creation, %s\n", i+1, strerror(errno));
-            exit(-1); 
-        }
-        if (pid == 0) {   /* child */
-            printf("Child %d successfully executing\n", ++i);
-            if (wait_child) sleep(wait_child);
-            printf("Child %d, parent %d, exiting\n", i, getppid());
-            exit(0);
-        } else {          /* parent */
-            printf("Spawned %d child, pid %d \n", i+1, pid);
-            if (wait_parent) sleep(wait_parent);
-            printf("Go to next child \n");
-        }
-    }
-    /* normal exit */
-    if (wait_end) sleep(wait_end);
-    return 0;
-}
-  \end{lstlisting}
+  \footnotesize \centering
+  \begin{minipage}[c]{15cm}
+  \includecodesample{listati/ForkTest.c}
+  \end{minipage}
+  \normalsize
   \caption{Esempio di codice per la creazione di nuovi processi.}
   \label{fig:proc_fork_code}
 \end{figure}
@@ -456,13 +415,15 @@ attende il numero di secondi specificato, e procede nell'esecuzione del ciclo;
 alla conclusione del ciclo, prima di uscire, può essere specificato un altro
 periodo di attesa.
 
-Se eseguiamo il comando senza specificare attese (come si può notare in
-\texttt{\small 17--19} i valori predefiniti specificano di non attendere),
-otterremo come output sul terminale:
+Se eseguiamo il comando\footnote{che è preceduto dall'istruzione \code{export
+    LD\_LIBRARY\_PATH=./} per permettere l'uso delle librerie dinamiche.}
+senza specificare attese (come si può notare in (\texttt{\small 17--19}) i
+valori predefiniti specificano di non attendere), otterremo come output sul
+terminale:
 
 \footnotesize
 \begin{verbatim}
-[piccardi@selidor sources]$ ./forktest 3
+[piccardi@selidor sources]$ export LD_LIBRARY_PATH=./; ./forktest 3
 Process 1963: forking 3 child
 Spawned 1 child, pid 1964 
 Child 1 successfully executing
@@ -493,7 +454,7 @@ ciclo successivo), mentre la terza volta 
 (fino alla conclusione) e poi il padre.
 
 In generale l'ordine di esecuzione dipenderà, oltre che dall'algoritmo di
-scheduling usato dal kernel, dalla particolare situazione in si trova la
+scheduling usato dal kernel, dalla particolare situazione in cui si trova la
 macchina al momento della chiamata, risultando del tutto impredicibile.
 Eseguendo più volte il programma di prova e producendo un numero diverso di
 figli, si sono ottenute situazioni completamente diverse, compreso il caso in
@@ -570,7 +531,7 @@ figlio, troveremo nel file anche tutto quello che il processo padre aveva
 scritto prima della sua creazione.  E alla fine del file (dato che in questo
 caso il padre esce per ultimo) troveremo anche l'output completo del padre.
 
-L'esempio ci mostra un'altro aspetto fondamentale dell'interazione con i file,
+L'esempio ci mostra un altro aspetto fondamentale dell'interazione con i file,
 valido anche per l'esempio precedente, ma meno evidente: il fatto cioè che non
 solo processi diversi possono scrivere in contemporanea sullo stesso file
 (l'argomento della condivisione dei file è trattato in dettaglio in
@@ -628,12 +589,12 @@ comune dopo l'esecuzione di una \func{fork} 
 \item i file aperti e gli eventuali flag di
   \textit{close-on-exec}\index{close-on-exec} impostati (vedi
   \secref{sec:proc_exec} e \secref{sec:file_fcntl}).
-\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
+\item gli identificatori per il controllo di accesso: l'\textsl{user-ID
+    reale}, il \textsl{group-ID reale}, l'\textsl{user-ID effettivo}, il
+  \textsl{group-ID effettivo} ed i \textit{group-ID supplementari} (vedi
   \secref{sec:proc_access_id}).
 \item gli identificatori per il controllo di sessione: il \textit{process
-    groupid} e il \textit{session id} ed il terminale di controllo (vedi
+    group-ID} e il \textit{session id} ed il terminale di controllo (vedi
   \secref{sec:sess_proc_group}).
 \item la directory di lavoro e la directory radice (vedi
   \secref{sec:file_work_dir} e \secref{sec:file_chroot}).
@@ -1008,9 +969,7 @@ generato dalla terminazione di un figlio, avremo la certezza che la chiamata a
     \val{WIFSIGNALED} ha restituito un valore non nullo.\\
     \macro{WCOREDUMP(s)}   & Vera se il processo terminato ha generato un
     file si \textit{core dump}. Può essere valutata solo se
-    \val{WIFSIGNALED} ha restituito un valore non nullo.\footnote{questa
-    macro non è definita dallo standard POSIX.1, ma è presente come estensione
-    sia in Linux che in altri Unix.}\\
+    \val{WIFSIGNALED} ha restituito un valore non nullo.\footnotemark \\
     \macro{WIFSTOPPED(s)}  & Vera se il processo che ha causato il ritorno di
     \func{waitpid} è bloccato. L'uso è possibile solo avendo specificato
     l'opzione \const{WUNTRACED}. \\
@@ -1024,6 +983,9 @@ generato dalla terminazione di un figlio, avremo la certezza che la chiamata a
   \label{tab:proc_status_macro}
 \end{table}
 
+\footnotetext{questa macro non è definita dallo standard POSIX.1, ma è
+    presente come estensione sia in Linux che in altri Unix.}
+
 Entrambe le funzioni di attesa restituiscono lo stato di terminazione del
 processo tramite il puntatore \param{status} (se non interessa memorizzare lo
 stato si può passare un puntatore nullo). Il valore restituito da entrambe le
@@ -1103,8 +1065,8 @@ famiglia di funzioni) che possono essere usate per questo compito, in realt
   \begin{errlist}
   \item[\errcode{EACCES}] il file non è eseguibile, oppure il filesystem è
     montato in \cmd{noexec}, oppure non è un file regolare o un interprete.
-  \item[\errcode{EPERM}] il file ha i bit \acr{suid} o \acr{sgid}, l'utente non
-    è root, e o il processo viene tracciato, o il filesystem è montato con
+  \item[\errcode{EPERM}] il file ha i bit \acr{suid} o \acr{sgid}, l'utente
+    non è root, il processo viene tracciato, o il filesystem è montato con
     l'opzione \cmd{nosuid}.
   \item[\errcode{ENOEXEC}] il file è in un formato non eseguibile o non
     riconosciuto come tale, o compilato per un'altra architettura.
@@ -1168,9 +1130,7 @@ questo vettore \emph{deve} essere terminato da un puntatore nullo.
 
 Nel secondo caso le stringhe degli argomenti sono passate alla funzione come
 lista di puntatori, nella forma:
-\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
-  char *arg0, char *arg1,  ..., char *argn, NULL
-\end{lstlisting}
+\includecodesnip{listati/char_list.c}
 che deve essere terminata da un puntatore nullo.  In entrambi i casi vale la
 convenzione che il primo argomento (\var{arg0} o \var{argv[0]}) viene usato
 per indicare il nome del file che contiene il programma che verrà eseguito.
@@ -1206,7 +1166,7 @@ La seconda differenza fra le funzioni riguarda le modalit
 specifica il programma che si vuole eseguire. Con lo mnemonico \code{p} si
 indicano le due funzioni che replicano il comportamento della shell nello
 specificare il comando da eseguire; quando il parametro \param{file} non
-contiene una \file{/} esso viene considerato come un nome di programma, e
+contiene una ``\file{/}'' esso viene considerato come un nome di programma, e
 viene eseguita automaticamente una ricerca fra i file presenti nella lista di
 directory specificate dalla variabile di ambiente \var{PATH}. Il file che
 viene posto in esecuzione è il primo che viene trovato. Se si ha un errore
@@ -1240,9 +1200,9 @@ la lista completa 
 \begin{itemize*}
 \item il \textit{process id} (\acr{pid}) ed il \textit{parent process id}
   (\acr{ppid}).
-\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} (\acr{sid}) ed il \textit{process groupid}
+\item l'\textsl{user-ID reale}, il \textit{group-ID reale} ed i
+  \textsl{group-ID supplementari} (vedi \secref{sec:proc_access_id}).
+\item il \textit{session id} (\acr{sid}) ed il \textit{process group-ID}
   (\acr{pgid}), vedi \secref{sec:sess_proc_group}.
 \item il terminale di controllo (vedi \secref{sec:sess_ctrl_term}).
 \item il tempo restante ad un allarme (vedi \secref{sec:sig_alarm_abort}).
@@ -1279,14 +1239,14 @@ attraverso una \func{exec}, in genere questo 
 l'impostazione del flag di \textit{close-on-exec}\index{close-on-exec} sulle
 directory che apre, in maniera trasparente all'utente.
 
-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}).
+Abbiamo detto che l'\textsl{user-ID reale} ed il \textsl{group-ID reale}
+restano gli stessi all'esecuzione di \func{exec}; lo stesso vale per
+l'\textsl{user-ID effettivo} ed il \textsl{group-ID 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{user-ID effettivo} ed il
+\textsl{group-ID 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
@@ -1297,8 +1257,8 @@ in genere questo 
 \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]
+deve esse un programma valido (binario, non un altro script) che verrà
+chiamato come se si fosse eseguito il comando \cmd{interpreter [argomenti]
   filename}.
 
 Con la famiglia delle \func{exec} si chiude il novero delle funzioni su cui è
@@ -1329,7 +1289,7 @@ Come accennato in \secref{sec:intro_multiuser} il modello base\footnote{in
   o il \textit{Mandatory Access Control} di SELinux; inoltre basandosi sul
   lavoro effettuato con SELinux, a partire dal kernel 2.5.x, è iniziato lo
   sviluppo di una infrastruttura di sicurezza, il \textit{Linux Security
-    Modules}, ol LSM, in grado di fornire diversi agganci a livello del kernel
+    Modules}, o LSM, in grado di fornire diversi agganci a livello del kernel
   per modularizzare tutti i possibili controlli di accesso.} di sicurezza di
 un sistema unix-like è fondato sui concetti di utente e gruppo, e sulla
 separazione fra l'amministratore (\textsl{root}, detto spesso anche
@@ -1341,7 +1301,7 @@ 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 userid ed il groupid; questi servono al kernel per
+identificatori univoci, lo user-ID ed il group-ID; 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
@@ -1373,27 +1333,27 @@ rispettivamente \textit{real} ed \textit{effective} (cio
                                         & \textbf{Significato} \\ 
     \hline
     \hline
-    \acr{uid}   & \textit{real} & \textsl{userid reale} 
+    \acr{uid}   & \textit{real} & \textsl{user-ID reale} 
                 & indica l'utente che ha lanciato il programma\\ 
-    \acr{gid}   & '' &\textsl{groupid reale} 
+    \acr{gid}   & '' &\textsl{group-ID reale} 
                 & indica il gruppo principale dell'utente che ha lanciato 
                   il programma \\ 
     \hline
-    \acr{euid}  & \textit{effective} &\textsl{userid effettivo} 
+    \acr{euid}  & \textit{effective} &\textsl{user-ID effettivo} 
                 & indica l'utente usato nel controllo di accesso \\ 
-    \acr{egid}  & '' & \textsl{groupid effettivo} 
+    \acr{egid}  & '' & \textsl{group-ID effettivo} 
                 & indica il gruppo usato nel controllo di accesso \\ 
-    --          & -- & \textsl{groupid supplementari} 
+    --          & -- & \textsl{group-ID supplementari} 
                 & indicano gli ulteriori gruppi cui l'utente appartiene \\ 
     \hline
-    --          & \textit{saved} & \textsl{userid salvato} 
+    --          & \textit{saved} & \textsl{user-ID salvato} 
                 & è una copia dell'\acr{euid} iniziale\\ 
-    --          & '' & \textsl{groupid salvato} 
+    --          & '' & \textsl{group-ID salvato} 
                 & è una copia dell'\acr{egid} iniziale \\ 
     \hline
-    \acr{fsuid} & \textit{filesystem} &\textsl{userid di filesystem} 
+    \acr{fsuid} & \textit{filesystem} &\textsl{user-ID di filesystem} 
                 & indica l'utente effettivo per l'accesso al filesystem \\ 
-    \acr{fsgid} & '' & \textsl{groupid di filesystem} 
+    \acr{fsgid} & '' & \textsl{group-ID di filesystem} 
                 & indica il gruppo effettivo per l'accesso al filesystem  \\ 
     \hline
   \end{tabular}
@@ -1402,7 +1362,7 @@ rispettivamente \textit{real} ed \textit{effective} (cio
   \label{tab:proc_uid_gid}
 \end{table}
 
-Al primo gruppo appartengono l'\textsl{userid reale} ed il \textsl{groupid
+Al primo gruppo appartengono l'\textsl{user-ID reale} ed il \textsl{group-ID
   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
@@ -1413,8 +1373,8 @@ 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 lo \textsl{userid effettivo} ed il
-\textsl{groupid effettivo} (a cui si aggiungono gli eventuali \textsl{groupid
+Al secondo gruppo appartengono lo \textsl{user-ID effettivo} ed il
+\textsl{group-ID effettivo} (a cui si aggiungono gli eventuali \textsl{group-ID
   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
@@ -1427,7 +1387,7 @@ Questi identificatori normalmente sono identici ai corrispondenti del gruppo
 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).
+privilegi o permessi di un altro (o dell'amministratore).
 
 Come nel caso del \acr{pid} e del \acr{ppid}, anche tutti questi
 identificatori possono essere letti attraverso le rispettive funzioni:
@@ -1436,16 +1396,16 @@ prototipi sono:
 \begin{functions}
   \headdecl{unistd.h}
   \headdecl{sys/types.h}  
-  \funcdecl{uid\_t getuid(void)} Restituisce l'\textsl{userid reale} del
+  \funcdecl{uid\_t getuid(void)} Restituisce l'\textsl{user-ID reale} del
   processo corrente.
 
-  \funcdecl{uid\_t geteuid(void)} Restituisce l'\textsl{userid effettivo} del
+  \funcdecl{uid\_t geteuid(void)} Restituisce l'\textsl{user-ID effettivo} del
   processo corrente.
 
-  \funcdecl{gid\_t getgid(void)} Restituisce il \textsl{groupid reale} del
+  \funcdecl{gid\_t getgid(void)} Restituisce il \textsl{group-ID reale} del
   processo corrente.
   
-  \funcdecl{gid\_t getegid(void)} Restituisce il \textsl{groupid effettivo}
+  \funcdecl{gid\_t getegid(void)} Restituisce il \textsl{group-ID effettivo}
   del processo corrente.
   
   \bodydesc{Queste funzioni non riportano condizioni di errore.}
@@ -1458,24 +1418,24 @@ 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 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
+Questo in Linux viene fatto usando 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.
 
-L'\textsl{userid salvato} ed il \textsl{groupid salvato} sono copie
-dell'\textsl{userid effettivo} e del \textsl{groupid effettivo} del processo
+L'\textsl{user-ID salvato} ed il \textsl{group-ID salvato} sono copie
+dell'\textsl{user-ID effettivo} e del \textsl{group-ID 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
+come copie dell'\textsl{user-ID effettivo} e del \textsl{group-ID effettivo}
+dopo che questi 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 di filesystem} e il \textsl{groupid di filesystem} sono
+L'\textsl{user-ID di filesystem} e il \textsl{group-ID 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 identificatori del gruppo \textit{effective}, ai
@@ -1492,16 +1452,16 @@ ignorarne l'esistenza, in quanto saranno del tutto equivalenti ai precedenti.
 Le due funzioni che vengono usate per cambiare identità (cioè utente e gruppo
 di appartenenza) ad un processo sono rispettivamente \funcd{setuid} e
 \funcd{setgid}; come accennato in \secref{sec:proc_access_id} in Linux esse
-seguono la semantica POSIX che prevede l'esistenza dell'\textit{userid
-  salvato} e del \textit{groupid salvato}; i loro prototipi sono:
+seguono la semantica POSIX che prevede l'esistenza dell'\textit{user-ID
+  salvato} e del \textit{group-ID salvato}; i loro prototipi sono:
 \begin{functions}
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setuid(uid\_t uid)} Imposta l'\textsl{userid} del processo
+\funcdecl{int setuid(uid\_t uid)} Imposta l'\textsl{user-ID} del processo
 corrente.
 
-\funcdecl{int setgid(gid\_t gid)} Imposta il \textsl{groupid} del processo
+\funcdecl{int setgid(gid\_t gid)} Imposta il \textsl{group-ID} del processo
 corrente.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1510,21 +1470,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 \textsl{groupid} invece che all'\textsl{userid}.  Gli
-eventuali \textsl{groupid supplementari} non vengono modificati.
+riferimento al \textsl{group-ID} invece che all'\textsl{user-ID}.  Gli
+eventuali \textsl{group-ID supplementari} non vengono modificati.
 
 L'effetto della chiamata è diverso a seconda dei privilegi del processo; se
-l'\textsl{userid effettivo} è zero (cioè è quello dell'amministratore di
+l'\textsl{user-ID 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 \param{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
+altrimenti viene impostato solo l'\textsl{user-ID effettivo}, e soltanto se il
+valore specificato corrisponde o all'\textsl{user-ID reale} o
+all'\textsl{user-ID salvato}. Negli altri casi viene segnalato un errore (con
 \errcode{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 (vedi
-\secref{sec:file_suid_sgid}) di riportare l'\textsl{userid effettivo} a quello
+\secref{sec:file_suid_sgid}) di riportare l'\textsl{user-ID effettivo} a quello
 dell'utente che ha lanciato il programma, effettuare il lavoro che non
 necessita di privilegi aggiuntivi, ed eventualmente tornare indietro.
 
@@ -1543,65 +1503,66 @@ Quando uno di questi programmi (ad esempio \cmd{xterm}) viene lanciato, la
 situazione degli identificatori è la seguente:
 \begin{eqnarray*}
   \label{eq:1}
-  \textsl{groupid reale}      &=& \textrm{\acr{gid} (del chiamante)} \\
-  \textsl{groupid effettivo}  &=& \textrm{\acr{utmp}} \\
-  \textsl{groupid salvato}    &=& \textrm{\acr{utmp}}
+  \textsl{group-ID reale}      &=& \textrm{\acr{gid} (del chiamante)} \\
+  \textsl{group-ID effettivo}  &=& \textrm{\acr{utmp}} \\
+  \textsl{group-ID salvato}    &=& \textrm{\acr{utmp}}
 \end{eqnarray*}
-in questo modo, dato che il \textsl{groupid effettivo} è quello giusto, il
+in questo modo, dato che il \textsl{group-ID 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 il \textsl{groupid effettivo} a quello dell'utente (e dato che il
-\textsl{groupid reale} corrisponde la funzione avrà successo), in questo modo
+impostare il \textsl{group-ID effettivo} a quello dell'utente (e dato che il
+\textsl{group-ID 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}
-  \textsl{groupid reale}      &=& \textrm{\acr{gid} (invariato)}  \\
-  \textsl{groupid effettivo}  &=& \textrm{\acr{gid}} \\
-  \textsl{groupid salvato}    &=& \textrm{\acr{utmp} (invariato)}
+  \textsl{group-ID reale}      &=& \textrm{\acr{gid} (invariato)}  \\
+  \textsl{group-ID effettivo}  &=& \textrm{\acr{gid}} \\
+  \textsl{group-ID salvato}    &=& \textrm{\acr{utmp} (invariato)}
 \end{eqnarray*}
 e ogni processo lanciato dal terminale avrebbe comunque \acr{gid} come
-\textsl{groupid effettivo}. All'uscita dal terminale, per poter di nuovo
+\textsl{group-ID 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 \textsl{groupid salvato} la
+in questo caso il valore richiesto corrisponde al \textsl{group-ID salvato} la
 funzione avrà successo e riporterà la situazione a:
 \begin{eqnarray*}
   \label{eq:3}
-  \textsl{groupid reale}      &=& \textrm{\acr{gid} (invariato)}  \\
-  \textsl{groupid effettivo}  &=& \textrm{\acr{utmp}} \\
-  \textsl{groupid salvato}    &=& \textrm{\acr{utmp} (invariato)}
+  \textsl{group-ID reale}      &=& \textrm{\acr{gid} (invariato)}  \\
+  \textsl{group-ID effettivo}  &=& \textrm{\acr{utmp}} \\
+  \textsl{group-ID salvato}    &=& \textrm{\acr{utmp} (invariato)}
 \end{eqnarray*}
 consentendo l'accesso a \file{/var/log/utmp}.
 
 Occorre però tenere conto che tutto questo non è possibile con un processo con
-i privilegi di root, in tal caso infatti l'esecuzione una \func{setuid}
-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'\textsl{userid effettivo} del processo per cedere i privilegi occorre
+i privilegi di amministratore, in tal caso infatti l'esecuzione di una
+\func{setuid} 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'\textsl{user-ID effettivo} del processo per cedere i privilegi occorre
 ricorrere ad altre funzioni (si veda ad esempio \secref{sec:proc_seteuid}).
 
 
-\subsection{Le funzioni \func{setreuid} e \func{setresuid}}
+\subsection{Le funzioni \func{setreuid} e \func{setregid}}
 \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.} gli
-identificatori del gruppo \textit{saved}, le usa per poter scambiare fra di
-loro \textit{effective} e \textit{real}. I loro prototipi sono:
+Le due funzioni \funcd{setreuid} e \funcd{setregid} derivano da BSD che, non
+supportando\footnote{almeno fino 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
+rispettivi prototipi sono:
 \begin{functions}
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Imposta l'\textsl{userid
-  reale} e l'\textsl{userid effettivo} del processo corrente ai valori
+\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Imposta l'\textsl{user-ID
+  reale} e l'\textsl{user-ID effettivo} del processo corrente ai valori
 specificati da \param{ruid} e \param{euid}.
   
-\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Imposta il \textsl{groupid
-  reale} ed il \textsl{groupid effettivo} del processo corrente ai valori
+\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Imposta il \textsl{group-ID
+  reale} ed il \textsl{group-ID effettivo} del processo corrente ai valori
 specificati da \param{rgid} e \param{egid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1609,14 +1570,14 @@ specificati da \param{rgid} e \param{egid}.
 \end{functions}
 
 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
+detto per la prima prima riguardo l'user-ID, si applica immediatamente alla
+seconda per il group-ID. I processi non privilegiati possono impostare solo i
+valori del loro user-ID 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 funzioni si possono scambiare fra loro gli userid reale e
+Con queste funzioni si possono scambiare fra loro gli user-ID 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
@@ -1624,36 +1585,37 @@ 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 userid reale privilegiato, che dovrà
+questo caso infatti essi avranno un user-ID 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 l'userid reale a quello effettivo) in
+prima della \func{exec} per uniformare l'user-ID 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 pone per l'userid salvato: questa funzione deriva da un'implementazione che
+si pone per l'user-ID 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.
+che si imposta un qualunque valore diverso da quello dall'user-ID reale
+corrente, l'user-ID salvato viene automaticamente uniformato al valore
+dell'user-ID effettivo.
 
 
-\subsection{Le funzioni \funcd{seteuid} e \funcd{setegid}}
+\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 vengono usate per cambiare gli
-identificatori del gruppo \textit{effective}; i loro prototipi sono:
+Le due funzioni \funcd{seteuid} e \funcd{setegid} sono un'estensione allo
+standard POSIX.1 (ma sono comunque 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'userid effettivo del processo
+\funcdecl{int seteuid(uid\_t uid)} Imposta l'user-ID effettivo del processo
 corrente a \param{uid}.
 
-\funcdecl{int setegid(gid\_t gid)} Imposta il groupid effettivo del processo
+\funcdecl{int setegid(gid\_t gid)} Imposta il group-ID effettivo del processo
 corrente a \param{gid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1661,30 +1623,31 @@ corrente a \param{gid}.
 \end{functions}
 
 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ò
+la prima. Gli utenti normali possono impostare l'user-ID effettivo solo al
+valore dell'user-ID reale o dell'user-ID 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
+all'amministratore di impostare solo l'user-ID effettivo, dato che l'uso
 normale di \func{setuid} comporta l'impostazione di tutti gli identificatori.
  
 
-\subsection{Le funzioni \funcd{setresuid} e \funcd{setresgid}}
+\subsection{Le funzioni \func{setresuid} e \func{setresgid}}
 \label{sec:proc_setresuid}
 
-Queste due funzioni sono un'estensione introdotta in Linux dal kernel 2.1.44,
-e permettono un completo controllo su tutti gli identificatori (\textit{real},
-\textit{effective} e \textit{saved}), i prototipi sono:
+Le due funzioni \funcd{setresuid} e \funcd{setresgid} sono un'estensione
+introdotta in Linux,\footnote{a partire dal kernel 2.1.44.} e permettono un
+completo controllo su tutti e tre i gruppi di identificatori (\textit{real},
+\textit{effective} e \textit{saved}), i loro prototipi sono:
 \begin{functions}
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
 \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 \param{ruid}, \param{euid} e
+l'user-ID reale, l'user-ID effettivo e l'user-ID salvato del processo corrente
+ai valori specificati rispettivamente da \param{ruid}, \param{euid} e
 \param{suid}.
   
 \funcdecl{int setresgid(gid\_t rgid, gid\_t egid, gid\_t sgid)} Imposta il
-groupid reale, il groupid effettivo ed il groupid salvato del processo
+group-ID reale, il group-ID effettivo ed il group-ID salvato del processo
 corrente ai valori specificati rispettivamente da \param{rgid}, \param{egid} e
 \param{sgid}.
 
@@ -1692,10 +1655,10 @@ corrente ai valori specificati rispettivamente da \param{rgid}, \param{egid} e
   di fallimento: l'unico errore è \errval{EPERM}.}
 \end{functions}
 
-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
+Le due funzioni sono identiche, quanto detto per la prima riguardo gli user-ID
+si applica alla seconda per i group-ID. I processi non privilegiati possono
+cambiare uno qualunque degli user-ID solo ad un valore corrispondente o
+all'user-ID 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.
 
@@ -1707,10 +1670,10 @@ prototipi sono:
 \headdecl{sys/types.h}
 
 \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.
+l'user-ID reale, l'user-ID effettivo e l'user-ID salvato del processo corrente.
   
 \funcdecl{int getresgid(gid\_t *rgid, gid\_t *egid, gid\_t *sgid)} Legge il
-groupid reale, il groupid effettivo e il groupid salvato del processo
+group-ID reale, il group-ID effettivo e il group-ID salvato del processo
 corrente.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso di
@@ -1720,7 +1683,7 @@ corrente.
 
 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
+specificati come puntatori (è un altro esempio di \textit{value result
   argument}). Si noti che queste funzioni sono le uniche in grado di leggere
 gli identificatori del gruppo \textit{saved}.
 
@@ -1728,25 +1691,26 @@ 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 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.
+Queste funzioni servono per impostare gli identificatori del gruppo
+\textit{filesystem} che sono 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 in circostanze normali 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.
+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'user-ID effettivo o l'user-ID 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'user-ID 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 \funcd{setfsuid}
 e \funcd{setfsgid}, ovviamente sono specifiche di Linux e non devono essere
@@ -1754,10 +1718,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 l'userid di filesystem del
+\funcdecl{int setfsuid(uid\_t fsuid)} Imposta l'user-ID di filesystem del
 processo corrente a \param{fsuid}.
 
-\funcdecl{int setfsgid(gid\_t fsgid)} Imposta il groupid di filesystem del
+\funcdecl{int setfsgid(gid\_t fsgid)} Imposta il group-ID di filesystem del
 processo corrente a \param{fsgid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1800,12 +1764,12 @@ prototipo 
 
 La funzione legge gli identificatori dei gruppi supplementari del processo sul
 vettore \param{list} di dimensione \param{size}. Non è specificato se la
-funzione inserisca o meno nella lista il groupid effettivo del processo. Se si
+funzione inserisca o meno nella lista il group-ID 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, \funcd{getgrouplist}, può invece essere usata per
-ottenere tutti i gruppi a cui appartiene un utente; il suo prototipo è:
+ottenere tutti i gruppi a cui appartiene un certo utente; il suo prototipo è:
 \begin{functions}
   \headdecl{sys/types.h} 
   \headdecl{grp.h}
@@ -1817,12 +1781,12 @@ ottenere tutti i gruppi a cui appartiene un utente; il suo prototipo 
     restituisce 0 in caso di successo e -1 in caso di fallimento.}
 \end{functions}
 
-La funzione legge i gruppi supplementari dell'utente \param{user} eseguendo
-una scansione del database dei gruppi (si veda \secref{sec:sys_user_group}) e
-ritorna in \param{groups} la lista di quelli a cui l'utente appartiene. Si
-noti che \param{ngroups} è passato come puntatore perché qualora il valore
-specificato sia troppo piccolo la funzione ritorna -1, passando indietro il
-numero dei gruppi trovati.
+La funzione legge i gruppi supplementari dell'utente specificato da
+\param{user}, eseguendo una scansione del database dei gruppi (si veda
+\secref{sec:sys_user_group}). Ritorna poi in \param{groups} la lista di quelli
+a cui l'utente appartiene. Si noti che \param{ngroups} è passato come
+puntatore perché, qualora il valore specificato sia troppo piccolo, la
+funzione ritorna -1, passando indietro il numero dei gruppi trovati.
 
 Per impostare i gruppi supplementari di un processo ci sono due funzioni, che
 possono essere usate solo se si hanno i privilegi di amministratore. La prima
@@ -1874,7 +1838,8 @@ con cui costruisce una lista di gruppi supplementari, a cui aggiunge anche
 \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 \cmd{-ansi}.
+compila con il flag \cmd{-ansi}, è pertanto meglio evitarle se si vuole
+scrivere codice portabile.
 
 
 \section{La gestione della priorità di esecuzione}
@@ -1942,7 +1907,7 @@ fintanto che esso si trova in uno qualunque degli altri stati.
     \textbf{Runnable}& \texttt{R} & Il processo è in esecuzione o è pronto ad
                                     essere eseguito (cioè è in attesa che gli
                                     venga assegnata la CPU). \\
-    \textbf{Sleep}   & \texttt{S} & Il processo processo è in attesa di un
+    \textbf{Sleep}   & \texttt{S} & Il processo  è in attesa di un
                                     risposta dal sistema, ma può essere 
                                     interrotto da un segnale. \\
     \textbf{Uninterrutible Sleep}& \texttt{D} & Il  processo è in
@@ -2024,7 +1989,7 @@ essere eseguito, e quando un processo potr
 nell'esecuzione.
 
 Il meccanismo usato da Linux è piuttosto semplice, ad ogni processo è
-assegnata una \textit{time-slice}, cioè in intervallo di tempo (letteralmente
+assegnata una \textit{time-slice}, cioè un intervallo di tempo (letteralmente
 una fetta) per il quale esso deve essere eseguito. Il valore della
 \textit{time-slice} è controllato dalla cosiddetta \textit{nice} (o
 \textit{niceness}) del processo.  Essa è contenuta nel campo \var{nice} di
@@ -2048,13 +2013,13 @@ verranno messi in esecuzione.
 
 La priorità di un processo è così controllata attraverso il valore di
 \var{nice}, che stabilisce la durata della \textit{time-slice}; per il
-meccanismo appena descritto infatti un valore più lungo infatti assicura una
-maggiore attribuzione di CPU.  L'origine del nome di questo parametro sta nel
-fatto che generalmente questo viene 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 \funcd{nice}, il cui prototipo è:
+meccanismo appena descritto infatti un valore più lungo assicura una maggiore
+attribuzione di CPU.  L'origine del nome di questo parametro sta nel fatto che
+generalmente questo viene 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 \funcd{nice}, il cui prototipo è:
 \begin{prototype}{unistd.h}
 {int nice(int inc)}
   Aumenta il valore di \var{nice} per il processo corrente.
@@ -2151,10 +2116,10 @@ La funzione imposta la priorit
 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
+derivano da SysV, è richiesto che l'user-ID 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'userid effettivo.
+Ultrix, *BSD) la corrispondenza può essere anche con l'user-ID effettivo.
 
 
 
@@ -2191,7 +2156,7 @@ Quando c'
 metterà in esecuzione prima di ogni processo normale. In caso di più processi
 sarà eseguito per primo quello con priorità assoluta più alta. Quando ci sono
 più processi con la stessa priorità assoluta questi vengono tenuti in una coda
-tocca al kernel decidere quale deve essere eseguito.
+e tocca al kernel decidere quale deve essere eseguito.
 
 Il meccanismo con cui vengono gestiti questi processi dipende dalla politica
 di scheduling che si è scelto; lo standard ne prevede due:
@@ -2261,7 +2226,7 @@ zero 
 \begin{figure}[!htb]
   \footnotesize \centering
   \begin{minipage}[c]{15cm}
-    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
+    \begin{lstlisting}[stepnumber=0]{}
 struct sched_param {
     int sched_priority;
 };
@@ -2324,7 +2289,7 @@ La priorit
   \end{errlist}}
 \end{prototype}
 
-La funzione restituisce il valore (secondo la quanto elencato in
+La funzione restituisce il valore (secondo quanto elencato in
 \tabref{tab:proc_sched_policy}) della politica di scheduling per il processo
 specificato; se \param{pid} è nullo viene restituito quello del processo
 chiamante.
@@ -2464,16 +2429,16 @@ condiviso, onde evitare problemi con le ottimizzazioni del codice.
   \textit{deadlock}\index{deadlock}}
 \label{sec:proc_race_cond}
 
-Si definiscono \textit{race condition} tutte quelle situazioni in cui processi
-diversi operano su una risorsa comune, ed in cui il risultato viene a
-dipendere dall'ordine in cui essi effettuano le loro operazioni. Il caso
-tipico è quello di un'operazione che viene eseguita da un processo in più
-passi, e può essere compromessa dall'intervento di un altro processo che
-accede alla stessa risorsa quando ancora non tutti i passi sono stati
-completati.
+Si definiscono \textit{race condition}\index{race condition} tutte quelle
+situazioni in cui processi diversi operano su una risorsa comune, ed in cui il
+risultato viene a dipendere dall'ordine in cui essi effettuano le loro
+operazioni. Il caso tipico è quello di un'operazione che viene eseguita da un
+processo in più passi, e può essere compromessa dall'intervento di un altro
+processo che accede alla stessa risorsa quando ancora non tutti i passi sono
+stati completati.
 
 Dato che in un sistema multitasking ogni processo può essere interrotto in
-qualunque momento per farne subentrare un'altro in esecuzione, niente può
+qualunque momento per farne subentrare un altro in esecuzione, niente può
 assicurare un preciso ordine di esecuzione fra processi diversi o che una
 sezione di un programma possa essere eseguita senza interruzioni da parte di
 altri. Queste situazioni comportano pertanto errori estremamente subdoli e
@@ -2483,32 +2448,32 @@ funzioner
 Per questo occorre essere ben consapevoli di queste problematiche, e del fatto
 che l'unico modo per evitarle è quello di riconoscerle come tali e prendere
 gli adeguati provvedimenti per far sì che non si verifichino. Casi tipici di
-\textit{race condition} si hanno quando diversi processi accedono allo stesso
-file, o nell'accesso a meccanismi di intercomunicazione come la memoria
-condivisa. In questi casi, se non si dispone della possibilità di eseguire
-atomicamente le operazioni necessarie, occorre che quelle parti di codice in
-cui si compiono le operazioni sulle risorse condivise (le cosiddette
+\textit{race condition}\index{race condition} si hanno quando diversi processi
+accedono allo stesso file, o nell'accesso a meccanismi di intercomunicazione
+come la memoria condivisa. In questi casi, se non si dispone della possibilità
+di eseguire atomicamente le operazioni necessarie, occorre che quelle parti di
+codice in cui si compiono le operazioni sulle risorse condivise (le cosiddette
 \textsl{sezioni critiche}\index{sezioni critiche}) del programma, siano
 opportunamente protette da meccanismi di sincronizzazione (torneremo su queste
 problematiche di questo tipo in \capref{cha:IPC}).
 
-Un caso particolare di \textit{race condition} sono poi i cosiddetti
-\textit{deadlock}\index{deadlock}, particolarmente gravi in quanto comportano
-spesso il blocco completo di un servizio, e non il fallimento di una singola
-operazione. Per definizione un \textit{deadlock}\index{deadlock} è una
-situazione in cui due o più processi non sono più in grado di proseguire
-perché ciascuno aspetta il risultato di una operazione che dovrebbe essere
-eseguita dall'altro.
+Un caso particolare di \textit{race condition}\index{race condition} sono poi
+i cosiddetti \textit{deadlock}\index{deadlock}, particolarmente gravi in
+quanto comportano spesso il blocco completo di un servizio, e non il
+fallimento di una singola operazione. Per definizione un
+\textit{deadlock}\index{deadlock} è una situazione in cui due o più processi
+non sono più in grado di proseguire perché ciascuno aspetta il risultato di
+una operazione che dovrebbe essere eseguita dall'altro.
 
 
 L'esempio tipico di una situazione che può condurre ad un
-\textit{deadlock}\index{deadlock} è quello in cui un flag di ``occupazione''
-viene rilasciato da un evento asincrono (come un segnale o un altro processo)
-fra il momento in cui lo si è controllato (trovandolo occupato) e la
-successiva operazione di attesa per lo sblocco. In questo caso, dato che
-l'evento di sblocco del flag è avvenuto senza che ce ne accorgessimo proprio
-fra il controllo e la messa in attesa, quest'ultima diventerà perpetua (da cui
-il nome di \textit{deadlock}\index{deadlock}).
+\textit{deadlock}\index{deadlock} è quello in cui un flag di
+``\textsl{occupazione}'' viene rilasciato da un evento asincrono (come un
+segnale o un altro processo) fra il momento in cui lo si è controllato
+(trovandolo occupato) e la successiva operazione di attesa per lo sblocco. In
+questo caso, dato che l'evento di sblocco del flag è avvenuto senza che ce ne
+accorgessimo proprio fra il controllo e la messa in attesa, quest'ultima
+diventerà perpetua (da cui il nome di \textit{deadlock}\index{deadlock}).
 
 In tutti questi casi è di fondamentale importanza il concetto di atomicità
 visto in \secref{sec:proc_atom_oper}; questi problemi infatti possono essere