system.tex

   1 \chapter{La gestione del sistema, delle risorse, e degli errori}
   2 \label{cha:system}
   3
   4 In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
   5 generali del sistema, come quelle per la gestione di parametri e
   6 configurazione, quelle per la lettura dei limiti e delle caratteristiche dello
   7 stesso, quelle per il controllo dell'uso delle risorse da parte dei processi,
   8 quelle per la gestione dei tempi e degli errori.
   9
  10
  11 \section{La lettura delle caratteristiche del sistema}
  12 \label{sec:sys_characteristics}
  13
  14 In questa sezione tratteremo le varie modalità con cui un programma può
  15 ottenere informazioni riguardo alle capacità del sistema. Ogni sistema infatti
  16 è contraddistinto da un gran numero di limiti e costanti che lo
  17 caratterizzano, e che possono dipendere da fattori molteplici, come
  18 l'architettura hardware, l'implementazione del kernel e delle librerie, le
  19 opzioni di configurazione.
  20
  21 La definizione di queste caratteristiche ed il tentativo di provvedere dei
  22 meccanismi generali che i programmi potessero usare per ricavarle è uno degli
  23 aspetti più complessi e controversi coi cui i vari standard si sono dovuti
  24 confrontare, spesso con risultati spesso tutt'altro che chiari. Proveremo
  25 comunque a dare una descrizione dei principali metodi previsti dai vari
  26 standard per ricavare sia le caratteristiche specifiche del sistema, che
  27 quelle dei file.
  28
  29
  30 \subsection{Limiti e parametri di sistema}
  31 \label{sec:sys_limits}
  32
  33 Quando si devono determinare le le caratteristiche generali del sistema ci si
  34 trova di fronte a diverse possibilità; alcune di queste infatti possono
  35 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
  36 interi), o dal sistema operativo (come la presenza o meno dei \textit{saved
  37   id}) , altre invece possono dipendere dalle opzioni con cui si è costruito
  38 il sistema (ad esempio da come si è compilato il kernel), o dalla
  39 configurazione del medesimo; per questo motivo in generale sono necessari due
  40 tipi diversi di funzionalità:
  41 \begin{itemize*}
  42 \item la possibilità di determinare limiti ed opzioni al momento della
  43   compilazione.
  44 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
  45 \end{itemize*}
  46
  47 La prima funzionalità si può ottenere includendo gli opportuni header file,
  48 mentre per la seconda sono ovviamente necessarie delle funzioni; la situazione
  49 è complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
  50 sono fissi in una implementazione mentre possono variare in un altra. Tutto
  51 questo crea una ambiguità che non è sempre possibile risolvere in maniera
  52 chiara; in generale quello che succede è che quando i limiti del sistema sono
  53 fissi essi vengono definiti come macro nel file \file{limits.h}, se invece
  54 possono variare, il loro valore sarà ottenibile tramite la funzione
  55 \func{sysconf} (che esamineremo in \secref{sec:sys_sysconf}).
  56
  57 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
  58 saranno sempre disponibili al momento della compilazione; un elenco, ripreso
  59 da \file{limits.h}, è riportato in \tabref{tab:sys_ansic_macro}. Come si può
  60 vedere per la maggior parte questi limiti attengono alle dimensioni dei dati
  61 interi, che sono in genere fissati dall'architettura hardware (le analoghe
  62 informazioni per i dati in virgola mobile sono definite a parte, ed
  63 accessibili includendo \file{float.h}). Lo standard prevede anche un'altra
  64 costante, \macro{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
  65 definita in \file{limits.h}; essa deve essere definita in \file{stdio.h} ed
  66 avere un valore minimo di 8.
  67
  68 \begin{table}[htb]
  69   \centering
  70   \footnotesize
  71   \begin{tabular}[c]{|l|r|l|}
  72     \hline
  73     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
  74     \hline
  75     \hline
  76     \macro{MB\_LEN\_MAX}&       16  & massima dimensione di un
  77                                       carattere multibyte\\
  78     \macro{CHAR\_BIT} &          8  & bit di \type{char}\\
  79     \macro{UCHAR\_MAX}&        255  & massimo di \type{unsigned char}\\
  80     \macro{SCHAR\_MIN}&       -128  & minimo di \type{signed char}\\
  81     \macro{SCHAR\_MAX}&        127  & massimo di \type{signed char}\\
  82     \macro{CHAR\_MIN} &\footnotemark& minimo di \type{char}\\
  83     \macro{CHAR\_MAX} &\footnotemark& massimo di \type{char}\\
  84     \macro{SHRT\_MIN} &     -32768  & minimo di \type{short}\\
  85     \macro{SHRT\_MAX} &      32767  & massimo di \type{short}\\
  86     \macro{USHRT\_MAX}&      65535  & massimo di \type{unsigned short}\\
  87     \macro{INT\_MAX}  & 2147483647  & minimo di \type{int}\\
  88     \macro{INT\_MIN}  &-2147483648  & minimo di \type{int}\\
  89     \macro{UINT\_MAX} & 4294967295  & massimo di \type{unsigned int}\\
  90     \macro{LONG\_MAX} & 2147483647  & massimo di \type{long}\\
  91     \macro{LONG\_MIN} &-2147483648  & minimo di \type{long}\\
  92     \macro{ULONG\_MAX}& 4294967295  & massimo di \type{unsigned long}\\
  93     \hline
  94   \end{tabular}
  95   \caption{Macro definite in \file{limits.h} in conformità allo standard
  96     ANSI C.}
  97   \label{tab:sys_ansic_macro}
  98 \end{table}
  99
 100 \footnotetext[1]{il valore può essere 0 o \macro{SCHAR\_MIN} a seconda che il
 101   sistema usi caratteri con segno o meno.}
 102
 103 \footnotetext[2]{il valore può essere \macro{UCHAR\_MAX} o \macro{SCHAR\_MAX}
 104   a seconda che il sistema usi caratteri con segno o meno.}
 105
 106 A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
 107 \type{long long} introdotto con il nuovo standard, i relativi valori sono in
 108 \tabref{tab:sys_isoc90_macro}.
 109
 110 \begin{table}[htb]
 111   \centering
 112   \footnotesize
 113   \begin{tabular}[c]{|l|r|l|}
 114     \hline
 115     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
 116     \hline
 117     \hline
 118     \macro{LLONG\_MAX}& 9223372036854775807& massimo di \type{long long}\\
 119     \macro{LLONG\_MIN}&-9223372036854775808& minimo di \type{long long}\\
 120     \macro{ULLONG\_MAX}&18446744073709551615&
 121     massimo di \type{unsigned long long}\\
 122     \hline
 123   \end{tabular}
 124   \caption{Macro definite in \file{limits.h} in conformità allo standard
 125     ISO C90.}
 126   \label{tab:sys_isoc90_macro}
 127 \end{table}
 128
 129 Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
 130 delle caratteristiche del sistema; mancano completamente tutte quelle che
 131 dipendono dalla implementazione dello stesso; questo per i sistemi unix-like è
 132 stato definito in gran parte dallo standard POSIX.1, che tratta anche i limiti
 133 delle caratteristiche dei file che vedremo in \secref{sec:sys_file_limits}.
 134
 135 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
 136 meno chiare\footnote{tanto che Stevens, in \cite{APUE}, la porta come esempio
 137   di ``standardese''.}, ad esempio lo standard prevede che ci siano 13 macro
 138 che descrivono le caratteristiche del sistema (7 per le caratteristiche
 139 generiche, riportate in \tabref{tab:sys_generic_macro}, e 6 per le
 140 caratteristiche dei file, riportate in \tabref{tab:sys_file_macro}).
 141
 142 \begin{table}[htb]
 143   \centering
 144   \footnotesize
 145   \begin{tabular}[c]{|l|r|p{8cm}|}
 146     \hline
 147     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
 148     \hline
 149     \hline
 150     \macro{ARG\_MAX} &131072& dimensione massima degli argomenti
 151                               passati ad una funzione della famiglia
 152                               \func{exec}.\\
 153     \macro{CHILD\_MAX} & 999& numero massimo di processi contemporanei
 154                               che un utente può eseguire.\\
 155     \macro{OPEN\_MAX}  & 256& numero massimo di file che un processo
 156                               può mantenere aperti in contemporanea.\\
 157     \macro{STREAM\_MAX}&   8& massimo numero di stream aperti per
 158                               processo in contemporanea.\\
 159     \macro{TZNAME\_MAX}&   6& dimensione massima del nome di una
 160                               \texttt{timezone} (vedi ).\\
 161     \macro{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
 162                               processo (vedi \secref{sec:proc_access_id}).\\
 163     \macro{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
 164     \hline
 165     \hline
 166   \end{tabular}
 167   \caption{Macro .}
 168   \label{tab:sys_generic_macro}
 169 \end{table}
 170
 171 Lo standard prevede che queste macro devono essere definite in \file{limits.h}
 172 quando i valori a cui fanno riferimento sono fissi, e altrimenti devono essere
 173 lasciate indefinite, ed i loro valori dei limiti devono essere accessibili
 174 solo attraverso \func{sysconf}.  Si tenga presente poi che alcuni di questi
 175 limiti possono assumere valori molto elevati (come \macro{CHILD\_MAX}), e non
 176 è pertanto il caso di utilizzarli per allocare staticamente della memoria.
 177
 178 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
 179 altre macro (che iniziano sempre con \code{\_POSIX\_}) che definiscono i
 180 valori minimi le stesse caratteristiche devono avere, perché una
 181 implementazione possa dichiararsi conforme allo standard; detti valori sono
 182 riportati in \tabref{tab:sys_posix1_base}.
 183
 184 \begin{table}[htb]
 185   \centering
 186   \footnotesize
 187   \begin{tabular}[c]{|l|r|p{8cm}|}
 188     \hline
 189     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
 190     \hline
 191     \hline
 192     \macro{\_POSIX\_ARG\_MAX}    & 4096& dimensione massima degli argomenti
 193                                          passati ad una funzione della famiglia
 194                                          \func{exec}.\\
 195     \macro{\_POSIX\_CHILD\_MAX}  &    6& numero massimo di processi
 196                                          contemporanei che un utente può
 197                                          eseguire.\\
 198     \macro{\_POSIX\_OPEN\_MAX}   &   16& numero massimo di file che un processo
 199                                          può mantenere aperti in
 200                                          contemporanea.\\
 201     \macro{\_POSIX\_STREAM\_MAX} &    8& massimo numero di stream aperti per
 202                                          processo in contemporanea.\\
 203     \macro{\_POSIX\_TZNAME\_MAX} &     & dimensione massima del nome di una
 204                                          \texttt{timezone} (vedi ).\\
 205     \macro{\_POSIX\_NGROUPS\_MAX}&    0& numero di gruppi supplementari per
 206                                          processo (vedi
 207                                          \secref{sec:proc_access_id}).\\
 208     \macro{\_POSIX\_SSIZE\_MAX}  &32767& valore massimo del tipo
 209                                          \type{ssize\_t}.\\
 210     \macro{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
 211     \macro{\_POSIX\_AIO\_MAX}    &    1& \\
 212     \hline
 213     \hline
 214   \end{tabular}
 215   \caption{Macro dei valori minimi delle caratteristiche generali del sistema
 216     per la conformità allo standard POSIX.1.}
 217   \label{tab:sys_posix1_general}
 218 \end{table}
 219
 220 In genere questi valori non servono a molto, la loro unica utilità è quella
 221 di indicare un limite superiore che assicura la portabilità senza necessità di
 222 ulteriori controlli. Tuttavia molti di essi sono troppo ristretti, ed
 223 ampiamente superati in tutti i sistemi POSIX in uso oggigiorno. Per questo è
 224 sempre meglio usare i valori provvisti da \func{sysconf}.
 225
 226 \begin{table}[htb]
 227   \centering
 228   \footnotesize
 229   \begin{tabular}[c]{|l|p{8cm}|}
 230     \hline
 231     \textbf{Macro}&\textbf{Significato}\\
 232     \hline
 233     \hline
 234     \macro{\_POSIX\_JOB\_CONTROL}& il sistema supporta il
 235                                    \textit{job control} (vedi
 236                                    \secref{sec:sess_xxx}).\\
 237     \macro{\_POSIX\_SAVED\_IDS}  & il sistema supporta i \textit{saved id}
 238                                    (vedi \secref{sec:proc_access_id}).
 239                                    per il controllo di accesso dei processi\\
 240     \macro{\_POSIX\_VERSION}     & fornisce la versione dello standard POSIX.1
 241                                    supportata nel formato YYYYMML (ad esempio
 242                                    199009L).\\
 243     \hline
 244   \end{tabular}
 245   \caption{Alcune macro definite in \file{limits.h} in conformità allo standard
 246     POSIX.1.}
 247   \label{tab:sys_posix1_other}
 248 \end{table}
 249
 250 Oltre ai precedenti valori (e a quelli elencati in
 251 \tabref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
 252 lo standard POSIX.1 ne prevede parecchi altri; in Linux la lista completa si
 253 può ricavare dall'header file \file{bits/posix1\_lim.h} (da non usare mai
 254 direttamente, è incluso automaticamente all'interno di \file{limits.h}); di
 255 questi vale la pena menzionare quelli di uso più comune, riportati in
 256 \tabref{tab:sys_posix1_other}, che permettono di ricavare alcune
 257 caratteristiche del sistema (come il supporto del \textit{job control} o dei
 258 \textit{saved id}).
 259
 260 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
 261 altre macro. Siccome queste sono principalmente attinenti a limiti relativi
 262 alle applicazioni di sistema presenti (come quelli su alcuni parametri delle
 263 espressioni regolari o del comando \cmd{bc}), non li tratteremo
 264 esplicitamente, se ne trova una menzione completa nell'header file
 265 \file{bits/posix2\_lim.h}, e alcuni di loro sono descritti nella man page di
 266 \func{sysconf} e nel manuale delle \acr{glibc}.
 267
 268
 269 \subsection{La funzione \func{sysconf}}
 270 \label{sec:sys_sysconf}
 271
 272 Come accennato in \secref{sec:sys_limits} quando uno dei limiti o delle
 273 caratteristiche del sistema può variare, è necessario ottenerne il valore
 274 attraverso la funzione \func{sysconf}, per non dover essere costretti a
 275 ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
 276 compilato il kernel, o alcuni dei parametri modificabili a run time. Il suo
 277 prototipo è:
 278 \begin{prototype}{unistd.h}{long sysconf(int name)}
 279   Restituisce il valore del parametro di sistema \param{name}.
 280
 281   \bodydesc{La funzione restituisce indietro il valore del parametro
 282     richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
 283     è disponibile e -1 in caso di errore (ma \var{errno} non viene settata).}
 284 \end{prototype}
 285
 286 La funzione prende come argomento un intero che specifica quale dei limiti si
 287 vuole conoscere; uno specchietto contenente i principali valori disponibili in
 288 Linux è riportato in \tabref{tab:sys_sysconf_par}; l'elenco completo è
 289 contenuto in \file{bits/confname}, ed una lista più esaustiva, con le relative
 290 spiegazioni, si può trovare nel manuale delle \acr{glibc}.
 291
 292 \begin{table}[htb]
 293   \centering
 294   \footnotesize
 295     \begin{tabular}[c]{|l|l|p{9cm}|}
 296       \hline
 297       \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
 298       \hline
 299       \hline
 300       \texttt{\_SC\_ARG\_MAX} &\macro{ARG\_MAX}&
 301       La dimensione massima degli argomenti passati ad una funzione
 302       della famiglia \func{exec}.\\
 303       \texttt{\_SC\_CHILD\_MAX}&\macro{\_CHILD\_MAX}&
 304       Il numero massimo di processi contemporanei che un utente può
 305       eseguire.\\
 306       \texttt{\_SC\_OPEN\_MAX}&\macro{\_OPEN\_MAX}&
 307       Il numero massimo di file che un processo può mantenere aperti in
 308       contemporanea.\\
 309       \texttt{\_SC\_STREAM\_MAX}& \macro{STREAM\_MAX}&
 310       Il massimo numero di stream che un processo può mantenere aperti in
 311       contemporanea. Questo limite previsto anche dallo standard ANSI C, che
 312       specifica la macro {FOPEN\_MAX}.\\
 313       \texttt{\_SC\_TZNAME\_MAX}&\macro{TZNAME\_MAX}&
 314       La dimensione massima di un nome di una \texttt{timezone} (vedi ).\\
 315       \texttt{\_SC\_NGROUPS\_MAX}&\macro{NGROUP\_MAX}&
 316       Massimo numero di gruppi supplementari che può avere un processo (vedi
 317       \secref{sec:proc_access_id}).\\
 318       \texttt{\_SC\_SSIZE\_MAX}&\macro{SSIZE\_MAX}&
 319       valore massimo del tipo di dato \type{ssize\_t}.\\
 320       \texttt{\_SC\_CLK\_TCK}& \macro{CLK\_TCK} &
 321       Il numero di \textit{clock tick} al secondo, cioè la frequenza delle
 322       interruzioni del timer di sistema (vedi \secref{sec:proc_priority}).\\
 323       \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
 324       Indica se è supportato il \textit{job control} (vedi
 325       \secref{sec:sess_xxx}) in stile POSIX.\\
 326       \texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
 327       Indica se il sistema supporta i \textit{saved id} (vedi
 328       \secref{sec:proc_access_id}).\\
 329       \texttt{\_SC\_VERSION}& \macro{\_POSIX\_VERSION} &
 330       Indica il mese e l'anno di approvazione della revisione dello standard
 331       POSIX.1 a cui il sistema fa riferimento, nel formato YYYYMML, la
 332       revisione più recente è 199009L, che indica il Settembre 1990.\\
 333      \hline
 334     \end{tabular}
 335   \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
 336   \label{tab:sys_sysconf_par}
 337 \end{table}
 338
 339 In generale ogni limite o caratteristica del sistema per cui è definita una
 340 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
 341 essere ottenuto attraverso una chiamata a \func{sysconf}. Il valore si otterrà
 342 speficando come valore del parametro \param{name} il nome ottenuto aggiungendo
 343 \code{\_SC\_} ai nomi delle macro definite dai primi due, o sostituendolo a
 344 \code{\_POSIX\_} per le macro definite dagli gli altri due.
 345
 346 In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
 347 macro non è definita, quindi con un codice analogo al seguente:
 348 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
 349 get_child_max(void)
 350 {
 351 #ifdef CHILD_MAX
 352     return CHILD_MAX;
 353 #else
 354     int val = sysconf(_SC_CHILD_MAX);
 355     if (val < 0) {
 356         perror("fatal error");
 357         exit(-1);
 358     }
 359     return val;
 360 }
 361 \end{lstlisting}
 362 ma in realtà in Linux queste macro sono comunque definite e indicando un
 363 limite generico, per cui è sempre meglio usare i valori restituiti da
 364 quest'ultima.
 365
 366
 367 \subsection{I limiti dei file}
 368 \label{sec:sys_file_limits}
 369
 370 Come per le caratteristiche generali del sistema anche per i file esistono una
 371 serie di limiti (come la lunghezza del nome del file o il numero massimo di
 372 link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
 373 in questo caso lo standard prevede alcune macro che ne specificano il valore,
 374 riportate in \tabref{tab:sys_file_macro}.
 375
 376 \begin{table}[htb]
 377   \centering
 378   \footnotesize
 379   \begin{tabular}[c]{|l|r|p{8cm}|}
 380     \hline
 381     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
 382     \hline
 383     \hline
 384     \macro{NAME\_MAX}&  14  & lunghezza in byte di un nome di file. \\
 385     \macro{PATH\_MAX}& 256  & lunghezza in byte di pathname.\\
 386     \macro{PIPE\_BUF}& 512  & byte scrivibili atomicamente in una pipe\\
 387     \macro{LINK\_MAX}   &8  & numero massimo di link a un file\\
 388     \macro{MAX\_CANON}&255  & spazio disponibile nella coda di input
 389                               canonica del terminale\\
 390     \macro{MAX\_INPUT}&255  & spazio disponibile nella coda di input
 391                               del terminale\\
 392     \hline
 393   \end{tabular}
 394   \caption{Macro per i limiti sulle caratteristiche dei file.}
 395   \label{tab:sys_file_macro}
 396 \end{table}
 397
 398 Come per i limiti di sistema POSIX.1 detta una serie di valori minimi per
 399 queste caratteristiche, che ogni sistema che vuole essere conforme deve
 400 rispettare; le relative macro sono riportate in \tabref{tab:sys_posix1_file},
 401 e per esse vale lo stesso discorso fatto per le analoghe di
 402 \tabref{tab:sys_posix1_general}.
 403
 404 \begin{table}[htb]
 405   \centering
 406   \footnotesize
 407   \begin{tabular}[c]{|l|r|p{8cm}|}
 408     \hline
 409     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
 410     \hline
 411     \hline
 412     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
 413     \macro{\_POSIX\_LINK\_MAX}   &8  & numero massimo di link a un file\\
 414     \macro{\_POSIX\_MAX\_CANON}&255  & spazio disponibile nella coda di input
 415                                        canonica del terminale\\
 416     \macro{\_POSIX\_MAX\_INPUT}&255  & spazio disponibile nella coda di input
 417                                        del terminale\\
 418     \macro{\_POSIX\_NAME\_MAX}&  14  & lunghezza in byte di un nome di file. \\
 419     \macro{\_POSIX\_PATH\_MAX}& 256  & lunghezza in byte di pathname.\\
 420     \macro{\_POSIX\_PIPE\_BUF}& 512  & byte scrivibili atomicamente in una
 421                                        pipe\\
 422     \macro{\_POSIX\_MQ\_OPEN\_MAX}&  8& \\
 423     \macro{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
 424     \macro{\_POSIX\_FD\_SETSIZE}& 16 & \\
 425     \macro{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
 426     \hline
 427   \end{tabular}
 428   \caption{Macro dei valori minimi delle caratteristiche dei file per la
 429     conformità allo standard POSIX.1.}
 430   \label{tab:sys_posix1_file}
 431 \end{table}
 432
 433 Tutti questi limiti sono definiti in \file{limits.h}; come nel caso precedente
 434 il loro uso è di scarsa utilità in quanto ampiamente superati in tutte le
 435 implementazioni moderne.
 436
 437
 438 \subsection{La funzione \func{pathconf}}
 439 \label{sec:sys_pathconf}
 440
 441 In generale i limiti per i file sono molto più soggetti ad essere variabili
 442 rispetto ai precedenti limiti generali del sistema; ad esempio parametri come
 443 la lunghezza del nome del file o il numero di link possono variare da
 444 filesystem a filesystem; per questo motivo questi limiti devono essere sempre
 445 controllati con la funzione \func{pathconf}, il cui prototipo è:
 446 \begin{prototype}{unistd.h}{long pathconf(char *path, int name)}
 447   Restituisce il valore del parametro \param{name} per il file \param{path}.
 448
 449   \bodydesc{La funzione restituisce indietro il valore del parametro
 450     richiesto, o -1 in caso di errore (ed \var{errno} viene settata ad uno
 451     degli errori possibili relativi all'accesso a \param{path}).}
 452 \end{prototype}
 453
 454 E si noti come la funzione in questo caso richieda un parametro che specifichi
 455 a quale file si fa riferimento, dato che il valore del limite cercato può
 456 variare a seconda del filesystem. Una seconda versione della funzione,
 457 \func{fpathconf}, opera su un file descriptor invece che su un pathname, il
 458 suo prototipo è:
 459 \begin{prototype}{unistd.h}{long fpathconf(int fd, int name)}
 460   Restituisce il valore del parametro \param{name} per il file \param{fd}.
 461
 462   \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
 463     invece di un pathname; pertanto gli errori restituiti cambiano di
 464     conseguenza.}
 465 \end{prototype}
 466 \noindent ed il suo comportamento è identico a quello di \func{fpathconf}.
 467
 468
 469 \subsection{La funzione \func{uname}}
 470 \label{sec:sys_uname}
 471
 472 Una altra funzione che si può utilizzare per raccogliere informazioni riguardo
 473 al sistema ed al computer su cui esso sta girando è \func{uname}, il suo
 474 prototipo è:
 475 \begin{prototype}{sys/utsname.h}{int uname(struct utsname *info)}
 476   Restituisce informazioni sul sistema nella struttura \param{info}.
 477
 478   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
 479   fallimento, nel qual caso \var{errno} viene settata a \macro{EFAULT}.}
 480 \end{prototype}
 481 \noindent la struttura è anch'essa definita in \file{sys/utsname.h} come:
 482 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
 483     struct utsname {
 484         char sysname[_UTSNAME_LENGTH];
 485         char nodename[_UTSNAME_LENGTH];
 486         char release[_UTSNAME_LENGTH];
 487         char version[_UTSNAME_LENGTH];
 488         char machine[_UTSNAME_LENGTH];
 489 #ifdef _GNU_SOURCE
 490         char domainname[_UTSNAME_DOMAIN_LENGTH];
 491 #endif
 492     };
 493 \end{lstlisting}
 494 ed i suoi menbri indicano rispettivamente:
 495 \begin{itemize*}
 496 \item il nome del systema operativo;
 497 \item il nome della release del kernel;
 498 \item il nome della versione del kernel;
 499 \item il tipo di macchina in uso;
 500 \item il nome della stazione;
 501 \item il nome del domino (è una estensione recente).
 502 \end{itemize*}
 503
 504
 505
 506 \section{Opzioni e configurazione del sistema}
 507 \label{sec:sys_config}
 508
 509 In questa sezione prenderemo in esame le funzioni per leggere e settare i vari
 510 parametri di configurazione del sistema.
 511
 512
 513 \subsection{La funzione \func{sysctl}}
 514 \label{sec:sys_sysctl}
 515
 516 \subsection{Il filesystem \file{/proc}}
 517 \label{sec:sys_proc_files}
 518
 519
 520 \subsection{La configurazione dei filesystem}
 521 \label{sec:sys_file_config}
 522
 523 \subsection{La funzione \func{statfs}}
 524 \label{sec:sys_file_stafs}
 525
 526
 527
 528 \section{Limitazione ed uso delle risorse}
 529 \label{sec:sys_res_limits}
 530
 531 In questa sezione esamineremo le funzioni che permettono di esaminare e
 532 controllare come le varie risorse del sistema (CPU, memoria, ecc.) vengono
 533 utilizzate dai processi, e le modalità con cui è possibile imporre dei limiti
 534 sul loro utilizzo.
 535
 536
 537
 538 \subsection{L'uso delle risorse}
 539 \label{sec:sys_resource_use}
 540
 541
 542 \subsection{Limiti sulle risorse}
 543 \label{sec:sys_resource_limit}
 544
 545
 546 \subsection{Le risorse di memoria}
 547 \label{sec:sys_memory_res}
 548
 549
 550 \subsection{Le risorse di processore}
 551 \label{sec:sys_cpu_load}
 552
 553
 554
 555 \begin{figure}[!htb]
 556   \footnotesize
 557   \centering
 558   \begin{minipage}[c]{15cm}
 559     \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
 560 struct rusage {
 561      struct timeval ru_utime; /* user time used */
 562      struct timeval ru_stime; /* system time used */
 563      long ru_maxrss;          /* maximum resident set size */
 564      long ru_ixrss;           /* integral shared memory size */
 565      long ru_idrss;           /* integral unshared data size */
 566      long ru_isrss;           /* integral unshared stack size */
 567      long ru_minflt;          /* page reclaims */
 568      long ru_majflt;          /* page faults */
 569      long ru_nswap;           /* swaps */
 570      long ru_inblock;         /* block input operations */
 571      long ru_oublock;         /* block output operations */
 572      long ru_msgsnd;          /* messages sent */
 573      long ru_msgrcv;          /* messages received */
 574      long ru_nsignals;   ;    /* signals received */
 575      long ru_nvcsw;           /* voluntary context switches */
 576      long ru_nivcsw;          /* involuntary context switches */
 577 };
 578     \end{lstlisting}
 579   \end{minipage}
 580   \normalsize
 581   \caption{La struttura \var{rusage} per la lettura delle informazioni dei
 582     delle risorse usate da un processo.}
 583   \label{fig:sys_rusage_struct}
 584 \end{figure}
 585
 586
 587
 588
 589 \var{tms\_utime}, \var{tms\_stime}, \var{tms\_cutime}, \var{tms\_uetime}
 590
 591
 592
 593 \section{La gestione dei tempi del sistema}
 594 \label{sec:sys_time}
 595
 596 In questa sezione tratteremo le varie funzioni per la gestione delle
 597 date e del tempo in un sistema unix-like, e quelle per convertire i vari
 598 tempi nelle differenti rappresentazioni che vengono utilizzate.
 599
 600
 601 \subsection{La misura del tempo in unix}
 602 \label{sec:sys_unix_time}
 603
 604 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti
 605 valori per i tempi all'interno del sistema, essi sono rispettivamente
 606 chiamati \textit{calendar time} e \textit{process time}, secondo le
 607 definizioni:
 608 \begin{itemize}
 609 \item \textit{calendar time}: è il numero di secondi dalla mezzanotte del
 610   primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
 611   usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
 612     Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
 613   dato che l'UTC corrisponde all'ora locale di Greenwich.  È il tempo su cui
 614   viene mantenuto l'orologio del calcolatore, e viene usato ad esempio per
 615   indicare le date di modifica dei file o quelle di avvio dei processi. Per
 616   memorizzare questo tempo è stato riservato il tipo primitivo \type{time\_t}.
 617 \item \textit{process time}: talvolta anche detto tempo di CPU. Viene misurato
 618   in \textit{clock tick}, corrispondenti al numero di interruzioni effettuate
 619   dal timer di sistema, e che per Linux avvengono ogni centesimo di
 620   secondo\footnote{eccetto per la piattaforma alpha dove avvengono ogni
 621     millesimo di secondo}. Il dato primitivo usato per questo tempo è
 622   \type{clock\_t}, inoltre la costante \macro{HZ} restituisce la frequenza di
 623   operazione del timer, e corrisponde dunque al numero di tick al secondo.  Lo
 624   standard POSIX definisce allo stesso modo la costante \macro{CLK\_TCK});
 625   questo valore può comunque essere ottenuto con \func{sysconf} (vedi
 626   \secref{sec:sys_limits}).
 627 \end{itemize}
 628
 629 In genere si usa il \textit{calendar time} per tenere le date dei file e le
 630 informazioni analoghe che riguardano i tempi di ``orologio'', usati ad esempio
 631 per i demoni che compiono lavori amministrativi ad ore definite, come
 632 \cmd{cron}. Di solito questo vene convertito automaticamente dal valore in UTC
 633 al tempo locale, utilizzando le opportune informazioni di localizzazione
 634 (specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
 635 mantenuto dal sistema e non corrisponde all'orologio hardware del calcolatore.
 636
 637 Il \textit{process time} di solito si esprime in secondi e viene usato appunto
 638 per tenere conto dei tempi di esecuzione dei processi. Per ciascun processo il
 639 kernel tiene tre di questi tempi:
 640 \begin{itemize*}
 641 \item \textit{clock time}
 642 \item \textit{user time}
 643 \item \textit{system time}
 644 \end{itemize*}
 645 il primo è il tempo ``reale'' (viene anche chiamato \textit{wall clock time})
 646 dall'avvio del processo, e misura il tempo trascorso fino alla sua
 647 conclusione; chiaramente un tale tempo dipende anche dal carico del sistema e
 648 da quanti altri processi stavano girando nello stesso periodo. Il secondo
 649 tempo è quello che la CPU ha speso nell'esecuzione delle istruzioni del
 650 processo in user space. Il terzo è il tempo impiegato dal kernel per eseguire
 651 delle system call per conto del processo medesimo (tipo quello usato per
 652 eseguire una \func{write} su un file). In genere la somma di user e system
 653 time viene chiamato \textit{CPU time}.
 654
 655
 656
 657
 658
 659 \section{La gestione degli errori}
 660 \label{sec:sys_errors}
 661
 662 La gestione degli errori è in genere una materia complessa. Inoltre il modello
 663 utilizzato dai sistema unix-like è basato sull'architettura a processi, e
 664 presenta una serie di problemi nel caso lo si debba usare con i thread.
 665 Esamineremo in questa sezione le sue caratteristiche principali.
 666
 667
 668 \subsection{La variabile \var{errno}}
 669 \label{sec:sys_errno}
 670
 671 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
 672 riportare condizioni di errore, ed è una buona norma di programmazione
 673 controllare sempre che le funzioni chiamate si siano concluse correttamente.
 674
 675 In genere le funzioni di libreria usano un valore speciale per indicare che
 676 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
 677 costante \macro{EOF} (a seconda della funzione); ma questo valore segnala solo
 678 che c'è stato un errore, non il tipo di errore.
 679
 680 Per riportare il tipo di errore il sistema usa la variabile globale
 681 \var{errno}\footnote{L'uso di una variabile globale può comportare alcuni
 682   problemi (ad esempio nel caso dei thread) ma lo standard ISO C consente
 683   anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
 684   può anche usare una macro, e questo è infatti il modo usato da Linux per
 685   renderla locale ai singoli thread.}, definita nell'header \file{errno.h}; la
 686 variabile è in genere definita come \type{volatile} dato che può essere
 687 cambiata in modo asincrono da un segnale (per una descrizione dei segnali si
 688 veda \secref{cha:signals}), ma dato che un manipolatore di segnale scritto
 689 bene salva e ripristina il valore della variabile, di questo non è necessario
 690 preoccuparsi nella programmazione normale.
 691
 692 I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},
 693 nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
 694 costanti numeriche che identificano i vari errori; essi iniziano tutti per
 695 \macro{E} e si possono considerare come nomi riservati. In seguito faremo
 696 sempre riferimento a tali valori, quando descriveremo i possibili errori
 697 restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
 698 codice relativo ad un valore numerico con l'opzione \cmd{-l}.
 699
 700 Il valore di \var{errno} viene sempre settato a zero all'avvio di un
 701 programma, gran parte delle funzioni di libreria settano \var{errno} ad un
 702 valore diverso da zero in caso di errore. Il valore è invece indefinito in
 703 caso di successo, perché anche se una funzione ha successo, può chiamarne
 704 altre al suo interno che falliscono, modificando così \var{errno}.
 705
 706 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
 707 essere il risultato di un errore precedente) e non lo si può usare per
 708 determinare quando o se una chiamata a funzione è fallita.  La procedura da
 709 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
 710 verificato il fallimento della funzione attraverso il suo codice di ritorno.
 711
 712
 713 \subsection{Le funzioni \func{strerror} e \func{perror}}
 714 \label{sec:sys_strerror}
 715
 716 Benché gli errori siano identificati univocamente dal valore numerico di
 717 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
 718 riportare in opportuni messaggi le condizioni di errore verificatesi.  La
 719 prima funzione che si può usare per ricavare i messaggi di errore è
 720 \func{strerror}, il cui prototipo è:
 721 \begin{prototype}{string.h}{char *strerror(int errnum)}
 722   Ritorna una stringa (statica) che descrive l'errore il cui codice è passato
 723   come parametro.
 724 \end{prototype}
 725
 726 In generale \func{strerror} viene usata passando \var{errno} come parametro;
 727 nel caso si specifichi un codice sbagliato verrà restituito un messaggio di
 728 errore sconosciuto. La funzione utilizza una stringa statica che non deve
 729 essere modificata dal programma e che è utilizzabile solo fino ad una chiamata
 730 successiva a \func{strerror}; nel caso si usino i thread è
 731 provvista\footnote{questa funzione è una estensione GNU, non fa parte dello
 732   standard POSIX} una versione apposita:
 733 \begin{prototype}{string.h}
 734 {char *strerror\_r(int errnum, char *buff, size\_t size)}
 735   Analoga a \func{strerror} ma ritorna il messaggio in un buffer
 736   specificato da \param{buff} di lunghezza massima (compreso il terminatore)
 737   \param{size}.
 738 \end{prototype}
 739 \noindent
 740 che utilizza un buffer che il singolo thread deve allocare, per evitare i
 741 problemi connessi alla condivisione del buffer statico. Infine, per completare
 742 la caratterizzazione dell'errore, si può usare anche la variabile
 743 globale\footnote{anche questa è una estensione GNU}
 744 \var{program\_invocation\_short\_name} che riporta il nome del programma
 745 attualmente in esecuzione.
 746
 747 Una seconda funzione usata per riportare i codici di errore in maniera
 748 automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) è
 749 \func{perror}, il cui prototipo è:
 750 \begin{prototype}{stdio.h}{void perror (const char *message)}
 751   Stampa il messaggio di errore relativo al valore corrente di \var{errno}
 752   sullo standard error; preceduto dalla stringa \var{message}.
 753 \end{prototype}
 754 i messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
 755 in \capref{cha:errors}), e, usando il valore corrente di \var{errno}, si
 756 riferiscono all'ultimo errore avvenuto. La stringa specificata con
 757 \var{message} viene stampato prime del messaggio d'errore, seguita dai due
 758 punti e da uno spazio, il messaggio è terminato con un a capo.
 759
 760 Il messaggio può essere riportato anche usando altre variabili globali
 761 dichiarate in \file{errno.h}:
 762 \begin{verbatim}
 763    const char *sys_errlist[];
 764    int sys_nerr;
 765 \end{verbatim}
 766 la prima contiene i puntatori alle stringhe di errore indicizzati da
 767 \var{errno}; la seconda esprime il valore più alto per un codice di errore,
 768 l'utilizzo di questa stringa è sostanzialmente equivalente a quello di
 769 \func{strerror}.
 770
 771 In \nfig\ è riportata la sezione attinente del codice del programma
 772 \cmd{errcode}, che può essere usato per stampare i messaggi di errore e le
 773 costanti usate per identificare i singoli errori; il sorgente completo del
 774 programma è allegato nel file \file{ErrCode.c} e contiene pure la gestione
 775 delle opzioni e tutte le definizioni necessarie ad associare il valore
 776 numerico alla costante simbolica. In particolare si è riportata la sezione che
 777 converte la stringa passata come parametro in un intero (\texttt{\small
 778   1--2}), controllando con i valori di ritorno di \func{strtol} che la
 779 conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi stampa,
 780 a seconda dell'opzione scelta il messaggio di errore (\texttt{\small 11--14})
 781 o la macro (\texttt{\small 15--17}) associate a quel codice.
 782
 783 \begin{figure}[!htb]
 784   \footnotesize
 785   \begin{lstlisting}{}
 786     /* convert string to number */
 787     err = strtol(argv[optind], NULL, 10);
 788     /* testing error condition on conversion */
 789     if (err==LONG_MIN) {
 790         perror("Underflow on error code");
 791         return 1;
 792     } else if (err==LONG_MIN) {
 793         perror("Overflow on error code");
 794         return 1;
 795     }
 796     /* conversion is fine */
 797     if (message) {
 798         printf("Error message for %d is %s\n", err, strerror(err));
 799     }
 800     if (label) {
 801         printf("Error label for %d is %s\n", err, err_code[err]);
 802     }
 803   \end{lstlisting}
 804   \caption{Codice per la stampa del messaggio di errore standard.}
 805   \label{fig:sys_err_mess}
 806 \end{figure}
 807
 808
 809 \section{La gestione di utenti e gruppi}
 810 \label{sec:sys_user_group}
 811
 812
 813 %%% Local Variables:
 814 %%% mode: latex
 815 %%% TeX-master: "gapil"
 816 %%% End: