Finito, spero, con i tempi
[gapil.git] / 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 dei parametri e della
6 configurazione dello stesso, quelle per la lettura dei limiti e delle
7 caratteristiche, quelle per il controllo dell'uso delle risorse dei processi,
8 quelle per la gestione ed il controllo dei filesystem, degli utenti, dei tempi
9 e degli errori.
10
11
12
13 \section{La lettura delle caratteristiche del sistema}
14 \label{sec:sys_characteristics}
15
16 In questa sezione tratteremo le varie modalità con cui un programma può
17 ottenere informazioni riguardo alle capacità del sistema. Ogni sistema
18 unix-like infatti è contraddistinto da un gran numero di limiti e costanti che
19 lo caratterizzano, e che possono dipendere da fattori molteplici, come
20 l'architettura hardware, l'implementazione del kernel e delle librerie, le
21 opzioni di configurazione.
22
23 La definizione di queste caratteristiche ed il tentativo di provvedere dei
24 meccanismi generali che i programmi potessero usare per ricavarle è uno degli
25 aspetti più complessi e controversi con cui le diverse standardizzazioni si
26 sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
27 Proveremo comunque a dare una descrizione dei principali metodi previsti dai
28 vari standard per ricavare sia le caratteristiche specifiche del sistema, che
29 quelle della gestione dei file.
30
31
32 \subsection{Limiti e parametri di sistema}
33 \label{sec:sys_limits}
34
35 Quando si devono determinare le le caratteristiche generali del sistema ci si
36 trova di fronte a diverse possibilità; alcune di queste infatti possono
37 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
38 interi), o dal sistema operativo (come la presenza o meno dei \textit{saved
39   id}), altre invece possono dipendere dalle opzioni con cui si è costruito
40 il sistema (ad esempio da come si è compilato il kernel), o dalla
41 configurazione del medesimo; per questo motivo in generale sono necessari due
42 tipi diversi di funzionalità:
43 \begin{itemize*}
44 \item la possibilità di determinare limiti ed opzioni al momento della
45   compilazione.
46 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
47 \end{itemize*}
48
49 La prima funzionalità si può ottenere includendo gli opportuni header file che
50 contengono le costanti necessarie definite come macro di preprocessore, per la
51 seconda invece sono ovviamente necessarie delle funzioni. La situazione è
52 complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
53 sono fissi in un'implementazione mentre possono variare in un altra. Tutto
54 questo crea una ambiguità che non è sempre possibile risolvere in maniera
55 chiara; in generale quello che succede è che quando i limiti del sistema sono
56 fissi essi vengono definiti come macro di preprocessore nel file
57 \file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
58 tramite la funzione \func{sysconf} (che esamineremo in
59 \secref{sec:sys_sysconf}).
60
61 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
62 saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
63 da \file{limits.h}, è riportato in \tabref{tab:sys_ansic_macro}. Come si può
64 vedere per la maggior parte questi limiti attengono alle dimensioni dei dati
65 interi, che sono in genere fissati dall'architettura hardware (le analoghe
66 informazioni per i dati in virgola mobile sono definite a parte, ed
67 accessibili includendo \file{float.h}). Lo standard prevede anche un'altra
68 costante, \macro{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
69 definita in \file{limits.h}; essa deve essere definita in \file{stdio.h} ed
70 avere un valore minimo di 8.
71
72 \begin{table}[htb]
73   \centering
74   \footnotesize
75   \begin{tabular}[c]{|l|r|l|}
76     \hline
77     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
78     \hline
79     \hline
80     \macro{MB\_LEN\_MAX}&       16  & massima dimensione di un 
81                                       carattere esteso\\
82     \macro{CHAR\_BIT} &          8  & bit di \ctyp{char}\\
83     \macro{UCHAR\_MAX}&        255  & massimo di \ctyp{unsigned char}\\
84     \macro{SCHAR\_MIN}&       -128  & minimo di \ctyp{signed char}\\
85     \macro{SCHAR\_MAX}&        127  & massimo di \ctyp{signed char}\\
86     \macro{CHAR\_MIN} &\footnotemark& minimo di \ctyp{char}\\
87     \macro{CHAR\_MAX} &\footnotemark& massimo di \ctyp{char}\\
88     \macro{SHRT\_MIN} &     -32768  & minimo di \ctyp{short}\\
89     \macro{SHRT\_MAX} &      32767  & massimo di \ctyp{short}\\
90     \macro{USHRT\_MAX}&      65535  & massimo di \ctyp{unsigned short}\\
91     \macro{INT\_MAX}  & 2147483647  & minimo di \ctyp{int}\\
92     \macro{INT\_MIN}  &-2147483648  & minimo di \ctyp{int}\\
93     \macro{UINT\_MAX} & 4294967295  & massimo di \ctyp{unsigned int}\\
94     \macro{LONG\_MAX} & 2147483647  & massimo di \ctyp{long}\\
95     \macro{LONG\_MIN} &-2147483648  & minimo di \ctyp{long}\\
96     \macro{ULONG\_MAX}& 4294967295  & massimo di \ctyp{unsigned long}\\
97     \hline                
98   \end{tabular}
99   \caption{Costanti definite in \file{limits.h} in conformità allo standard
100     ANSI C.}
101   \label{tab:sys_ansic_macro}
102 \end{table}
103
104 \footnotetext[1]{il valore può essere 0 o \macro{SCHAR\_MIN} a seconda che il
105   sistema usi caratteri con segno o meno.} 
106
107 \footnotetext[2]{il valore può essere \macro{UCHAR\_MAX} o \macro{SCHAR\_MAX}
108   a seconda che il sistema usi caratteri con segno o meno.}
109
110 A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
111 \ctyp{long long} introdotto con il nuovo standard, i relativi valori sono in
112 \tabref{tab:sys_isoc90_macro}.
113
114 \begin{table}[htb]
115   \centering
116   \footnotesize
117   \begin{tabular}[c]{|l|r|l|}
118     \hline
119     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
120     \hline
121     \hline
122     \macro{LLONG\_MAX}& 9223372036854775807& massimo di \ctyp{long long}\\
123     \macro{LLONG\_MIN}&-9223372036854775808& minimo di \ctyp{long long}\\
124     \macro{ULLONG\_MAX}&18446744073709551615&
125     massimo di \ctyp{unsigned long long}\\
126     \hline                
127   \end{tabular}
128   \caption{Macro definite in \file{limits.h} in conformità allo standard
129     ISO C90.}
130   \label{tab:sys_isoc90_macro}
131 \end{table}
132
133 Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
134 delle caratteristiche del sistema; mancano completamente tutte quelle che
135 dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
136 sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
137 limiti relativi alle caratteristiche dei file che vedremo in
138 \secref{sec:sys_file_limits}.
139
140 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
141 meno chiare\footnote{tanto che Stevens, in \cite{APUE}, la porta come esempio
142   di ``standardese''.}. Lo standard prevede che ci siano 13 macro che
143 descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
144 riportate in \tabref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
145 file, riportate in \tabref{tab:sys_file_macro}).
146
147 \begin{table}[htb]
148   \centering
149   \footnotesize
150   \begin{tabular}[c]{|l|r|p{8cm}|}
151     \hline
152     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
153     \hline
154     \hline
155     \macro{ARG\_MAX} &131072& dimensione massima degli argomenti
156                               passati ad una funzione della famiglia
157                               \func{exec}.\\ 
158     \macro{CHILD\_MAX} & 999& numero massimo di processi contemporanei
159                               che un utente può eseguire.\\
160     \macro{OPEN\_MAX}  & 256& numero massimo di file che un processo
161                               può mantenere aperti in contemporanea.\\
162     \macro{STREAM\_MAX}&   8& massimo numero di stream aperti per
163                               processo in contemporanea.\\
164     \macro{TZNAME\_MAX}&   6& dimensione massima del nome di una
165                               \texttt{timezone} (vedi ).\\ 
166     \macro{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
167                               processo (vedi \secref{sec:proc_access_id}).\\
168     \macro{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
169     \hline
170     \hline
171   \end{tabular}
172   \caption{Costanti per i limiti del sistema.}
173   \label{tab:sys_generic_macro}
174 \end{table}
175
176 Lo standard dice che queste macro devono essere definite in \file{limits.h}
177 quando i valori a cui fanno riferimento sono fissi, e altrimenti devono essere
178 lasciate indefinite, ed i loro valori dei limiti devono essere accessibili
179 solo attraverso \func{sysconf}.  In realtà queste vengono sempre definite ad
180 un valore generico. Si tenga presente poi che alcuni di questi limiti possono
181 assumere valori molto elevati (come \macro{CHILD\_MAX}), e non è pertanto il
182 caso di utilizzarli per allocare staticamente della memoria.
183
184 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
185 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
186 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
187 implementazione possa dichiararsi conforme allo standard; detti valori sono
188 riportati in \tabref{tab:sys_posix1_general}.
189
190 \begin{table}[htb]
191   \centering
192   \footnotesize
193   \begin{tabular}[c]{|l|r|p{8cm}|}
194     \hline
195     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
196     \hline
197     \hline
198     \macro{\_POSIX\_ARG\_MAX}    & 4096& dimensione massima degli argomenti
199                                          passati ad una funzione della famiglia
200                                          \func{exec}.\\ 
201     \macro{\_POSIX\_CHILD\_MAX}  &    6& numero massimo di processi
202                                          contemporanei che un utente può 
203                                          eseguire.\\
204     \macro{\_POSIX\_OPEN\_MAX}   &   16& numero massimo di file che un processo
205                                          può mantenere aperti in 
206                                          contemporanea.\\
207     \macro{\_POSIX\_STREAM\_MAX} &    8& massimo numero di stream aperti per
208                                          processo in contemporanea.\\
209     \macro{\_POSIX\_TZNAME\_MAX} &     & dimensione massima del nome di una
210                                          \texttt{timezone} (vedi ).\\ 
211     \macro{\_POSIX\_NGROUPS\_MAX}&    0& numero di gruppi supplementari per
212                                          processo (vedi 
213                                          \secref{sec:proc_access_id}).\\
214     \macro{\_POSIX\_SSIZE\_MAX}  &32767& valore massimo del tipo 
215                                          \type{ssize\_t}.\\
216     \macro{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
217     \macro{\_POSIX\_AIO\_MAX}    &    1& \\
218     \hline                
219     \hline                
220   \end{tabular}
221   \caption{Macro dei valori minimi delle caratteristiche generali del sistema
222     per la conformità allo standard POSIX.1.}
223   \label{tab:sys_posix1_general}
224 \end{table}
225
226 In genere questi valori non servono a molto, la loro unica utilità è quella di
227 indicare un limite superiore che assicura la portabilità senza necessità di
228 ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
229 i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
230 valori ottenuti da \func{sysconf}.
231
232 \begin{table}[htb]
233   \centering
234   \footnotesize
235   \begin{tabular}[c]{|l|p{8cm}|}
236     \hline
237     \textbf{Macro}&\textbf{Significato}\\
238     \hline
239     \hline
240     \macro{\_POSIX\_JOB\_CONTROL}& il sistema supporta il 
241                                    \textit{job control} (vedi 
242                                    \secref{sec:sess_xxx}).\\
243     \macro{\_POSIX\_SAVED\_IDS}  & il sistema supporta i \textit{saved id} 
244                                    (vedi \secref{sec:proc_access_id}). 
245                                    per il controllo di accesso dei processi\\
246     \macro{\_POSIX\_VERSION}     & fornisce la versione dello standard POSIX.1
247                                    supportata nel formato YYYYMML (ad esempio 
248                                    199009L).\\
249     \hline
250   \end{tabular}
251   \caption{Alcune macro definite in \file{limits.h} in conformità allo standard
252     POSIX.1.}
253   \label{tab:sys_posix1_other}
254 \end{table}
255
256 Oltre ai precedenti valori (e a quelli relativi ai file elencati in
257 \tabref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
258 lo standard POSIX.1 ne prevede parecchi altri.  La lista completa si trova
259 dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
260 incluso automaticamente all'interno di \file{limits.h}). Di questi vale la
261 pena menzionare alcune macro di uso comune, (riportate in
262 \tabref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
263 denotano la presenza di alcune funzionalità nel sistema (come il supporto del
264 \textit{job control} o dei \textit{saved id}).
265
266 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
267 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
268 alle applicazioni di sistema presenti (come quelli su alcuni parametri delle
269 espressioni regolari o del comando \cmd{bc}), non li tratteremo
270 esplicitamente, se ne trova una menzione completa nell'header file
271 \file{bits/posix2\_lim.h}, e alcuni di loro sono descritti nella man page di
272 \func{sysconf} e nel manuale delle \acr{glibc}.
273
274
275 \subsection{La funzione \func{sysconf}}
276 \label{sec:sys_sysconf}
277
278 Come accennato in \secref{sec:sys_limits} quando uno dei limiti o delle
279 caratteristiche del sistema può variare, per non dover essere costretti a
280 ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
281 compilato il kernel, o alcuni dei parametri modificabili a run time, è
282 necessario ottenerne il valore attraverso la funzione \func{sysconf}. Il
283 prototipo di questa funzione è:
284 \begin{prototype}{unistd.h}{long sysconf(int name)}
285   Restituisce il valore del parametro di sistema \param{name}.
286   
287   \bodydesc{La funzione restituisce indietro il valore del parametro
288     richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
289     è disponibile e -1 in caso di errore (ma \var{errno} non viene settata).}
290 \end{prototype}
291
292 La funzione prende come argomento un intero che specifica quale dei limiti si
293 vuole conoscere; uno specchietto contenente i principali valori disponibili in
294 Linux è riportato in \tabref{tab:sys_sysconf_par}; l'elenco completo è
295 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
296 relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
297
298 \begin{table}[htb]
299   \centering
300   \footnotesize
301     \begin{tabular}[c]{|l|l|p{9cm}|}
302       \hline
303       \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
304       \hline
305       \hline
306       \texttt{\_SC\_ARG\_MAX} &\macro{ARG\_MAX}&
307       La dimensione massima degli argomenti passati ad una funzione
308       della famiglia \func{exec}.\\
309       \texttt{\_SC\_CHILD\_MAX}&\macro{\_CHILD\_MAX}&
310       Il numero massimo di processi contemporanei che un utente può
311       eseguire.\\
312       \texttt{\_SC\_OPEN\_MAX}&\macro{\_OPEN\_MAX}&
313       Il numero massimo di file che un processo può mantenere aperti in
314       contemporanea.\\
315       \texttt{\_SC\_STREAM\_MAX}& \macro{STREAM\_MAX}&
316       Il massimo numero di stream che un processo può mantenere aperti in
317       contemporanea. Questo limite previsto anche dallo standard ANSI C, che
318       specifica la macro {FOPEN\_MAX}.\\
319       \texttt{\_SC\_TZNAME\_MAX}&\macro{TZNAME\_MAX}&
320       La dimensione massima di un nome di una \texttt{timezone} (vedi ).\\
321       \texttt{\_SC\_NGROUPS\_MAX}&\macro{NGROUP\_MAX}&
322       Massimo numero di gruppi supplementari che può avere un processo (vedi
323       \secref{sec:proc_access_id}).\\ 
324       \texttt{\_SC\_SSIZE\_MAX}&\macro{SSIZE\_MAX}& 
325       valore massimo del tipo di dato \type{ssize\_t}.\\
326       \texttt{\_SC\_CLK\_TCK}& \macro{CLK\_TCK} &
327       Il numero di \textit{clock tick} al secondo, cioè l'unità di misura del
328       \textit{process time} (vedi \secref{sec:sys_unix_time}).\\
329       \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
330       Indica se è supportato il \textit{job control} (vedi
331       \secref{sec:sess_xxx}) in stile POSIX.\\
332       \texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
333       Indica se il sistema supporta i \textit{saved id} (vedi
334       \secref{sec:proc_access_id}).\\ 
335       \texttt{\_SC\_VERSION}& \macro{\_POSIX\_VERSION} &
336       Indica il mese e l'anno di approvazione della revisione dello standard
337       POSIX.1 a cui il sistema fa riferimento, nel formato YYYYMML, la
338       revisione più recente è 199009L, che indica il Settembre 1990.\\
339      \hline
340     \end{tabular}
341   \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
342   \label{tab:sys_sysconf_par}
343 \end{table}
344
345 In generale ogni limite o caratteristica del sistema per cui è definita una
346 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
347 essere ottenuto attraverso una chiamata a \func{sysconf}. Il valore si otterrà
348 specificando come valore del parametro \param{name} il nome ottenuto
349 aggiungendo \code{\_SC\_} ai nomi delle macro definite dai primi due, o
350 sostituendolo a \code{\_POSIX\_} per le macro definite dagli gli altri due.
351
352 In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
353 macro non è definita, quindi con un codice analogo al seguente:
354 %\footnotesize
355 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
356 get_child_max(void)
357 {
358 #ifdef CHILD_MAX
359     return CHILD_MAX;
360 #else
361     int val = sysconf(_SC_CHILD_MAX);
362     if (val < 0) {
363         perror("fatal error");
364         exit(-1);
365     }
366     return val;
367 }
368 \end{lstlisting}
369 %\normalsize 
370 ma in realtà in Linux queste macro sono comunque definite, indicando però un
371 limite generico. Per questo motivo è sempre meglio usare i valori restituiti
372 da \func{sysconf}.
373
374
375 \subsection{I limiti dei file}
376 \label{sec:sys_file_limits}
377
378 Come per le caratteristiche generali del sistema anche per i file esistono una
379 serie di limiti (come la lunghezza del nome del file o il numero massimo di
380 link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
381 in questo caso lo standard prevede alcune macro che ne specificano il valore,
382 riportate in \tabref{tab:sys_file_macro}.
383
384 \begin{table}[htb]
385   \centering
386   \footnotesize
387   \begin{tabular}[c]{|l|r|p{8cm}|}
388     \hline
389     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
390     \hline
391     \hline                
392     \macro{NAME\_MAX}&  14  & lunghezza in byte di un nome di file. \\
393     \macro{PATH\_MAX}& 256  & lunghezza in byte di pathname.\\
394     \macro{PIPE\_BUF}& 512  & byte scrivibili atomicamente in una pipe\\
395     \macro{LINK\_MAX}   &8  & numero massimo di link a un file\\
396     \macro{MAX\_CANON}&255  & spazio disponibile nella coda di input
397                               canonica del terminale\\
398     \macro{MAX\_INPUT}&255  & spazio disponibile nella coda di input 
399                               del terminale\\
400     \hline                
401   \end{tabular}
402   \caption{Macro per i limiti sulle caratteristiche dei file.}
403   \label{tab:sys_file_macro}
404 \end{table}
405
406 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
407 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
408 conforme deve rispettare; le relative macro sono riportate in
409 \tabref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per le
410 analoghe di \tabref{tab:sys_posix1_general}.
411
412 \begin{table}[htb]
413   \centering
414   \footnotesize
415   \begin{tabular}[c]{|l|r|p{8cm}|}
416     \hline
417     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
418     \hline
419     \hline
420     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
421     \macro{\_POSIX\_LINK\_MAX}   &8  & numero massimo di link a un file\\
422     \macro{\_POSIX\_MAX\_CANON}&255  & spazio disponibile nella coda di input
423                                        canonica del terminale\\
424     \macro{\_POSIX\_MAX\_INPUT}&255  & spazio disponibile nella coda di input 
425                                        del terminale\\
426     \macro{\_POSIX\_NAME\_MAX}&  14  & lunghezza in byte di un nome di file. \\
427     \macro{\_POSIX\_PATH\_MAX}& 256  & lunghezza in byte di pathname.\\
428     \macro{\_POSIX\_PIPE\_BUF}& 512  & byte scrivibili atomicamente in una
429                                        pipe\\
430 %    \macro{\_POSIX\_MQ\_OPEN\_MAX}&  8& \\
431 %    \macro{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
432 %    \macro{\_POSIX\_FD\_SETSIZE}& 16 & \\
433 %    \macro{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
434     \hline
435   \end{tabular}
436   \caption{Macro dei valori minimi delle caratteristiche dei file per la
437     conformità allo standard POSIX.1.}
438   \label{tab:sys_posix1_file}
439 \end{table}
440
441 Tutti questi limiti sono definiti in \file{limits.h}; come nel caso precedente
442 il loro uso è di scarsa utilità in quanto ampiamente superati in tutte le
443 implementazioni moderne.
444
445
446 \subsection{La funzione \func{pathconf}}
447 \label{sec:sys_pathconf}
448
449 In generale i limiti per i file sono molto più soggetti ad essere variabili
450 rispetto ai limiti generali del sistema; ad esempio parametri come la
451 lunghezza del nome del file o il numero di link possono variare da filesystem
452 a filesystem; per questo motivo questi limiti devono essere sempre controllati
453 con la funzione \func{pathconf}, il cui prototipo è:
454 \begin{prototype}{unistd.h}{long pathconf(char *path, int name)}
455   Restituisce il valore del parametro \param{name} per il file \param{path}.
456   
457   \bodydesc{La funzione restituisce indietro il valore del parametro
458     richiesto, o -1 in caso di errore (ed \var{errno} viene settata ad uno
459     degli errori possibili relativi all'accesso a \param{path}).}
460 \end{prototype}
461
462 E si noti come la funzione in questo caso richieda un parametro che specifichi
463 a quale file si fa riferimento, dato che il valore del limite cercato può
464 variare a seconda del filesystem. Una seconda versione della funzione,
465 \func{fpathconf}, opera su un file descriptor invece che su un pathname. Il
466 suo prototipo è:
467 \begin{prototype}{unistd.h}{long fpathconf(int fd, int name)}
468   Restituisce il valore del parametro \param{name} per il file \param{fd}.
469   
470   \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
471     invece di un pathname; pertanto gli errori restituiti cambiano di
472     conseguenza.}
473 \end{prototype}
474 \noindent ed il suo comportamento è identico a quello di \func{pathconf}.
475
476
477 \subsection{La funzione \func{uname}}
478 \label{sec:sys_uname}
479
480 Un'altra funzione che si può utilizzare per raccogliere informazioni sia
481 riguardo al sistema che al computer su cui esso sta girando è \func{uname}; il
482 suo prototipo è:
483 \begin{prototype}{sys/utsname.h}{int uname(struct utsname *info)}
484   Restituisce informazioni sul sistema nella struttura \param{info}.
485   
486   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
487   fallimento, nel qual caso \var{errno} viene settata a \macro{EFAULT}.}
488 \end{prototype}
489
490 La funzione, che viene usata dal comando \cmd{uname}, restituisce le
491 informazioni richieste nella struttura \param{info}; anche questa struttura è
492 definita in \file{sys/utsname.h}, secondo quanto mostrato in
493 \secref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
494 indicano rispettivamente:
495 \begin{itemize*}
496 \item il nome del sistema 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.
502 \end{itemize*}
503 l'ultima informazione è stata aggiunta di recente e non è prevista dallo
504 standard POSIX, essa è accessibile, come mostrato in \figref{fig:sig_stack_t},
505 solo definendo \macro{\_GNU\_SOURCE}.
506
507 \begin{figure}[!htb]
508   \footnotesize \centering
509   \begin{minipage}[c]{15cm}
510   \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
511 struct utsname {
512     char sysname[];
513     char nodename[];
514     char release[];
515     char version[];
516     char machine[];
517 #ifdef _GNU_SOURCE
518     char domainname[];
519 #endif
520 };
521   \end{lstlisting}
522   \end{minipage}
523   \normalsize 
524   \caption{La struttura \var{utsname}.} 
525   \label{fig:sys_utsname}
526 \end{figure}
527
528 In generale si tenga presente che le dimensioni delle stringe di una
529 \var{utsname} non è specificata, e che esse sono sempre terminate con
530 \macro{NULL}; il manuale delle \acr{glibc} indica due diverse dimensioni,
531 \macro{\_UTSNAME\_LENGTH} per i campi standard e
532 \macro{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
533 altri sistemi usano nomi diversi come \macro{SYS\_NMLN} o \macro{\_SYS\_NMLN}
534 or \macro{UTSLEN} che possono avere valori diversi. Nel caso di Linux
535 \func{uname} corrisponde in realtà a 3 system call diverse, le prime due usano
536 rispettivamente delle lunghezze delle stringhe di 9 e 65 byte; la terza usa
537 anch'essa 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con
538 una lunghezza di 257 byte.
539
540
541 \section{Opzioni e configurazione del sistema}
542 \label{sec:sys_config}
543
544 Come abbiamo accennato nella sezione precedente, non tutti i limiti che
545 caratterizzano il sistema sono fissi, o perlomeno non lo sono in tutte le
546 implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
547 di esaminare il meccanismo che permette, quando questi possono variare durante
548 l'esecuzione del sistema, di modificarli.
549
550 Inoltre, al di la di quelli che possono essere limiti caratteristici previsti
551 da uno standard, ogni sistema può avere una sua serie di altri parametri di
552 configurazione, che, non essendo mai fissi e variando da sistema a sistema,
553 non sono stati inclusi nella standardizzazione della sezione precedente. Per
554 questi occorre, oltre al meccanismo di settaggio, pure un meccanismo di
555 lettura.
556
557 Affronteremo questi argomenti in questa sezione, insieme alle funzioni che si
558 usano per il controllo di altre caratteristiche generali del sistema, come
559 quelle per la gestione dei filesystem e di utenti e gruppi.
560
561
562 \subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
563 \label{sec:sys_sysctl}
564
565 La funzione che permette la lettura ed il settaggio dei parametri del sistema
566 è \func{sysctl}; è una funzione derivata da BSD4.4, ma l'implementazione è
567 specifica di Linux; il suo prototipo è:
568 \begin{functions}
569 \headdecl{unistd.h}
570 \headdecl{linux/unistd.h}
571 \headdecl{linux/sysctl.h}
572 \funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
573   *newval, size\_t newlen)}
574
575 Legge o scrive uno dei parametri di sistema.
576
577 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
578   errore, nel qual caso \var{errno} viene settato ai valori:
579   \begin{errlist}
580   \item[\macro{EPERM}] il processo non ha il permesso di accedere ad uno dei
581     componenti nel cammino specificato per il parametro, o non ha il permesso
582     di accesso al parametro nella modalità scelta.
583   \item[\macro{ENOTDIR}] non esiste un parametro corrispondente al nome
584     \param{name}.
585   \item[\macro{EFAULT}] si è specificato \param{oldlenp} zero quando
586     \param{oldval} è non nullo. 
587   \item[\macro{EINVAL}] o si è specificato un valore non valido per il
588     parametro che si vuole settare o lo spazio provvisto per il ritorno di un
589     valore non è delle giuste dimensioni.
590   \item[\macro{ENOMEM}] talvolta viene usato più correttamente questo errore
591     quando non si è specificato sufficiente spazio per ricevere il valore di un
592     parametro.
593   \end{errlist}
594 }
595 \end{functions}
596
597 I parametri a cui la funzione permettere di accedere sono organizzati in
598 maniera gerarchica all'interno un albero; per accedere ad uno di essi occorre
599 specificare un cammino attraverso i vari nodi dell'albero, in maniera analoga
600 a come avviene per la risoluzione di un pathname (da cui l'uso alternativo del
601 filesystem \file{/proc}, che vedremo dopo).
602
603 Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
604 arriva ad identificare un parametro specifico è passato alla funzione
605 attraverso l'array \param{name}, di lunghezza \param{nlen}, che contiene la
606 sequenza dei vari nodi da attraversare. Ogni parametro ha un valore in un
607 formato specifico che può essere un intero, una stringa o anche una struttura
608 complessa, per questo motivo il valori vengono passati come puntatori
609 \ctyp{void}.
610
611 L'indirizzo a cui il valore corrente del parametro deve essere letto è
612 specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
613 \param{oldlenp} (passato come puntatore per avere indietro la dimensione
614 effettiva di quanto letto); il valore che si vuole settare nel sistema è
615 passato in \param{newval} e la sua dimensione in \param{newlen}.
616
617 Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
618 valore letto restituito dalla funzione è quello precedente alla scrittura.
619
620 I parametri accessibili attraverso questa funzione sono moltissimi, e possono
621 essere trovati in \file{sysctl.h}, essi inoltre dipendono anche dallo stato
622 corrente del kernel (ad esempio dai moduli che sono stati caricati nel
623 sistema) e in genere i loro nomi possono variare da una versione di kernel
624 all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
625 quando esistono modalità alternative per ottenere le stesse informazioni.
626 Alcuni esempi di parametri ottenibili sono:
627 \begin{itemize*}
628 \item il nome di dominio
629 \item i parametri del meccanismo di \textit{paging}.
630 \item il filesystem montato come radice
631 \item la data di compilazione del kernel
632 \item i parametri dello stack TCP
633 \item il numero massimo di file aperti
634 \end{itemize*}
635
636 Come accennato in Linux si ha una modalità alternativa per accedere alle
637 stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
638 \file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
639 kernel, che non fa riferimento a nessun dispositivo fisico, ma presenta in
640 forma di file alcune delle strutture interne del kernel stesso.
641
642 In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
643 di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
644 specificando un pathname e leggendo e scrivendo sul file corrispondente al
645 parametro scelto.  Il kernel si occupa di generare al volo il contenuto ed i
646 nomi dei file corrispondenti, e questo ha il grande vantaggio di rendere
647 accessibili i vari parametri a qualunque comando di shell e di permettere la
648 navigazione dell'albero dei valori.
649
650 Alcune delle corrispondenze dei file presenti in \file{/proc/sys} con i valori
651 di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
652 in \file{linux/sysctl.h},\footnote{indicando un file di definizioni si fa
653   riferimento alla directory standard dei file di include, che in ogni
654   distribuzione che si rispetti è \file{/usr/include}.} la informazione
655 disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
656 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
657
658 Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc} 
659 sono disponibili moltissime altre informazioni, fra cui ad esempio anche
660 quelle fornite da \func{uname} (vedi \secref{sec:sys_config}) che sono
661 mantenute nei file \file{ostype}, \file{hostname}, \file{osrelease},
662 \file{version} e \file{domainname} di \file{/proc/kernel/}.
663
664
665
666 \subsection{La gestione delle proprietà dei filesystem}
667 \label{sec:sys_file_config}
668
669 Come accennato in \secref{sec:file_organization} per poter accedere ai file
670 occorre prima rendere disponibile al sistema il filesystem su cui essi sono
671 memorizzati; l'operazione di attivazione del filesystem è chiamata
672 \textsl{montaggio}, per far questo in Linux\footnote{la funzione è specifica
673   di Linux e non è portabile.} si usa la funzione \func{mount} il cui prototipo
674 è:
675 \begin{prototype}{sys/mount.h}
676 {mount(const char *source, const char *target, const char *filesystemtype, 
677   unsigned long mountflags, const void *data)}
678
679 Monta il filesystem di tipo \param{filesystemtype} contenuto in \param{source}
680 sulla directory \param{target}.
681   
682   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
683   fallimento, nel qual caso gli errori comuni a tutti i filesystem che possono
684   essere restituiti in \var{errno} sono:
685   \begin{errlist}
686   \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
687   \item[\macro{ENODEV}] \param{filesystemtype} non esiste o non è configurato
688     nel kernel.
689   \item[\macro{ENOTBLK}] non si è usato un \textit{block device} per
690     \param{source} quando era richiesto.
691   \item[\macro{EBUSY}] \param{source} è già montato, o non può essere
692     rimontato in read-only perché ci sono ancora file aperti in scrittura, o
693     \param{target} è ancora in uso.
694   \item[\macro{EINVAL}] il device \param{source} presenta un
695     \textit{superblock} non valido, o si è cercato di rimontare un filesystem
696     non ancora montato, o di montarlo senza che \param{target} sia un
697     \textit{mount point} o di spostarlo quando \param{target} non è un
698     \textit{mount point} o è \file{/}.
699   \item[\macro{EACCES}] non si ha il permesso di accesso su uno dei componenti
700   del pathname, o si è cercato di montare un filesystem disponibile in sola
701   lettura senza averlo specificato o il device \param{source} è su un
702   filesystem montato con l'opzione \macro{MS\_NODEV}.
703   \item[\macro{ENXIO}] il \textit{major number} del device \param{source} è
704     sbagliato.
705   \item[\macro{EMFILE}] la tabella dei device \textit{dummy} è piena.
706   \end{errlist}
707   ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
708   \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
709 \end{prototype}
710
711 La funzione monta sulla directory \param{target}, detta \textit{mount point},
712 il filesystem contenuto in \param{source}. In generale un filesystem è
713 contenuto su un disco, e l'operazione di montaggio corrisponde a rendere
714 visibile al sistema il contenuto del suddetto disco, identificato attraverso
715 il file di dispositivo ad esso associato.
716
717 Ma la struttura del virtual filesystem vista in \secref{sec:file_vfs} è molto
718 più flessibile e può essere usata anche per oggetti diversi da un disco. Ad
719 esempio usando il \textit{loop device} si può montare un file qualunque (come
720 l'immagine di un CD-ROM o di un floppy) che contiene un filesystem, inoltre
721 alcuni filesystem, come \file{proc} o \file{devfs} sono del tutto virtuali, i
722 loro dati sono generati al volo ad ogni lettura, e passati al kernel ad ogni
723 scrittura. 
724
725 Il tipo di filesystem è specificato da \param{filesystemtype}, che deve essere
726 una delle stringhe riportate nel file \file{/proc/filesystems}, che contiene
727 l'elenco dei filesystem supportati dal kernel; nel caso si sia indicato uno
728 dei filesystem virtuali, il contenuto di \param{source} viene ignorato.
729
730 Dopo l'esecuzione della funzione il contenuto del filesystem viene resto
731 disponibile nella directory specificata come \textit{mount point}, il
732 precedente contenuto di detta directory viene mascherato dal contenuto della
733 directory radice del filesystem montato.
734
735 Dal kernel 2.4.x inoltre è divenuto possibile sia spostare atomicamente un
736 \textit{mount point} da una directory ad un'altra, sia montare in diversi
737 \textit{mount point} lo stesso filesystem, sia montare più filesystem sullo
738 stesso \textit{mount point} (nel qual caso vale quanto appena detto, e solo il
739 contenuto dell'ultimo filesystem montato sarà visibile).
740
741 Ciascun filesystem è dotato di caratteristiche specifiche che possono essere
742 attivate o meno, alcune di queste sono generali (anche se non è detto siano
743 disponibili in ogni filesystem), e vengono specificate come opzioni di
744 montaggio con l'argomento \param{mountflags}.  
745
746 In Linux \param{mountflags} deve essere un intero a 32 bit i cui 16 più
747 significativi sono un \textit{magic number}\footnote{cioè un numero speciale
748   usato come identificativo, che nel caso è \code{0xC0ED}; si può usare la
749   costante \macro{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
750   riservata al \textit{magic number}.} mentre i 16 meno significativi sono
751 usati per specificare le opzioni; essi sono usati come maschera binaria e
752 vanno settati con un OR aritmetico della costante \macro{MS\_MGC\_VAL} con i
753 valori riportati in \ntab.
754
755 \begin{table}[htb]
756   \footnotesize
757   \centering
758   \begin{tabular}[c]{|l|r|l|}
759     \hline
760     \textbf{Parametro} & \textbf{Valore}&\textbf{Significato}\\
761     \hline
762     \hline
763     \macro{MS\_RDONLY}     &  1 & monta in sola lettura\\
764     \macro{MS\_NOSUID}     &  2 & ignora i bit \acr{suid} e \acr{sgid}\\
765     \macro{MS\_NODEV}      &  4 & impedisce l'accesso ai file di dispositivo\\
766     \macro{MS\_NOEXEC}     &  8 & impedisce di eseguire programmi \\
767     \macro{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
768     \macro{MS\_REMOUNT}    & 32 & rimonta il filesystem cambiando i flag\\
769     \macro{MS\_MANDLOCK}   & 64 & consente il \textit{mandatory locking} (vedi
770                                   \secref{sec:file_mand_locking})\\
771     \macro{S\_WRITE}      & 128 & scrive normalmente \\
772     \macro{S\_APPEND}     & 256 & consente la scrittura solo in \textit{append
773                                   mode} (vedi \secref{sec:file_sharing})\\
774     \macro{S\_IMMUTABLE}  & 512 & impedisce che si possano modificare i file \\
775     \macro{MS\_NOATIME}   &1024 & non aggiorna gli \textit{access time} (vedi
776                                   \secref{sec:file_file_times})\\
777     \macro{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
778                                   directory\\
779     \macro{MS\_BIND}      &4096 & monta il filesystem altrove\\
780     \macro{MS\_MOVE}      &8192 & sposta atomicamente il punto di montaggio \\
781     \hline
782   \end{tabular}
783   \caption{Tabella dei codici dei flag di montaggio di un filesystem.}
784   \label{tab:sys_mount_flags}
785 \end{table}
786
787 Per il settaggio delle caratteristiche particolari di ciascun filesystem si
788 usa invece l'argomento \param{data} che serve per passare le ulteriori
789 informazioni necessarie, che ovviamente variano da filesystem a filesystem.
790
791 La funzione \func{mount} può essere utilizzata anche per effettuare il
792 \textsl{rimontaggio} di un filesystem, cosa che permette di cambiarne al volo
793 alcune delle caratteristiche di funzionamento (ad esempio passare da sola
794 lettura a lettura/scrittura). Questa operazione è attivata attraverso uno dei
795 bit di \param{mountflags}, \macro{MS\_REMOUNT}, che se settato specifica che
796 deve essere effettuato il rimontaggio del filesystem (con le opzioni
797 specificate dagli altri bit), anche in questo caso il valore di \param{source}
798 viene ignorato.
799
800 Una volta che non si voglia più utilizzare un certo filesystem è possibile
801 \textsl{smontarlo} usando la funzione \func{umount}, il cui prototipo è:
802 \begin{prototype}{sys/mount.h}{umount(const char *target)}
803   
804   Smonta il filesystem montato sulla directory \param{target}.
805   
806   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
807     fallimento, nel qual caso \var{errno} viene settata a:
808   \begin{errlist}
809   \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
810   \item[\macro{EBUSY}]  \param{target} è la directory di lavoro di qualche
811   processo, o contiene dei file aperti, o un altro mount point.
812   \end{errlist}
813   ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
814   \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
815 \end{prototype}
816 \noindent la funzione prende il nome della directory su cui il filesystem è
817 montato e non il file o il dispositivo che è stato montato,\footnote{questo è
818   vero a partire dal kernel 2.3.99-pre7, prima esistevano due chiamate
819   separate e la funzione poteva essere usata anche specificando il file di
820   dispositivo.} in quanto con il kernel 2.4.x è possibile montare lo stesso
821 dispositivo in più punti. Nel caso più di un filesystem sia stato montato
822 sullo stesso \textit{mount point} viene smontato quello che è stato montato
823 per ultimo.
824
825 Si tenga presente che la funzione fallisce quando il filesystem è
826 \textsl{occupato}, questo avviene quando ci sono ancora file aperti sul
827 filesystem, se questo contiene la directory di lavoro corrente di un qualunque
828 processo o il mount point di un altro filesystem; in questo caso l'errore
829 restituito è \macro{EBUSY}.
830
831 Linux provvede inoltre una seconda funzione, \func{umount2}, che in alcuni
832 casi permette di forzare lo smontaggio di un filesystem, anche quando questo
833 risulti occupato; il suo prototipo è:
834 \begin{prototype}{sys/mount.h}{umount2(const char *target, int flags)}
835   
836   La funzione è identica a \func{umount} per comportamento e codici di errore,
837   ma con \param{flags} si può specificare se forzare lo smontaggio.
838 \end{prototype}
839
840 Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
841 definito è il bit \macro{MNT\_FORCE}; gli altri bit devono essere nulli.
842 Specificando \macro{MNT\_FORCE} la funzione cercherà di liberare il filesystem
843 anche se è occupato per via di una delle condizioni descritte in precedenza. A
844 seconda del tipo di filesystem alcune (o tutte) possono essere superate,
845 evitando l'errore di \macro{EBUSY}.  In tutti i casi prima dello smontaggio
846 viene eseguita una sincronizzazione dei dati. 
847
848 Altre due funzioni specifiche di Linux,\footnote{esse si trovano anche su BSD,
849   ma con una struttura diversa.} utili per ottenere in maniera diretta
850 informazioni riguardo al filesystem su cui si trova un certo file, sono
851 \func{statfs} e \func{fstatfs}, i cui prototipi sono:
852 \begin{functions}
853   \headdecl{sys/vfs.h} 
854   \funcdecl{int statfs(const char *path, struct statfs *buf)} 
855
856   \funcdecl{int fstatfs(int fd, struct statfs *buf)} 
857   
858   Restituisce in \param{buf} le informazioni relative al filesystem su cui è
859   posto il file specificato.
860   
861   \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
862     errore, nel qual caso \var{errno} viene settato ai valori:
863   \begin{errlist}
864   \item[\macro{ENOSYS}] il filesystem su cui si trova il file specificato non
865   supporta la funzione.
866   \end{errlist}
867   e \macro{EFAULT} ed \macro{EIO} per entrambe, \macro{EBADF} per
868   \func{fstatfs}, \macro{ENOTDIR}, \macro{ENAMETOOLONG}, \macro{ENOENT},
869   \macro{EACCES}, \macro{ELOOP} per \func{statfs}.}
870 \end{functions}
871
872 Queste funzioni permettono di ottenere una serie di informazioni generali
873 riguardo al filesystem su cui si trova il file specificato; queste vengono
874 restituite una struttura \param{buf} di tipo \type{statfs} definita come in
875 \ref{fig:sys_statfs}, ed i campi che sono indefiniti per il filesystem in
876 esame sono settati a zero.  I valori del campo \var{f\_type} sono definiti per
877 i vari filesystem nei relativi file di header dei sorgenti del kernel da
878 costanti del tipo \macro{XXX\_SUPER\_MAGIC}, dove \macro{XXX} in genere è il
879 nome del filesystem stesso.
880
881 \begin{figure}[!htb]
882   \footnotesize \centering
883   \begin{minipage}[c]{15cm}
884   \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
885 struct statfs {
886    long    f_type;     /* tipo di filesystem */
887    long    f_bsize;    /* dimensione ottimale dei blocchi di I/O */
888    long    f_blocks;   /* blocchi totali nel filesystem */
889    long    f_bfree;    /* blocchi liberi nel filesystem */
890    long    f_bavail;   /* blocchi liberi agli utenti normali */
891    long    f_files;    /* inodes totali nel filesystem */
892    long    f_ffree;    /* inodes liberi nel filesystem */
893    fsid_t  f_fsid;     /* filesystem id */
894    long    f_namelen;  /* lunghezza massima dei nomi dei file */
895    long    f_spare[6]; /* riservati per uso futuro */
896 };
897 \end{lstlisting}
898   \end{minipage}
899   \normalsize 
900   \caption{La struttura \var{statfs}.} 
901   \label{fig:sys_statfs}
902 \end{figure}
903
904
905 Le \acr{glibc} provvedono infine una serie di funzioni per la gestione dei due
906 file standard \file{/etc/fstab} e \file{/etc/mtab}, che convenzionalmente sono
907 usati in quasi tutti i sistemi unix-like per mantenere rispettivamente le
908 informazioni riguardo ai filesystem da montare e a quelli correntemente
909 montati. Le funzioni servono a leggere il contenuto di questi file in
910 opportune strutture \var{struct fstab} e \var{struct mntent}, e, per
911 \file{/etc/mtab} per inserire e rimuovere le voci presenti nel file.  
912
913 In generale si dovrebbero usare queste funzioni (in particolar modo quelle
914 relative a \file{/etc/mtab}), quando si debba scrivere un programma che
915 effettua il montaggio di un filesystem; in realtà in questi casi è molto più
916 semplice invocare direttamente il programma \cmd{mount}, per cui ne
917 tralasceremo la trattazione, rimandando al manuale delle \acr{glibc}
918 \cite{glibc} per la documentazione completa.
919
920
921 \subsection{La gestione di utenti e gruppi}
922 \label{sec:sys_user_group}
923
924 Tradizionalmente l'informazione per la gestione di utenti e gruppi veniva
925 tenuta tutta nei due file di testo \file{/etc/passwd} ed \file{/etc/group}, e
926 tutte le funzioni facevano riferimento ad essi.  Oggi la maggior parte delle
927 distribuzioni di Linux usa la libreria PAM (sigla che sta \textit{Pluggable
928   Authentication Method}) che permette di separare completamente i meccanismi
929 di gestione degli utenti (autenticazione, riconoscimento, ecc.) dalle modalità
930 in cui i relativi dati vengono mantenuti, per cui pur restando in gran parte
931 le stesse\footnote{in genere quello che viene cambiato è l'informazione usata
932   per l'autenticazione, che non è più necessariamente una password criptata da
933   verificare, ma può assumere le forme più diverse, come impronte digitali,
934   chiavi elettroniche, ecc.}, le informazioni non sono più necessariamente
935 mantenute in quei file.
936
937 In questo paragrafo ci limiteremo comunque alle funzioni classiche per la
938 lettura delle informazioni relative a utenti e gruppi previste dallo standard
939 POSIX.1, che fanno riferimento a quanto memorizzato nei due file appena
940 citati, il cui formato è descritto dalle relative pagine del manuale (cioè
941 \cmd{man 5 passwd} e \cmd{man 5 group}).
942
943 Per leggere le informazioni relative ad un utente si possono usare due
944 funzioni, \func{getpwuid} e \func{getpwnam}, i cui prototipi sono:
945 \begin{functions}
946   \headdecl{pwd.h} 
947   \headdecl{sys/types.h} 
948   \funcdecl{struct passwd *getpwuid(uid\_t uid)} 
949   
950   \funcdecl{struct passwd *getpwnam(const char *name)} 
951
952   Restituiscono le informazioni relative all'utente specificato.
953   
954   \bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
955     informazioni in caso di successo e \macro{NULL} nel caso non sia stato
956     trovato nessun utente corrispondente a quanto specificato.}
957 \end{functions}
958
959 Le due funzioni forniscono le informazioni memorizzate nel database degli
960 utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
961 relative all'utente specificato attraverso il suo \acr{uid} o il nome di
962 login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
963 tipo \type{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
964 riportata in \figref{fig:sys_passwd_struct}, dove è pure brevemente illustrato
965 il significato dei vari campi. 
966
967 \begin{figure}[!htb]
968   \footnotesize
969   \centering
970   \begin{minipage}[c]{15cm}
971     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
972 struct passwd {
973     char    *pw_name;       /* user name */
974     char    *pw_passwd;     /* user password */
975     uid_t   pw_uid;         /* user id */
976     gid_t   pw_gid;         /* group id */
977     char    *pw_gecos;      /* real name */
978     char    *pw_dir;        /* home directory */
979     char    *pw_shell;      /* shell program */
980 };
981     \end{lstlisting}
982   \end{minipage} 
983   \normalsize 
984   \caption{La struttura \var{passwd} contenente le informazioni relative ad un
985     utente del sistema.}
986   \label{fig:sys_passwd_struct}
987 \end{figure}
988
989 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
990 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
991 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
992 fanno riferimento. Ovviamente questo implica che dette funzioni non posono
993 essere rientranti, per cui ne esistono anche due versioni alternative
994 (denotate dalla solita estensione \code{\_r}), i cui prototipi sono:
995 \begin{functions}
996   \headdecl{pwd.h} 
997   
998   \headdecl{sys/types.h} 
999   
1000   \funcdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
1001     char *buffer, size\_t buflen, struct passwd **result)}
1002   
1003   \funcdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
1004     *password, char *buffer, size\_t buflen, struct passwd **result)}
1005
1006   Restituiscono le informazioni relative all'utente specificato.
1007   
1008   \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1009     altrimenti, nel qual caso \var{errno} sarà settato opportunamente.}
1010 \end{functions}
1011
1012 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
1013 la memoria necessaria a contenere le informazioni. In particolare i valori
1014 della struttura \var{passwd} saranno restituiti all'indirizzo \param{password}
1015 mentre la memoria allocata all'indirizzo \param{buffer}, per un massimo di
1016 \param{buflen} byte, sarà utilizzata per contenere le stringhe puntate dai
1017 campi di \param{password}. Infine all'indirizzo puntato da \param{result}
1018 viene restituito il puntatore ai dati ottenuti, cioè \param{buffer} nel caso
1019 l'utente esista, o \macro{NULL} altrimenti.  Qualora i dati non possano essere
1020 contenuti nei byte specificati da \param{buflen}, la funzione fallirà
1021 restituendo \macro{ERANGE} (e \param{result} sarà comunque settato a
1022 \macro{NULL}).
1023
1024 Del tutto analoghe alle precedenti sono le funzioni \func{getgrnam} e
1025 \func{getgrgid} (e le relative analoghe rientranti con la stessa estensione
1026 \code{\_r}) che permettono di leggere le informazioni relative ai gruppi, i
1027 loro prototipi sono:
1028 \begin{functions}
1029   \headdecl{grp.h} 
1030   \headdecl{sys/types.h} 
1031
1032   \funcdecl{struct group *getgrgid(gid\_t gid)} 
1033   
1034   \funcdecl{struct group *getgrnam(const char *name)} 
1035   
1036   \funcdecl{struct group *getpwuid\_r(gid\_t gid, struct group *password,
1037     char *buffer, size\_t buflen, struct group **result)}
1038   
1039   \funcdecl{struct group *getpwnam\_r(const char *name, struct group
1040     *password, char *buffer, size\_t buflen, struct group **result)}
1041
1042   Restituiscono le informazioni relative al gruppo specificato.
1043   
1044   \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1045     altrimenti, nel qual caso \var{errno} sarà settato opportunamente.}
1046 \end{functions}
1047
1048 Il comportamento di tutte queste funzioni è assolutamente identico alle
1049 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
1050 in questo caso le informazioni vengono restituite in una struttura di tipo
1051 \type{group}, la cui definizione è riportata in \figref{fig:sys_group_struct}.
1052
1053 \begin{figure}[!htb]
1054   \footnotesize
1055   \centering
1056   \begin{minipage}[c]{15cm}
1057     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1058 struct group {
1059     char    *gr_name;        /* group name */
1060     char    *gr_passwd;      /* group password */
1061     gid_t   gr_gid;          /* group id */
1062     char    **gr_mem;        /* group members */
1063 };
1064     \end{lstlisting}
1065   \end{minipage} 
1066   \normalsize 
1067   \caption{La struttura \var{group} contenente le informazioni relative ad un
1068     gruppo del sistema.}
1069   \label{fig:sys_group_struct}
1070 \end{figure}
1071
1072 Le funzioni viste finora sono in grado di leggere le informazioni sia dal file
1073 delle password in \file{/etc/passwd} che con qualunque altro metodo sia stato
1074 utilizzato per mantenere il database degli utenti. Non permettono però di
1075 settare direttamente le password; questo è possibile con un'altra interfaccia
1076 al database degli utenti, derivata da SVID, che però funziona soltanto con un
1077 database che sia tenuto su un file che abbia il formato classico di
1078 \file{/etc/passwd}.
1079
1080 \begin{table}[htb]
1081   \footnotesize
1082   \centering
1083   \begin{tabular}[c]{|l|p{8cm}|}
1084     \hline
1085     \textbf{Funzione} & \textbf{Significato}\\
1086     \hline
1087     \hline
1088     \func{fgetpwent}   & Legge una voce dal database utenti da un file 
1089                          specificato aprendolo la prima volta.\\
1090     \func{fgetpwent\_r}& Come la precedente, ma rientrante.\\
1091     \func{getpwent}    & Legge una voce dal database utenti (da 
1092                          \file{/etc/passwd}) aprendolo la prima volta.\\
1093     \func{getpwent\_r} & Come la precedente, ma rientrante.\\
1094     \func{setpwent}    & Ritorna all'inizio del database.\\
1095     \func{putpwent}    & Immette una voce nel database utenti.\\
1096     \func{endpwent}    & Chiude il database degli utenti.\\
1097     \func{fgetgrent}   & Legge una voce dal database dei gruppi da un file 
1098                          specificato aprendolo la prima volta.\\
1099     \func{fgetgrent\_r}& Come la precedente, ma rientrante.\\
1100     \func{getgrent}    & Legge una voce dal database dei gruppi (da 
1101                          \file{/etc/passwd}) aprendolo la prima volta.\\
1102     \func{getgrent\_r} & Come la precedente, ma rientrante.\\
1103     \func{setgrent}    & Immette una voce nel database dei gruppi.\\
1104     \func{putgrent}    & Immette una voce nel database dei gruppi.\\
1105     \func{endgrent}    & Chiude il database dei gruppi.\\
1106     \hline
1107   \end{tabular}
1108   \caption{Funzioni per la manipolazione dei campi di un file usato come
1109     database di utenti e gruppi nel formato di \file{/etc/passwd} e
1110     \file{/etc/groups}.} 
1111   \label{tab:sys_passwd_func}
1112 \end{table}
1113
1114 Dato che ormai la gran parte delle distribuzioni di Linux utilizzano PAM, che
1115 come minimo usa almeno le \textit{shadow password} (quindi con delle modifiche
1116 rispetto al formato classico di \file{/etc/passwd}), le funzioni che danno la
1117 capacità scrivere delle voci nel database (cioè \func{putpwent} e
1118 \func{putgrent}) non permettono di effettuarne una specificazione in maniera
1119 completa. Per questo motivo l'uso di queste funzioni è deprecato in favore
1120 dell'uso di PAM, ci limiteremo pertanto ad elencarle in
1121 \tabref{tab:sys_passwd_func}, rimandando chi fosse interessato alle rispettive
1122 man page e al manuale delle \acr{glibc} per i dettagli del loro funzionamento.
1123
1124
1125
1126 \subsection{Il database di accounting}
1127 \label{sec:sys_accounting}
1128
1129 L'ultimo insieme di funzioni relative alla gestione del sistema che
1130 esamineremo è quello che permette di accedere ai dati del database di
1131 \textit{accounting}.  In esso vengono mantenute una serie di informazioni
1132 storiche relative sia agli utenti che si sono collegati al sistema, (tanto per
1133 quelli correntemente collegati, che per la registrazione degli accessi
1134 precedenti), sia relative all'intero sistema, come il momento di lancio di
1135 processi da parte di \cmd{init}, il cambiamento dell'orologio di sistema, il
1136 cambiamento di runlevel o il riavvio della macchina.
1137
1138 I dati vengono usualmente\footnote{questa è la locazione specificata dal
1139   \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
1140   delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
1141 \file{/var/log/wtmp}. Quando un utente si collega viene aggiunta una voce a
1142 \file{/var/run/utmp} in cui viene memorizzato il nome di login, il terminale
1143 da cui ci si collega, l'\acr{uid} della shell di login, l'orario della
1144 connessione ed altre informazioni.  La voce resta nel file fino al logout,
1145 quando viene cancellata e spostata in \file{/var/log/wtmp}.
1146
1147 In questo modo il primo file viene utilizzato per registrare sta utilizzando
1148 il sistema al momento corrente, mentre il secondo mantiene la registrazione
1149 delle attività degli utenti. A quest'ultimo vengono anche aggiunte delle voci
1150 speciali per tenere conto dei cambiamenti del sistema, come la modifica del
1151 runlevel, il riavvio della macchina, ecc. Tutte queste informazioni sono
1152 descritte in dettaglio nel manuale delle \acr{glibc}.
1153
1154 Questi file non devono mai essere letti direttamente, ma le informazioni che
1155 contengono possono essere ricavate attraverso le opportune funzioni di
1156 libreria. Queste sono analoghe alle precedenti (vedi
1157 \tabref{tab:sys_passwd_func}) usate per accedere al database degli utenti,
1158 solo che in questo caso la struttura del database di accounting è molto più
1159 complessa, dato che contiene diversi tipi di informazione.
1160
1161 Le prime tre funzioni, \func{setutent}, \func{endutent} e \func{utmpname}
1162 servono rispettivamente a aprire e a chiudere il file che contiene il
1163 database, e a specificare su quale file esso viene mantenuto. I loro prototipi
1164 sono:
1165 \begin{functions}
1166   \headdecl{utmp.h} 
1167   
1168   \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
1169   database di \textit{accounting}.
1170   
1171   \funcdecl{void setutent(void)} Apre il file del database di
1172   \textit{accounting}, posizionandosi al suo inizio.
1173   
1174   \funcdecl{void endutent(void)} Chiude il file del database di
1175   \textit{accounting}.
1176   
1177   \bodydesc{Le funzioni non ritornano codici di errore.}
1178 \end{functions}
1179
1180 In caso questo non venga specificato nessun file viene usato il valore
1181 standard \macro{\_PATH\_UTMP} (che è definito in \file{paths.h}); in genere
1182 \func{utmpname} prevede due possibili valori:
1183 \begin{basedescript}{\desclabelwidth{2.0cm}}
1184 \item[\macro{\_PATH\_UTMP}] Specifica il database di accounting per gli utenti
1185   correntemente collegati.
1186 \item[\macro{\_PATH\_WTMP}] Specifica il database di accounting per l'archivio
1187   storico degli utenti collegati.
1188 \end{basedescript}
1189 corrispondenti ai file \file{/var/run/utmp} e \file{/var/log/wtmp} visti in
1190 precedenza.
1191
1192 Una volta aperto il file si può eseguire una scansione leggendo o scrivendo
1193 una voce con le funzioni \func{getutent}, \func{getutid}, \func{getutline} e 
1194 \func{pututline}, i cui prototipi sono:
1195 \begin{functions}
1196   \headdecl{utmp.h} 
1197
1198   \funcdecl{struct utmp *getutent(void)} 
1199   Legge una voce dal dalla posizione corrente nel database.
1200   
1201   \funcdecl{struct utmp *getutid(struct utmp *ut)} 
1202   Ricerca una voce sul database in base al contenuto di \param{ut}.
1203
1204   \funcdecl{struct utmp *getutline(struct utmp *ut)} 
1205   Ricerca nel database la prima voce corrispondente ad un processo sulla linea
1206   di terminale specificata tramite \param{ut}.
1207
1208   \funcdecl{struct utmp *pututline(struct utmp *ut)} 
1209   Scrive una voce nel database.
1210
1211   \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
1212     caso di successo e \macro{NULL} in caso di errore.}
1213 \end{functions}
1214
1215 Tutte queste funzioni fanno riferimento ad una struttura di tipo \var{utmp},
1216 la cui definizione in Linux è riportata in \secref{fig:sys_utmp_struct}. Le
1217 prime tre funzioni servono per leggere una voce dal database; \func{getutent}
1218 legge semplicemente la prima voce disponibile; le altre due permettono di
1219 eseguire una ricerca.
1220
1221 \begin{figure}[!htb]
1222   \footnotesize
1223   \centering
1224   \begin{minipage}[c]{15cm}
1225     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1226 struct utmp
1227 {
1228     short int ut_type;            /* Type of login.  */
1229     pid_t ut_pid;                 /* Process ID of login process.  */
1230     char ut_line[UT_LINESIZE];    /* Devicename.  */
1231     char ut_id[4];                /* Inittab ID.  */
1232     char ut_user[UT_NAMESIZE];    /* Username.  */
1233     char ut_host[UT_HOSTSIZE];    /* Hostname for remote login.  */
1234     struct exit_status ut_exit;   /* Exit status of a process marked
1235                                      as DEAD_PROCESS.  */
1236     long int ut_session;          /* Session ID, used for windowing.  */
1237     struct timeval ut_tv;         /* Time entry was made.  */
1238     int32_t ut_addr_v6[4];        /* Internet address of remote host.  */
1239     char __unused[20];            /* Reserved for future use.  */
1240 };
1241     \end{lstlisting}
1242   \end{minipage} 
1243   \normalsize 
1244   \caption{La struttura \var{utmp} contenente le informazioni di una voce del
1245     database di \textit{accounting}.}
1246   \label{fig:sys_utmp_struct}
1247 \end{figure}
1248
1249 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1250 campo \var{ut\_type} dell'argomento \param{ut}.  Questo può assumere i valori
1251 riportati in \tabref{tab:sys_ut_type}, quando assume i valori
1252 \macro{RUN\_LVL}, \macro{BOOT\_TIME}, \macro{OLD\_TIME}, \macro{NEW\_TIME},
1253 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1254 invece assume i valori \macro{INIT\_PROCESS}, \macro{LOGIN\_PROCESS},
1255 \macro{USER\_PROCESS} o \macro{DEAD\_PROCESS} verrà restiuita la prima voce
1256 corripondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1257
1258 \begin{table}[htb]
1259   \footnotesize
1260   \centering
1261   \begin{tabular}[c]{|l|p{8cm}|}
1262     \hline
1263     \textbf{Funzione} & \textbf{Significato}\\
1264     \hline
1265     \hline
1266     \macro{EMPTY}         & Non contiene informazioni valide. \\
1267     \macro{RUN\_LVL}      & Identica il runlevel del sistema. \\
1268     \macro{BOOT\_TIME}    & Identifica il tempo di avvio del sistema \\
1269     \macro{OLD\_TIME}     & Identifica quando è stato modificato l'orologio di
1270                             sistema. \\
1271     \macro{NEW\_TIME}     & Identifica da quanto è stato modificato il 
1272                             sistema. \\
1273     \macro{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}. \\
1274     \macro{LOGIN\_PROCESS}& Identifica un processo di login. \\
1275     \macro{USER\_PROCESS} & Identifica un processo utente. \\
1276     \macro{DEAD\_PROCESS} & Identifica un processo terminato. \\
1277     \macro{ACCOUNTING}    & ??? \\
1278     \hline
1279   \end{tabular}
1280   \caption{Classificazione delle voci del database di accounting a seconda dei
1281     possibili valori del campo \var{ut\_type}.} 
1282   \label{tab:sys_ut_type}
1283 \end{table}
1284
1285 La funzione \func{getutline} esegue la ricerca sulle voci che hanno
1286 \var{ut\_type} uguale a \macro{LOGIN\_PROCESS} o \macro{USER\_PROCESS},
1287 restituendo la prima che corrisponde al valore di \var{ut\_line}, che
1288 specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
1289 terminale che interessa. Lo stesso criterio di ricerca è usato da
1290 \func{pututline} per trovare uno spazio dove inserire la voce specificata,
1291 qualora non sia trovata la voce viene aggiunta in coda al database.
1292
1293 In generale occorre però tenere conto che queste funzioni non sono
1294 completamente standardizzate, e che in sistemi diversi possono esserci
1295 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1296 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1297 fornita dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1298 introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
1299 sono un sovrainsieme di \code{utmp}. 
1300
1301 Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
1302 inutili queste nuove strutture; pertanto esse e le relative funzioni di
1303 gestione (\func{getutxent}, \func{getutxid}, \func{getutxline},
1304 \func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
1305 sinonimi delle funzioni appena viste.
1306
1307 Come visto in \secref{sec:sys_user_group}, l'uso di strutture allocate
1308 staticamente rende le funzioni di lettura non rientranti; per questo motivo le
1309 \acr{glibc} forniscono anche delle versioni rientranti: \func{getutent\_r},
1310 \func{getutid\_r}, \func{getutline\_r}, che invece di restituire un puntatore
1311 restituiscono un intero e prendono due argomenti aggiuntivi. Le funzioni si
1312 comportano esattamente come le analoge non rientranti, solo che restituiscono
1313 il risultato all'indirizzo specificato dal primo argomento aggiuntivo (di tipo
1314 \code{struct utmp *buffer}) mentre il secondo (di tipo \code{struct utmp
1315   **result)} viene usato per restituire il puntatore allo stesso buffer.
1316
1317 Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
1318 in \file{wmtp} altre due funzioni, \func{updwtmp} e \func{logwtmp}, i cui
1319 prototipi sono:
1320 \begin{functions}
1321   \headdecl{utmp.h} 
1322   
1323   \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1324   Aggiunge la voce \param{ut} nel database di accounting \file{wmtp}.
1325   
1326   \funcdecl{void logwtmp(const char *line, const char *name, const char
1327     *host)} Aggiunge nel database di accounting una voce con i valori
1328   specificati.
1329
1330   \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
1331     caso di successo e \macro{NULL} in caso di errore.}
1332 \end{functions}
1333
1334 La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
1335 direttamente una struttura \type{utmp}, mentre la seconda utilizza gli
1336 argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
1337 poi aggiunge chiamando \func{updwtmp}.
1338
1339
1340 \section{Limitazione ed uso delle risorse}
1341 \label{sec:sys_res_limits}
1342
1343
1344 Dopo aver esaminato le funzioni che permettono di controllare le varie
1345 caratteristiche, capacità e limiti del sistema a livello globale, in questa
1346 sezione tratteremo le varie funzioni che vengono usate per quantificare le
1347 risorse (CPU, memoria, ecc.)  utilizzate da ogni singolo processo e quelle che
1348 permettono di imporre a ciascuno di essi vincoli e limiti di utilizzo.
1349
1350
1351 \subsection{L'uso delle risorse}
1352 \label{sec:sys_resource_use}
1353
1354 Come abbiamo accennato in \secref{sec:proc_wait4} le informazioni riguardo
1355 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1356 di tipo \code{struct }\type{rusage}, la cui definizione (che si trova in
1357 \file{sys/resource.h}) è riportata in \figref{fig:sys_rusage_struct}.
1358
1359 \begin{figure}[!htb]
1360   \footnotesize
1361   \centering
1362   \begin{minipage}[c]{15cm}
1363     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1364 struct rusage {
1365     struct timeval ru_utime; /* user time used */
1366     struct timeval ru_stime; /* system time used */
1367     long ru_maxrss;          /* maximum resident set size */
1368     long ru_ixrss;           /* integral shared memory size */
1369     long ru_idrss;           /* integral unshared data size */
1370     long ru_isrss;           /* integral unshared stack size */
1371     long ru_minflt;          /* page reclaims */
1372     long ru_majflt;          /* page faults */
1373     long ru_nswap;           /* swaps */
1374     long ru_inblock;         /* block input operations */
1375     long ru_oublock;         /* block output operations */
1376     long ru_msgsnd;          /* messages sent */
1377     long ru_msgrcv;          /* messages received */
1378     long ru_nsignals;   ;    /* signals received */
1379     long ru_nvcsw;           /* voluntary context switches */
1380     long ru_nivcsw;          /* involuntary context switches */
1381 };
1382     \end{lstlisting}
1383   \end{minipage} 
1384   \normalsize 
1385   \caption{La struttura \var{rusage} per la lettura delle informazioni dei 
1386     delle risorse usate da un processo.}
1387   \label{fig:sys_rusage_struct}
1388 \end{figure}
1389
1390 La struttura è ripresa da BSD 4.3, ma attualmente (con i kernel della serie
1391 2.4.x) i soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
1392 \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I primi due indicano
1393 rispettivamente il tempo impiegato dal processo nell'eseguire le istruzioni in
1394 user space, e quello impiegato dal kernel nelle system call eseguite per conto
1395 del processo.
1396
1397 Gli altri tre campi servono a quantificare l'uso della memoria virtuale e
1398 corrispondono rispettivamente al numero di \textit{page fault}\index{page
1399   fault} (vedi \secref{sec:proc_mem_gen}) avvenuti senza richiedere I/O (i
1400 cosiddetti \textit{minor page fault}), a quelli che invece han richiesto I/O
1401 (detti invece \textit{major page fault}) ed al numero di volte che il processo
1402 è stato completamente tolto dalla memoria per essere inserito nello swap.
1403
1404 In genere includere esplicitamente \file{<sys/time.h>} non è più necessario,
1405 ma aumenta la portabilità, e serve comunque quando, come nella maggior parte
1406 dei casi, si debba accedere ai campi di \var{rusage} relativi ai tempi di
1407 utilizzo del processore, che sono definiti come \code{struct }\type{timeval}.
1408
1409
1410 Questa è la stessa struttura utilizzata da \func{wait4}  per ricavare la
1411 quantità di risorse impiegato dal processo di cui si è letto lo stato di
1412 terminazione, ma essa può anche essere letta direttamente utilizzando la
1413 funzione \func{getrusage}, il cui prototipo è:
1414 \begin{functions}
1415   \headdecl{sys/time.h} 
1416   \headdecl{sys/resource.h} 
1417   \headdecl{unistd.h} 
1418   
1419   \funcdecl{int getrusage(int who, struct rusage *usage)} 
1420   Legge la quantità di risorse usate da un processo.
1421
1422
1423   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1424   nel qual caso \var{errno} può essere \macro{EINVAL} o \macro{EFAULT}.}
1425 \end{functions}
1426
1427 L'argomento \param{who} permette di specificare il processo di cui si vuole
1428 leggere l'uso delle risorse; esso può assumere solo i due valori
1429 \macro{RUSAGE\_SELF} per indicare il processo corrente e
1430 \macro{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
1431 ricevuto lo stato di terminazione. 
1432
1433
1434 \subsection{Limiti sulle risorse}
1435 \label{sec:sys_resource_limit}
1436
1437 Come accennato nell'introduzione oltre a leggere l'uso delle risorse da parte
1438 di un processo si possono anche imporre dei limiti sulle sue capacità. Ogni
1439 processo ha in generale due limiti associati ad ogni risorsa; questi sono
1440 detti il \textsl{limite corrente} (o \textit{current limit}) che esprime il
1441 valore che attualmente il processo non può superare, ed il \textsl{limite
1442   massimo} (o \textit{maximum limit}) che esprime il valore massimo che può
1443 assumere il \textsl{limite corrente}.
1444
1445 In generale il primo viene chiamato un limite \textsl{soffice} (o \textit{soft
1446   limit}) dato che il suo valore può essere aumentato, mentre il secondo è
1447 detto \textsl{duro} (o \textit{hard limit}), in quanto un processo normale non
1448 può modificarne il valore. Il valore di questi limiti è mantenuto in una
1449 struttura \var{rlimit}, la cui definizione è riportata in
1450 \figref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a limite
1451 corrente e massimo.
1452
1453 \begin{figure}[!htb]
1454   \footnotesize
1455   \centering
1456   \begin{minipage}[c]{15cm}
1457     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1458 struct rlimit {
1459      rlim_t    rlim_cur;
1460      rlim_t    rlim_max;
1461 };
1462     \end{lstlisting}
1463   \end{minipage} 
1464   \normalsize 
1465   \caption{La struttura \var{rlimit} per impostare i limiti di utilizzo 
1466     delle risorse usate da un processo.}
1467   \label{fig:sys_rlimit_struct}
1468 \end{figure}
1469
1470 In genere il superamento di un limite comporta o l'emissione di un segnale o
1471 il fallimento della system call che lo ha provocato; per far leggere o settare
1472 i limiti di utilizzo delle risorse da parte di un processo le \acr{glibc}
1473 prevedono due funzioni, \func{getrlimit} e \func{setrlimit}, i cui prototipi
1474 sono:
1475 \begin{functions}
1476   \headdecl{sys/time.h} 
1477   \headdecl{sys/resource.h} 
1478   \headdecl{unistd.h} 
1479   
1480   \funcdecl{int getrlimit(int resource, struct rlimit *rlim)} 
1481
1482   Legge il limite corrente per la risorsa \param{resource}.
1483   
1484   \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)} 
1485   
1486   Setta il limite per la risorsa \param{resource}.
1487   
1488   \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
1489     errore, nel qual caso \var{errno} viene settata ai valori:
1490     \begin{errlist}
1491     \item[\macro{INVAL}] I valori per \param{resource} non sono validi.
1492     \item[\macro{EPERM}] Un processo senza i privilegi di amministratore ha
1493     cercato di innalzare i propri limiti.
1494     \end{errlist}
1495   ed \macro{EFAULT}.}
1496 \end{functions}
1497
1498 Entrambe le funzioni permettono di specificare su quale risorsa si vuole
1499 operare attraverso \param{resource}, i cui possibili valori sono elencati in
1500 \secref{tab:sys_rlimit_values}, e utilizzano una struttura \var{rlimit} per
1501 specificarne i valori.
1502
1503 \begin{table}[htb]
1504   \footnotesize
1505   \centering
1506   \begin{tabular}[c]{|l|p{12cm}|}
1507     \hline
1508     \textbf{Valore} & \textbf{Significato}\\
1509     \hline
1510     \hline
1511     \macro{RLIMIT\_CPU}    &  Il massimo tempo di CPU che il processo può
1512                               usare. Il superamento del limite comporta
1513                               l'emissione di un segnale di \macro{SIGXCPU}.\\
1514     \macro{RLIMIT\_FSIZE}  &  La massima dimensione di un file che un processo
1515                               può usare. Se il processo cerca di scrivere
1516                               oltre questa dimensione riceverà un segnale di
1517                               \macro{SIGXFSZ}.\\
1518     \macro{RLIMIT\_DATA}   &  La massima dimensione della memoria dati di un
1519                               processo. Il tentatico di allocare più memoria
1520                               causa il fallimento della funzione di
1521                               allocazione. \\
1522     \macro{RLIMIT\_STACK}  &  La massima dimensione dello stack del
1523                               processo. Se il processo esegue operazioni che
1524                               estendano lo stack oltre questa dimensione
1525                               riceverà un segnale di \macro{SIGSEGV}.\\
1526     \macro{RLIMIT\_CORE}   &  La massima dimensione di un file di \textit{core
1527                               dump} creato da un processo. Nel caso le 
1528                               dimensioni dovessero essere maggiori il file non
1529                               verrebbe generato.\footnotemark\\
1530     \macro{RLIMIT\_RSS}    &  L'ammontare massimo di memoria fisica dato al
1531                               processo. Il limite è solo una indicazione per
1532                               il kernel, qualora ci fosse un surplus di
1533                               memoria questa verrebbe assegnata.\\
1534     \macro{RLIMIT\_NPROC}  &  Il numero massimo di processi che possono essere
1535                               creati sullo stesso user id. Se il limite viene
1536                               raggiunto \func{fork} fallirà con un
1537                               \macro{EAGAIN}.\\
1538     \macro{RLIMIT\_NOFILE} &  Il numero massimo di file che il processo può
1539                               aprire. L'apertura di un ulteriore file fallirà
1540                               con un errore \macro{EMFILE}.\\
1541     \macro{RLIMIT\_MEMLOCK}&  L'ammontare massimo di memoria che può essere
1542                               bloccata (vedi \secref{sec:proc_mem_lock}).\\
1543     \macro{RLIMIT\_AS}     &  La dimensione massima di tutta la memoria che il
1544                               processo può ottenere. Se il processo tenta di
1545                               allocarne di più  funzioni come \func{brk},
1546                               \func{malloc} o \func{mmap} falliranno. \\
1547     \hline
1548   \end{tabular}
1549   \caption{Valori possibili dell'argomento \param{resource} delle funzioni
1550     \func{getrlimit} e \func{setrlimit}.} 
1551   \label{tab:sys_rlimit_values}
1552 \end{table}
1553
1554 \footnotetext{Settare questo limite a zero è la maniera più semplice per
1555   evitare la creazione di \file{core} file.}
1556
1557 È inoltre definita la costante \macro{RLIM\_INFINITY} che permette di
1558 sbloccare l'uso di una risorsa, ma solo un processo con i privilegi di
1559 amministratore può innalzare un limite al di sopra del valore corrente del
1560 limite massimo. Si tenga conto infine che tutti i limiti vengono ereditati dal
1561 processo padre attraverso una \func{fork} (vedi \secref{sec:proc_fork}) e
1562 mantenuti attraverso una \func{exec} (vedi \secref{sec:proc_exec}).
1563
1564
1565 \subsection{Le risorse di memoria e processore}
1566 \label{sec:sys_memory_res}
1567
1568 La gestione della memoria è già stata affrontata in dettaglio in
1569 \secref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1570 meccanismo della memoria virtuale attraverso la divisione della memoria fisica
1571 in pagine.
1572
1573 In genere questo è del tutto trasparente al singolo processo, ma in certi
1574 casi, come per l'I/O mappato in memoria (vedi \ref{sec:file_memory_map}) che
1575 usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
1576 dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
1577 gestire in maniera ottimale l'interazione della memoria allocata con il
1578 meccanismo della paginazione.
1579
1580 Di solito la dimensione delle pagine di memoria è fissata dall'architettura
1581 hardware, per cui in genere la dimensione delle pagine di memoria era una
1582 costante definita in fase di compilazione, ma oggi alcune architetture (ad
1583 esempio su Sun Sparc) permettono di variare questa dimensione, e non volendo
1584 dover fornire binari diversi per ogni possibile modello, è necessario poter
1585 utilizzare una funzione. 
1586
1587 In genere questa dimensione può essere ottenuta attraverso una chiamata a
1588 \func{sysconf} come \func{sysconf(\_SC\_PAGESIZE)}, ma in BSD 4.2 è stata
1589 introdotta una apposita funzione, \func{getpagesize}, che restituisce la
1590 dimensione delle pagine di memoria; il suo prototipo è:
1591 \begin{prototype}{unistd.h}{int getpagesize(void)}
1592   Legge le dimensioni delle pagine di memoria.
1593   
1594   \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
1595     sono previsti errori.}
1596 \end{prototype}
1597
1598 La funzione è prevista in SVr4, 4.4BSD e SUSv2, anche se questo ultimo
1599 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1600 ha eliminata. In Linux è implementata come una system call nelle architetture
1601 in cui essa è necessaria, ed in genere restituisce il valore del simbolo
1602 \macro{PAGE\_SIZE} del kernel, anche se le versioni delle librerie del C
1603 precedenti le \acr{glibc} 2.1 implementavano questa funzione restituendo
1604 sempre un valore statico.
1605
1606 Le \acr{glibc} forniscono, come specifica estensione GNU, altre due funzioni,
1607 \func{get\_phys\_pages} e \func{get\_avphys\_pages} che permettono di ottenere
1608 informazioni riguardo la memoria; i loro prototipi sono:
1609 \begin{functions}
1610   \headdecl{sys/sysinfo.h} 
1611   
1612   \funcdecl{long int get\_phys\_pages(void)} 
1613
1614   Legge il numero totale di pagine di memoria disponibili per il sistema.
1615   
1616   \funcdecl{long int get\_avphys\_pages(void)} 
1617   
1618   Legge il numero di pagine di memoria disponibili nel sistema. 
1619   
1620   \bodydesc{Le funzioni restituiscono un numero di pagine.}
1621 \end{functions}
1622
1623 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1624 rispettivamente con i parametri \macro{\_SC\_PHYS\_PAGES} e
1625 \macro{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1626 corrispondenti alla RAM della macchina; la seconda invece la memoria
1627 effettivamente disponibile per i processi.
1628
1629 Le \acr{glibc} supportano inoltre, come estenzioni GNU, due funzioni che
1630 restituiscono il numero di processori della macchina (e quello dei processori
1631 attivi); anche queste sono informazioni comunque ottenibili attraverso
1632 \func{sysconf} utilizzando rispettivamente i parametri
1633 \macro{\_SC\_NPROCESSORS\_CONF} e \macro{\_SC\_NPROCESSORS\_ONLN}.
1634
1635 Infine le \acr{glibc} riprendono da BSD la funzione \func{getloadavg} che
1636 permette di ottenere il carico di processore della macchina, in questo modo è
1637 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1638 Il suo prototipo è:
1639 \begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
1640   Legge il carico medio della macchina.
1641   
1642   \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
1643     errore.}
1644 \end{prototype}
1645
1646 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1647 di processi attivi sulla coda dello scheduler, calcolato su un diverso
1648 intervalli di tempo.  Il numero di intervalli che si vogliono leggere è
1649 specificato da \param{nelem}, dato che nel caso di Linux il carico viene
1650 valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti), questo è
1651 anche il massimo valore che può essere assegnato a questo argomento.
1652
1653
1654
1655 \section{La gestione dei tempi del sistema}
1656 \label{sec:sys_time}
1657
1658 In questa sezione, una volta introdotti i concetti base della gestione dei
1659 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
1660 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
1661 veri tempi di sistema associati ai processi, a quelle per convertire i vari
1662 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
1663 gestione di data e ora.
1664
1665
1666 \subsection{La misura del tempo in Unix}
1667 \label{sec:sys_unix_time}
1668
1669 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
1670 dati per la misure dei tempi all'interno del sistema: essi sono
1671 rispettivamente chiamati \textit{calendar time} e \textit{process time},
1672 secondo le definizioni:
1673 \begin{description}
1674 \item[\textit{calendar time}]: detto anche \textsl{tempo di calendario}. È il
1675   numero di secondi dalla mezzanotte del primo gennaio 1970, in tempo
1676   universale coordinato (o UTC), data che viene usualmente indicata con
1677   00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the Epoch}. Questo tempo viene
1678   anche chiamato anche GMT (Greenwich Mean Time) dato che l'UTC corrisponde
1679   all'ora locale di Greenwich.  È il tempo su cui viene mantenuto l'orologio
1680   del kernel, e viene usato ad esempio per indicare le date di modifica dei
1681   file o quelle di avvio dei processi. Per memorizzare questo tempo è stato
1682   riservato il tipo primitivo \type{time\_t}.
1683 \item[\textit{process time}]: detto talvolta \textsl{tempo di processore}.
1684   Viene misurato in \textit{clock tick}. Un tempo questo corrispondeva al
1685   numero di interruzioni effettuate dal timer di sistema, adesso lo standard
1686   POSIX richiede che esso sia pari al valore della costante
1687   \macro{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000, qualunque
1688   sia la risoluzione reale dell'orologio di sistema e la frequenza delle
1689   interruzioni del timer.\footnote{quest'ultima, come accennato in
1690     \secref{sec:proc_hierarchy}, è invece data dalla costante \macro{HZ}.} Il
1691   dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi una
1692   risoluzione del microsecondo. Il numero di tick al secondo può essere
1693   ricavato anche attraverso \func{sysconf} (vedi \secref{sec:sys_sysconf}). Il
1694   vecchio simbolo \macro{CLK\_TCK} definito in \file{time.h} è ormai
1695   considerato obsoleto.
1696 \end{description}
1697
1698 In genere si usa il \textit{calendar time} per esprimere le date dei file e le
1699 informazioni analoghe che riguardano i cosiddetti \textsl{tempi di orologio},
1700 che vengono usati ad esempio per i demoni che compiono lavori amministrativi
1701 ad ore definite, come \cmd{cron}. 
1702
1703 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
1704 tempo locale, utilizzando le opportune informazioni di localizzazione
1705 (specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
1706 mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
1707 dall'orologio hardware del calcolatore.
1708
1709 Anche il \textit{process time} di solito si esprime in secondi, ma provvede
1710 una precisione ovviamente superiore al \textit{calendar time} (che è mantenuto
1711 dal sistema con una granularità di un secondo) e viene usato per tenere conto
1712 dei tempi di esecuzione dei processi. Per ciascun processo il kernel calcola
1713 tre tempi diversi:
1714 \begin{description*}
1715 \item[\textit{clock time}]: il tempo \textsl{reale} (viene chiamato anche
1716   \textit{wall clock time}) passato dall'avvio del processo. Chiaramente tale
1717   tempo dipende anche dal carico del sistema e da quanti altri processi
1718   stavano girando nello stesso periodo.
1719 \item[\textit{user time}]: il tempo che la CPU ha impiegato nell'esecuzione
1720   delle istruzioni del processo in user space.
1721 \item[\textit{system time}]: il tempo che la CPU ha impiegato nel kernel per
1722   eseguire delle system call per conto del processo.
1723 \end{description*}
1724
1725 In genere la somma di \textit{user time} e \textit{system time} indica il
1726 tempo di processore totale in cui il sistema è stato effettivamente impegnato
1727 nell'eseguire un certo processo e viene chiamato \textit{CPU time} o
1728 \textsl{tempo di CPU}.
1729
1730
1731
1732 \subsection{La gestione del \textit{process time}}
1733 \label{sec:sys_cpu_times}
1734
1735 Di norma tutte le operazioni del sistema fanno sempre riferimento al
1736 \textit{calendar time}, l'uso del \textit{process time} è riservato a quei
1737 casi in cui serve conoscere i tempi di esecuzione di un processo (ad esempio
1738 per valutarne l'efficienza). In tal caso infatti fare ricorso al
1739 \textit{calendar time} è inutile in quanto il tempo può essere trascorso mentre
1740 un altro processo era in esecuzione o in attesa del risultato di una
1741 operazione di I/O. 
1742
1743 La funzione più semplice per leggere il \textit{process time} di un processo è
1744 \func{clock}, che da una valutazione approssimativa del tempo di CPU
1745 utilizzato dallo stesso; il suo prototipo è:
1746 \begin{prototype}{time.h}{clock\_t clock(void)}
1747   Legge il valore corrente del tempo di CPU.
1748   
1749   \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
1750     caso di errore.}
1751 \end{prototype}
1752
1753 La funzione restituisce il tempo in tick, quindi se si vuole il tempo in
1754 secondi occorre moltiplicare il risultato per la costante
1755 \macro{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
1756   POSIX richiede che \macro{CLOCKS\_PER\_SEC} sia definito pari a 1000000
1757   indipendetemente dalla risoluzione del timer di sistema.} In genere
1758 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
1759 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
1760 riprenderà lo stesso valore iniziale.
1761
1762 Come accennato in \secref{sec:sys_unix_time} il tempo di CPU è la somma di
1763 altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
1764 quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
1765 possono essere letti attraverso la funzione \func{times}, il cui prototipo è:
1766 \begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
1767   Legge in \param{buf} il valore corrente dei tempi di processore.
1768   
1769   \bodydesc{La funzione ritorna il numero di clock tick dall'avvio del sistema
1770     in caso di successo e -1 in caso di errore.}
1771 \end{prototype}
1772
1773 La funzione restituisce i valori di process time del processo corrente in una
1774 struttura di tipo \var{tms}, la cui definizione è riportata in
1775 \secref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi due,
1776 \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
1777 \textit{system time} del processo, così come definiti in
1778 \secref{sec:sys_unix_time}.
1779
1780 \begin{figure}[!htb]
1781   \footnotesize
1782   \centering
1783   \begin{minipage}[c]{15cm}
1784     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1785 struct tms {
1786        clock_t tms_utime;  /* user time */
1787        clock_t tms_stime;  /* system time */
1788        clock_t tms_cutime; /* user time of children */
1789        clock_t tms_cstime; /* system time of children */
1790 };
1791     \end{lstlisting}
1792   \end{minipage} 
1793   \normalsize 
1794   \caption{La struttura \var{tms} dei tempi di processore associati a un
1795     processo.} 
1796   \label{fig:sys_tms_struct}
1797 \end{figure}
1798
1799 Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
1800   time} ed del \textit{system time} di tutti i processi figli che sono
1801 terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
1802 \var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
1803 ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.
1804
1805 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
1806 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
1807 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
1808 lo stato di teminazione di tutti i suoi figli, questi processi ``nipoti'' non
1809 verranno considerati nel calcolo di questi tempi.
1810
1811
1812
1813 \subsection{Le funzioni per il \textit{calendar time}}
1814 \label{sec:sys_time_base}
1815
1816 Come anticipato in \secref{sec:sys_unix_time} il \textit{calendar time} è
1817 mantenuto dal kernel in una variabile di tipo \type{time\_t}, che usualmente
1818 corrisponde ad un tipo nativo (in Linux è un intero a 32 bit).  Il valore
1819 corrente del \textit{calendar time}, che indicheremo come \textsl{tempo di
1820   sistema}, può essere ottenuto con la funzione \func{time} che lo restituisce
1821 in nel suddetto formato; il suo prototipo è:
1822 \begin{prototype}{time.h}{time\_t time(time\_t *t)}
1823   Legge il valore corrente del \textit{calendar time}.
1824   
1825   \bodydesc{La funzione ritorna il valore del \textit{calendar time} in caso
1826     di successo e -1 in caso di errore, che può essere solo \macro{EFAULT}.}
1827 \end{prototype}
1828 \noindent dove \param{t}, se non nullo, deve essere  l'indirizzo di una
1829 variabile su cui duplicare il valore di ritorno.
1830
1831 Analoga a \func{time} è la funzione \func{stime} che serve per effettuare
1832 l'operazione inversa, e cioè per settare il tempo di sistema qualora questo
1833 sia necessario; il suo prototipo è:
1834 \begin{prototype}{time.h}{int stime(time\_t *t)}
1835   Setta a \param{t} il valore corrente del \textit{calendar time}.
1836   
1837   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1838     che può essere \macro{EFAULT} o \macro{EPERM}.}
1839 \end{prototype}
1840 \noindent dato che modificare l'ora ha un impatto su tutto il sistema 
1841 il cambiamento dell'orologio è una operazione privilegiata e questa funzione
1842 può essere usata solo da un processo con i privilegi di amministratore,
1843 altrimenti la chiamata fallirà con un errore di \macro{EPERM}.
1844
1845 Data la scarsa precisione nell'uso di \type{time\_t} (che ha una risoluzione
1846 massima di un secondo) quando si devono effettuare operazioni sui tempi di
1847 norma l'uso delle funzioni precedenti è sconsigliato, ed esse sono di solito
1848 sostituite da \func{gettimeofday} e \func{settimeofday},\footnote{le due
1849   funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
1850   \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
1851   in BSD4.3 sono indicate come sostitute delle precedenti.}  mentre i cui
1852 prototipi sono:
1853 \begin{functions}
1854   \headdecl{sys/time.h}
1855   \headdecl{time.h}
1856   
1857   \funcdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)} 
1858
1859   Legge il tempo corrente del sistema.
1860   
1861   \funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
1862     *tz)}
1863   
1864   Setta il tempo di sistema.
1865   
1866   \bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
1867     caso di errore, nel qual caso \var{errno} può assumere il valori
1868     \macro{EINVAL} \macro{EFAULT} e per \func{settimeofday} anche
1869     \macro{EPERM}.}
1870 \end{functions}
1871
1872 Queste funzioni utilizzano una struttura di tipo \var{timeval}, la cui
1873 definizione, insieme a quella della analoga \var{timespec}, è riportata in
1874 \figref{fig:sys_timeval_struct}. Le \acr{glibc} infatti provvedono queste due
1875 rappresentazioni alternative del \textit{calendar time} che rispetto a
1876 \type{time\_t} consentono rispettivamente precisioni del microsecondo e del
1877 nanosecondo.\footnote{la precisione è solo teorica, la precisione reale della
1878   misura del tempo dell'orologio di sistema non dipende dall'uso di queste
1879   strutture.}
1880
1881 \begin{figure}[!htb]
1882   \footnotesize \centering
1883   \begin{minipage}[c]{15cm}
1884     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1885 struct timeval 
1886 {
1887     long tv_sec;            /* seconds */
1888     long tv_usec;           /* microseconds */
1889 };
1890 struct timespec {
1891     time_t  tv_sec;         /* seconds */
1892     long    tv_nsec;        /* nanoseconds */
1893 };
1894     \end{lstlisting}
1895   \end{minipage} 
1896   \normalsize 
1897   \caption{Le strutture \var{timeval} e \var{timespec} usate per una
1898     rappresentazione ad alta risoluzione del \textit{calendar time}.}
1899   \label{fig:sys_timeval_struct}
1900 \end{figure}
1901
1902 Come nel caso di \func{stime} anche \func{settimeofday} (e qualunque funzione
1903 vada a modificare l'orologio di sistema, come quelle che tratteremo in
1904 seguito) può essere utilizzata solo da un processo coi privilegi di
1905 amministratore.  Il secondo parametro di entrambe le funzioni è una struttura
1906 \var{timezone}, che storicamente veniva utilizzata per specificare appunto la
1907 \textit{timezone}, cioè l'insieme del fuso orario e delle convenzioni per
1908 l'ora legale che permettevano il passaggio dal tempo universale all'ora
1909 locale. Questo parametro è obsoleto e in Linux non è mai stato utilizzato e
1910 non è supportato né dalle vecchie \textsl{libc5}, né dalle \textsl{glibc}:
1911 pertanto deve essere sempre settato a \macro{NULL}.
1912
1913 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
1914 in quanto esse effettuano un cambiamento immediato. Ad esempio se si porta
1915 avanti l'orologio si possono perdere delle esecuzioni di \cmd{cron}
1916 programmate nell'intervallo che si è saltato. Per questo motivo la modalità
1917 più corretta per settare l'ora è quella di usare la funzione \func{adjtime},
1918 il cui prototipo è:
1919 \begin{prototype}{sys/time.h}
1920 {int adjtime(const struct timeval *delta, struct timeval *olddelta)} 
1921   
1922   Aggiusta del valore \param{delta} l'orologio di sistema.
1923   
1924   \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
1925     errore, nel qual caso \var{errno} assumerà il valore \macro{EPERM}.}
1926 \end{prototype}
1927
1928 Questa funzione permette di avere un aggiustamento graduale del tempo di
1929 sistema in modo che esso sia sempre monotonicamente crescente. Il valore di
1930 \param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
1931 positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
1932 il tempo richiesto, altrimenti sarà rallentato. Il secondo parametro viene
1933 usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
1934 effettuto.
1935
1936 Linux poi prevede un'altra funzione, \func{adjtimex}, che consente un
1937 aggiustamento molto più dettagliato, permettendo ad esempio anche di
1938 modificare anche la velocità dell'orologio di sistema.  Il suo prototipo è:
1939 \begin{prototype}{sys/timex.h}
1940 {int adjtimex(struct timex *buf)} 
1941   
1942   Aggiusta del valore \param{delta} l'orologio di sistema.
1943   
1944   \bodydesc{La funzione restituisce lo stato dell'orologio (un valore $>0$) in
1945     caso di successo e -1 in caso di errore, nel qual caso \var{errno}
1946     assumerà i valori \macro{EFAULT}, \macro{EINVAL} ed \macro{EPERM}.}
1947 \end{prototype}
1948
1949 La funzione richiede una struttura di tipo \var{timex}, la cui definizione,
1950 così come effettuata in \file{sys/timex.h}, è riportata in
1951 \figref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore del
1952 campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
1953 specificato in un opportuno campo di \var{timex}, deve essere settato. Un
1954 valore nullo serve per leggere i parametri correnti; i valori diversi da zero
1955 devono essere specificati come OR binario delle costanti riportate in
1956 \secref{tab:sys_timex_mode}.
1957
1958 \begin{figure}[!htb]
1959   \footnotesize \centering
1960   \begin{minipage}[c]{15cm}
1961     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1962 struct timex {
1963     unsigned int modes;   /* mode selector */
1964     long int offset;      /* time offset (usec) */
1965     long int freq;        /* frequency offset (scaled ppm) */
1966     long int maxerror;    /* maximum error (usec) */
1967     long int esterror;    /* estimated error (usec) */
1968     int status;           /* clock command/status */
1969     long int constant;    /* pll time constant */
1970     long int precision;   /* clock precision (usec) (read only) */
1971     long int tolerance;   /* clock frequency tolerance (ppm) (read only) */
1972     struct timeval time;  /* (read only) */
1973     long int tick;        /* (modified) usecs between clock ticks */
1974     long int ppsfreq;     /* pps frequency (scaled ppm) (ro) */
1975     long int jitter;      /* pps jitter (us) (ro) */
1976     int shift;            /* interval duration (s) (shift) (ro) */
1977     long int stabil;      /* pps stability (scaled ppm) (ro) */
1978     long int jitcnt;      /* jitter limit exceeded (ro) */
1979     long int calcnt;      /* calibration intervals (ro) */
1980     long int errcnt;      /* calibration errors (ro) */
1981     long int stbcnt;      /* stability limit exceeded (ro) */
1982 };
1983     \end{lstlisting}
1984   \end{minipage} 
1985   \normalsize 
1986   \caption{La struttura \var{timex} per il controllo dell'orologio di sistema.}
1987   \label{fig:sys_timex_struct}
1988 \end{figure}
1989
1990 La funzione utilizza il meccanismo di David L. Mills, descritto nell'RFC~1305,
1991 che è alla base del protocollo NTP; la funzione è specifica di Linux e non
1992 deve essere usata se la portabilità è un requisito, le \acr{glibc} provvedono
1993 anche un suo omonimo \func{ntp\_adjtime}.  La trattazione completa di questa
1994 funzione necessita di una lettura approfondita del meccanismo descritto
1995 nell'RFC~1305, ci limitiamo a descrivere in \tabref{tab:sys_timex_mode} i
1996 principali valori utilizzabili per il campo \var{mode}, un elenco più
1997 dettagliato del significato dei vari campi della struttura \var{timex} può
1998 essere ritrovato in \cite{glibc}.
1999
2000 \begin{table}[htb]
2001   \footnotesize
2002   \centering
2003   \begin{tabular}[c]{|l|c| p{10cm}|}
2004     \hline
2005     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2006     \hline
2007     \hline
2008     \macro{ADJ\_OFFSET}         & 0x0001 & Setta la differenza fra il tempo
2009                                            reale e l'orologio di sistema, che 
2010                                            deve essere indicata in microsecondi
2011                                            nel campo \var{offset} di
2012                                            \var{timex}.\\ 
2013     \macro{ADJ\_FREQUENCY}      & 0x0002 & Setta la differenze in frequenza
2014                                            fra il tempo reale e l'orologio di
2015                                            sistema, che deve essere indicata
2016                                            in parti per milione nel campo
2017                                            \var{frequency} di \var{timex}.\\
2018     \macro{ADJ\_MAXERROR}       & 0x0004 & Setta il valore massimo dell'errore
2019                                            sul tempo, espresso in microsecondi 
2020                                            nel campo \var{maxerror} di
2021                                            \var{timex}.\\ 
2022     \macro{ADJ\_ESTERROR}       & 0x0008 & Setta la stima dell'errore
2023                                            sul tempo, espresso in microsecondi 
2024                                            nel campo \var{esterror} di
2025                                            \var{timex}.\\
2026     \macro{ADJ\_STATUS}         & 0x0010 & Setta alcuni
2027                                            valori di stato interni usati dal
2028                                            sistema nella gestione
2029                                            dell'orologio specificati nel campo
2030                                            \var{status} di \var{timex}.\\ 
2031     \macro{ADJ\_TIMECONST}      & 0x0020 & Setta la larghezza di banda del PLL
2032                                            implementato dal kernel,
2033                                            specificato nel campo
2034                                            \var{constant} di \var{timex}.\\ 
2035     \macro{ADJ\_TICK}           & 0x4000 & Setta il valore dei tick del timer
2036                                            in microsecondi, espresso nel campo
2037                                            \var{tick} di \var{timex}.\\ 
2038     \macro{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Setta uno spostamento una tantum 
2039                                            dell'orologio secondo il valore del
2040                                            campo \var{offset} simulando il
2041                                            comportamento di \func{adjtime}.\\ 
2042     \hline
2043   \end{tabular}
2044   \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
2045     struttura \var{timex}.} 
2046   \label{tab:sys_timex_mode}
2047 \end{table}
2048
2049 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
2050 sintassi specificata per la forma equivalente di questa funzione definita come
2051 \func{ntp\_adjtime}, utilizzando il prefisso \macro{MOD} al posto di
2052 \macro{ADJ}.
2053
2054 \begin{table}[htb]
2055   \footnotesize
2056   \centering
2057   \begin{tabular}[c]{|l|c| p{10cm}|}
2058     \hline
2059     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2060     \hline
2061     \hline
2062     \macro{TIME\_OK}   & 0 & L'orologio è sincronizzato.\\ 
2063     \macro{TIME\_INS}  & 1 & insert leap second.\\ 
2064     \macro{TIME\_DEL}  & 2 & delete leap second.\\ 
2065     \macro{TIME\_OOP}  & 3 & leap second in progress.\\ 
2066     \macro{TIME\_WAIT} & 4 & leap second has occurred.\\ 
2067     \macro{TIME\_BAD}  & 5 & L'orologio non è sincronizzato.\\ 
2068     \hline
2069   \end{tabular}
2070   \caption{Possibili valori di ritorno di \func{adjtimex}.} 
2071   \label{tab:sys_adjtimex_return}
2072 \end{table}
2073
2074 La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
2075 sistema; questo può assumere i valori riportati in
2076 \tabref{tab:sys_adjtimex_return}.  Un valore di -1 viene usato per riportare
2077 un errore; al solito se si cercherà di modificare l'orologio di sistema
2078 (specificando un \var{mode} diverso da zero) senza avere i privilegi di
2079 amministratore si otterrà un errore di \macro{EPERM}.
2080
2081
2082 \subsection{La gestione delle date.}
2083 \label{sec:sys_date}
2084
2085 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
2086 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
2087 illustrate, se han senso per specificare un intervallo, non sono molto
2088 intuitive quando si deve esprimere un'ora o una data.  Per questo motivo è
2089 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2090   time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2091   time} usuale in ore, minuti, secondi, ecc.
2092
2093 \begin{figure}[!htb]
2094   \footnotesize \centering
2095   \begin{minipage}[c]{15cm}
2096     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
2097 struct tm {
2098         int     tm_sec;         /* seconds */
2099         int     tm_min;         /* minutes */
2100         int     tm_hour;        /* hours */
2101         int     tm_mday;        /* day of the month */
2102         int     tm_mon;         /* month */
2103         int     tm_year;        /* year */
2104         int     tm_wday;        /* day of the week */
2105         int     tm_yday;        /* day in the year */
2106         int     tm_isdst;       /* daylight saving time */
2107         long int tm_gmtoff;     /* Seconds east of UTC.  */
2108         cost char *tm_zone;     /* Timezone abbreviation.  */
2109 };
2110     \end{lstlisting}
2111   \end{minipage} 
2112   \normalsize 
2113   \caption{La struttura \var{tm} per una rappresentazione del tempo in termini
2114     di ora, minuti, secondi, ecc.}
2115   \label{fig:sys_tm_struct}
2116 \end{figure}
2117
2118 Questo viene effettuato attraverso una opportuna struttura \var{tm}, la cui
2119 definizione è riportata in \figref{fig:sys_tm_struct}, ed è in genere questa
2120 struttura che si utilizza quando si deve specificare un tempo a partire dai
2121 dati naturali (ora e data), dato che essa consente anche di trattare la
2122 gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
2123   \var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste per da BSD e
2124   dalle \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la
2125   forma in \figref{fig:sys_tm_struct}.}
2126
2127 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2128 da quelle usate per convertire gli altri formati in questo, usando o meno
2129 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2130 tempo in una stringa contenente data ed ora, i loro prototipi sono:
2131 \begin{functions}
2132   \headdecl{time.h}
2133   \funcdecl{char *asctime(const struct tm *tm)} 
2134   Produce una stringa con data e ora partendo da un valore espresso in
2135   \textit{broken-down time}.
2136
2137   \funcdecl{char *ctime(const time\_t *timep)} 
2138   Produce una stringa con data e ora partendo da un valore espresso in
2139   in formato \type{time\_t}.
2140   
2141   \funcdecl{struct tm *gmtime(const time\_t *timep)} 
2142   Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2143   \textit{broken-down time} espresso in UTC.
2144
2145   \funcdecl{struct tm *localtime(const time\_t *timep)} 
2146   Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2147   \textit{broken-down time} espresso nell'ora locale.
2148
2149   \funcdecl{time\_t mktime(struct tm *tm)}   
2150   Converte il \textit{broken-down time} in formato \type{time\_t}.
2151   
2152   \bodydesc{Tutte le funzioni restituiscono un puntatore al risultato in caso
2153   di successo e \macro{NULL} in caso di errore, tranne che \func{mktime} che
2154   restitusce direttamente il valore o -1 in caso di errore.}
2155 \end{functions}
2156
2157 Le prime due funzioni, \func{asctime} e \func{ctime} servono per poter
2158 stampare in forma leggibile un tempo; esse restituiscono il puntatore ad una
2159 stringa, allocata staticamente, nella forma:
2160 \begin{verbatim}
2161 "Wed Jun 30 21:49:08 1993\n"
2162 \end{verbatim}
2163 e settano anche la variabile \var{tzname} con l'infomazione della \textit{time
2164   zone} corrente; \func{ctime} è banalmente definita in termini di
2165 \func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
2166 statica rende le funzioni non rientranti POSIX.1c e SUSv2 prevedono due
2167 sostitute rientranti, il cui nome è al solito ottenuto appendendo un
2168 \code{\_r}, che prendono un secondo parametro \code{char *buf}, in cui
2169 l'utente deve specificare il buffer su cui la stringa deve essere copiata
2170 (deve essere di almeno 26 caratteri).
2171
2172 Le altre tre funzioni, \func{gmtime}, \func{localtime} e \func{mktime} servono
2173 per convertire il tempo dal formato \type{time\_t} a quello di \var{tm} e
2174 viceversa; \func{gmtime} effettua la conversione usando il tempo coordinato
2175 universale (UTC), cioè l'ora di Greenwich; mentre \func{localtime} usa l'ora
2176 locale; \func{mktime} esegue la conversione inversa.  
2177
2178 Anche in questo caso le prime due funzioni restituiscono l'indirizzo di una
2179 struttura allocata staticamente, per questo sono state definite anche altre
2180 due versioni rientranti (con la solita estensione \code{\_r}), che prevedono
2181 un secondo parametro \code{struct tm *result}, fornito dal chiamante, che deve
2182 preallocare la struttura su cui sarà restituita la conversione.
2183
2184 Come mostrato in \figref{fig:sys_tm_struct} il \textit{broken-down time}
2185 permette di tenere conto anche della differenza fra tempo universale e ora
2186 locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
2187 variabli globali mostrate in \figref{fig:sys_tzname}, cui si accede quando si
2188 include \file{time.h}. Queste variabili vengono settate quando si chiama una
2189 delle precedenti funzioni di conversione, oppure invocando direttamente la
2190 funzione \func{tzset}, il cui prototipo è:
2191 \begin{prototype}{sys/timex.h}
2192 {void tzset(void)} 
2193   
2194   Setta le variabili globali della \textit{time zone}.
2195   
2196   \bodydesc{La funzione non ritorna niente e non dà errori.}
2197 \end{prototype}
2198
2199 La funzione inizializza le varaibili di \figref{fig:sys_tzname} a partire dal
2200 valore della variabile di ambiente \macro{TZ}, se quest'ultima non è definita
2201 verrà usato il file \file{/etc/localtime}.
2202
2203 \begin{figure}[!htb]
2204   \footnotesize
2205   \centering
2206   \begin{minipage}[c]{15cm}
2207     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
2208 extern char *tzname[2];
2209 extern long timezone;
2210 extern int daylight;
2211     \end{lstlisting}
2212   \end{minipage} 
2213   \normalsize 
2214   \caption{Le variabili globali usate per la gestione delle \textit{time
2215       zone}.}  
2216   \label{fig:sys_tzname}
2217 \end{figure}
2218
2219 La variabile \var{tzname} contiene due stringhe, che indicano i due nomi
2220 standard della \textit{time zone} corrente. La prima è il nome per l'ora
2221 solare, la seconda per l'ora legale.\footnote{anche se sono indicati come
2222   \code{char *} non è il caso di modificare queste stringhe.} La variabile
2223 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2224 \var{daylight} indica se è attiva o meno l'ora legale. 
2225
2226
2227
2228 \section{La gestione degli errori}
2229 \label{sec:sys_errors}
2230
2231 La gestione degli errori è in genere una materia complessa. Inoltre il modello
2232 utilizzato dai sistema unix-like è basato sull'architettura a processi, e
2233 presenta una serie di problemi nel caso lo si debba usare con i thread.
2234 Esamineremo in questa sezione le sue caratteristiche principali.
2235
2236
2237 \subsection{La variabile \var{errno}}
2238 \label{sec:sys_errno}
2239
2240 Quasi tutte le funzioni delle librerie del C sono in  grado di individuare e
2241 riportare condizioni di errore, ed è una buona norma di programmazione
2242 controllare sempre che le funzioni chiamate si siano concluse correttamente.
2243
2244 In genere le funzioni di libreria usano un valore speciale per indicare che
2245 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
2246 costante \macro{EOF} (a seconda della funzione); ma questo valore segnala solo
2247 che c'è stato un errore, non il tipo di errore. 
2248
2249 Per riportare il tipo di errore il sistema usa la variabile globale
2250 \var{errno},\footnote{L'uso di una variabile globale può comportare alcuni
2251   problemi (ad esempio nel caso dei thread) ma lo standard ISO C consente
2252   anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
2253   può anche usare una macro, e questo è infatti il modo usato da Linux per
2254   renderla locale ai singoli thread.} definita nell'header \file{errno.h}; la
2255 variabile è in genere definita come \ctyp{volatile} dato che può essere
2256 cambiata in modo asincrono da un segnale (si veda \ref{sec:sig_sigchld} per un
2257 esempio, ricordando quanto trattato in \ref{sec:proc_race_cond}), ma dato che
2258 un manipolatore di segnale scritto bene salva e ripristina il valore della
2259 variabile, di questo non è necessario preoccuparsi nella programmazione
2260 normale.
2261
2262 I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},
2263 nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
2264 costanti numeriche che identificano i vari errori; essi iniziano tutti per
2265 \macro{E} e si possono considerare come nomi riservati. In seguito faremo
2266 sempre riferimento a tali valori, quando descriveremo i possibili errori
2267 restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
2268 codice relativo ad un valore numerico con l'opzione \cmd{-l}.
2269
2270 Il valore di \var{errno} viene sempre settato a zero all'avvio di un
2271 programma, gran parte delle funzioni di libreria settano \var{errno} ad un
2272 valore diverso da zero in caso di errore. Il valore è invece indefinito in
2273 caso di successo, perché anche se una funzione ha successo, può chiamarne
2274 altre al suo interno che falliscono, modificando così \var{errno}.
2275
2276 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
2277 essere il risultato di un errore precedente) e non lo si può usare per
2278 determinare quando o se una chiamata a funzione è fallita.  La procedura da
2279 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
2280 verificato il fallimento della funzione attraverso il suo codice di ritorno.
2281
2282
2283 \subsection{Le funzioni \func{strerror} e \func{perror}}
2284 \label{sec:sys_strerror}
2285
2286 Benché gli errori siano identificati univocamente dal valore numerico di
2287 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
2288 riportare in opportuni messaggi le condizioni di errore verificatesi.  La
2289 prima funzione che si può usare per ricavare i messaggi di errore è
2290 \func{strerror}, il cui prototipo è:
2291 \begin{prototype}{string.h}{char *strerror(int errnum)} 
2292   Ritorna una stringa (statica) che descrive l'errore il cui codice è passato
2293   come parametro.
2294 \end{prototype}
2295
2296 In generale \func{strerror} viene usata passando \var{errno} come parametro;
2297 nel caso si specifichi un codice sbagliato verrà restituito un messaggio di
2298 errore sconosciuto. La funzione utilizza una stringa statica che non deve
2299 essere modificata dal programma e che è utilizzabile solo fino ad una chiamata
2300 successiva a \func{strerror}; nel caso si usino i thread è
2301 provvista\footnote{questa funzione è una estensione GNU, non fa parte dello
2302   standard POSIX.} una versione apposita:
2303 \begin{prototype}{string.h}
2304 {char *strerror\_r(int errnum, char *buff, size\_t size)} 
2305   Analoga a \func{strerror} ma ritorna il messaggio in un buffer
2306   specificato da \param{buff} di lunghezza massima (compreso il terminatore)
2307   \param{size}.
2308 \end{prototype}
2309 \noindent
2310 che utilizza un buffer che il singolo thread deve allocare, per evitare i
2311 problemi connessi alla condivisione del buffer statico. Infine, per completare
2312 la caratterizzazione dell'errore, si può usare anche la variabile
2313 globale\footnote{anche questa è un'estensione GNU.}
2314 \var{program\_invocation\_short\_name} che riporta il nome del programma
2315 attualmente in esecuzione.
2316
2317 Una seconda funzione usata per riportare i codici di errore in maniera
2318 automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) è
2319 \func{perror}, il cui prototipo è:
2320 \begin{prototype}{stdio.h}{void perror (const char *message)} 
2321   Stampa il messaggio di errore relativo al valore corrente di \var{errno}
2322   sullo standard error; preceduto dalla stringa \var{message}.
2323 \end{prototype}
2324 i messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
2325 in \capref{cha:errors}), e, usando il valore corrente di \var{errno}, si
2326 riferiscono all'ultimo errore avvenuto. La stringa specificata con
2327 \var{message} viene stampato prime del messaggio d'errore, seguita dai due
2328 punti e da uno spazio, il messaggio è terminato con un a capo.
2329
2330 Il messaggio può essere riportato anche usando altre variabili globali
2331 dichiarate in \file{errno.h}:
2332 \begin{verbatim}
2333    const char *sys_errlist[];
2334    int sys_nerr;
2335 \end{verbatim}
2336 la prima contiene i puntatori alle stringhe di errore indicizzati da
2337 \var{errno}; la seconda esprime il valore più alto per un codice di errore,
2338 l'utilizzo di questa stringa è sostanzialmente equivalente a quello di
2339 \func{strerror}.
2340
2341 In \nfig\ è riportata la sezione attinente del codice del programma
2342 \cmd{errcode}, che può essere usato per stampare i messaggi di errore e le
2343 costanti usate per identificare i singoli errori; il sorgente completo del
2344 programma è allegato nel file \file{ErrCode.c} e contiene pure la gestione
2345 delle opzioni e tutte le definizioni necessarie ad associare il valore
2346 numerico alla costante simbolica. In particolare si è riportata la sezione che
2347 converte la stringa passata come parametro in un intero (\texttt{\small
2348   1--2}), controllando con i valori di ritorno di \func{strtol} che la
2349 conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi stampa,
2350 a seconda dell'opzione scelta il messaggio di errore (\texttt{\small 11--14})
2351 o la macro (\texttt{\small 15--17}) associate a quel codice.
2352
2353 \begin{figure}[!htb]
2354   \footnotesize
2355   \begin{lstlisting}{}
2356     /* convert string to number */
2357     err = strtol(argv[optind], NULL, 10);
2358     /* testing error condition on conversion */
2359     if (err==LONG_MIN) {
2360         perror("Underflow on error code");
2361         return 1;
2362     } else if (err==LONG_MIN) {
2363         perror("Overflow on error code");
2364         return 1;
2365     }
2366     /* conversion is fine */
2367     if (message) {
2368         printf("Error message for %d is %s\n", err, strerror(err));
2369     }
2370     if (label) {
2371         printf("Error label for %d is %s\n", err, err_code[err]);
2372     }
2373   \end{lstlisting}
2374   \caption{Codice per la stampa del messaggio di errore standard.}
2375   \label{fig:sys_err_mess}
2376 \end{figure}
2377
2378
2379
2380 %%% Local Variables: 
2381 %%% mode: latex
2382 %%% TeX-master: "gapil"
2383 %%% End: