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