Risistemata tutta la parte sui clock tick (e corrette le fregnacce dette

[gapil.git] / system.tex

fo \chapter{La gestione del sistema, delle risorse, e degli errori}
\label{cha:system}

In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
generali del sistema, come quelle per la gestione dei parametri e della
configurazione dello stesso, quelle per la lettura dei limiti e delle
caratteristiche, quelle per il controllo dell'uso delle risorse dei processi,
quelle per la gestione ed il controllo dei filesystem, degli utenti, dei tempi
e degli errori.



\section{La lettura delle caratteristiche del sistema}
\label{sec:sys_characteristics}

In questa sezione tratteremo le varie modalità con cui un programma può
ottenere informazioni riguardo alle capacità del sistema. Ogni sistema
unix-like infatti è contraddistinto da un gran numero di limiti e costanti che
lo caratterizzano, e che possono dipendere da fattori molteplici, come
l'architettura hardware, l'implementazione del kernel e delle librerie, le
opzioni di configurazione.

La definizione di queste caratteristiche ed il tentativo di provvedere dei
meccanismi generali che i programmi potessero usare per ricavarle è uno degli
aspetti più complessi e controversi con cui le diverse standardizzazioni si
sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
Proveremo comunque a dare una descrizione dei principali metodi previsti dai
vari standard per ricavare sia le caratteristiche specifiche del sistema, che
quelle della gestione dei file.


\subsection{Limiti e parametri di sistema}
\label{sec:sys_limits}

Quando si devono determinare le le caratteristiche generali del sistema ci si
trova di fronte a diverse possibilità; alcune di queste infatti possono
dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
interi), o dal sistema operativo (come la presenza o meno dei \textit{saved
  id}), altre invece possono dipendere dalle opzioni con cui si è costruito
il sistema (ad esempio da come si è compilato il kernel), o dalla
configurazione del medesimo; per questo motivo in generale sono necessari due
tipi diversi di funzionalità:
\begin{itemize*}
\item la possibilità di determinare limiti ed opzioni al momento della
  compilazione.
\item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
\end{itemize*}

La prima funzionalità si può ottenere includendo gli opportuni header file che
contengono le costanti necessarie definite come macro di preprocessore, per la
seconda invece sono ovviamente necessarie delle funzioni. La situazione è
complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
sono fissi in un'implementazione mentre possono variare in un altra. Tutto
questo crea una ambiguità che non è sempre possibile risolvere in maniera
chiara; in generale quello che succede è che quando i limiti del sistema sono
fissi essi vengono definiti come macro di preprocessore nel file
\file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
tramite la funzione \func{sysconf} (che esamineremo in
\secref{sec:sys_sysconf}).

Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
da \file{limits.h}, è riportato in \tabref{tab:sys_ansic_macro}. Come si può
vedere per la maggior parte questi limiti attengono alle dimensioni dei dati
interi, che sono in genere fissati dall'architettura hardware (le analoghe
informazioni per i dati in virgola mobile sono definite a parte, ed
accessibili includendo \file{float.h}). Lo standard prevede anche un'altra
costante, \macro{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
definita in \file{limits.h}; essa deve essere definita in \file{stdio.h} ed
avere un valore minimo di 8.

\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}[c]{|l|r|l|}
    \hline
    \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
    \hline
    \hline
    \macro{MB\_LEN\_MAX}&       16  & massima dimensione di un 
                                      carattere esteso\\
    \macro{CHAR\_BIT} &          8  & bit di \ctyp{char}\\
    \macro{UCHAR\_MAX}&        255  & massimo di \ctyp{unsigned char}\\
    \macro{SCHAR\_MIN}&       -128  & minimo di \ctyp{signed char}\\
    \macro{SCHAR\_MAX}&        127  & massimo di \ctyp{signed char}\\
    \macro{CHAR\_MIN} &\footnotemark& minimo di \ctyp{char}\\
    \macro{CHAR\_MAX} &\footnotemark& massimo di \ctyp{char}\\
    \macro{SHRT\_MIN} &     -32768  & minimo di \ctyp{short}\\
    \macro{SHRT\_MAX} &      32767  & massimo di \ctyp{short}\\
    \macro{USHRT\_MAX}&      65535  & massimo di \ctyp{unsigned short}\\
    \macro{INT\_MAX}  & 2147483647  & minimo di \ctyp{int}\\
    \macro{INT\_MIN}  &-2147483648  & minimo di \ctyp{int}\\
    \macro{UINT\_MAX} & 4294967295  & massimo di \ctyp{unsigned int}\\
    \macro{LONG\_MAX} & 2147483647  & massimo di \ctyp{long}\\
    \macro{LONG\_MIN} &-2147483648  & minimo di \ctyp{long}\\
    \macro{ULONG\_MAX}& 4294967295  & massimo di \ctyp{unsigned long}\\
    \hline                
  \end{tabular}
  \caption{Costanti definite in \file{limits.h} in conformità allo standard
    ANSI C.}
  \label{tab:sys_ansic_macro}
\end{table}

\footnotetext[1]{il valore può essere 0 o \macro{SCHAR\_MIN} a seconda che il
  sistema usi caratteri con segno o meno.} 

\footnotetext[2]{il valore può essere \macro{UCHAR\_MAX} o \macro{SCHAR\_MAX}
  a seconda che il sistema usi caratteri con segno o meno.}

A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
\ctyp{long long} introdotto con il nuovo standard, i relativi valori sono in
\tabref{tab:sys_isoc90_macro}.

\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}[c]{|l|r|l|}
    \hline
    \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
    \hline
    \hline
    \macro{LLONG\_MAX}& 9223372036854775807& massimo di \ctyp{long long}\\
    \macro{LLONG\_MIN}&-9223372036854775808& minimo di \ctyp{long long}\\
    \macro{ULLONG\_MAX}&18446744073709551615&
    massimo di \ctyp{unsigned long long}\\
    \hline                
  \end{tabular}
  \caption{Macro definite in \file{limits.h} in conformità allo standard
    ISO C90.}
  \label{tab:sys_isoc90_macro}
\end{table}

Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
delle caratteristiche del sistema; mancano completamente tutte quelle che
dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
limiti relativi alle caratteristiche dei file che vedremo in
\secref{sec:sys_file_limits}.

Purtroppo la sezione dello standard che tratta questi argomenti è una delle
meno chiare\footnote{tanto che Stevens, in \cite{APUE}, la porta come esempio
  di ``standardese''.}. Lo standard prevede che ci siano 13 macro che
descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
riportate in \tabref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
file, riportate in \tabref{tab:sys_file_macro}).

\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}[c]{|l|r|p{8cm}|}
    \hline
    \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
    \hline
    \hline
    \macro{ARG\_MAX} &131072& dimensione massima degli argomenti
                              passati ad una funzione della famiglia
                              \func{exec}.\\ 
    \macro{CHILD\_MAX} & 999& numero massimo di processi contemporanei
                              che un utente può eseguire.\\
    \macro{OPEN\_MAX}  & 256& numero massimo di file che un processo
                              può mantenere aperti in contemporanea.\\
    \macro{STREAM\_MAX}&   8& massimo numero di stream aperti per
                              processo in contemporanea.\\
    \macro{TZNAME\_MAX}&   6& dimensione massima del nome di una
                              \texttt{timezone} (vedi ).\\ 
    \macro{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
                              processo (vedi \secref{sec:proc_access_id}).\\
    \macro{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
    \hline
    \hline
  \end{tabular}
  \caption{Costanti per i limiti del sistema.}
  \label{tab:sys_generic_macro}
\end{table}

Lo standard dice che queste macro devono essere definite in \file{limits.h}
quando i valori a cui fanno riferimento sono fissi, e altrimenti devono essere
lasciate indefinite, ed i loro valori dei limiti devono essere accessibili
solo attraverso \func{sysconf}.  In realtà queste vengono sempre definite ad
un valore generico. Si tenga presente poi che alcuni di questi limiti possono
assumere valori molto elevati (come \macro{CHILD\_MAX}), e non è pertanto il
caso di utilizzarli per allocare staticamente della memoria.

A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
definiscono i valori minimi le stesse caratteristiche devono avere, perché una
implementazione possa dichiararsi conforme allo standard; detti valori sono
riportati in \tabref{tab:sys_posix1_general}.

\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}[c]{|l|r|p{8cm}|}
    \hline
    \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
    \hline
    \hline
    \macro{\_POSIX\_ARG\_MAX}    & 4096& dimensione massima degli argomenti
                                         passati ad una funzione della famiglia
                                         \func{exec}.\\ 
    \macro{\_POSIX\_CHILD\_MAX}  &    6& numero massimo di processi
                                         contemporanei che un utente può 
                                         eseguire.\\
    \macro{\_POSIX\_OPEN\_MAX}   &   16& numero massimo di file che un processo
                                         può mantenere aperti in 
                                         contemporanea.\\
    \macro{\_POSIX\_STREAM\_MAX} &    8& massimo numero di stream aperti per
                                         processo in contemporanea.\\
    \macro{\_POSIX\_TZNAME\_MAX} &     & dimensione massima del nome di una
                                         \texttt{timezone} (vedi ).\\ 
    \macro{\_POSIX\_NGROUPS\_MAX}&    0& numero di gruppi supplementari per
                                         processo (vedi 
                                         \secref{sec:proc_access_id}).\\
    \macro{\_POSIX\_SSIZE\_MAX}  &32767& valore massimo del tipo 
                                         \type{ssize\_t}.\\
    \macro{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
    \macro{\_POSIX\_AIO\_MAX}    &    1& \\
    \hline                
    \hline                
  \end{tabular}
  \caption{Macro dei valori minimi delle caratteristiche generali del sistema
    per la conformità allo standard POSIX.1.}
  \label{tab:sys_posix1_general}
\end{table}

In genere questi valori non servono a molto, la loro unica utilità è quella di
indicare un limite superiore che assicura la portabilità senza necessità di
ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
valori ottenuti da \func{sysconf}.

\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}[c]{|l|p{8cm}|}
    \hline
    \textbf{Macro}&\textbf{Significato}\\
    \hline
    \hline
    \macro{\_POSIX\_JOB\_CONTROL}& il sistema supporta il 
                                   \textit{job control} (vedi 
                                   \secref{sec:sess_xxx}).\\
    \macro{\_POSIX\_SAVED\_IDS}  & il sistema supporta i \textit{saved id} 
                                   (vedi \secref{sec:proc_access_id}). 
                                   per il controllo di accesso dei processi\\
    \macro{\_POSIX\_VERSION}     & fornisce la versione dello standard POSIX.1
                                   supportata nel formato YYYYMML (ad esempio 
                                   199009L).\\
    \hline
  \end{tabular}
  \caption{Alcune macro definite in \file{limits.h} in conformità allo standard
    POSIX.1.}
  \label{tab:sys_posix1_other}
\end{table}

Oltre ai precedenti valori (e a quelli relativi ai file elencati in
\tabref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
lo standard POSIX.1 ne prevede parecchi altri.  La lista completa si trova
dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
incluso automaticamente all'interno di \file{limits.h}). Di questi vale la
pena menzionare alcune macro di uso comune, (riportate in
\tabref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
denotano la presenza di alcune funzionalità nel sistema (come il supporto del
\textit{job control} o dei \textit{saved id}).

Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
alle applicazioni di sistema presenti (come quelli su alcuni parametri delle
espressioni regolari o del comando \cmd{bc}), non li tratteremo
esplicitamente, se ne trova una menzione completa nell'header file
\file{bits/posix2\_lim.h}, e alcuni di loro sono descritti nella man page di
\func{sysconf} e nel manuale delle \acr{glibc}.


\subsection{La funzione \func{sysconf}}
\label{sec:sys_sysconf}

Come accennato in \secref{sec:sys_limits} quando uno dei limiti o delle
caratteristiche del sistema può variare, per non dover essere costretti a
ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
compilato il kernel, o alcuni dei parametri modificabili a run time, è
necessario ottenerne il valore attraverso la funzione \func{sysconf}. Il
prototipo di questa funzione è:
\begin{prototype}{unistd.h}{long sysconf(int name)}
  Restituisce il valore del parametro di sistema \param{name}.
  
  \bodydesc{La funzione restituisce indietro il valore del parametro
    richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
    è disponibile e -1 in caso di errore (ma \var{errno} non viene settata).}
\end{prototype}

La funzione prende come argomento un intero che specifica quale dei limiti si
vuole conoscere; uno specchietto contenente i principali valori disponibili in
Linux è riportato in \tabref{tab:sys_sysconf_par}; l'elenco completo è
contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.

\begin{table}[htb]
  \centering
  \footnotesize
    \begin{tabular}[c]{|l|l|p{9cm}|}
      \hline
      \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
      \hline
      \hline
      \texttt{\_SC\_ARG\_MAX} &\macro{ARG\_MAX}&
      La dimensione massima degli argomenti passati ad una funzione
      della famiglia \func{exec}.\\
      \texttt{\_SC\_CHILD\_MAX}&\macro{\_CHILD\_MAX}&
      Il numero massimo di processi contemporanei che un utente può
      eseguire.\\
      \texttt{\_SC\_OPEN\_MAX}&\macro{\_OPEN\_MAX}&
      Il numero massimo di file che un processo può mantenere aperti in
      contemporanea.\\
      \texttt{\_SC\_STREAM\_MAX}& \macro{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}&\macro{TZNAME\_MAX}&
      La dimensione massima di un nome di una \texttt{timezone} (vedi ).\\
      \texttt{\_SC\_NGROUPS\_MAX}&\macro{NGROUP\_MAX}&
      Massimo numero di gruppi supplementari che può avere un processo (vedi
      \secref{sec:proc_access_id}).\\ 
      \texttt{\_SC\_SSIZE\_MAX}&\macro{SSIZE\_MAX}& 
      valore massimo del tipo di dato \type{ssize\_t}.\\
      \texttt{\_SC\_CLK\_TCK}& \macro{CLK\_TCK} &
      Il numero di \textit{clock tick} al secondo, cioè l'unità di misura del
      \textit{process time} (vedi \secref{sec:sys_unix_time}).\\
      \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
      Indica se è supportato il \textit{job control} (vedi
      \secref{sec:sess_xxx}) in stile POSIX.\\
      \texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
      Indica se il sistema supporta i \textit{saved id} (vedi
      \secref{sec:proc_access_id}).\\ 
      \texttt{\_SC\_VERSION}& \macro{\_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}.}
  \label{tab:sys_sysconf_par}
\end{table}

In generale ogni limite o caratteristica del sistema per cui è definita una
macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
essere ottenuto attraverso una chiamata a \func{sysconf}. Il valore si otterrà
specificando come valore del parametro \param{name} il nome ottenuto
aggiungendo \code{\_SC\_} ai nomi delle macro definite dai primi due, o
sostituendolo a \code{\_POSIX\_} per le macro definite dagli gli altri due.

In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
macro non è definita, quindi con un codice analogo al seguente:
%\footnotesize
\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
get_child_max(void)
{
#ifdef CHILD_MAX
    return CHILD_MAX;
#else
    int val = sysconf(_SC_CHILD_MAX);
    if (val < 0) {
        perror("fatal error");
        exit(-1);
    }
    return val;
}
\end{lstlisting}
%\normalsize 
ma in realtà in Linux queste macro sono comunque definite, indicando però un
limite generico. Per questo motivo è sempre meglio usare i valori restituiti
da \func{sysconf}.


\subsection{I limiti dei file}
\label{sec:sys_file_limits}

Come per le caratteristiche generali del sistema anche per i file esistono una
serie di limiti (come la lunghezza del nome del file o il numero massimo di
link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
in questo caso lo standard prevede alcune macro che ne specificano il valore,
riportate in \tabref{tab:sys_file_macro}.

\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}[c]{|l|r|p{8cm}|}
    \hline
    \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
    \hline
    \hline                
    \macro{NAME\_MAX}&  14  & lunghezza in byte di un nome di file. \\
    \macro{PATH\_MAX}& 256  & lunghezza in byte di pathname.\\
    \macro{PIPE\_BUF}& 512  & byte scrivibili atomicamente in una pipe\\
    \macro{LINK\_MAX}   &8  & numero massimo di link a un file\\
    \macro{MAX\_CANON}&255  & spazio disponibile nella coda di input
                              canonica del terminale\\
    \macro{MAX\_INPUT}&255  & spazio disponibile nella coda di input 
                              del terminale\\
    \hline                
  \end{tabular}
  \caption{Macro per i limiti sulle caratteristiche dei file.}
  \label{tab:sys_file_macro}
\end{table}

Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
minimi anche per queste caratteristiche, che ogni sistema che vuole essere
conforme deve rispettare; le relative macro sono riportate in
\tabref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per le
analoghe di \tabref{tab:sys_posix1_general}.

\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}[c]{|l|r|p{8cm}|}
    \hline
    \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
    \hline
    \hline
    \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
    \macro{\_POSIX\_LINK\_MAX}   &8  & numero massimo di link a un file\\
    \macro{\_POSIX\_MAX\_CANON}&255  & spazio disponibile nella coda di input
                                       canonica del terminale\\
    \macro{\_POSIX\_MAX\_INPUT}&255  & spazio disponibile nella coda di input 
                                       del terminale\\
    \macro{\_POSIX\_NAME\_MAX}&  14  & lunghezza in byte di un nome di file. \\
    \macro{\_POSIX\_PATH\_MAX}& 256  & lunghezza in byte di pathname.\\
    \macro{\_POSIX\_PIPE\_BUF}& 512  & byte scrivibili atomicamente in una
                                       pipe\\
%    \macro{\_POSIX\_MQ\_OPEN\_MAX}&  8& \\
%    \macro{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
%    \macro{\_POSIX\_FD\_SETSIZE}& 16 & \\
%    \macro{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
    \hline
  \end{tabular}
  \caption{Macro dei valori minimi delle caratteristiche dei file per la
    conformità allo standard POSIX.1.}
  \label{tab:sys_posix1_file}
\end{table}

Tutti questi limiti sono definiti in \file{limits.h}; come nel caso precedente
il loro uso è di scarsa utilità in quanto ampiamente superati in tutte le
implementazioni moderne.


\subsection{La funzione \func{pathconf}}
\label{sec:sys_pathconf}

In generale i limiti per i file sono molto più soggetti ad essere variabili
rispetto ai limiti generali del sistema; ad esempio parametri come la
lunghezza del nome del file o il numero di link possono variare da filesystem
a filesystem; per questo motivo questi limiti devono essere sempre controllati
con la funzione \func{pathconf}, il cui prototipo è:
\begin{prototype}{unistd.h}{long pathconf(char *path, int name)}
  Restituisce il valore del parametro \param{name} per il file \param{path}.
  
  \bodydesc{La funzione restituisce indietro il valore del parametro
    richiesto, o -1 in caso di errore (ed \var{errno} viene settata ad uno
    degli errori possibili relativi all'accesso a \param{path}).}
\end{prototype}

E si noti come la funzione in questo caso richieda un parametro che specifichi
a quale file si fa riferimento, dato che il valore del limite cercato può
variare a seconda del filesystem. Una seconda versione della funzione,
\func{fpathconf}, opera su un file descriptor invece che su un pathname. Il
suo prototipo è:
\begin{prototype}{unistd.h}{long fpathconf(int fd, int name)}
  Restituisce il valore del parametro \param{name} per il file \param{fd}.
  
  \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
    invece di un pathname; pertanto gli errori restituiti cambiano di
    conseguenza.}
\end{prototype}
\noindent ed il suo comportamento è identico a quello di \func{pathconf}.


\subsection{La funzione \func{uname}}
\label{sec:sys_uname}

Un'altra funzione che si può utilizzare per raccogliere informazioni sia
riguardo al sistema che al computer su cui esso sta girando è \func{uname}; il
suo prototipo è:
\begin{prototype}{sys/utsname.h}{int uname(struct utsname *info)}
  Restituisce informazioni sul sistema nella struttura \param{info}.
  
  \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
  fallimento, nel qual caso \var{errno} viene settata a \macro{EFAULT}.}
\end{prototype}

La funzione, che viene usata dal comando \cmd{uname}, restituisce le
informazioni richieste nella struttura \param{info}; anche questa struttura è
definita in \file{sys/utsname.h}, secondo quanto mostrato in
\secref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
indicano rispettivamente:
\begin{itemize*}
\item il nome del sistema operativo;
\item il nome della release del kernel;
\item il nome della versione del kernel;
\item il tipo di macchina in uso;
\item il nome della stazione;
\item il nome del domino.
\end{itemize*}
l'ultima informazione è stata aggiunta di recente e non è prevista dallo
standard POSIX, essa è accessibile, come mostrato in \figref{fig:sig_stack_t},
solo definendo \macro{\_GNU\_SOURCE}.

\begin{figure}[!htb]
  \footnotesize \centering
  \begin{minipage}[c]{15cm}
  \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
struct utsname {
    char sysname[];
    char nodename[];
    char release[];
    char version[];
    char machine[];
#ifdef _GNU_SOURCE
    char domainname[];
#endif
};
  \end{lstlisting}
  \end{minipage}
  \normalsize 
  \caption{La struttura \var{utsname}.} 
  \label{fig:sys_utsname}
\end{figure}

In generale si tenga presente che le dimensioni delle stringe di una
\var{utsname} non è specificata, e che esse sono sempre terminate con
\macro{NULL}; il manuale delle \acr{glibc} indica due diverse dimensioni,
\macro{\_UTSNAME\_LENGTH} per i campi standard e
\macro{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
altri sistemi usano nomi diversi come \macro{SYS\_NMLN} o \macro{\_SYS\_NMLN}
or \macro{UTSLEN} che possono avere valori diversi. Nel caso di Linux
\func{uname} corrisponde in realtà a 3 system call diverse, le prime due usano
rispettivamente delle lunghezze delle stringhe di 9 e 65 byte; la terza usa
anch'essa 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con
una lunghezza di 257 byte.


\section{Opzioni e configurazione del sistema}
\label{sec:sys_config}

Come abbiamo accennato nella sezione precedente, non tutti i limiti che
caratterizzano il sistema sono fissi, o perlomeno non lo sono in tutte le
implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
di esaminare il meccanismo che permette, quando questi possono variare durante
l'esecuzione del sistema, di modificarli.

Inoltre, al di la di quelli che possono essere limiti caratteristici previsti
da uno standard, ogni sistema può avere una sua serie di altri parametri di
configurazione, che, non essendo mai fissi e variando da sistema a sistema,
non sono stati inclusi nella standardizzazione della sezione precedente. Per
questi occorre, oltre al meccanismo di settaggio, pure un meccanismo di
lettura.

Affronteremo questi argomenti in questa sezione, insieme alle funzioni che si
usano per il controllo di altre caratteristiche generali del sistema, come
quelle per la gestione dei filesystem e di utenti e gruppi.


\subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
\label{sec:sys_sysctl}

La funzione che permette la lettura ed il settaggio dei parametri del sistema
è \func{sysctl}; è una funzione derivata da BSD4.4, ma l'implementazione è
specifica di Linux; il suo prototipo è:
\begin{functions}
\headdecl{unistd.h}
\headdecl{linux/unistd.h}
\headdecl{linux/sysctl.h}
\funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
  *newval, size\_t newlen)}

Legge o scrive uno dei parametri di sistema.

\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
  errore, nel qual caso \var{errno} viene settato ai valori:
  \begin{errlist}
  \item[\macro{EPERM}] il processo non ha il permesso di accedere ad uno dei
    componenti nel cammino specificato per il parametro, o non ha il permesso
    di accesso al parametro nella modalità scelta.
  \item[\macro{ENOTDIR}] non esiste un parametro corrispondente al nome
    \param{name}.
  \item[\macro{EFAULT}] si è specificato \param{oldlenp} zero quando
    \param{oldval} è non nullo. 
  \item[\macro{EINVAL}] o si è specificato un valore non valido per il
    parametro che si vuole settare o lo spazio provvisto per il ritorno di un
    valore non è delle giuste dimensioni.
  \item[\macro{ENOMEM}] talvolta viene usato più correttamente questo errore
    quando non si è specificato sufficiente spazio per ricevere il valore di un
    parametro.
  \end{errlist}
}
\end{functions}

I parametri a cui la funzione permettere di accedere sono organizzati in
maniera gerarchica all'interno un albero; per accedere ad uno di essi occorre
specificare un cammino attraverso i vari nodi dell'albero, in maniera analoga
a come avviene per la risoluzione di un pathname (da cui l'uso alternativo del
filesystem \file{/proc}, che vedremo dopo).

Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
arriva ad identificare un parametro specifico è passato alla funzione
attraverso l'array \param{name}, di lunghezza \param{nlen}, che contiene la
sequenza dei vari nodi da attraversare. Ogni parametro ha un valore in un
formato specifico che può essere un intero, una stringa o anche una struttura
complessa, per questo motivo il valori vengono passati come puntatori
\ctyp{void}.

L'indirizzo a cui il valore corrente del parametro deve essere letto è
specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
\param{oldlenp} (passato come puntatore per avere indietro la dimensione
effettiva di quanto letto); il valore che si vuole settare nel sistema è
passato in \param{newval} e la sua dimensione in \param{newlen}.

Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
valore letto restituito dalla funzione è quello precedente alla scrittura.

I parametri accessibili attraverso questa funzione sono moltissimi, e possono
essere trovati in \file{sysctl.h}, essi inoltre dipendono anche dallo stato
corrente del kernel (ad esempio dai moduli che sono stati caricati nel
sistema) e in genere i loro nomi possono variare da una versione di kernel
all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
quando esistono modalità alternative per ottenere le stesse informazioni.
Alcuni esempi di parametri ottenibili sono:
\begin{itemize*}
\item il nome di dominio
\item i parametri del meccanismo di \textit{paging}.
\item il filesystem montato come radice
\item la data di compilazione del kernel
\item i parametri dello stack TCP
\item il numero massimo di file aperti
\end{itemize*}

Come accennato in Linux si ha una modalità alternativa per accedere alle
stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
\file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
kernel, che non fa riferimento a nessun dispositivo fisico, ma presenta in
forma di file alcune delle strutture interne del kernel stesso.

In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
specificando un pathname e leggendo e scrivendo sul file corrispondente al
parametro scelto.  Il kernel si occupa di generare al volo il contenuto ed i
nomi dei file corrispondenti, e questo ha il grande vantaggio di rendere
accessibili i vari parametri a qualunque comando di shell e di permettere la
navigazione dell'albero dei valori.

Alcune delle corrispondenze dei file presenti in \file{/proc/sys} con i valori
di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
in \file{linux/sysctl.h},\footnote{indicando un file di definizioni si fa
  riferimento alla directory standard dei file di include, che in ogni
  distribuzione che si rispetti è \file{/usr/include}.} la informazione
disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.

Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc} 
sono disponibili moltissime altre informazioni, fra cui ad esempio anche
quelle fornite da \func{uname} (vedi \secref{sec:sys_config}) che sono
mantenute nei file \file{ostype}, \file{hostname}, \file{osrelease},
\file{version} e \file{domainname} di \file{/proc/kernel/}.



\subsection{La gestione delle proprietà dei filesystem}
\label{sec:sys_file_config}

Come accennato in \secref{sec:file_organization} per poter accedere ai file
occorre prima rendere disponibile al sistema il filesystem su cui essi sono
memorizzati; l'operazione di attivazione del filesystem è chiamata
\textsl{montaggio}, per far questo in Linux\footnote{la funzione è specifica
  di Linux e non è portabile.} si usa la funzione \func{mount} il cui prototipo
è:
\begin{prototype}{sys/mount.h}
{mount(const char *source, const char *target, const char *filesystemtype, 
  unsigned long mountflags, const void *data)}

Monta il filesystem di tipo \param{filesystemtype} contenuto in \param{source}
sulla directory \param{target}.
  
  \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
  fallimento, nel qual caso gli errori comuni a tutti i filesystem che possono
  essere restituiti in \var{errno} sono:
  \begin{errlist}
  \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
  \item[\macro{ENODEV}] \param{filesystemtype} non esiste o non è configurato
    nel kernel.
  \item[\macro{ENOTBLK}] non si è usato un \textit{block device} per
    \param{source} quando era richiesto.
  \item[\macro{EBUSY}] \param{source} è già montato, o non può essere
    rimontato in read-only perché ci sono ancora file aperti in scrittura, o
    \param{target} è ancora in uso.
  \item[\macro{EINVAL}] il device \param{source} presenta un
    \textit{superblock} non valido, o si è cercato di rimontare un filesystem
    non ancora montato, o di montarlo senza che \param{target} sia un
    \textit{mount point} o di spostarlo quando \param{target} non è un
    \textit{mount point} o è \file{/}.
  \item[\macro{EACCES}] non si ha il permesso di accesso su uno dei componenti
  del pathname, o si è cercato di montare un filesystem disponibile in sola
  lettura senza averlo specificato o il device \param{source} è su un
  filesystem montato con l'opzione \macro{MS\_NODEV}.
  \item[\macro{ENXIO}] il \textit{major number} del device \param{source} è
    sbagliato.
  \item[\macro{EMFILE}] la tabella dei device \textit{dummy} è piena.
  \end{errlist}
  ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
  \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
\end{prototype}

La funzione monta sulla directory \param{target}, detta \textit{mount point},
il filesystem contenuto in \param{source}. In generale un filesystem è
contenuto su un disco, e l'operazione di montaggio corrisponde a rendere
visibile al sistema il contenuto del suddetto disco, identificato attraverso
il file di dispositivo ad esso associato.

Ma la struttura del virtual filesystem vista in \secref{sec:file_vfs} è molto
più flessibile e può essere usata anche per oggetti diversi da un disco. Ad
esempio usando il \textit{loop device} si può montare un file qualunque (come
l'immagine di un CD-ROM o di un floppy) che contiene un filesystem, inoltre
alcuni filesystem, come \file{proc} o \file{devfs} sono del tutto virtuali, i
loro dati sono generati al volo ad ogni lettura, e passati al kernel ad ogni
scrittura. 

Il tipo di filesystem è specificato da \param{filesystemtype}, che deve essere
una delle stringhe riportate nel file \file{/proc/filesystems}, che contiene
l'elenco dei filesystem supportati dal kernel; nel caso si sia indicato uno
dei filesystem virtuali, il contenuto di \param{source} viene ignorato.

Dopo l'esecuzione della funzione il contenuto del filesystem viene resto
disponibile nella directory specificata come \textit{mount point}, il
precedente contenuto di detta directory viene mascherato dal contenuto della
directory radice del filesystem montato.

Dal kernel 2.4.x inoltre è divenuto possibile sia spostare atomicamente un
\textit{mount point} da una directory ad un'altra, sia montare in diversi
\textit{mount point} lo stesso filesystem, sia montare più filesystem sullo
stesso \textit{mount point} (nel qual caso vale quanto appena detto, e solo il
contenuto dell'ultimo filesystem montato sarà visibile).

Ciascun filesystem è dotato di caratteristiche specifiche che possono essere
attivate o meno, alcune di queste sono generali (anche se non è detto siano
disponibili in ogni filesystem), e vengono specificate come opzioni di
montaggio con l'argomento \param{mountflags}.  

In Linux \param{mountflags} deve essere un intero a 32 bit i cui 16 più
significativi sono un \textit{magic number}\footnote{cioè un numero speciale
  usato come identificativo, che nel caso è \code{0xC0ED}; si può usare la
  costante \macro{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
  riservata al \textit{magic number}.} mentre i 16 meno significativi sono
usati per specificare le opzioni; essi sono usati come maschera binaria e
vanno settati con un OR aritmetico della costante \macro{MS\_MGC\_VAL} con i
valori riportati in \ntab.

\begin{table}[htb]
  \footnotesize
  \centering
  \begin{tabular}[c]{|l|r|l|}
    \hline
    \textbf{Parametro} & \textbf{Valore}&\textbf{Significato}\\
    \hline
    \hline
    \macro{MS\_RDONLY}     &  1 & monta in sola lettura\\
    \macro{MS\_NOSUID}     &  2 & ignora i bit \acr{suid} e \acr{sgid}\\
    \macro{MS\_NODEV}      &  4 & impedisce l'accesso ai file di dispositivo\\
    \macro{MS\_NOEXEC}     &  8 & impedisce di eseguire programmi \\
    \macro{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
    \macro{MS\_REMOUNT}    & 32 & rimonta il filesystem cambiando i flag\\
    \macro{MS\_MANDLOCK}   & 64 & consente il \textit{mandatory locking} (vedi
                                  \secref{sec:file_mand_locking})\\
    \macro{S\_WRITE}      & 128 & scrive normalmente \\
    \macro{S\_APPEND}     & 256 & consente la scrittura solo in \textit{append
                                  mode} (vedi \secref{sec:file_sharing})\\
    \macro{S\_IMMUTABLE}  & 512 & impedisce che si possano modificare i file \\
    \macro{MS\_NOATIME}   &1024 & non aggiorna gli \textit{access time} (vedi
                                  \secref{sec:file_file_times})\\
    \macro{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
                                  directory\\
    \macro{MS\_BIND}      &4096 & monta il filesystem altrove\\
    \macro{MS\_MOVE}      &8192 & sposta atomicamente il punto di montaggio \\
    \hline
  \end{tabular}
  \caption{Tabella dei codici dei flag di montaggio di un filesystem.}
  \label{tab:sys_mount_flags}
\end{table}

Per il settaggio delle caratteristiche particolari di ciascun filesystem si
usa invece l'argomento \param{data} che serve per passare le ulteriori
informazioni necessarie, che ovviamente variano da filesystem a filesystem.

La funzione \func{mount} può essere utilizzata anche per effettuare il
\textsl{rimontaggio} di un filesystem, cosa che permette di cambiarne al volo
alcune delle caratteristiche di funzionamento (ad esempio passare da sola
lettura a lettura/scrittura). Questa operazione è attivata attraverso uno dei
bit di \param{mountflags}, \macro{MS\_REMOUNT}, che se settato specifica che
deve essere effettuato il rimontaggio del filesystem (con le opzioni
specificate dagli altri bit), anche in questo caso il valore di \param{source}
viene ignorato.

Una volta che non si voglia più utilizzare un certo filesystem è possibile
\textsl{smontarlo} usando la funzione \func{umount}, il cui prototipo è:
\begin{prototype}{sys/mount.h}{umount(const char *target)}
  
  Smonta il filesystem montato sulla directory \param{target}.
  
  \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
    fallimento, nel qual caso \var{errno} viene settata a:
  \begin{errlist}
  \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
  \item[\macro{EBUSY}]  \param{target} è la directory di lavoro di qualche
  processo, o contiene dei file aperti, o un altro mount point.
  \end{errlist}
  ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
  \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
\end{prototype}
\noindent la funzione prende il nome della directory su cui il filesystem è
montato e non il file o il dispositivo che è stato montato,\footnote{questo è
  vero a partire dal kernel 2.3.99-pre7, prima esistevano due chiamate
  separate e la funzione poteva essere usata anche specificando il file di
  dispositivo.} in quanto con il kernel 2.4.x è possibile montare lo stesso
dispositivo in più punti. Nel caso più di un filesystem sia stato montato
sullo stesso \textit{mount point} viene smontato quello che è stato montato
per ultimo.

Si tenga presente che la funzione fallisce quando il filesystem è
\textsl{occupato}, questo avviene quando ci sono ancora file aperti sul
filesystem, se questo contiene la directory di lavoro corrente di un qualunque
processo o il mount point di un altro filesystem; in questo caso l'errore
restituito è \macro{EBUSY}.

Linux provvede inoltre una seconda funzione, \func{umount2}, che in alcuni
casi permette di forzare lo smontaggio di un filesystem, anche quando questo
risulti occupato; il suo prototipo è:
\begin{prototype}{sys/mount.h}{umount2(const char *target, int flags)}
  
  La funzione è identica a \func{umount} per comportamento e codici di errore,
  ma con \param{flags} si può specificare se forzare lo smontaggio.
\end{prototype}

Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
definito è il bit \macro{MNT\_FORCE}; gli altri bit devono essere nulli.
Specificando \macro{MNT\_FORCE} la funzione cercherà di liberare il filesystem
anche se è occupato per via di una delle condizioni descritte in precedenza. A
seconda del tipo di filesystem alcune (o tutte) possono essere superate,
evitando l'errore di \macro{EBUSY}.  In tutti i casi prima dello smontaggio
viene eseguita una sincronizzazione dei dati. 

Altre due funzioni specifiche di Linux,\footnote{esse si trovano anche su BSD,
  ma con una struttura diversa.} utili per ottenere in maniera diretta
informazioni riguardo al filesystem su cui si trova un certo file, sono
\func{statfs} e \func{fstatfs}, i cui prototipi sono:
\begin{functions}
  \headdecl{sys/vfs.h} 
  \funcdecl{int statfs(const char *path, struct statfs *buf)} 

  \funcdecl{int fstatfs(int fd, struct statfs *buf)} 
  
  Restituisce in \param{buf} le informazioni relative al filesystem su cui è
  posto il file specificato.
  
  \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
    errore, nel qual caso \var{errno} viene settato ai valori:
  \begin{errlist}
  \item[\macro{ENOSYS}] il filesystem su cui si trova il file specificato non
  supporta la funzione.
  \end{errlist}
  e \macro{EFAULT} ed \macro{EIO} per entrambe, \macro{EBADF} per
  \func{fstatfs}, \macro{ENOTDIR}, \macro{ENAMETOOLONG}, \macro{ENOENT},
  \macro{EACCES}, \macro{ELOOP} per \func{statfs}.}
\end{functions}

Queste funzioni permettono di ottenere una serie di informazioni generali
riguardo al filesystem su cui si trova il file specificato; queste vengono
restituite una struttura \param{buf} di tipo \type{statfs} definita come in
\ref{fig:sys_statfs}, ed i campi che sono indefiniti per il filesystem in
esame sono settati a zero.  I valori del campo \var{f\_type} sono definiti per
i vari filesystem nei relativi file di header dei sorgenti del kernel da
costanti del tipo \macro{XXX\_SUPER\_MAGIC}, dove \macro{XXX} in genere è il
nome del filesystem stesso.

\begin{figure}[!htb]
  \footnotesize \centering
  \begin{minipage}[c]{15cm}
  \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
    struct statfs {
       long    f_type;     /* tipo di filesystem */
       long    f_bsize;    /* dimensione ottimale dei blocchi di I/O */
       long    f_blocks;   /* blocchi totali nel filesystem */
       long    f_bfree;    /* blocchi liberi nel filesystem */
       long    f_bavail;   /* blocchi liberi agli utenti normali */
       long    f_files;    /* inodes totali nel filesystem */
       long    f_ffree;    /* inodes liberi nel filesystem */
       fsid_t  f_fsid;     /* filesystem id */
       long    f_namelen;  /* lunghezza massima dei nomi dei file */
       long    f_spare[6]; /* riservati per uso futuro */
    };
\end{lstlisting}
  \end{minipage}
  \normalsize 
  \caption{La struttura \var{statfs}.} 
  \label{fig:sys_statfs}
\end{figure}


Le \acr{glibc} provvedono infine una serie di funzioni per la gestione dei due
file standard \file{/etc/fstab} e \file{/etc/mtab}, che convenzionalmente sono
usati in quasi tutti i sistemi unix-like per mantenere rispettivamente le
informazioni riguardo ai filesystem da montare e a quelli correntemente
montati. Le funzioni servono a leggere il contenuto di questi file in
opportune strutture \var{struct fstab} e \var{struct mntent}, e, per
\file{/etc/mtab} per inserire e rimuovere le voci presenti nel file.  

In generale si dovrebbero usare queste funzioni (in particolar modo quelle
relative a \file{/etc/mtab}), quando si debba scrivere un programma che
effettua il montaggio di un filesystem; in realtà in questi casi è molto più
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.


\subsection{La gestione di utenti e gruppi}
\label{sec:sys_user_group}

Tradizionalmente l'informazione per la gestione di utenti e gruppi veniva
tenuta tutta nei due file di testo \file{/etc/passwd} ed \file{/etc/group}, e
tutte le funzioni facevano riferimento ad essi.  Oggi la maggior parte delle
distribuzioni di Linux usa la libreria PAM (sigla che sta \textit{Pluggable
  Authentication Method}) che permette di separare completamente i meccanismi
di gestione degli utenti (autenticazione, riconoscimento, ecc.) dalle modalità
in cui i relativi dati vengono mantenuti, per cui pur restando in gran parte
le stesse\footnote{in genere quello che viene cambiato è l'informazione usata
  per l'autenticazione, che non è più necessariamente una password criptata da
  verificare, ma può assumere le forme più diverse, come impronte digitali,
  chiavi elettroniche, ecc.}, le informazioni non sono più necessariamente
mantenute in quei file.

In questo paragrafo ci limiteremo comunque alle funzioni classiche per la
lettura delle informazioni relative a utenti e gruppi previste dallo standard
POSIX.1, che fanno riferimento a quanto memorizzato nei due file appena
citati, il cui formato è descritto dalle relative pagine del manuale (cioè
\cmd{man 5 passwd} e \cmd{man 5 group}).

Per leggere le informazioni relative ad un utente si possono usare due
funzioni, \func{getpwuid} e \func{getpwnam}, i cui prototipi sono:
\begin{functions}
  \headdecl{pwd.h} 
  \headdecl{sys/types.h} 
  \funcdecl{struct passwd *getpwuid(uid\_t uid)} 
  
  \funcdecl{struct passwd *getpwnam(const char *name)} 

  Restituiscono le informazioni relative all'utente specificato.
  
  \bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
    informazioni in caso di successo e \macro{NULL} nel caso non sia stato
    trovato nessun utente corrispondente a quanto specificato.}
\end{functions}

Le due funzioni forniscono le informazioni memorizzate nel database degli
utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
relative all'utente specificato attraverso il suo \acr{uid} o il nome di
login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
tipo \type{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
riportata in \figref{fig:sys_passwd_struct}, dove è pure brevemente illustrato
il significato dei vari campi. 

\begin{figure}[!htb]
  \footnotesize
  \centering
  \begin{minipage}[c]{15cm}
    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
struct passwd {
    char    *pw_name;       /* user name */
    char    *pw_passwd;     /* user password */
    uid_t   pw_uid;         /* user id */
    gid_t   pw_gid;         /* group id */
    char    *pw_gecos;      /* real name */
    char    *pw_dir;        /* home directory */
    char    *pw_shell;      /* shell program */
};
    \end{lstlisting}
  \end{minipage} 
  \normalsize 
  \caption{La struttura \var{passwd} contenente le informazioni relative ad un
    utente del sistema.}
  \label{fig:sys_passwd_struct}
\end{figure}

La struttura usata da entrambe le funzioni è allocata staticamente, per questo
motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
fanno riferimento. Ovviamente questo implica che dette funzioni non posono
essere rientranti, per cui ne esistono anche due versioni alternative
(denotate dalla solita estensione \code{\_r}), i cui prototipi sono:
\begin{functions}
  \headdecl{pwd.h} 
  
  \headdecl{sys/types.h} 
  
  \funcdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
    char *buffer, size\_t buflen, struct passwd **result)}
  
  \funcdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
    *password, char *buffer, size\_t buflen, struct passwd **result)}

  Restituiscono le informazioni relative all'utente specificato.
  
  \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
    altrimenti, nel qual caso \var{errno} sarà settato opportunamente.}
