system.tex

   1 \chapter{La gestione del sistema}
   2 \label{cha:system}
   3
   4 In questo capitolo si è raccolta le trattazione delle varie funzioni
   5 concernenti la gestione generale del sistema che permettono di trattare le
   6 varie informazioni ad esso connesse, i limiti sulle risorse, la gestione dei
   7 tempi, degli errori e degli utenti ed in generale la gestione dei vari
   8 parametri di configurazione dei vari componenti del sistema.
   9
  10
  11 \section{La gestione della configurazione del sistema}
  12 \label{sec:sys_config}
  13
  14
  15 \subsection{Opzioni e configurazione del systema}
  16 \label{sec:sys_sys_config}
  17
  18 La funzione \func{sysconf} ...
  19
  20 \subsection{La configurazione dei file}
  21 \label{sec:sys_file_config}
  22
  23 La funzione \func{statfs} ...
  24
  25 La funzione \func{pathconf} ...
  26
  27
  28 \section{La gestione delle risorse e dei limiti di sistema}
  29 \label{sec:sys_limits}
  30
  31 In questa sezione esamimeremo le funzioni che permettono di gestire le varie
  32 risorse associate ad un processo ed i relativi limiti, e quelle relatica al
  33 sistema in quanto tale.
  34
  35
  36 \begin{figure}[!htb]
  37   \footnotesize
  38   \centering
  39   \begin{minipage}[c]{15cm}
  40     \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
  41 struct rusage {
  42      struct timeval ru_utime; /* user time used */
  43      struct timeval ru_stime; /* system time used */
  44      long ru_maxrss;          /* maximum resident set size */
  45      long ru_ixrss;           /* integral shared memory size */
  46      long ru_idrss;           /* integral unshared data size */
  47      long ru_isrss;           /* integral unshared stack size */
  48      long ru_minflt;          /* page reclaims */
  49      long ru_majflt;          /* page faults */
  50      long ru_nswap;           /* swaps */
  51      long ru_inblock;         /* block input operations */
  52      long ru_oublock;         /* block output operations */
  53      long ru_msgsnd;          /* messages sent */
  54      long ru_msgrcv;          /* messages received */
  55      long ru_nsignals;   ;    /* signals received */
  56      long ru_nvcsw;           /* voluntary context switches */
  57      long ru_nivcsw;          /* involuntary context switches */
  58 };
  59     \end{lstlisting}
  60   \end{minipage}
  61   \normalsize
  62   \caption{La struttura \var{rusage} per la lettura delle informazioni dei
  63     delle risorse usate da un processo.}
  64   \label{fig:sys_rusage_struct}
  65 \end{figure}
  66
  67
  68
  69
  70 \var{tms\_utime}, \var{tms\_stime}, \var{tms\_cutime}, \var{tms\_uetime}
  71
  72
  73
  74 \section{La gestione dei tempi del sistema}
  75 \label{sec:sys_time}
  76
  77 In questa sezione tratteremo le varie funzioni per la gestione delle
  78 date e del tempo in un sistema unix-like, e quelle per convertire i vari
  79 tempi nelle differenti rappresentazioni che vengono utilizzate.
  80
  81
  82 \subsection{La misura del tempo in unix}
  83 \label{sec:sys_unix_time}
  84
  85 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti
  86 valori per i tempi all'interno del sistema, essi sono rispettivamente
  87 chiamati \textit{calendar time} e \textit{process time}, secondo le
  88 definizioni:
  89 \begin{itemize}
  90 \item \textit{calendar time}: è il numero di secondi dalla mezzanotte del
  91   primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
  92   usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
  93     Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
  94   dato che l'UTC corrisponde all'ora locale di Greenwich.  È il tempo su cui
  95   viene mantenuto l'orologio del calcolatore, e viene usato ad esempio per
  96   indicare le date di modifica dei file o quelle di avvio dei processi. Per
  97   memorizzare questo tempo è stato riservato il tipo primitivo \type{time\_t}.
  98 \item \textit{process time}: talvolta anche detto tempo di CPU. Viene misurato
  99   in \textit{clock tick}, corrispondenti al numero di interruzioni effettuate
 100   dal timer di sistema, e che per Linux avvengono ogni centesimo di
 101   secondo\footnote{eccetto per la piattaforma alpha dove avvengono ogni
 102     millesimo di secondo}. Il dato primitivo usato per questo tempo è
 103   \type{clock\_t}, inoltre la costante \macro{HZ} restituisce la frequenza di
 104   operazione del timer, e corrisponde dunque al numero di tick al secondo.  Lo
 105   standard POSIX definisce allo stesso modo la costante \macro{CLK\_TCK});
 106   questo valore può comunque essere ottenuto con \func{sysconf} (vedi
 107   \secref{sec:sys_limits}).
 108 \end{itemize}
 109
 110 In genere si usa il \textit{calendar time} per tenere le date dei file e le
 111 informazioni analoghe che riguardano i tempi di ``orologio'', usati ad esempio
 112 per i demoni che compiono lavori amministrativi ad ore definite, come
 113 \cmd{cron}. Di solito questo vene convertito automaticamente dal valore in UTC
 114 al tempo locale, utilizzando le opportune informazioni di localizzazione
 115 (specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
 116 mantenuto dal sistema e non corrisponde all'orologio hardware del calcolatore.
 117
 118 Il \textit{process time} di solito si esprime in secondi e viene usato appunto
 119 per tenere conto dei tempi di esecuzione dei processi. Per ciascun processo il
 120 kernel tiene tre di questi tempi:
 121 \begin{itemize*}
 122 \item \textit{clock time}
 123 \item \textit{user time}
 124 \item \textit{system time}
 125 \end{itemize*}
 126 il primo è il tempo ``reale'' (viene anche chiamato \textit{wall clock time})
 127 dall'avvio del processo, e misura il tempo trascorso fino alla sua
 128 conclusione; chiaramente un tale tempo dipende anche dal carico del sistema e
 129 da quanti altri processi stavano girando nello stesso periodo. Il secondo
 130 tempo è quello che la CPU ha speso nell'esecuzione delle istruzioni del
 131 processo in user space. Il terzo è il tempo impiegato dal kernel per eseguire
 132 delle system call per conto del processo medesimo (tipo quello usato per
 133 eseguire una \func{write} su un file). In genere la somma di user e system
 134 time viene chiamato \textit{CPU time}.
 135
 136
 137
 138
 139
 140 \section{La gestione degli errori}
 141 \label{sec:sys_errors}
 142
 143 La gestione degli errori è in genere una materia complessa. Inoltre il modello
 144 utilizzato dai sistema unix-like è basato sull'architettura a processi, e
 145 presenta una serie di problemi nel caso lo si debba usare con i thread.
 146 Esamineremo in questa sezione le sue caratteristiche principali.
 147
 148
 149 \subsection{La variabile \var{errno}}
 150 \label{sec:sys_errno}
 151
 152 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
 153 riportare condizioni di errore, ed è una buona norma di programmazione
 154 controllare sempre che le funzioni chiamate si siano concluse correttamente.
 155
 156 In genere le funzioni di libreria usano un valore speciale per indicare che
 157 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
 158 costante \macro{EOF} (a seconda della funzione); ma questo valore segnala solo
 159 che c'è stato un errore, non il tipo di errore.
 160
 161 Per riportare il tipo di errore il sistema usa la variabile globale
 162 \var{errno}\footnote{L'uso di una variabile globale può comportare alcuni
 163   problemi (ad esempio nel caso dei thread) ma lo standard ISO C consente
 164   anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
 165   può anche usare una macro, e questo è infatti il modo usato da Linux per
 166   renderla locale ai singoli thread }, definita nell'header \file{errno.h}, la
 167 variabile è in genere definita come \type{volatile} dato che può essere
 168 cambiata in modo asincrono da un segnale (per una descrizione dei segnali si
 169 veda \secref{cha:signals}), ma dato che un manipolatore di segnale scritto
 170 bene salva e ripristina il valore della variabile, di questo non è necessario
 171 preoccuparsi nella programmazione normale.
 172
 173 I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},
 174 nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
 175 costanti numeriche che identificano i vari errori; essi iniziano tutti per
 176 \macro{E} e si possono considerare come nomi riservati. In seguito faremo
 177 sempre rifermento a tali valori, quando descriveremo i possibili errori
 178 restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
 179 codice relativo ad un valore numerico con l'opzione \cmd{-l}.
 180
 181 Il valore di \var{errno} viene sempre settato a zero all'avvio di un
 182 programma, gran parte delle funzioni di libreria settano \var{errno} ad un
 183 valore diverso da zero in caso di errore. Il valore è invece indefinito in
 184 caso di successo, perché anche se una funzione ha successo, può chiamarne
 185 altre al suo interno che falliscono, modificando così \var{errno}.
 186
 187 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
 188 essere il risultato di un errore precedente) e non lo si può usare per
 189 determinare quando o se una chiamata a funzione è fallita.  La procedura da
 190 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
 191 verificato il fallimento della funzione attraverso il suo codice di ritorno.
 192
 193
 194 \subsection{Le funzioni \func{strerror} e \func{perror}}
 195 \label{sec:sys_strerror}
 196
 197 Benché gli errori siano identificati univocamente dal valore numerico di
 198 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
 199 riportare in opportuni messaggi le condizioni di errore verificatesi.  La
 200 prima funzione che si può usare per ricavare i messaggi di errore è
 201 \func{strerror}, il cui prototipo è:
 202 \begin{prototype}{string.h}{char * strerror(int errnum)}
 203   Ritorna una stringa (statica) che descrive l'errore il cui codice è passato
 204   come parametro.
 205 \end{prototype}
 206
 207 In generale \func{strerror} viene usata passando \var{errno} come parametro;
 208 nel caso si specifichi un codice sbagliato verrà restituito un messaggio di
 209 errore sconosciuto. La funzione utilizza una stringa statica che non deve
 210 essere modificata dal programma e che è utilizzabile solo fino ad una chiamata
 211 successiva a \func{strerror}; nel caso si usino i thread è
 212 provvista\footnote{questa funzione è una estensione GNU, non fa parte dello
 213   standard POSIX} una versione apposita:
 214 \begin{prototype}{string.h}
 215 {char * strerror\_r(int errnum, char * buff, size\_t size)}
 216   Analoga a \func{strerror} ma ritorna il messaggio in un buffer
 217   specificato da \param{buff} di lunghezza massima (compreso il terminatore)
 218   \param{size}.
 219 \end{prototype}
 220 \noindent
 221 che utilizza un buffer che il singolo thread deve allocare, per evitare i
 222 problemi connessi alla condivisione del buffer statico. Infine, per completare
 223 la caratterizzazione dell'errore, si può usare anche la variabile
 224 globale\footnote{anche questa è una estensione GNU}
 225 \var{program\_invocation\_short\_name} che riporta il nome del programma
 226 attualmente in esecuzione.
 227
 228 Una seconda funzione usata per riportare i codici di errore in maniera
 229 automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) è
 230 \func{perror}, il cui prototipo è:
 231 \begin{prototype}{stdio.h}{void perror (const char *message)}
 232   Stampa il messaggio di errore relativo al valore corrente di \var{errno}
 233   sullo standard error; preceduto dalla stringa \var{message}.
 234 \end{prototype}
 235 i messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
 236 in \capref{cha:errors}), e, usando il valore corrente di \var{errno}, si
 237 riferiscono all'ultimo errore avvenuto. La stringa specificata con
 238 \var{message} viene stampato prime del messaggio d'errore, seguita dai due
 239 punti e da uno spazio, il messaggio è terminato con un a capo.
 240
 241 Il messaggio può essere riportato anche usando altre variabili globali
 242 dichiarate in \file{errno.h}:
 243 \begin{verbatim}
 244    const char *sys_errlist[];
 245    int sys_nerr;
 246 \end{verbatim}
 247 la prima contiene i puntatori alle stringhe di errore indicizzati da
 248 \var{errno}; la seconda esprime il valore più alto per un codice di errore,
 249 l'utilizzo di questa stringa è sostanzialmente equivalente a quello di
 250 \func{strerror}.
 251
 252 In \nfig\ è riportata la sezione attinente del codice del programma
 253 \cmd{errcode}, che può essere usato per stampare i messaggi di errore e le
 254 costanti usate per identificare i singoli errori; il sorgente completo del
 255 programma è allegato nel file \file{ErrCode.c} e contiene pure la gestione
 256 delle opzioni e tutte le definizioni necessarie ad associare il valore
 257 numerico alla costante simbolica. In particolare si è riportata la sezione che
 258 converte la stringa passata come parametro in un intero (\texttt{\small
 259   1--2}), controllando con i valori di ritorno di \func{strtol} che la
 260 conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi stampa,
 261 a seconda dell'opzione scelta il messaggio di errore (\texttt{\small 11--14})
 262 o la macro (\texttt{\small 15--17}) associate a quel codice.
 263
 264 \begin{figure}[!htb]
 265   \footnotesize
 266   \begin{lstlisting}{}
 267     /* convert string to number */
 268     err = strtol(argv[optind], NULL, 10);
 269     /* testing error condition on conversion */
 270     if (err==LONG_MIN) {
 271         perror("Underflow on error code");
 272         return 1;
 273     } else if (err==LONG_MIN) {
 274         perror("Overflow on error code");
 275         return 1;
 276     }
 277     /* conversion is fine */
 278     if (message) {
 279         printf("Error message for %d is %s\n", err, strerror(err));
 280     }
 281     if (label) {
 282         printf("Error label for %d is %s\n", err, err_code[err]);
 283     }
 284   \end{lstlisting}
 285   \caption{Codice per la stampa del messaggio di errore standard.}
 286   \label{fig:sys_err_mess}
 287 \end{figure}
 288
 289
 290 \section{La gestione di utenti e gruppi}
 291 \label{sec:sys_user_group}
 292
 293
 294 %%% Local Variables:
 295 %%% mode: latex
 296 %%% TeX-master: "gapil"
 297 %%% End: