Lavoro fatto a casa senza ADSL, correzioni multiple agli indici, documentato
[gapil.git] / system.tex
index d9b86d27071e46c7fce9e150949b347c8db4bd6b..446c0f67c51648c1ad29ad48f441b57495ccddea 100644 (file)
@@ -316,40 +316,52 @@ relative spiegazioni, si pu
       \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
       \hline
       \hline
       \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
       \hline
       \hline
-      \texttt{\_SC\_ARG\_MAX} &\const{ARG\_MAX}&
-      La dimensione massima degli argomenti passati ad una funzione
-      della famiglia \func{exec}.\\
-      \texttt{\_SC\_CHILD\_MAX}&\const{\_CHILD\_MAX}&
-      Il numero massimo di processi contemporanei che un utente può
-      eseguire.\\
-      \texttt{\_SC\_OPEN\_MAX}&\const{\_OPEN\_MAX}&
-      Il numero massimo di file che un processo può mantenere aperti in
-      contemporanea.\\
+      \texttt{\_SC\_ARG\_MAX}   & \const{ARG\_MAX}&
+                                  La dimensione massima degli argomenti passati
+                                  ad una funzione della famiglia \func{exec}.\\
+      \texttt{\_SC\_CHILD\_MAX} & \const{\_CHILD\_MAX}&
+                                  Il numero massimo di processi contemporanei
+                                  che un utente può eseguire.\\
+      \texttt{\_SC\_OPEN\_MAX}  & \const{\_OPEN\_MAX}&
+                                  Il numero massimo di file che un processo può
+                                  mantenere aperti in contemporanea.\\
       \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
       \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
-      Il massimo numero di stream che un processo può mantenere aperti in
-      contemporanea. Questo limite previsto anche dallo standard ANSI C, che
-      specifica la macro {FOPEN\_MAX}.\\
-      \texttt{\_SC\_TZNAME\_MAX}&\const{TZNAME\_MAX}&
-      La dimensione massima di un nome di una \texttt{timezone} (vedi
-      sez.~\ref{sec:sys_date}).\\ 
+                                  Il massimo numero di stream che un processo
+                                  può mantenere aperti in contemporanea. Questo
+                                  limite previsto anche dallo standard ANSI C,
+                                  che specifica la macro {FOPEN\_MAX}.\\
+      \texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
+                                  La dimensione massima di un nome di una
+                                  \texttt{timezone} (vedi
+                                  sez.~\ref{sec:sys_date}).\\
       \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
       \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
-      Massimo numero di gruppi supplementari che può avere un processo (vedi
-      sez.~\ref{sec:proc_access_id}).\\ 
-      \texttt{\_SC\_SSIZE\_MAX}&\const{SSIZE\_MAX}& 
-      valore massimo del tipo di dato \type{ssize\_t}.\\
-      \texttt{\_SC\_CLK\_TCK}& \const{CLK\_TCK} &
-      Il numero di \textit{clock tick} al secondo, cioè l'unità di misura del
-      \textit{process time} (vedi sez.~\ref{sec:sys_unix_time}).\\
+                                  Massimo numero di gruppi supplementari che
+                                  può avere un processo (vedi
+                                  sez.~\ref{sec:proc_access_id}).\\
+      \texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}& 
+                                  Valore massimo del tipo di dato
+                                  \type{ssize\_t}.\\ 
+      \texttt{\_SC\_CLK\_TCK}   & \const{CLK\_TCK} &
+                                  Il numero di \textit{clock tick} al secondo,
+                                  cioè l'unità di misura del
+                                  \itindex{process~time} \textit{process
+                                    time} (vedi
+                                  sez.~\ref{sec:sys_unix_time}).\\  
       \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
       \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
-      Indica se è supportato il \textit{job control} (vedi
-      sez.~\ref{sec:sess_job_control}) in stile POSIX.\\
-      \texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
-      Indica se il sistema supporta i \textit{saved id} (vedi
-      sez.~\ref{sec:proc_access_id}).\\ 
-      \texttt{\_SC\_VERSION}& \const{\_POSIX\_VERSION} &
-      Indica il mese e l'anno di approvazione della revisione dello standard
-      POSIX.1 a cui il sistema fa riferimento, nel formato YYYYMML, la
-      revisione più recente è 199009L, che indica il Settembre 1990.\\
+                                  Indica se è supportato il \textit{job
+                                    control} (vedi
+                                  sez.~\ref{sec:sess_job_control}) in stile
+                                  POSIX.\\ 
+      \texttt{\_SC\_SAVED\_IDS} & \macro{\_POSIX\_SAVED\_IDS}&
+                                  Indica se il sistema supporta i
+                                  \textit{saved id} (vedi
+                                  sez.~\ref{sec:proc_access_id}).\\  
+      \texttt{\_SC\_VERSION}    & \const{\_POSIX\_VERSION} &
+                                  Indica il mese e l'anno di approvazione
+                                  della revisione dello standard POSIX.1 a cui
+                                  il sistema fa riferimento, nel formato
+                                  YYYYMML, la revisione più recente è 199009L,
+                                  che indica il Settembre 1990.\\ 
      \hline
     \end{tabular}
   \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
      \hline
     \end{tabular}
   \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