\end{functions}

In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
la memoria necessaria a contenere le informazioni. In particolare i valori
della struttura \var{passwd} saranno restituiti all'indirizzo \param{password}
mentre la memoria allocata all'indirizzo \param{buffer}, per un massimo di
\param{buflen} byte, sarà utilizzata per contenere le stringhe puntate dai
campi di \param{password}. Infine all'indirizzo puntato da \param{result}
viene restituito il puntatore ai dati ottenuti, cioè \param{buffer} nel caso
l'utente esista, o \macro{NULL} altrimenti.  Qualora i dati non possano essere
contenuti nei byte specificati da \param{buflen}, la funzione fallirà
restituendo \macro{ERANGE} (e \param{result} sarà comunque settato a
\macro{NULL}).

Del tutto analoghe alle precedenti sono le funzioni \func{getgrnam} e
\func{getgrgid} (e le relative analoghe rientranti con la stessa estensione
\code{\_r}) che permettono di leggere le informazioni relative ai gruppi, i
loro prototipi sono:
\begin{functions}
  \headdecl{grp.h} 
  \headdecl{sys/types.h} 

  \funcdecl{struct group *getgrgid(gid\_t gid)} 
  
  \funcdecl{struct group *getgrnam(const char *name)} 
  
  \funcdecl{struct group *getpwuid\_r(gid\_t gid, struct group *password,
    char *buffer, size\_t buflen, struct group **result)}
  
  \funcdecl{struct group *getpwnam\_r(const char *name, struct group
    *password, char *buffer, size\_t buflen, struct group **result)}

  Restituiscono le informazioni relative al gruppo specificato.
  
  \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
    altrimenti, nel qual caso \var{errno} sarà settato opportunamente.}
\end{functions}

Il comportamento di tutte queste funzioni è assolutamente identico alle
precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
in questo caso le informazioni vengono restituite in una struttura di tipo
\type{group}, la cui definizione è riportata in \figref{fig:sys_group_struct}.

\begin{figure}[!htb]
  \footnotesize
  \centering
  \begin{minipage}[c]{15cm}
    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
struct group {
    char    *gr_name;        /* group name */
    char    *gr_passwd;      /* group password */
    gid_t   gr_gid;          /* group id */
    char    **gr_mem;        /* group members */
};
    \end{lstlisting}
  \end{minipage} 
  \normalsize 
  \caption{La struttura \var{group} contenente le informazioni relative ad un
    gruppo del sistema.}
  \label{fig:sys_group_struct}
\end{figure}

Le funzioni viste finora sono in grado di leggere le informazioni sia dal file
delle password in \file{/etc/passwd} che con qualunque altro metodo sia stato
utilizzato per mantenere il database degli utenti. Non permettono però di
settare direttamente le password; questo è possibile con un'altra interfaccia
al database degli utenti, derivata da SVID, che però funziona soltanto con un
database che sia tenuto su un file che abbia il formato classico di
\file{/etc/passwd}.

\begin{table}[htb]
  \footnotesize
  \centering
  \begin{tabular}[c]{|l|p{8cm}|}
    \hline
    \textbf{Funzione} & \textbf{Significato}\\
    \hline
    \hline
    \func{fgetpwent}   & Legge una voce dal database utenti da un file 
                         specificato aprendolo la prima volta.\\
    \func{fgetpwent\_r}& Come la precedente, ma rientrante.\\
    \func{getpwent}    & Legge una voce dal database utenti (da 
                         \file{/etc/passwd}) aprendolo la prima volta.\\
    \func{getpwent\_r} & Come la precedente, ma rientrante.\\
    \func{setpwent}    & Ritorna all'inizio del database.\\
    \func{putpwent}    & Immette una voce nel database utenti.\\
    \func{endpwent}    & Chiude il database degli utenti.\\
    \func{fgetgrent}   & Legge una voce dal database dei gruppi da un file 
                         specificato aprendolo la prima volta.\\
    \func{fgetgrent\_r}& Come la precedente, ma rientrante.\\
    \func{getgrent}    & Legge una voce dal database dei gruppi (da 
                         \file{/etc/passwd}) aprendolo la prima volta.\\
    \func{getgrent\_r} & Come la precedente, ma rientrante.\\
    \func{setgrent}    & Immette una voce nel database dei gruppi.\\
    \func{putgrent}    & Immette una voce nel database dei gruppi.\\
    \func{endgrent}    & Chiude il database dei gruppi.\\
    \hline
  \end{tabular}
  \caption{Funzioni per la manipolazione dei campi di un file usato come
    database di utenti e gruppi nel formato di \file{/etc/passwd} e
    \file{/etc/groups}.} 
  \label{tab:sys_passwd_func}
\end{table}

Dato che ormai la gran parte delle distribuzioni di Linux utilizzano PAM, che
come minimo usa almeno le \textit{shadow password} (quindi con delle modifiche
rispetto al formato classico di \file{/etc/passwd}), le funzioni che danno la
capacità scrivere delle voci nel database (cioè \func{putpwent} e
\func{putgrent}) non permettono di effettuarne una specificazione in maniera
completa. Per questo motivo l'uso di queste funzioni è deprecato in favore
dell'uso di PAM, ci limiteremo pertanto ad elencarle in
\tabref{tab:sys_passwd_func}, rimandando chi fosse interessato alle rispettive
man page e al manuale delle \acr{glibc} per i dettagli del loro funzionamento.



\subsection{Il database di accounting}
\label{sec:sys_accounting}

L'ultimo insieme di funzioni relative alla gestione del sistema che
esamineremo è quello che permette di accedere ai dati del database di
\textit{accounting}.  In esso vengono mantenute una serie di informazioni
storiche relative sia agli utenti che si sono collegati al sistema, (tanto per
quelli correntemente collegati, che per la registrazione degli accessi
precedenti), sia relative all'intero sistema, come il momento di lancio di
processi da parte di \cmd{init}, il cambiamento dell'orologio di sistema, il
cambiamento di runlevel o il riavvio della macchina.

