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