@@ -754,7 +766,8 @@ valori riportati in tab.~\ref{tab:sys_mount_flags}.
     \hline
     \hline
     \const{MS\_RDONLY}     &  1 & monta in sola lettura\\
     \hline
     \hline
     \const{MS\_RDONLY}     &  1 & monta in sola lettura\\
-    \const{MS\_NOSUID}     &  2 & ignora i bit \acr{suid} e \acr{sgid}\\
+    \const{MS\_NOSUID}     &  2 & ignora i bit \itindex{suid~bit} \acr{suid} e
+                                  \itindex{sgid~bit}\acr{sgid}\\ 
     \const{MS\_NODEV}      &  4 & impedisce l'accesso ai file di dispositivo\\
     \const{MS\_NOEXEC}     &  8 & impedisce di eseguire programmi \\
     \const{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
     \const{MS\_NODEV}      &  4 & impedisce l'accesso ai file di dispositivo\\
     \const{MS\_NOEXEC}     &  8 & impedisce di eseguire programmi \\
     \const{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
@@ -897,6 +910,7 @@ semplice invocare direttamente il programma \cmd{mount}, per cui ne
 tralasceremo la trattazione, rimandando al manuale delle \acr{glibc}
 \cite{glibc} per la documentazione completa.
 
 tralasceremo la trattazione, rimandando al manuale delle \acr{glibc}
 \cite{glibc} per la documentazione completa.
 
+% TODO scrivere relativamente alle varie funzioni (getfsent e getmntent &C)
 
 \subsection{La gestione delle informazioni su utenti e gruppi}
 \label{sec:sys_user_group}
 
 \subsection{La gestione delle informazioni su utenti e gruppi}
 \label{sec:sys_user_group}
@@ -1319,7 +1333,7 @@ argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
 poi aggiunge chiamando \func{updwtmp}.
 
 
 poi aggiunge chiamando \func{updwtmp}.
 
 
-\section{Limitazione ed uso delle risorse}
+\section{Il controllo dell'uso delle risorse}
 \label{sec:sys_res_limits}
 
 
 \label{sec:sys_res_limits}
 
 
@@ -1352,15 +1366,16 @@ di tipo \struct{rusage}, la cui definizione (che si trova in
 \end{figure}
 
 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
 \end{figure}
 
 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
-da BSD 4.3,\footnote{questo non ha a nulla a che fare con il \textit{BSD
-    accounting} che si trova nelle opzioni di compilazione del kernel (e di
-  norma è disabilitato) che serve per mantenere una contabilità delle risorse
-  usate da ciascun processo in maniera molto più dettagliata.} ma attualmente
-(con i kernel della serie 2.4.x e 2.6.x) i soli campi che sono mantenuti sono:
-\var{ru\_utime}, \var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e
-\var{ru\_nswap}. I primi due indicano rispettivamente il tempo impiegato dal
-processo nell'eseguire le istruzioni in user space, e quello impiegato dal
-kernel nelle system call eseguite per conto del processo.
+da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
+  \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si trova
+  nelle opzioni di compilazione del kernel (e di norma è disabilitato) che
+  serve per mantenere una contabilità delle risorse usate da ciascun processo
+  in maniera molto più dettagliata.} ma attualmente (con i kernel della serie
+2.4.x e 2.6.x) i soli campi che sono mantenuti sono: \var{ru\_utime},
+\var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I
+primi due indicano rispettivamente il tempo impiegato dal processo
+nell'eseguire le istruzioni in user space, e quello impiegato dal kernel nelle
+system call eseguite per conto del processo.
 
 Gli altri tre campi servono a quantificare l'uso della memoria
 virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
 
 Gli altri tre campi servono a quantificare l'uso della memoria
 virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
@@ -1404,42 +1419,137 @@ ricevuto lo stato di terminazione.
 \subsection{Limiti sulle risorse}
 \label{sec:sys_resource_limit}
 
 \subsection{Limiti sulle risorse}
 \label{sec:sys_resource_limit}
 
-Come accennato nell'introduzione oltre a mantenere i dati relativi all'uso
-delle risorse da parte dei vari processi, il kernel mette anche a disposizione
-delle funzioni con cui si possono imporre dei limiti sulle risorse che essi
-possono utilizzare.  In generale ad ogni processo vengono associati due
-diversi limiti per ogni risorsa; questi sono detti il \textsl{limite corrente}
-(o \textit{current limit}) che esprime il valore massimo che attualmente il
-processo non può superare, ed il \textsl{limite massimo} (o \textit{maximum
-  limit}) che esprime il valore massimo che può assumere il \textsl{limite
-  corrente}.
+Come accennato nell'introduzione il kernel mette a disposizione delle
+funzionalita che permettono non solo di mantenere dati statistici relativi
+all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
+utilizzo da parte dei vari processi o degli utenti.
+
+Per far questo esistono una serie di risorse e ad ogni processo vengono
+associati due diversi limiti per ciascuna di esse; questi sono il
+\textsl{limite corrente} (o \textit{current limit}) che esprime un valore
+massimo che il processo non può superare ad un certo momento, ed il
+\textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
+valore massimo che può assumere il \textsl{limite corrente}. In generale il
+primo viene chiamato anche \textit{soft limit} dato che il suo valore può
+essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
+fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
+  limit}.
 
 
-\begin{figure}[!htb]
+\begin{table}[htb]
   \footnotesize
   \centering
   \footnotesize
   \centering
-  \begin{minipage}[c]{15cm}
-    \includestruct{listati/rlimit.h}
-  \end{minipage} 
-  \normalsize 
-  \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo 
-    delle risorse usate da un processo.}
-  \label{fig:sys_rlimit_struct}
-\end{figure}
-
-In generale il primo viene chiamato anche \textsl{limite soffice} (o
-\textit{soft limit}) dato che il suo valore può essere aumentato fino al
-valore del secondo, mentre il secondo è detto \textsl{limite duro} (o
-\textit{hard limit}), in quanto un processo normale può solo diminuirne il
-valore. Il valore di questi due limiti è mantenuto in una struttura
-\struct{rlimit}, la cui definizione è riportata in
-fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
-limite corrente e limite massimo.
+  \begin{tabular}[c]{|l|p{12cm}|}
+    \hline
+    \textbf{Valore} & \textbf{Significato}\\
+    \hline
+    \hline
+    \const{RLIMIT\_AS}     &  La dimensione massima della memoria virtuale di
+                              un processo, il cosidetto \textit{Address
+                                Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se
+                              il limite viene superato dall'uso di funzioni
+                              come \func{brk}, \func{mremap} o \func{mmap}
+                              esse falliranno con un errore di
+                              \errcode{ENOMEM}, mentre se il superamento viene
+                              causato dalla crescita dello \itindex{stack}
+                              stack il processo riceverà un segnale di
+                              \const{SIGSEGV}. \\  
+    \const{RLIMIT\_CORE}   &  La massima dimensione per di un file di
+                              \textit{core dump}\itindex{core~dump} (vedi
+                              sez.~\ref{sec:sig_prog_error}) creato nella
+                              terminazione di un processo; file di dimensioni 
+                              maggiori verranno troncati a questo valore,
+                              mentre con un valore si bloccherà la creazione
+                              dei \textit{core dump}\itindex{core~dump}.\\ 
+    \const{RLIMIT\_CPU}    &  Il massimo tempo di CPU (vedi
+                              sez.~\ref{sec:sys_cpu_times}) che il processo può
+                              usare. Il superamento del limite corrente
+                              comporta l'emissione di un segnale di
+                              \const{SIGXCPU} la cui azione predefinita (vedi
+                              sez.~\ref{sec:sig_classification}) è terminare
+                              il processo. Il superamento del limite massimo
+                              comporta l'emissione di un segnale di
+                              \const{SIGKILL}.\footnotemark\\
+    \const{RLIMIT\_DATA}   &  La massima dimensione del ndex{segmento!dati}
+                              segmento dati di un 
+                              processo (vedi sez.~\ref{sec:proc_mem_layout}).
+                              Il tentativo di allocare più memoria di quanto
+                              indicato dal limite corrente causa il fallimento
+                              della funzione di allocazione (\func{brk} o
+                              \func{sbrk}) con un errore di \errcode{ENOMEM}.\\
+    \const{RLIMIT\_FSIZE}  &  La massima dimensione di un file che un processo
+                              può creare. Se il processo cerca di scrivere
+                              oltre questa dimensione riceverà un segnale di
+                              \const{SIGXFSZ}, che di norma termina il
+                              processo; se questo viene intercettato la
+                              system call che ha causato l'errore fallirà con
+                              un errore di \errcode{EFBIG}.\\
+    \const{RLIMIT\_LOCKS}&    È un limite presente solo nelle prime versioni
+                              del kernel 2.4 sul numero massimo di
+                              \index{file!locking}\textit{file lock} (vedi
+                              sez.~\ref{sec:file_locking}) che un
+                              processo poteva effettuare.\\ 
+    \const{RLIMIT\_MEMLOCK}&  L'ammontare massimo di memoria che può essere
+                              bloccata in RAM da un processo (vedi
+                              sez.~\ref{sec:proc_mem_lock}). Dal kernel 2.6.9
+                              questo limite comprende anche la memoria che può
+                              essere bloccata da ciascun utente nell'uso della
+                              memoria condivisa (vedi
+                              sez.~\ref{sec:ipc_sysv_shm}) che viene
+                              contabilizzata separatamente ma sulla quale
+                              viene applicato questo stesso limite.\\ 
+    \const{RLIMIT\_NOFILE} &  Il numero massimo di file che il processo può
+                              aprire. L'apertura di un ulteriore file farà
+                              fallire la funzione (\func{open}, \func{dup} o
+                              \func{pipe}) con un errore \errcode{EMFILE}.\\
+    \const{RLIMIT\_NPROC}  &  Il numero massimo di processi che possono essere
+                              creati sullo stesso user id real. Se il limite
+                              viene raggiunto \func{fork} fallirà con un
+                              \errcode{EAGAIN}.\\
+    \const{RLIMIT\_SIGPENDING}& Il numero massimo di segnali che possono
+                              essere mantenuti in coda per ciascun utente,
+                              considerando sia i segnali normali che real-time
+                              (vedi sez.~\ref{sec:sig_real_time}). Il limite è
+                              attivo solo per \func{sigqueue}, con \func{kill}
+                              si potrà sempre inviare un segnale che non sia
+                              già presente su una coda.\footnotemark\\
+    \const{RLIMIT\_STACK}  &  La massima dimensione dello \itindex{stack}
+                              stack del 
+                              processo. Se il processo esegue operazioni che
+                              estendano lo stack oltre questa dimensione
+                              riceverà un segnale di \const{SIGSEGV}.\\
+    \const{RLIMIT\_RSS}    &  L'ammontare massimo di pagine di memoria dato al
+                              \index{segmento!testo} testo del processo. Il
+                              limite è solo una indicazione per il kernel,
+                              qualora ci fosse un surplus di memoria questa
+                              verrebbe assegnata.\\ 
+% TODO integrare con la roba di madvise
+    \hline
+  \end{tabular}
+  \caption{Valori possibili dell'argomento \param{resource} delle funzioni
+    \func{getrlimit} e \func{setrlimit}.} 
+  \label{tab:sys_rlimit_values}
+\end{table}
 
 
-In genere il superamento di un limite comporta o l'emissione di un segnale o
-il fallimento della system call che lo ha provocato; per permettere di leggere
-e di impostare i limiti di utilizzo delle risorse da parte di un processo
-Linux prevede due funzioni, \funcd{getrlimit} e \funcd{setrlimit}, i cui
-prototipi sono:
+\footnotetext[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
+  oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
+  avviene quando viene superato il \textit{soft limit}; perciò per avere
+  operazioni portabili è sempre opportuno intercettare \const{SIGXCPU} e
+  terminare in maniera ordinata il processo.}
+
+\footnotetext{il limite su questa risorsa è stato introdotto con il kernel
+  2.6.8.}
+
+In generale il superamento di un limite corrente\footnote{di norma quanto
+  riportato in tab.~\ref{tab:sys_rlimit_values} fa riferimento a quanto
+  avviene al superamento del limite corrente, con l'eccesione
+  \const{RLIMIT\_CPU} in cui si ha in comportamento diverso per il superamento
+  dei due limiti.}  comporta o l'emissione di un segnale o il fallimento della
+system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
+  \const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
+  creazinone) dei file di \itindex{core~dump}\textit{core dump}.} per
+permettere di leggere e di impostare i limiti di utilizzo delle risorse da
+parte di un processo sono previste due funzioni, \funcd{getrlimit} e
+\funcd{setrlimit}, i cui prototipi sono:
 \begin{functions}
   \headdecl{sys/time.h} 
   \headdecl{sys/resource.h} 
 \begin{functions}
   \headdecl{sys/time.h} 
   \headdecl{sys/resource.h} 
@@ -1469,73 +1579,34 @@ Entrambe le funzioni permettono di specificare, attraverso l'argomento
 questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
 (rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
 poi effettuato attraverso la struttura \struct{rlimit} puntata da
 questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
 (rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
 poi effettuato attraverso la struttura \struct{rlimit} puntata da
-\param{rlim}.
+\param{rlim}, la cui definizione è riportata in
+fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
+limite corrente e limite massimo.
 
 
-\begin{table}[htb]
+
+\begin{figure}[!htb]
   \footnotesize
   \centering
   \footnotesize
   \centering
-  \begin{tabular}[c]{|l|p{12cm}|}
-    \hline
-    \textbf{Valore} & \textbf{Significato}\\
-    \hline
-    \hline
-    \const{RLIMIT\_CPU}    &  Il massimo tempo di CPU che il processo può
-                              usare. Il superamento del limite comporta
-                              l'emissione di un segnale di \const{SIGXCPU}.\\
-    \const{RLIMIT\_FSIZE}  &  La massima dimensione di un file che un processo
-                              può usare. Se il processo cerca di scrivere
-                              oltre questa dimensione riceverà un segnale di
-                              \const{SIGXFSZ}.\\
-    \const{RLIMIT\_DATA}   &  La massima dimensione della memoria dati di un
-                              processo. Il tentativo di allocare più memoria
-                              causa il fallimento della funzione di
-                              allocazione. \\
-    \const{RLIMIT\_STACK}  &  La massima dimensione dello stack del
-                              processo. Se il processo esegue operazioni che
-                              estendano lo stack oltre questa dimensione
-                              riceverà un segnale di \const{SIGSEGV}.\\
-    \const{RLIMIT\_CORE}   &  La massima dimensione di un file di \textit{core
-                              dump} creato da un processo. Nel caso le 
-                              dimensioni dovessero essere maggiori il file non
-                              verrebbe generato.\footnotemark\\
-    \const{RLIMIT\_RSS}    &  L'ammontare massimo di memoria fisica dato al
-                              processo. Il limite è solo una indicazione per
-                              il kernel, qualora ci fosse un surplus di
-                              memoria questa verrebbe assegnata.\\
-    \const{RLIMIT\_NPROC}  &  Il numero massimo di processi che possono essere
-                              creati sullo stesso user id. Se il limite viene
-                              raggiunto \func{fork} fallirà con un
-                              \errcode{EAGAIN}.\\
-    \const{RLIMIT\_NOFILE} &  Il numero massimo di file che il processo può
-                              aprire. L'apertura di un ulteriore file fallirà
-                              con un errore \errcode{EMFILE}.\\
-    \const{RLIMIT\_MEMLOCK}&  L'ammontare massimo di memoria che può essere
-                              bloccata in RAM senza
-                              paginazione\index{paginazione} (vedi
-                              sez.~\ref{sec:proc_mem_lock}).\\ 
-    \const{RLIMIT\_AS}     &  La dimensione massima di tutta la memoria che il
-                              processo può ottenere. Se il processo tenta di
-                              allocarne di più  funzioni come \func{brk},
-                              \func{malloc} o \func{mmap} falliranno. \\
-    \hline
-  \end{tabular}
-  \caption{Valori possibili dell'argomento \param{resource} delle funzioni
-    \func{getrlimit} e \func{setrlimit}.} 
-  \label{tab:sys_rlimit_values}
-\end{table}
+  \begin{minipage}[c]{15cm}
+    \includestruct{listati/rlimit.h}
+  \end{minipage} 
+  \normalsize 
+  \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo 
+    delle risorse usate da un processo.}
+  \label{fig:sys_rlimit_struct}
+\end{figure}
 
 
-\footnotetext{Impostare questo limite a zero è la maniera più semplice per
-  evitare la creazione di \file{core} file (al proposito si veda
-  sez.~\ref{sec:sig_prog_error}).}
 
 Nello specificare un limite, oltre a fornire dei valori specifici, si può
 anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
 di una risorsa; ma si ricordi che solo un processo con i privilegi di
 
 Nello specificare un limite, oltre a fornire dei valori specifici, si può
 anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
 di una risorsa; ma si ricordi che solo un processo con i privilegi di
-amministratore può innalzare un limite al di sopra del valore corrente del
-limite massimo. Si tenga conto infine che tutti i limiti vengono ereditati dal
-processo padre attraverso una \func{fork} (vedi sez.~\ref{sec:proc_fork}) e
-mantenuti per gli altri programmi eseguiti attraverso una \func{exec} (vedi
-sez.~\ref{sec:proc_exec}).
+amministratore\footnote{per essere precisi in questo caso quello che serve è
+  la \itindex{capabilities}\textit{capability} \const{CAP\_SYS\_RESOURCE}.}
+può innalzare un limite al di sopra del valore corrente del limite massimo ed
+usare un valore qualsiasi per entrambi i limiti. Si tenga conto infine che
+tutti i limiti vengono ereditati dal processo padre attraverso una \func{fork}
+(vedi sez.~\ref{sec:proc_fork}) e mantenuti per gli altri programmi eseguiti
+attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
 
 
 \subsection{Le risorse di memoria e processore}
 
 
 \subsection{Le risorse di memoria e processore}
@@ -1562,9 +1633,10 @@ scelta di dimensioni, 
 
 Dato che si tratta di una caratteristica generale del sistema, questa
 dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
 
 Dato che si tratta di una caratteristica generale del sistema, questa
 dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
-\func{sysconf} (nel caso \code{sysconf(\_SC\_PAGESIZE)}, ma in BSD 4.2 è stata
-introdotta una apposita funzione, \funcd{getpagesize}, che restituisce la
-dimensione delle pagine di memoria; il suo prototipo è:
+\func{sysconf}, \footnote{nel caso specifico si dovrebbe utilizzare il
+  parametro \const{\_SC\_PAGESIZE}.}  ma in BSD 4.2 è stata introdotta una
+apposita funzione, \funcd{getpagesize}, che restituisce la dimensione delle
+pagine di memoria; il suo prototipo è:
 \begin{prototype}{unistd.h}{int getpagesize(void)}
   Legge le dimensioni delle pagine di memoria.
   
 \begin{prototype}{unistd.h}{int getpagesize(void)}
   Legge le dimensioni delle pagine di memoria.
   
@@ -1576,13 +1648,15 @@ La funzione 
 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
 ha eliminata. In Linux è implementata come una system call nelle architetture
 in cui essa è necessaria, ed in genere restituisce il valore del simbolo
 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
 ha eliminata. In Linux è implementata come una system call nelle architetture
 in cui essa è necessaria, ed in genere restituisce il valore del simbolo
-\const{PAGE\_SIZE} del kernel, anche se le versioni delle librerie del C
-precedenti le \acr{glibc} 2.1 implementavano questa funzione restituendo
-sempre un valore statico.
+\const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
+se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
+implementavano questa funzione restituendo sempre un valore statico.
+
+% TODO verificare meglio la faccenda di const{PAGE\_SIZE} 
 
 
-Le \acr{glibc} forniscono, come specifica estensione GNU, altre due funzioni,
-\funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono di
-ottenere informazioni riguardo la memoria; i loro prototipi sono:
+Le \textsl{glibc} forniscono, come specifica estensione GNU, altre due
+funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
+di ottenere informazioni riguardo la memoria; i loro prototipi sono:
 \begin{functions}
   \headdecl{sys/sysinfo.h} 
   
 \begin{functions}
   \headdecl{sys/sysinfo.h} 
   
@@ -1628,6 +1702,66 @@ viene valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti),
 questo è anche il massimo valore che può essere assegnato a questo argomento.
 
 
 questo è anche il massimo valore che può essere assegnato a questo argomento.
 
 
+\subsection{La contabilità in stile BSD}
+\label{sec:sys_bsd_accounting}
+
+Una ultima modalità per monitorare l'uso delle risorse è quella, se si è
+compilato il kernel con il relativo supporto,\footnote{se cioè si è abilitata
+  l'opzione di compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} di attivare
+il cosiddetto \textit{BSD accounting}, che consente di registrare su file una
+serie di informazioni\footnote{contenute nella struttura \texttt{acct}
+  definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
+riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
+che viene terminato.
+
+Linux consente di salvare la contabilità delle informazioni relative alle
+risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
+prototipo è:
+\begin{prototype}{unistd.h}{int acct(const char *filename)}
+  Abilita il \textit{BSD accounting}.
+  
+  \bodydesc{La funzione ritorna 0 in caso di successo o $-1$ in caso di
+    errore, nel qual caso \var{errno} assumerà uno dei valori:
+    \begin{errlist}
+    \item[\errcode{EACCESS}] non si hanno i permessi per accedere a
+      \param{pathname}.
+    \item[\errcode{EPERM}] Il processo non ha privilegi sufficienti ad
+      abilitare il \textit{BSD accounting}.
+    \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
+    \item[\errcode{EUSER}] non sono disponibili nel kernel strutture per il
+      file o si è finita la memoria.
+    \end{errlist}
+    ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
+    \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
+    \errval{ENOTDIR}, \errval{EROFS}.}
+\end{prototype}
+
+La funzione attiva il salvataggio dei dati sul file indicato dal pathname
+contenuti nella stringa puntata da \param{filename}; la funzione richiede che
+il processo abbia i privilegi di amministratore (è necessaria la
+\itindex{capabilities} capability \const{CAP\_SYS\_PACCT}, vedi
+sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \const{NULL} per
+\param{filename} il \textit{BSD accounting} viene invece disabilitato.
+
+Quando si attiva la contabilità il file che si indica deve esistere; esso
+verrà aperto in sola scrittura;\footnote{si applicano al pathname indicato da
+  \param{filename} tutte le restrizioni viste in cap.~\ref{cha:file_intro}.}
+le informazioni verranno registrate in \textit{append} in coda al file tutte
+le volte che un processo termina. Le informazioni vengono salvate in formato
+binario, e corrispondono al contenuto della apposita struttura dati definita
+all'interno del kernel.
+
+Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
+parametro di sistema, modificabile attraverso \file{/proc/sys/kernel/acct} (o
+tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi, il
+primo indica la percentuale di spazio disco libero sopra il quale viene
+ripresa una registrazione che era stata sospesa per essere scesi sotto il
+minimo indicato dal secondo valore (sempre in percentuale di spazio disco
+libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
+essere controllata detta percentuale.
+
+
+
 
 \section{La gestione dei tempi del sistema}
 \label{sec:sys_time}
 
 \section{La gestione dei tempi del sistema}
 \label{sec:sys_time}
@@ -1645,25 +1779,25 @@ gestione di data e ora.
 
 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
 dati per la misure dei tempi all'interno del sistema: essi sono
 
 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
 dati per la misure dei tempi all'interno del sistema: essi sono
-rispettivamente chiamati \textit{calendar time} e \textit{process time},
-secondo le definizioni:
+rispettivamente chiamati \itindend{calendar~time} \textit{calendar time} e
+\itindex{process~time} \textit{process time}, secondo le definizioni:
 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
-\item[\textit{calendar time}] detto anche \textsl{tempo di calendario}. È il
-  numero di secondi dalla mezzanotte del primo gennaio 1970, in tempo
-  universale coordinato (o UTC), data che viene usualmente indicata con
-  00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the Epoch}. Questo tempo viene
-  anche chiamato anche GMT (Greenwich Mean Time) dato che l'UTC corrisponde
-  all'ora locale di Greenwich.  È il tempo su cui viene mantenuto l'orologio
-  del kernel, e viene usato ad esempio per indicare le date di modifica dei
-  file o quelle di avvio dei processi. Per memorizzare questo tempo è stato
-  riservato il tipo primitivo \type{time\_t}.
-\item[\textit{process time}] detto talvolta \textsl{tempo di processore}.
-  Viene misurato in \textit{clock tick}. Un tempo questo corrispondeva al
-  numero di interruzioni effettuate dal timer di sistema, adesso lo standard
-  POSIX richiede che esso sia pari al valore della costante
-  \const{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000, qualunque
-  sia la risoluzione reale dell'orologio di sistema e la frequenza delle
-  interruzioni del timer.\footnote{quest'ultima, come accennato in
+\item[\textit{calendar time}] \itindend{calendar~time} detto anche
+  \textsl{tempo di calendario}. È il numero di secondi dalla mezzanotte del
+  primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
+  usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
+    Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
+  dato che l'UTC corrisponde all'ora locale di Greenwich.  È il tempo su cui
+  viene mantenuto l'orologio del kernel, e viene usato ad esempio per indicare
+  le date di modifica dei file o quelle di avvio dei processi. Per memorizzare
+  questo tempo è stato riservato il tipo primitivo \type{time\_t}.
+\item[\textit{process time}] \itindex{process~time} detto talvolta
+  \textsl{tempo di processore}.  Viene misurato in \textit{clock tick}. Un
+  tempo questo corrispondeva al numero di interruzioni effettuate dal timer di
+  sistema, adesso lo standard POSIX richiede che esso sia pari al valore della
+  costante \const{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000,
+  qualunque sia la risoluzione reale dell'orologio di sistema e la frequenza
+  delle interruzioni del timer.\footnote{quest'ultima, come accennato in
     sez.~\ref{sec:proc_hierarchy}, è invece data dalla costante \const{HZ}.}
   Il dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi
   una risoluzione del microsecondo. Il numero di tick al secondo può essere
     sez.~\ref{sec:proc_hierarchy}, è invece data dalla costante \const{HZ}.}
   Il dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi
   una risoluzione del microsecondo. Il numero di tick al secondo può essere
@@ -1672,10 +1806,10 @@ secondo le definizioni:
   considerato obsoleto.
 \end{basedescript}
 
   considerato obsoleto.
 \end{basedescript}
 
-In genere si usa il \textit{calendar time} per esprimere le date dei file e le
-informazioni analoghe che riguardano i cosiddetti \textsl{tempi di orologio},
-che vengono usati ad esempio per i demoni che compiono lavori amministrativi
-ad ore definite, come \cmd{cron}. 
+In genere si usa il \itindend{calendar~time} \textit{calendar time} per
+esprimere le date dei file e le informazioni analoghe che riguardano i
+cosiddetti \textsl{tempi di orologio}, che vengono usati ad esempio per i
+demoni che compiono lavori amministrativi ad ore definite, come \cmd{cron}.
 
 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
 tempo locale, utilizzando le opportune informazioni di localizzazione
 
 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
 tempo locale, utilizzando le opportune informazioni di localizzazione
@@ -1683,11 +1817,11 @@ tempo locale, utilizzando le opportune informazioni di localizzazione
 mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
 dall'orologio hardware del calcolatore.
 
 mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
 dall'orologio hardware del calcolatore.
 
-Anche il \textit{process time} di solito si esprime in secondi, ma provvede
-una precisione ovviamente superiore al \textit{calendar time} (che è mantenuto
-dal sistema con una granularità di un secondo) e viene usato per tenere conto
-dei tempi di esecuzione dei processi. Per ciascun processo il kernel calcola
-tre tempi diversi:
+Anche il \itindex{process~time} \textit{process time} di solito si esprime in
+secondi, ma provvede una precisione ovviamente superiore al \textit{calendar
+  time} (che è mantenuto dal sistema con una granularità di un secondo) e
+viene usato per tenere conto dei tempi di esecuzione dei processi. Per ciascun
+processo il kernel calcola tre tempi diversi:
 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
 \item[\textit{clock time}] il tempo \textsl{reale} (viene chiamato anche
   \textit{wall clock time} o \textit{elapsed time}) passato dall'avvio del
 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
 \item[\textit{clock time}] il tempo \textsl{reale} (viene chiamato anche
   \textit{wall clock time} o \textit{elapsed time}) passato dall'avvio del
@@ -1717,13 +1851,15 @@ del comando \cmd{time}.
 \subsection{La gestione del \textit{process time}}
 \label{sec:sys_cpu_times}
 
 \subsection{La gestione del \textit{process time}}
 \label{sec:sys_cpu_times}
 
+\itindbeg{process~time}
+
 Di norma tutte le operazioni del sistema fanno sempre riferimento al
 Di norma tutte le operazioni del sistema fanno sempre riferimento al
-\textit{calendar time}, l'uso del \textit{process time} è riservato a quei
-casi in cui serve conoscere i tempi di esecuzione di un processo (ad esempio
-per valutarne l'efficienza). In tal caso infatti fare ricorso al
-\textit{calendar time} è inutile in quanto il tempo può essere trascorso mentre
-un altro processo era in esecuzione o in attesa del risultato di una
-operazione di I/O. 
+\itindend{calendar~time} \textit{calendar time}, l'uso del \textit{process
+  time} è riservato a quei casi in cui serve conoscere i tempi di esecuzione
+di un processo (ad esempio per valutarne l'efficienza). In tal caso infatti
+fare ricorso al \textit{calendar time} è inutile in quanto il tempo può essere
+trascorso mentre un altro processo era in esecuzione o in attesa del risultato
+di una operazione di I/O.
 
 La funzione più semplice per leggere il \textit{process time} di un processo è
 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
 
 La funzione più semplice per leggere il \textit{process time} di un processo è
 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
@@ -1755,10 +1891,10 @@ possono essere letti attraverso la funzione \funcd{times}, il cui prototipo 
     in caso di successo e -1 in caso di errore.}
 \end{prototype}
 
     in caso di successo e -1 in caso di errore.}
 \end{prototype}
 
-La funzione restituisce i valori di process time del processo corrente in una
-struttura di tipo \struct{tms}, la cui definizione è riportata in
-fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi due,
-\var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
+La funzione restituisce i valori di \textit{process time} del processo
+corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
+in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
+due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
 \textit{system time} del processo, così come definiti in
 sez.~\ref{sec:sys_unix_time}.
 
 \textit{system time} del processo, così come definiti in
 sez.~\ref{sec:sys_unix_time}.
 
@@ -1786,10 +1922,14 @@ ritornata. Per questo motivo se un processo figlio termina prima di ricevere
 lo stato di terminazione di tutti i suoi figli, questi processi ``nipoti'' non
 verranno considerati nel calcolo di questi tempi.
 
 lo stato di terminazione di tutti i suoi figli, questi processi ``nipoti'' non
 verranno considerati nel calcolo di questi tempi.
 
+\itindend{process~time}
+
 
 \subsection{Le funzioni per il \textit{calendar time}}
 \label{sec:sys_time_base}
 
 
 \subsection{Le funzioni per il \textit{calendar time}}
 \label{sec:sys_time_base}
 
+\itindbeg{calendar~time}
+
 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
 mantenuto dal kernel in una variabile di tipo \type{time\_t}, che usualmente
 corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
 mantenuto dal kernel in una variabile di tipo \type{time\_t}, che usualmente
 corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
@@ -1953,22 +2093,22 @@ a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
 campi della struttura \struct{timex} può essere ritrovato in \cite{glibc}.
 
 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
 campi della struttura \struct{timex} può essere ritrovato in \cite{glibc}.
 
-\begin{table}[htb]
+\begin{table}[!htb]
   \footnotesize
   \centering
   \footnotesize
   \centering
-  \begin{tabular}[c]{|l|c|p{7cm}|}
+  \begin{tabular}[c]{|l|c|p{8.5cm}|}
     \hline
     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
     \hline
     \hline
     \const{ADJ\_OFFSET}         & 0x0001 & Imposta la differenza fra il tempo
     \hline
     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
     \hline
     \hline
     \const{ADJ\_OFFSET}         & 0x0001 & Imposta la differenza fra il tempo
-                                           reale e l'orologio di sistema, che 
+                                           reale e l'orologio di sistema: 
                                            deve essere indicata in microsecondi
                                            nel campo \var{offset} di
                                            \struct{timex}.\\ 
     \const{ADJ\_FREQUENCY}      & 0x0002 & Imposta la differenze in frequenza
                                            fra il tempo reale e l'orologio di
                                            deve essere indicata in microsecondi
                                            nel campo \var{offset} di
                                            \struct{timex}.\\ 
     \const{ADJ\_FREQUENCY}      & 0x0002 & Imposta la differenze in frequenza
                                            fra il tempo reale e l'orologio di
-                                           sistema, che deve essere indicata
+                                           sistema: deve essere indicata
                                            in parti per milione nel campo
                                            \var{frequency} di \struct{timex}.\\
     \const{ADJ\_MAXERROR}       & 0x0004 & Imposta il valore massimo 
                                            in parti per milione nel campo
                                            \var{frequency} di \struct{timex}.\\
     \const{ADJ\_MAXERROR}       & 0x0004 & Imposta il valore massimo 
@@ -2036,6 +2176,7 @@ un errore; al solito se si cercher
 amministratore si otterrà un errore di \errcode{EPERM}.
 
 
 amministratore si otterrà un errore di \errcode{EPERM}.
 
 
+
 \subsection{La gestione delle date.}
 \label{sec:sys_date}
 
 \subsection{La gestione delle date.}
 \label{sec:sys_date}
 
@@ -2238,6 +2379,7 @@ viene utilizzato come modificatore; alcuni\footnote{per la precisione quelli
 in tab.~\ref{tab:sys_strftime_format}. La funzione tiene conto anche della
 presenza di una localizzazione per stampare in maniera adeguata i vari nomi.
 
 in tab.~\ref{tab:sys_strftime_format}. La funzione tiene conto anche della
 presenza di una localizzazione per stampare in maniera adeguata i vari nomi.
 
+\itindend{calendar~time}
 
 
 \section{La gestione degli errori}
 
 
 \section{La gestione degli errori}
@@ -2332,7 +2474,7 @@ La funzione utilizza una stringa statica che non deve essere modificata dal
 programma; essa è utilizzabile solo fino ad una chiamata successiva a
 \func{strerror} o \func{perror}, nessun'altra funzione di libreria tocca
 questa stringa. In ogni caso l'uso di una stringa statica rende la funzione
 programma; essa è utilizzabile solo fino ad una chiamata successiva a
 \func{strerror} o \func{perror}, nessun'altra funzione di libreria tocca
 questa stringa. In ogni caso l'uso di una stringa statica rende la funzione
-non rientrante, per cui nel caso nel caso si usino i thread le librerie
+non rientrante, per cui nel caso si usino i thread le librerie
 forniscono\footnote{questa funzione è la versione prevista dalle \acr{glibc},
   ed effettivamente definita in \file{string.h}, ne esiste una analoga nello
   standard SUSv3 (quella riportata dalla pagina di manuale), che restituisce
 forniscono\footnote{questa funzione è la versione prevista dalle \acr{glibc},
   ed effettivamente definita in \file{string.h}, ne esiste una analoga nello
   standard SUSv3 (quella riportata dalla pagina di manuale), che restituisce