I dati vengono usualmente\footnote{questa è la locazione specificata dal
  \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
  delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
\file{/var/log/wtmp}. Quando un utente si collega viene aggiunta una voce a
\file{/var/run/utmp} in cui viene memorizzato il nome di login, il terminale
da cui ci si collega, l'\acr{uid} della shell di login, l'orario della
connessione ed altre informazioni.  La voce resta nel file fino al logout,
quando viene cancellata e spostata in \file{/var/log/wtmp}.

In questo modo il primo file viene utilizzato per registrare sta utilizzando
il sistema al momento corrente, mentre il secondo mantiene la registrazione
delle attività degli utenti. A quest'ultimo vengono anche aggiunte delle voci
speciali per tenere conto dei cambiamenti del sistema, come la modifica del
runlevel, il riavvio della macchina, ecc. Tutte queste informazioni sono
descritte in dettaglio nel manuale delle \acr{glibc}.

Questi file non devono mai essere letti direttamente, ma le informazioni che
contengono possono essere ricavate attraverso le opportune funzioni di
libreria. Queste sono analoghe alle precedenti (vedi
\tabref{tab:sys_passwd_func}) usate per accedere al database degli utenti,
solo che in questo caso la struttura del database di accounting è molto più
complessa, dato che contiene diversi tipi di informazione.

Le prime tre funzioni, \func{setutent}, \func{endutent} e \func{utmpname}
servono rispettivamente a aprire e a chiudere il file che contiene il
database, e a specificare su quale file esso viene mantenuto. I loro prototipi
sono:
\begin{functions}
  \headdecl{utmp.h} 
  
  \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
  database di \textit{accounting}.
  
  \funcdecl{void setutent(void)} Apre il file del database di
  \textit{accounting}, posizionandosi al suo inizio.
  
  \funcdecl{void endutent(void)} Chiude il file del database di
  \textit{accounting}.
  
  \bodydesc{Le funzioni non ritornano codici di errore.}
\end{functions}

In caso questo non venga specificato nessun file viene usato il valore
standard \macro{\_PATH\_UTMP} (che è definito in \file{paths.h}); in genere
\func{utmpname} prevede due possibili valori:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\macro{\_PATH\_UTMP}] Specifica il database di accounting per gli utenti
  correntemente collegati.
\item[\macro{\_PATH\_WTMP}] Specifica il database di accounting per l'archivio
  storico degli utenti collegati.
\end{basedescript}
corrispondenti ai file \file{/var/run/utmp} e \file{/var/log/wtmp} visti in
precedenza.

Una volta aperto il file si può eseguire una scansione leggendo o scrivendo
una voce con le funzioni \func{getutent}, \func{getutid}, \func{getutline} e 
\func{pututline}, i cui prototipi sono:
\begin{functions}
  \headdecl{utmp.h} 

  \funcdecl{struct utmp *getutent(void)} 
  Legge una voce dal dalla posizione corrente nel database.
  
  \funcdecl{struct utmp *getutid(struct utmp *ut)} 
  Ricerca una voce sul database in base al contenuto di \param{ut}.

  \funcdecl{struct utmp *getutline(struct utmp *ut)} 
  Ricerca nel database la prima voce corrispondente ad un processo sulla linea
  di terminale specificata tramite \param{ut}.

  \funcdecl{struct utmp *pututline(struct utmp *ut)} 
  Scrive una voce nel database.

  \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
    caso di successo e \macro{NULL} in caso di errore.}
\end{functions}

Tutte queste funzioni fanno riferimento ad una struttura di tipo \var{utmp},
la cui definizione in Linux è riportata in \secref{fig:sys_utmp_struct}. Le
prime tre funzioni servono per leggere una voce dal database; \func{getutent}
legge semplicemente la prima voce disponibile; le altre due permettono di
eseguire una ricerca.

\begin{figure}[!htb]
  \footnotesize
  \centering
  \begin{minipage}[c]{15cm}
    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
struct utmp
{
    short int ut_type;            /* Type of login.  */
    pid_t ut_pid;                 /* Process ID of login process.  */
    char ut_line[UT_LINESIZE];    /* Devicename.  */
    char ut_id[4];                /* Inittab ID.  */
    char ut_user[UT_NAMESIZE];    /* Username.  */
    char ut_host[UT_HOSTSIZE];    /* Hostname for remote login.  */
    struct exit_status ut_exit;   /* Exit status of a process marked
                                     as DEAD_PROCESS.  */
    long int ut_session;          /* Session ID, used for windowing.  */
    struct timeval ut_tv;         /* Time entry was made.  */
    int32_t ut_addr_v6[4];        /* Internet address of remote host.  */
    char __unused[20];            /* Reserved for future use.  */
};
    \end{lstlisting}
  \end{minipage} 
  \normalsize 
  \caption{La struttura \var{utmp} contenente le informazioni di una voce del
    database di \textit{accounting}.}
  \label{fig:sys_utmp_struct}
\end{figure}

Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
campo \var{ut\_type} dell'argomento \param{ut}.  Questo può assumere i valori
riportati in \tabref{tab:sys_ut_type}, quando assume i valori
\macro{RUN\_LVL}, \macro{BOOT\_TIME}, \macro{OLD\_TIME}, \macro{NEW\_TIME},
verrà restituito la prima voce che corrisponde al tipo determinato; quando
invece assume i valori \macro{INIT\_PROCESS}, \macro{LOGIN\_PROCESS},
\macro{USER\_PROCESS} o \macro{DEAD\_PROCESS} verrà restiuita la prima voce
corripondente al valore del campo \var{ut\_id} specificato in \param{ut}.

\begin{table}[htb]
  \footnotesize
  \centering
  \begin{tabular}[c]{|l|p{8cm}|}
    \hline
    \textbf{Funzione} & \textbf{Significato}\\
    \hline
    \hline
    \macro{EMPTY}         & Non contiene informazioni valide. \\
    \macro{RUN\_LVL}      & Identica il runlevel del sistema. \\
    \macro{BOOT\_TIME}    & Identifica il tempo di avvio del sistema \\
    \macro{OLD\_TIME}     & Identifica quando è stato modificato l'orologio di
                            sistema. \\
    \macro{NEW\_TIME}     & Identifica da quanto è stato modificato il 
                            sistema. \\
    \macro{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}. \\
    \macro{LOGIN\_PROCESS}& Identifica un processo di login. \\
    \macro{USER\_PROCESS} & Identifica un processo utente. \\
    \macro{DEAD\_PROCESS} & Identifica un processo terminato. \\
    \macro{ACCOUNTING}    & ??? \\
    \hline
  \end{tabular}
  \caption{Classificazione delle voci del database di accounting a seconda dei
    possibili valori del campo \var{ut\_type}.} 
  \label{tab:sys_ut_type}
\end{table}

La funzione \func{getutline} esegue la ricerca sulle voci che hanno
\var{ut\_type} uguale a \macro{LOGIN\_PROCESS} o \macro{USER\_PROCESS},
restituendo la prima che corrisponde al valore di \var{ut\_line}, che
specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
terminale che interessa. Lo stesso criterio di ricerca è usato da
\func{pututline} per trovare uno spazio dove inserire la voce specificata,
qualora non sia trovata la voce viene aggiunta in coda al database.

In generale occorre però tenere conto che queste funzioni non sono
completamente standardizzate, e che in sistemi diversi possono esserci
differenze; ad esempio \func{pututline} restituisce \code{void} in vari
sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
fornita dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
sono un sovrainsieme di \code{utmp}. 

Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
inutili queste nuove strutture; pertanto esse e le relative funzioni di
gestione (\func{getutxent}, \func{getutxid}, \func{getutxline},
\func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
sinonimi delle funzioni appena viste.

Come visto in \secref{sec:sys_user_group}, l'uso di strutture allocate
staticamente rende le funzioni di lettura non rientranti; per questo motivo le
\acr{glibc} forniscono anche delle versioni rientranti: \func{getutent\_r},
\func{getutid\_r}, \func{getutline\_r}, che invece di restituire un puntatore
restituiscono un intero e prendono due argomenti aggiuntivi. Le funzioni si
comportano esattamente come le analoge non rientranti, solo che restituiscono
il risultato all'indirizzo specificato dal primo argomento aggiuntivo (di tipo
\code{struct utmp *buffer}) mentre il secondo (di tipo \code{struct utmp
  **result)} viene usato per restituire il puntatore allo stesso buffer.

Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
in \file{wmtp} altre due funzioni, \func{updwtmp} e \func{logwtmp}, i cui
prototipi sono:
\begin{functions}
  \headdecl{utmp.h} 
  
  \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
  Aggiunge la voce \param{ut} nel database di accounting \file{wmtp}.
  
  \funcdecl{void logwtmp(const char *line, const char *name, const char
    *host)} Aggiunge nel database di accounting una voce con i valori
  specificati.

  \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
    caso di successo e \macro{NULL} in caso di errore.}
\end{functions}

La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
direttamente una struttura \type{utmp}, mentre la seconda utilizza gli
argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
poi aggiunge chiamando \func{updwtmp}.


\section{Limitazione ed uso delle risorse}
\label{sec:sys_res_limits}


Dopo aver esaminato le funzioni che permettono di controllare le varie
caratteristiche, capacità e limiti del sistema a livello globale, in questa
sezione tratteremo le varie funzioni che vengono usate per quantificare le
risorse (CPU, memoria, ecc.)  utilizzate da ogni singolo processo e quelle che
permettono di imporre a ciascuno di essi vincoli e limiti di utilizzo.


\subsection{L'uso delle risorse}
\label{sec:sys_resource_use}

Come abbiamo accennato in \secref{sec:proc_wait4} le informazioni riguardo
l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
di tipo \code{struct }\type{rusage}, la cui definizione (che si trova in
\file{sys/resource.h}) è riportata in \figref{fig:sys_rusage_struct}.

\begin{figure}[!htb]
  \footnotesize
  \centering
  \begin{minipage}[c]{15cm}
    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
struct rusage {
    struct timeval ru_utime; /* user time used */
    struct timeval ru_stime; /* system time used */
    long ru_maxrss;          /* maximum resident set size */
    long ru_ixrss;           /* integral shared memory size */
    long ru_idrss;           /* integral unshared data size */
    long ru_isrss;           /* integral unshared stack size */
    long ru_minflt;          /* page reclaims */
    long ru_majflt;          /* page faults */
    long ru_nswap;           /* swaps */
    long ru_inblock;         /* block input operations */
    long ru_oublock;         /* block output operations */
    long ru_msgsnd;          /* messages sent */
    long ru_msgrcv;          /* messages received */
    long ru_nsignals;   ;    /* signals received */
    long ru_nvcsw;           /* voluntary context switches */
    long ru_nivcsw;          /* involuntary context switches */
};
    \end{lstlisting}
  \end{minipage} 
  \normalsize 
  \caption{La struttura \var{rusage} per la lettura delle informazioni dei 
    delle risorse usate da un processo.}
  \label{fig:sys_rusage_struct}
\end{figure}

La struttura è ripresa da BSD 4.3, ma attualmente (con i kernel della serie
2.4.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 e
corrispondono rispettivamente al numero di \textit{page fault}\index{page
  fault} (vedi \secref{sec:proc_mem_gen}) avvenuti senza richiedere I/O (i
cosiddetti \textit{minor page fault}), a quelli che invece han richiesto I/O
(detti invece \textit{major page fault}) ed al numero di volte che il processo
è stato completamente tolto dalla memoria per essere inserito nello swap.

In genere includere esplicitamente \file{<sys/time.h>} non è più necessario,
ma aumenta la portabilità, e serve comunque quando, come nella maggior parte
dei casi, si debba accedere ai campi di \var{rusage} relativi ai tempi di
utilizzo del processore, che sono definiti come \code{struct }\type{timeval}.


Questa è la stessa struttura utilizzata da \func{wait4}  per ricavare la
quantità di risorse impiegato dal processo di cui si è letto lo stato di
terminazione, ma essa può anche essere letta direttamente utilizzando la
funzione \func{getrusage}, il cui prototipo è:
\begin{functions}
  \headdecl{sys/time.h} 
  \headdecl{sys/resource.h} 
  \headdecl{unistd.h} 
  
  \funcdecl{int getrusage(int who, struct rusage *usage)} 
  Legge la quantità di risorse usate da un processo.


  \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
  nel qual caso \var{errno} può essere \macro{EINVAL} o \macro{EFAULT}.}
\end{functions}

L'argomento \param{who} permette di specificare il processo di cui si vuole
leggere l'uso delle risorse; esso può assumere solo i due valori
\macro{RUSAGE\_SELF} per indicare il processo corrente e
\macro{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
ricevuto lo stato di terminazione. 


\subsection{Limiti sulle risorse}
\label{sec:sys_resource_limit}

Come accennato nell'introduzione oltre a leggere l'uso delle risorse da parte
di un processo si possono anche imporre dei limiti sulle sue capacità. Ogni
processo ha in generale due limiti associati ad ogni risorsa; questi sono
detti il \textsl{limite corrente} (o \textit{current limit}) che esprime il
valore 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}.

In generale il primo viene chiamato un limite \textsl{soffice} (o \textit{soft
  limit}) dato che il suo valore può essere aumentato, mentre il secondo è
detto \textsl{duro} (o \textit{hard limit}), in quanto un processo normale non
può modificarne il valore. Il valore di questi limiti è mantenuto in una
struttura \var{rlimit}, la cui definizione è riportata in
\figref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a limite
corrente e massimo.

\begin{figure}[!htb]
  \footnotesize
  \centering
  \begin{minipage}[c]{15cm}
    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
    struct rlimit {
         rlim_t    rlim_cur;
         rlim_t    rlim_max;
    };
    \end{lstlisting}
  \end{minipage} 
  \normalsize 
  \caption{La struttura \var{rlimit} per impostare i limiti di utilizzo 
    delle risorse usate da un processo.}
  \label{fig:sys_rlimit_struct}
\end{figure}

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 far leggere o settare
i limiti di utilizzo delle risorse da parte di un processo le \acr{glibc}
prevedono due funzioni, \func{getrlimit} e \func{setrlimit}, i cui prototipi
sono:
\begin{functions}
  \headdecl{sys/time.h} 
  \headdecl{sys/resource.h} 
  \headdecl{unistd.h} 
  
  \funcdecl{int getrlimit(int resource, struct rlimit *rlim)} 

  Legge il limite corrente per la risorsa \param{resource}.
  
  \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)} 
  
  Setta il limite per la risorsa \param{resource}.
  
  \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
    errore, nel qual caso \var{errno} viene settata ai valori:
    \begin{errlist}
    \item[\macro{INVAL}] I valori per \param{resource} non sono validi.
    \item[\macro{EPERM}] Un processo senza i privilegi di amministratore ha
    cercato di innalzare i propri limiti.
    \end{errlist}
  ed \macro{EFAULT}.}
\end{functions}

Entrambe le funzioni permettono di specificare su quale risorsa si vuole
operare attraverso \param{resource}, i cui possibili valori sono elencati in
\secref{tab:sys_rlimit_values}, e utilizzano una struttura \var{rlimit} per
specificarne i valori.

\begin{table}[htb]
  \footnotesize
  \centering
  \begin{tabular}[c]{|l|p{12cm}|}
    \hline
    \textbf{Valore} & \textbf{Significato}\\
    \hline
    \hline
    \macro{RLIMIT\_CPU}    &  Il massimo tempo di CPU che il processo può
                              usare. Il superamento del limite comporta
                              l'emissione di un segnale di \macro{SIGXCPU}.\\
    \macro{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
                              \macro{SIGXFSZ}.\\
    \macro{RLIMIT\_DATA}   &  La massima dimensione della memoria dati di un
                              processo. Il tentatico di allocare più memoria
                              causa il fallimento della funzione di
                              allocazione. \\
    \macro{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 \macro{SIGSEGV}.\\
    \macro{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\\
    \macro{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.\\
    \macro{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
                              \macro{EAGAIN}.\\
    \macro{RLIMIT\_NOFILE} &  Il numero massimo di file che il processo può
                              aprire. L'apertura di un ulteriore file fallirà
                              con un errore \macro{EMFILE}.\\
    \macro{RLIMIT\_MEMLOCK}&  L'ammontare massimo di memoria che può essere
                              bloccata (vedi \secref{sec:proc_mem_lock}).\\
    \macro{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}

\footnotetext{Settare questo limite a zero è la maniera più semplice per
  evitare la creazione di \file{core} file.}

È inoltre definita la costante \macro{RLIM\_INFINITY} che permette di
sbloccare l'uso di una risorsa, ma 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 \secref{sec:proc_fork}) e
mantenuti attraverso una \func{exec} (vedi \secref{sec:proc_exec}).


\subsection{Le risorse di memoria e processore}
\label{sec:sys_memory_res}

La gestione della memoria è già stata affrontata in dettaglio in
\secref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
meccanismo della memoria virtuale attraverso la divisione della memoria fisica
in pagine.

In genere questo è del tutto trasparente al singolo processo, ma in certi
casi, come per l'I/O mappato in memoria (vedi \ref{sec:file_memory_map}) che
usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
gestire in maniera ottimale l'interazione della memoria allocata con il
meccanismo della paginazione.

Di solito la dimensione delle pagine di memoria è fissata dall'architettura
hardware, per cui in genere la dimensione delle pagine di memoria era una
costante definita in fase di compilazione, ma oggi alcune architetture (ad
esempio su Sun Sparc) permettono di variare questa dimensione, e non volendo
dover fornire binari diversi per ogni possibile modello, è necessario poter
utilizzare una funzione. 

In genere questa dimensione può essere ottenuta attraverso una chiamata a
\func{sysconf} come \func{sysconf(\_SC\_PAGESIZE)}, ma in BSD 4.2 è stata
introdotta una apposita funzione, \func{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.
  
  \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
    sono previsti errori.}
\end{prototype}

La funzione è prevista in SVr4, 4.4BSD e SUSv2, anche se questo ultimo
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
\macro{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.

Le \acr{glibc} forniscono, come specifica estensione GNU, altre due funzioni,
\func{get\_phys\_pages} e \func{get\_avphys\_pages} che permettono di ottenere
informazioni riguardo la memoria; i loro prototipi sono:
\begin{functions}
  \headdecl{sys/sysinfo.h} 
  
  \funcdecl{long int get\_phys\_pages(void)} 

  Legge il numero totale di pagine di memoria disponibili per il sistema.
  
  \funcdecl{long int get\_avphys\_pages(void)} 
  
  Legge il numero di pagine di memoria disponibili nel sistema. 
  
  \bodydesc{Le funzioni restituiscono il numero di pagine, }
\end{functions}

Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
rispettivamente con i parametri \macro{\_SC\_PHYS\_PAGES} e
\macro{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
corrispondenti alla RAM della macchina; la seconda invece la memoria
effettivamente disponibile per i processi.

Le \acr{glibc} supportano inoltre, come estenzioni GNU, due funzioni che
restituiscono il numero di processori della macchina (e quello dei processori
attivi); anche queste sono informazioni comunque ottenibili attraverso
\func{sysconf} utilizzando rispettivamente i parametri
\macro{\_SC\_NPROCESSORS\_CONF} e \macro{\_SC\_NPROCESSORS\_ONLN}.

Infine le \acr{glibc} riprendono da BSD la funzione \func{getloadavg} che
permette di ottenere il carico di processore della macchina, in questo modo è
possibile prendere decisioni su quando far partire eventuali nuovi processi.
Il suo prototipo è:
\begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
  Legge il carico medio della macchina.
  
  \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
    errore.}
\end{prototype}

La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
di processi attivi sulla coda dello scheduler, calcolato su un diverso
intervalli di tempo.  Il numero di intervalli che si vogliono leggere è
specificato da \param{nelem}, dato che nel caso di Linux il carico 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.



\section{La gestione dei tempi del sistema}
\label{sec:sys_time}

In questa sezione, una volta introdotti i concetti base della gestione dei
tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
veri tempi di sistema associati ai processi, a quelle per convertire i vari
tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
gestione di data e ora.


\subsection{La misura del tempo in Unix}
\label{sec:sys_unix_time}

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:
\begin{description}
\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
  \macro{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
    \secref{sec:proc_hierarchy}, è invece data dalla costante \macro{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
  ricavato anche attraverso \func{sysconf} (vedi \secref{sec:sys_sysconf}). Il
  vecchio simbolo \macro{CLK\_TCK} definito in \file{time.h} è ormai
  considerato obsoleto.
\end{description}

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}. 

Di solito questo tempo viene convertito automaticamente dal valore in UTC al
tempo locale, utilizzando le opportune informazioni di localizzazione
(specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
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:
\begin{description*}
\item[\textit{clock time}]: il tempo \textsl{reale} (viene chiamato anche
  \textit{wall clock time}) passato dall'avvio del processo. Chiaramente tale
  tempo dipende anche dal carico del sistema e da quanti altri processi
  stavano girando nello stesso periodo.
\item[\textit{user time}]: il tempo che la CPU ha impiegato nell'esecuzione
  delle istruzioni del processo in user space.
\item[\textit{system time}]: il tempo che la CPU ha impiegato nel kernel per
  eseguire delle system call per conto del processo.
\end{description*}

In genere la somma di \textit{user time} e \textit{system time} indica il
tempo di processore totale in cui il sistema è stato effettivamente impegnato
nell'eseguire un certo processo e viene chiamato \textit{CPU time} o
\textsl{tempo di CPU}.



\subsection{La gestione del \textit{process time}}
\label{sec:sys_cpu_times}

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. 

La funzione più semplice per leggere il \textit{process time} di un processo è
\func{clock}, che da una valutazione approssimativa del tempo di CPU
utilizzato dallo stesso; il suo prototipo è:
\begin{prototype}{time.h}{clock\_t clock(void)}
  Legge il valore corrente del tempo di CPU.
  
  \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
    caso di errore.}
\end{prototype}

La funzione restituisce il tempo in tick, quindi se si vuole il tempo in
secondi occorre moltiplicare il risultato per la costante
\macro{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
  POSIX richiede che \macro{CLOCKS\_PER\_SEC} sia definito pari a 1000000
  indipendetemente dalla risoluzione del timer di sistema.} In genere
\type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
riprenderà lo stesso valore iniziale.

Come accennato in \secref{sec:sys_unix_time} il tempo di CPU è la somma di
altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
possono essere letti attraverso la funzione \func{times}, il cui prototipo è:
\begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
  Legge in \param{buf} il valore corrente dei tempi di processore.
  
  \bodydesc{La funzione ritorna il numero di clock tick dall'avvio del sistema
    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 \var{tms}, la cui definizione è riportata in
\secref{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
\secref{sec:sys_unix_time}.

\begin{figure}[!htb]
  \footnotesize
  \centering
  \begin{minipage}[c]{15cm}
    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
    struct tms {
           clock_t tms_utime;  /* user time */
           clock_t tms_stime;  /* system time */
           clock_t tms_cutime; /* user time of children */
           clock_t tms_cstime; /* system time of children */
    };
    \end{lstlisting}
  \end{minipage} 
  \normalsize 
  \caption{La struttura \var{tms} dei tempi di processore associati a un
    processo.} 
  \label{fig:sys_tms_struct}
\end{figure}

Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
  time} ed del \textit{system time} di tutti i processi figli che sono
terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
\var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.

Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
ritornata. Per questo motivo se un figlio termina prima di altri suoi figli,
questi ``nipoti'' non potranno essere considerati nel calcolo di questi tempi.



\subsection{Le funzioni per il \textit{calendar time}}
\label{sec:sys_time_base}

Normalmente il \textit{calendar time} è mantenuto in una variabile di tipo
\type{time\_t}, che usualmente corrisponde ad un tipo nativo (in Linux è un
intero a 32 bit).  Le \acr{glibc} provvedono delle rappresentazioni
alternative che consentono un suo utilizzo per diversi scopi; in particolare
quando necessita manipolare


\begin{figure}[!htb]
  \footnotesize
  \centering
  \begin{minipage}[c]{15cm}
    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
struct timeval 
{
    long tv_sec;                /* seconds */
    long tv_usec;               /* microseconds */
};
    \end{lstlisting}
  \end{minipage} 
  \normalsize 
  \caption{La struttura \var{timeval} per il calendar time.}
  \label{fig:sys_timeval_struct}
\end{figure}




\section{La gestione degli errori}
\label{sec:sys_errors}

La gestione degli errori è in genere una materia complessa. Inoltre il modello
utilizzato dai sistema unix-like è basato sull'architettura a processi, e
presenta una serie di problemi nel caso lo si debba usare con i thread.
Esamineremo in questa sezione le sue caratteristiche principali.


\subsection{La variabile \var{errno}}
\label{sec:sys_errno}

Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
riportare condizioni di errore, ed è una buona norma di programmazione
controllare sempre che le funzioni chiamate si siano concluse correttamente.

In genere le funzioni di libreria usano un valore speciale per indicare che
c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
costante \macro{EOF} (a seconda della funzione); ma questo valore segnala solo
che c'è stato un errore, non il tipo di errore. 

Per riportare il tipo di errore il sistema usa la variabile globale
\var{errno},\footnote{L'uso di una variabile globale può comportare alcuni
  problemi (ad esempio nel caso dei thread) ma lo standard ISO C consente
  anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
  può anche usare una macro, e questo è infatti il modo usato da Linux per
  renderla locale ai singoli thread.} definita nell'header \file{errno.h}; la
variabile è in genere definita come \ctyp{volatile} dato che può essere
cambiata in modo asincrono da un segnale (si veda \ref{sec:sig_sigchld} per un
esempio, ricordando quanto trattato in \ref{sec:proc_race_cond}), ma dato che
un manipolatore di segnale scritto bene salva e ripristina il valore della
variabile, di questo non è necessario preoccuparsi nella programmazione
normale.

I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},
nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
costanti numeriche che identificano i vari errori; essi iniziano tutti per
\macro{E} e si possono considerare come nomi riservati. In seguito faremo
sempre riferimento a tali valori, quando descriveremo i possibili errori
restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
codice relativo ad un valore numerico con l'opzione \cmd{-l}.

Il valore di \var{errno} viene sempre settato a zero all'avvio di un
programma, gran parte delle funzioni di libreria settano \var{errno} ad un
valore diverso da zero in caso di errore. Il valore è invece indefinito in
caso di successo, perché anche se una funzione ha successo, può chiamarne
altre al suo interno che falliscono, modificando così \var{errno}.

Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
essere il risultato di un errore precedente) e non lo si può usare per
determinare quando o se una chiamata a funzione è fallita.  La procedura da
seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
verificato il fallimento della funzione attraverso il suo codice di ritorno.


\subsection{Le funzioni \func{strerror} e \func{perror}}
\label{sec:sys_strerror}

Benché gli errori siano identificati univocamente dal valore numerico di
\var{errno} le librerie provvedono alcune funzioni e variabili utili per
riportare in opportuni messaggi le condizioni di errore verificatesi.  La
prima funzione che si può usare per ricavare i messaggi di errore è
\func{strerror}, il cui prototipo è:
\begin{prototype}{string.h}{char *strerror(int errnum)} 
  Ritorna una stringa (statica) che descrive l'errore il cui codice è passato
  come parametro.
\end{prototype}

In generale \func{strerror} viene usata passando \var{errno} come parametro;
nel caso si specifichi un codice sbagliato verrà restituito un messaggio di
errore sconosciuto. La funzione utilizza una stringa statica che non deve
essere modificata dal programma e che è utilizzabile solo fino ad una chiamata
successiva a \func{strerror}; nel caso si usino i thread è
provvista\footnote{questa funzione è una estensione GNU, non fa parte dello
  standard POSIX.} una versione apposita:
\begin{prototype}{string.h}
{char *strerror\_r(int errnum, char *buff, size\_t size)} 
  Analoga a \func{strerror} ma ritorna il messaggio in un buffer
  specificato da \param{buff} di lunghezza massima (compreso il terminatore)
  \param{size}.
\end{prototype}
\noindent
che utilizza un buffer che il singolo thread deve allocare, per evitare i
problemi connessi alla condivisione del buffer statico. Infine, per completare
la caratterizzazione dell'errore, si può usare anche la variabile
globale\footnote{anche questa è un'estensione GNU.}
\var{program\_invocation\_short\_name} che riporta il nome del programma
attualmente in esecuzione.

Una seconda funzione usata per riportare i codici di errore in maniera
automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) è
\func{perror}, il cui prototipo è:
\begin{prototype}{stdio.h}{void perror (const char *message)} 
  Stampa il messaggio di errore relativo al valore corrente di \var{errno}
  sullo standard error; preceduto dalla stringa \var{message}.
\end{prototype}
i messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
in \capref{cha:errors}), e, usando il valore corrente di \var{errno}, si
riferiscono all'ultimo errore avvenuto. La stringa specificata con
\var{message} viene stampato prime del messaggio d'errore, seguita dai due
punti e da uno spazio, il messaggio è terminato con un a capo.

Il messaggio può essere riportato anche usando altre variabili globali
dichiarate in \file{errno.h}:
\begin{verbatim}
   const char *sys_errlist[];
   int sys_nerr;
\end{verbatim}
la prima contiene i puntatori alle stringhe di errore indicizzati da
\var{errno}; la seconda esprime il valore più alto per un codice di errore,
l'utilizzo di questa stringa è sostanzialmente equivalente a quello di
\func{strerror}.

In \nfig\ è riportata la sezione attinente del codice del programma
\cmd{errcode}, che può essere usato per stampare i messaggi di errore e le
costanti usate per identificare i singoli errori; il sorgente completo del
programma è allegato nel file \file{ErrCode.c} e contiene pure la gestione
delle opzioni e tutte le definizioni necessarie ad associare il valore
numerico alla costante simbolica. In particolare si è riportata la sezione che
converte la stringa passata come parametro in un intero (\texttt{\small
  1--2}), controllando con i valori di ritorno di \func{strtol} che la
conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi stampa,
a seconda dell'opzione scelta il messaggio di errore (\texttt{\small 11--14})
o la macro (\texttt{\small 15--17}) associate a quel codice.

\begin{figure}[!htb]
  \footnotesize
  \begin{lstlisting}{}
    /* convert string to number */
    err = strtol(argv[optind], NULL, 10);
    /* testing error condition on conversion */
    if (err==LONG_MIN) {
        perror("Underflow on error code");
        return 1;
    } else if (err==LONG_MIN) {
        perror("Overflow on error code");
        return 1;
    }
    /* conversion is fine */
    if (message) {
        printf("Error message for %d is %s\n", err, strerror(err));
    }
    if (label) {
        printf("Error label for %d is %s\n", err, err_code[err]);
    }
  \end{lstlisting}
  \caption{Codice per la stampa del messaggio di errore standard.}
  \label{fig:sys_err_mess}
\end{figure}



%%% Local Variables: 
%%% mode: latex
%%% TeX-master: "gapil"
%%% End: