5ba240a08baa8d9bfbe8e4b6356ac5e410a8df81
[gapil.git] / system.tex
1 %% system.tex
2 %%
3 %% Copyright (C) 2000-2006 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 "Un preambolo",
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 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 sez.~\ref{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 tab.~\ref{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 tab.~\ref{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 sez.~\ref{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 ``\textsl{standardese}''.}. Lo standard prevede che ci siano 13 macro che
153 descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
154 riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
155 file, riportate in tab.~\ref{tab:sys_file_macro}).
156
157 \begin{table}[htb]
158   \centering
159   \footnotesize
160   \begin{tabular}[c]{|l|r|p{7cm}|}
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                               sez.~\ref{sec:sys_time_base})).\\  
177     \const{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
178                               processo (vedi sez.~\ref{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 tab.~\ref{tab:sys_posix1_general}.
200
201 \begin{table}[htb]
202   \centering
203   \footnotesize
204   \begin{tabular}[c]{|l|r|p{7cm}|}
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                                          \textit{timezone} (vedi
222                                          sez.~\ref{sec:sys_date}). \\ 
223     \const{\_POSIX\_NGROUPS\_MAX}&    0& numero di gruppi supplementari per
224                                          processo (vedi 
225                                          sez.~\ref{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                                    sez.~\ref{sec:sess_job_control}).\\
255     \macro{\_POSIX\_SAVED\_IDS}  & il sistema supporta gli identificatori del 
256                                    gruppo \textit{saved} (vedi 
257                                    sez.~\ref{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 tab.~\ref{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 tab.~\ref{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 sez.~\ref{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 tab.~\ref{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
321                                   ad una funzione della famiglia \func{exec}.\\
322       \texttt{\_SC\_CHILD\_MAX} & \const{\_CHILD\_MAX}&
323                                   Il numero massimo di processi contemporanei
324                                   che un utente può eseguire.\\
325       \texttt{\_SC\_OPEN\_MAX}  & \const{\_OPEN\_MAX}&
326                                   Il numero massimo di file che un processo può
327                                   mantenere aperti in contemporanea.\\
328       \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
329                                   Il massimo numero di stream che un processo
330                                   può mantenere aperti in contemporanea. Questo
331                                   limite previsto anche dallo standard ANSI C,
332                                   che specifica la macro {FOPEN\_MAX}.\\
333       \texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
334                                   La dimensione massima di un nome di una
335                                   \texttt{timezone} (vedi
336                                   sez.~\ref{sec:sys_date}).\\
337       \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
338                                   Massimo numero di gruppi supplementari che
339                                   può avere un processo (vedi
340                                   sez.~\ref{sec:proc_access_id}).\\
341       \texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}& 
342                                   Valore massimo del tipo di dato
343                                   \type{ssize\_t}.\\ 
344       \texttt{\_SC\_CLK\_TCK}   & \const{CLK\_TCK} &
345                                   Il numero di \textit{clock tick} al secondo,
346                                   cioè l'unità di misura del
347                                   \itindex{process~time} \textit{process
348                                     time} (vedi
349                                   sez.~\ref{sec:sys_unix_time}).\\  
350       \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
351                                   Indica se è supportato il \textit{job
352                                     control} (vedi
353                                   sez.~\ref{sec:sess_job_control}) in stile
354                                   POSIX.\\ 
355       \texttt{\_SC\_SAVED\_IDS} & \macro{\_POSIX\_SAVED\_IDS}&
356                                   Indica se il sistema supporta i
357                                   \textit{saved id} (vedi
358                                   sez.~\ref{sec:proc_access_id}).\\  
359       \texttt{\_SC\_VERSION}    & \const{\_POSIX\_VERSION} &
360                                   Indica il mese e l'anno di approvazione
361                                   della revisione dello standard POSIX.1 a cui
362                                   il sistema fa riferimento, nel formato
363                                   YYYYMML, la revisione più recente è 199009L,
364                                   che indica il Settembre 1990.\\ 
365      \hline
366     \end{tabular}
367   \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
368   \label{tab:sys_sysconf_par}
369 \end{table}
370
371 In generale ogni limite o caratteristica del sistema per cui è definita una
372 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
373 essere ottenuto attraverso una chiamata a \func{sysconf}. Il valore si otterrà
374 specificando come valore dell'argomento \param{name} il nome ottenuto
375 aggiungendo \code{\_SC\_} ai nomi delle macro definite dai primi due, o
376 sostituendolo a \code{\_POSIX\_} per le macro definite dagli gli altri due.
377
378 In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
379 macro non è definita, quindi con un codice analogo al seguente:
380 \includecodesnip{listati/get_child_max.c}
381 ma in realtà in Linux queste macro sono comunque definite, indicando però un
382 limite generico. Per questo motivo è sempre meglio usare i valori restituiti
383 da \func{sysconf}.
384
385
386 \subsection{I limiti dei file}
387 \label{sec:sys_file_limits}
388
389 Come per le caratteristiche generali del sistema anche per i file esistono una
390 serie di limiti (come la lunghezza del nome del file o il numero massimo di
391 link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
392 in questo caso lo standard prevede alcune macro che ne specificano il valore,
393 riportate in tab.~\ref{tab:sys_file_macro}.
394
395 \begin{table}[htb]
396   \centering
397   \footnotesize
398   \begin{tabular}[c]{|l|r|l|}
399     \hline
400     \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
401     \hline
402     \hline                
403     \const{LINK\_MAX}   &8  & numero massimo di link a un file\\
404     \const{NAME\_MAX}&  14  & lunghezza in byte di un nome di file. \\
405     \const{PATH\_MAX}& 256  & lunghezza in byte di un
406                               \itindex{pathname}\textit{pathname}.\\
407     \const{PIPE\_BUF}&4096  & byte scrivibili atomicamente in una pipe
408                               (vedi sez.~\ref{sec:ipc_pipes}).\\
409     \const{MAX\_CANON}&255  & dimensione di una riga di terminale in modo 
410                               canonico (vedi sez.~\ref{sec:term_design}).\\
411     \const{MAX\_INPUT}&255  & spazio disponibile nella coda di input 
412                               del terminale (vedi 
413                               sez.~\ref{sec:term_design}).\\
414     \hline                
415   \end{tabular}
416   \caption{Costanti per i limiti sulle caratteristiche dei file.}
417   \label{tab:sys_file_macro}
418 \end{table}
419
420 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
421 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
422 conforme deve rispettare; le relative macro sono riportate in
423 tab.~\ref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per
424 le analoghe di tab.~\ref{tab:sys_posix1_general}.
425
426 \begin{table}[htb]
427   \centering
428   \footnotesize
429   \begin{tabular}[c]{|l|r|l|}
430     \hline
431     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
432     \hline
433     \hline
434     \const{\_POSIX\_LINK\_MAX}   &8  & numero massimo di link a un file.\\
435     \const{\_POSIX\_NAME\_MAX}&  14  & lunghezza in byte di un nome di file. \\
436     \const{\_POSIX\_PATH\_MAX}& 256  & lunghezza in byte di un 
437                                   \itindex{pathname}\textit{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 argomento 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
480 \itindex{pathname}\textit{pathname}. Il 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 \itindex{pathname}\textit{pathname}; pertanto gli errori
486     restituiti cambiano di 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 fig.~\ref{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
519 fig.~\ref{fig:sys_utsname}, solo definendo \macro{\_GNU\_SOURCE}.
520
521 \begin{figure}[!htb]
522   \footnotesize \centering
523   \begin{minipage}[c]{15cm}
524     \includestruct{listati/ustname.h}
525   \end{minipage}
526   \normalsize 
527   \caption{La struttura \structd{utsname}.} 
528   \label{fig:sys_utsname}
529 \end{figure}
530
531 In generale si tenga presente che le dimensioni delle stringe di una
532 \struct{utsname} non è specificata, e che esse sono sempre terminate con NUL;
533 il manuale delle \acr{glibc} indica due diverse dimensioni,
534 \const{\_UTSNAME\_LENGTH} per i campi standard e
535 \const{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
536 altri sistemi usano nomi diversi come \const{SYS\_NMLN} o \const{\_SYS\_NMLN}
537 o \const{UTSLEN} che possono avere valori diversi.\footnote{Nel caso di Linux
538   \func{uname} corrisponde in realtà a 3 system call diverse, le prime due
539   usano rispettivamente delle lunghezze delle stringhe di 9 e 65 byte; la
540   terza usa anch'essa 65 byte, ma restituisce anche l'ultimo campo,
541   \var{domainname}, con una lunghezza di 257 byte.}
542
543
544 \section{Opzioni e configurazione del sistema}
545 \label{sec:sys_config}
546
547 Come abbiamo accennato nella sezione precedente, non tutti i limiti che
548 caratterizzano il sistema sono fissi, o perlomeno non lo sono in tutte le
549 implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
550 di esaminare il meccanismo che permette, quando questi possono variare durante
551 l'esecuzione del sistema, di modificarli.
552
553 Inoltre, al di la di quelli che possono essere limiti caratteristici previsti
554 da uno standard, ogni sistema può avere una sua serie di altri parametri di
555 configurazione, che, non essendo mai fissi e variando da sistema a sistema,
556 non sono stati inclusi nella standardizzazione della sezione precedente. Per
557 questi occorre, oltre al meccanismo di impostazione, pure un meccanismo di
558 lettura.  Affronteremo questi argomenti in questa sezione, insieme alle
559 funzioni che si usano per il controllo di altre caratteristiche generali del
560 sistema, come quelle per la gestione dei filesystem e di utenti e gruppi.
561
562
563 \subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
564 \label{sec:sys_sysctl}
565
566 La funzione che permette la lettura ed l'impostazione dei parametri del
567 sistema è \funcd{sysctl}; è una funzione derivata da BSD4.4, ma
568 l'implementazione è specifica di Linux; il suo prototipo è:
569 \begin{functions}
570 \headdecl{unistd.h}
571 \funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
572   *newval, size\_t newlen)}
573
574 Legge o scrive uno dei parametri di sistema.
575
576 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
577   errore, nel qual caso \var{errno} assumerà uno dei valori:
578   \begin{errlist}
579   \item[\errcode{EPERM}] non si ha il permesso di accedere ad uno dei
580     componenti nel cammino specificato per il parametro, o di accedere al
581     parametro nella modalità scelta.
582   \item[\errcode{ENOTDIR}] non esiste un parametro corrispondente al nome
583     \param{name}.
584 %  \item[\errcode{EFAULT}] si è specificato \param{oldlenp} zero quando
585 %    \param{oldval} è non nullo. 
586   \item[\errcode{EINVAL}] o si è specificato un valore non valido per il
587     parametro che si vuole impostare o lo spazio provvisto per il ritorno di un
588     valore non è delle giuste dimensioni.
589   \item[\errcode{ENOMEM}] talvolta viene usato più correttamente questo errore
590     quando non si è specificato sufficiente spazio per ricevere il valore di un
591     parametro.
592   \end{errlist}
593   ed inoltre \errval{EFAULT}.
594 }
595 \end{functions}
596
597 I parametri a cui la funzione permettere di accedere sono organizzati in
598 maniera gerarchica all'interno di un albero;\footnote{si tenga presente che
599   includendo solo \file{unistd.h}, saranno definiti solo i parametri generici;
600   dato che ce ne sono molti specifici dell'implementazione, nel caso di Linux
601   occorrerà includere anche i file \file{linux/unistd.h} e
602   \file{linux/sysctl.h}.} per accedere ad uno di essi occorre specificare un
603 cammino attraverso i vari nodi dell'albero, in maniera analoga a come avviene
604 per la risoluzione di un \itindex{pathname}\textit{pathname} (da cui l'uso
605 alternativo del filesystem \file{/proc}, che vedremo dopo).
606
607 Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
608 arriva ad identificare un parametro specifico è passato alla funzione
609 attraverso l'array \param{name}, di lunghezza \param{nlen}, che contiene la
610 sequenza dei vari nodi da attraversare. Ogni parametro ha un valore in un
611 formato specifico che può essere un intero, una stringa o anche una struttura
612 complessa, per questo motivo i valori vengono passati come puntatori
613 \ctyp{void}.
614
615 L'indirizzo a cui il valore corrente del parametro deve essere letto è
616 specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
617 \param{oldlenp} (passato come puntatore per avere indietro la dimensione
618 effettiva di quanto letto); il valore che si vuole impostare nel sistema è
619 passato in \param{newval} e la sua dimensione in \param{newlen}.
620
621 Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
622 valore letto restituito dalla funzione è quello precedente alla scrittura.
623
624 I parametri accessibili attraverso questa funzione sono moltissimi, e possono
625 essere trovati in \file{sysctl.h}, essi inoltre dipendono anche dallo stato
626 corrente del kernel (ad esempio dai moduli che sono stati caricati nel
627 sistema) e in genere i loro nomi possono variare da una versione di kernel
628 all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
629 quando esistono modalità alternative per ottenere le stesse informazioni.
630 Alcuni esempi di parametri ottenibili sono:
631 \begin{itemize}
632 \item il nome di dominio
633 \item i parametri del meccanismo di \textit{paging}.
634 \item il filesystem montato come radice
635 \item la data di compilazione del kernel
636 \item i parametri dello stack TCP
637 \item il numero massimo di file aperti
638 \end{itemize}
639
640 Come accennato in Linux si ha una modalità alternativa per accedere alle
641 stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
642 \file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
643 kernel, che non fa riferimento a nessun dispositivo fisico, ma presenta in
644 forma di file alcune delle strutture interne del kernel stesso.
645
646 In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
647 di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
648 specificando un \itindex{pathname}\textit{pathname} e leggendo e scrivendo sul
649 file corrispondente al parametro scelto.  Il kernel si occupa di generare al
650 volo il contenuto ed i nomi dei file corrispondenti, e questo ha il grande
651 vantaggio di rendere accessibili i vari parametri a qualunque comando di shell
652 e di permettere la navigazione dell'albero dei valori.
653
654 Alcune delle corrispondenze dei file presenti in \file{/proc/sys} con i valori
655 di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
656 in \file{linux/sysctl.h},\footnote{indicando un file di definizioni si fa
657   riferimento alla directory standard dei file di include, che in ogni
658   distribuzione che si rispetti è \file{/usr/include}.} la informazione
659 disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
660 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
661
662 Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc} 
663 sono disponibili moltissime altre informazioni, fra cui ad esempio anche
664 quelle fornite da \func{uname} (vedi sez.~\ref{sec:sys_config}) che sono
665 mantenute nei file \file{ostype}, \file{hostname}, \file{osrelease},
666 \file{version} e \file{domainname} di \file{/proc/kernel/}.
667
668
669
670 \subsection{La gestione delle proprietà dei filesystem}
671 \label{sec:sys_file_config}
672
673 Come accennato in sez.~\ref{sec:file_organization} per poter accedere ai file
674 occorre prima rendere disponibile al sistema il filesystem su cui essi sono
675 memorizzati; l'operazione di attivazione del filesystem è chiamata
676 \textsl{montaggio}, per far questo in Linux\footnote{la funzione è specifica
677   di Linux e non è portabile.} si usa la funzione \funcd{mount} il cui
678 prototipo è:
679 \begin{prototype}{sys/mount.h}
680 {mount(const char *source, const char *target, const char *filesystemtype, 
681   unsigned long mountflags, const void *data)}
682
683 Monta il filesystem di tipo \param{filesystemtype} contenuto in \param{source}
684 sulla directory \param{target}.
685   
686   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
687   fallimento, nel qual caso gli errori comuni a tutti i filesystem che possono
688   essere restituiti in \var{errno} sono:
689   \begin{errlist}
690   \item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
691   \item[\errcode{ENODEV}] \param{filesystemtype} non esiste o non è configurato
692     nel kernel.
693   \item[\errcode{ENOTBLK}] non si è usato un \textit{block device} per
694     \param{source} quando era richiesto.
695   \item[\errcode{EBUSY}] \param{source} è già montato, o non può essere
696     rimontato in read-only perché ci sono ancora file aperti in scrittura, o
697     \param{target} è ancora in uso.
698   \item[\errcode{EINVAL}] il device \param{source} presenta un
699     \textit{superblock} non valido, o si è cercato di rimontare un filesystem
700     non ancora montato, o di montarlo senza che \param{target} sia un
701     \textit{mount point} o di spostarlo quando \param{target} non è un
702     \textit{mount point} o è \file{/}.
703   \item[\errcode{EACCES}] non si ha il permesso di accesso su uno dei
704     componenti del \itindex{pathname}\textit{pathname}, o si è cercato
705     di montare un filesystem disponibile in sola lettura senza averlo
706     specificato o il device \param{source} è su un filesystem montato con
707     l'opzione \const{MS\_NODEV}.
708   \item[\errcode{ENXIO}] il \textit{major number} del device \param{source} è
709     sbagliato.
710   \item[\errcode{EMFILE}] la tabella dei device \textit{dummy} è piena.
711   \end{errlist}
712   ed inoltre \errval{ENOTDIR}, \errval{EFAULT}, \errval{ENOMEM},
713   \errval{ENAMETOOLONG}, \errval{ENOENT} o \errval{ELOOP}.}
714 \end{prototype}
715
716 La funzione monta sulla directory \param{target}, detta \textit{mount point},
717 il filesystem contenuto in \param{source}. In generale un filesystem è
718 contenuto su un disco, e l'operazione di montaggio corrisponde a rendere
719 visibile al sistema il contenuto del suddetto disco, identificato attraverso
720 il file di dispositivo ad esso associato.
721
722 Ma la struttura del virtual filesystem vista in sez.~\ref{sec:file_vfs} è molto
723 più flessibile e può essere usata anche per oggetti diversi da un disco. Ad
724 esempio usando il \textit{loop device} si può montare un file qualunque (come
725 l'immagine di un CD-ROM o di un floppy) che contiene un filesystem, inoltre
726 alcuni filesystem, come \file{proc} o \file{devfs} sono del tutto virtuali, i
727 loro dati sono generati al volo ad ogni lettura, e passati al kernel ad ogni
728 scrittura. 
729
730 Il tipo di filesystem è specificato da \param{filesystemtype}, che deve essere
731 una delle stringhe riportate nel file \file{/proc/filesystems}, che contiene
732 l'elenco dei filesystem supportati dal kernel; nel caso si sia indicato uno
733 dei filesystem virtuali, il contenuto di \param{source} viene ignorato.
734
735 Dopo l'esecuzione della funzione il contenuto del filesystem viene resto
736 disponibile nella directory specificata come \textit{mount point}, il
737 precedente contenuto di detta directory viene mascherato dal contenuto della
738 directory radice del filesystem montato.
739
740 Dal kernel 2.4.x inoltre è divenuto possibile sia spostare atomicamente un
741 \textit{mount point} da una directory ad un'altra, sia montare in diversi
742 \textit{mount point} lo stesso filesystem, sia montare più filesystem sullo
743 stesso \textit{mount point} (nel qual caso vale quanto appena detto, e solo il
744 contenuto dell'ultimo filesystem montato sarà visibile).
745
746 Ciascun filesystem è dotato di caratteristiche specifiche che possono essere
747 attivate o meno, alcune di queste sono generali (anche se non è detto siano
748 disponibili in ogni filesystem), e vengono specificate come opzioni di
749 montaggio con l'argomento \param{mountflags}.  
750
751 In Linux \param{mountflags} deve essere un intero a 32 bit i cui 16 più
752 significativi sono un \textit{magic number}\footnote{cioè un numero speciale
753   usato come identificativo, che nel caso è \code{0xC0ED}; si può usare la
754   costante \const{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
755   riservata al \textit{magic number}.} mentre i 16 meno significativi sono
756 usati per specificare le opzioni; essi sono usati come maschera binaria e
757 vanno impostati con un OR aritmetico della costante \const{MS\_MGC\_VAL} con i
758 valori riportati in tab.~\ref{tab:sys_mount_flags}.
759
760 \begin{table}[htb]
761   \footnotesize
762   \centering
763   \begin{tabular}[c]{|l|r|l|}
764     \hline
765     \textbf{Parametro} & \textbf{Valore}&\textbf{Significato}\\
766     \hline
767     \hline
768     \const{MS\_RDONLY}     &  1 & monta in sola lettura.\\
769     \const{MS\_NOSUID}     &  2 & ignora i bit \itindex{suid~bit} \acr{suid} e
770                                   \itindex{sgid~bit}\acr{sgid}.\\ 
771     \const{MS\_NODEV}      &  4 & impedisce l'accesso ai file di dispositivo.\\
772     \const{MS\_NOEXEC}     &  8 & impedisce di eseguire programmi.\\
773     \const{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona.\\
774     \const{MS\_REMOUNT}    & 32 & rimonta il filesystem cambiando i flag.\\
775     \const{MS\_MANDLOCK}   & 64 & consente il \textit{mandatory locking} (vedi
776                                   sez.~\ref{sec:file_mand_locking}).\\
777     \const{S\_WRITE}      & 128 & scrive normalmente.\\
778     \const{S\_APPEND}     & 256 & consente la scrittura solo in
779                                   \itindex{append~mode} \textit{append mode} 
780                                   (vedi sez.~\ref{sec:file_sharing}).\\
781     \const{S\_IMMUTABLE}  & 512 & impedisce che si possano modificare i file.\\
782     \const{MS\_NOATIME}   &1024 & non aggiorna gli \textit{access time} (vedi
783                                   sez.~\ref{sec:file_file_times}).\\
784     \const{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
785                                   directory.\\
786     \const{MS\_BIND}      &4096 & monta il filesystem altrove.\\
787     \const{MS\_MOVE}      &8192 & sposta atomicamente il punto di montaggio.\\
788     \hline
789   \end{tabular}
790   \caption{Tabella dei codici dei flag di montaggio di un filesystem.}
791   \label{tab:sys_mount_flags}
792 \end{table}
793
794 Per l'impostazione delle caratteristiche particolari di ciascun filesystem si
795 usa invece l'argomento \param{data} che serve per passare le ulteriori
796 informazioni necessarie, che ovviamente variano da filesystem a filesystem.
797
798 La funzione \func{mount} può essere utilizzata anche per effettuare il
799 \textsl{rimontaggio} di un filesystem, cosa che permette di cambiarne al volo
800 alcune delle caratteristiche di funzionamento (ad esempio passare da sola
801 lettura a lettura/scrittura). Questa operazione è attivata attraverso uno dei
802 bit di \param{mountflags}, \const{MS\_REMOUNT}, che se impostato specifica che
803 deve essere effettuato il rimontaggio del filesystem (con le opzioni
804 specificate dagli altri bit), anche in questo caso il valore di \param{source}
805 viene ignorato.
806
807 Una volta che non si voglia più utilizzare un certo filesystem è possibile
808 \textsl{smontarlo} usando la funzione \funcd{umount}, il cui prototipo è:
809 \begin{prototype}{sys/mount.h}{umount(const char *target)}
810   
811   Smonta il filesystem montato sulla directory \param{target}.
812   
813   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
814     fallimento, nel qual caso \var{errno} assumerà uno dei valori:
815   \begin{errlist}
816   \item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
817   \item[\errcode{EBUSY}]  \param{target} è la directory di lavoro di qualche
818   processo, o contiene dei file aperti, o un altro mount point.
819   \end{errlist}
820   ed inoltre \errval{ENOTDIR}, \errval{EFAULT}, \errval{ENOMEM},
821   \errval{ENAMETOOLONG}, \errval{ENOENT} o \errval{ELOOP}.}
822 \end{prototype}
823 \noindent la funzione prende il nome della directory su cui il filesystem è
824 montato e non il file o il dispositivo che è stato montato,\footnote{questo è
825   vero a partire dal kernel 2.3.99-pre7, prima esistevano due chiamate
826   separate e la funzione poteva essere usata anche specificando il file di
827   dispositivo.} in quanto con il kernel 2.4.x è possibile montare lo stesso
828 dispositivo in più punti. Nel caso più di un filesystem sia stato montato
829 sullo stesso \textit{mount point} viene smontato quello che è stato montato
830 per ultimo.
831
832 Si tenga presente che la funzione fallisce quando il filesystem è
833 \textsl{occupato}, questo avviene quando ci sono ancora file aperti sul
834 filesystem, se questo contiene la directory di lavoro corrente di un qualunque
835 processo o il mount point di un altro filesystem; in questo caso l'errore
836 restituito è \errcode{EBUSY}.
837
838 Linux provvede inoltre una seconda funzione, \funcd{umount2}, che in alcuni
839 casi permette di forzare lo smontaggio di un filesystem, anche quando questo
840 risulti occupato; il suo prototipo è:
841 \begin{prototype}{sys/mount.h}{umount2(const char *target, int flags)}
842   
843   La funzione è identica a \func{umount} per comportamento e codici di errore,
844   ma con \param{flags} si può specificare se forzare lo smontaggio.
845 \end{prototype}
846
847 Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
848 definito è il bit \const{MNT\_FORCE}; gli altri bit devono essere nulli.
849 Specificando \const{MNT\_FORCE} la funzione cercherà di liberare il filesystem
850 anche se è occupato per via di una delle condizioni descritte in precedenza. A
851 seconda del tipo di filesystem alcune (o tutte) possono essere superate,
852 evitando l'errore di \errcode{EBUSY}.  In tutti i casi prima dello smontaggio
853 viene eseguita una sincronizzazione dei dati. 
854
855 Altre due funzioni specifiche di Linux,\footnote{esse si trovano anche su BSD,
856   ma con una struttura diversa.} utili per ottenere in maniera diretta
857 informazioni riguardo al filesystem su cui si trova un certo file, sono
858 \funcd{statfs} e \funcd{fstatfs}, i cui prototipi sono:
859 \begin{functions}
860   \headdecl{sys/vfs.h} 
861   \funcdecl{int statfs(const char *path, struct statfs *buf)} 
862
863   \funcdecl{int fstatfs(int fd, struct statfs *buf)} 
864   
865   Restituisce in \param{buf} le informazioni relative al filesystem su cui è
866   posto il file specificato.
867   
868   \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
869     errore, nel qual caso \var{errno} assumerà uno dei valori:
870   \begin{errlist}
871   \item[\errcode{ENOSYS}] il filesystem su cui si trova il file specificato non
872   supporta la funzione.
873   \end{errlist}
874   e \errval{EFAULT} ed \errval{EIO} per entrambe, \errval{EBADF} per
875   \func{fstatfs}, \errval{ENOTDIR}, \errval{ENAMETOOLONG}, \errval{ENOENT},
876   \errval{EACCES}, \errval{ELOOP} per \func{statfs}.}
877 \end{functions}
878
879 Queste funzioni permettono di ottenere una serie di informazioni generali
880 riguardo al filesystem su cui si trova il file specificato; queste vengono
881 restituite all'indirizzo \param{buf} di una struttura \struct{statfs} definita
882 come in fig.~\ref{fig:sys_statfs}, ed i campi che sono indefiniti per il
883 filesystem in esame sono impostati a zero.  I valori del campo \var{f\_type}
884 sono definiti per i vari filesystem nei relativi file di header dei sorgenti
885 del kernel da costanti del tipo \var{XXX\_SUPER\_MAGIC}, dove \var{XXX} in
886 genere è il nome del filesystem stesso.
887
888 \begin{figure}[!htb]
889   \footnotesize \centering
890   \begin{minipage}[c]{15cm}
891     \includestruct{listati/statfs.h}
892   \end{minipage}
893   \normalsize 
894   \caption{La struttura \structd{statfs}.} 
895   \label{fig:sys_statfs}
896 \end{figure}
897
898
899 Le \acr{glibc} provvedono infine una serie di funzioni per la gestione dei due
900 file \file{/etc/fstab} ed \file{/etc/mtab}, che convenzionalmente sono usati
901 in quasi tutti i sistemi unix-like per mantenere rispettivamente le
902 informazioni riguardo ai filesystem da montare e a quelli correntemente
903 montati. Le funzioni servono a leggere il contenuto di questi file in
904 opportune strutture \struct{fstab} e \struct{mntent}, e, per \file{/etc/mtab}
905 per inserire e rimuovere le voci presenti nel file.
906
907 In generale si dovrebbero usare queste funzioni (in particolare quelle
908 relative a \file{/etc/mtab}), quando si debba scrivere un programma che
909 effettua il montaggio di un filesystem; in realtà in questi casi è molto più
910 semplice invocare direttamente il programma \cmd{mount}, per cui ne
911 tralasceremo la trattazione, rimandando al manuale delle \acr{glibc}
912 \cite{glibc} per la documentazione completa.
913
914 % TODO scrivere relativamente alle varie funzioni (getfsent e getmntent &C)
915
916 \subsection{La gestione delle informazioni su utenti e gruppi}
917 \label{sec:sys_user_group}
918
919 Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
920 (password, corrispondenze fra nomi simbolici e user-id, home directory, ecc.)
921 venivano registrate all'interno dei due file di testo \file{/etc/passwd} ed
922 \file{/etc/group},\footnote{in realtà oltre a questi nelle distribuzioni più
923   recenti è stato introdotto il sistema delle \textit{shadow password} che
924   prevede anche i due file \file{/etc/shadow} e \file{/etc/gshadow}, in cui
925   sono state spostate le informazioni di autenticazione (ed inserite alcune
926   estensioni) per toglierle dagli altri file che devono poter essere letti per
927   poter effettuare l'associazione fra username e \acr{uid}.} il cui formato è
928 descritto dalle relative pagine del manuale\footnote{nella quinta sezione,
929   quella dei file di configurazione, occorre cioè usare \cmd{man 5 passwd}
930   dato che altrimenti si avrebbe la pagina di manuale del comando
931   \cmd{passwd}.} e tutte le funzioni che richiedevano l'accesso a queste
932 informazione andavano a leggere direttamente il contenuto di questi file.
933
934 Col tempo però questa impostazione ha incominciato a mostrare dei limiti: da
935 una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
936 la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
937 che sta per \textit{Pluggable Authentication Method}) che fornisce una
938 interfaccia comune per i processi di autenticazione,\footnote{il
939   \textit{Pluggable Authentication Method} è un sistema modulare, in cui è
940   possibile utilizzare anche più meccanismi insieme, diventa così possibile
941   avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
942   diversi formati per le password e diversi supporti per le informazioni, il
943   tutto in maniera trasparente per le applicazioni purché per ciascun
944   meccanismo si disponga della opportuna libreria che implementa l'interfaccia
945   di PAM.}  svincolando completamente le singole applicazione dai dettagli del
946 come questa viene eseguita e di dove vengono mantenuti i dati relativi;
947 dall'altra con il diffondersi delle reti la necessità di centralizzare le
948 informazioni degli utenti e dei gruppi per insiemi di macchine, in modo da
949 mantenere coerenti i dati, ha portato anche alla necessità di poter recuperare
950 e memorizzare dette informazioni su supporti diversi, introducendo il sistema
951 del \itindex{Name~Service~Switch}\textit{Name Service Switch} che tratteremo
952 brevemente più avanti (in sez.~\ref{sec:sock_resolver}) dato che la maggior
953 parte delle sua applicazioni sono relative alla risoluzioni di nomi di rete.
954
955 In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
956 per la lettura delle informazioni relative a utenti e gruppi tralasciando
957 completamente quelle relative all'autenticazione. 
958 %  Per questo non tratteremo
959 % affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
960 % \textit{Name Service Switch}, un meccanismo messo a disposizione dalle
961 % \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
962 % necessario trovare una corrispondenza fra un nome ed un numero (od altra
963 % informazione) ad esso associato, come appunto, quella fra uno username ed un
964 % \acr{uid} o fra un \acr{gid} ed il nome del gruppo corrispondente.
965 Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
966 queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
967   Service Switch}, per cui sono in grado di ricevere informazioni qualunque
968 sia il supporto su cui esse vengono mantenute.  Per leggere le informazioni
969 relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
970 \funcd{getpwnam}, i cui prototipi sono:
971 \begin{functions}
972   \headdecl{pwd.h} 
973   \headdecl{sys/types.h} 
974   \funcdecl{struct passwd *getpwuid(uid\_t uid)} 
975   
976   \funcdecl{struct passwd *getpwnam(const char *name)} 
977
978   Restituiscono le informazioni relative all'utente specificato.
979   
980   \bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
981     informazioni in caso di successo e \val{NULL} nel caso non sia stato
982     trovato nessun utente corrispondente a quanto specificato.}
983 \end{functions}
984
985 Le due funzioni forniscono le informazioni memorizzate nel registro degli
986 utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
987 relative all'utente specificato attraverso il suo \acr{uid} o il nome di
988 login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
989 tipo \struct{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
990 riportata in fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente
991 illustrato il significato dei vari campi.
992
993 \begin{figure}[!htb]
994   \footnotesize
995   \centering
996   \begin{minipage}[c]{15cm}
997     \includestruct{listati/passwd.h}
998   \end{minipage} 
999   \normalsize 
1000   \caption{La struttura \structd{passwd} contenente le informazioni relative ad
1001     un utente del sistema.}
1002   \label{fig:sys_passwd_struct}
1003 \end{figure}
1004
1005 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
1006 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
1007 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
1008 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
1009 essere rientranti; per questo motivo ne esistono anche due versioni
1010 alternative (denotate dalla solita estensione \code{\_r}), i cui prototipi
1011 sono:
1012 \begin{functions}
1013   \headdecl{pwd.h} 
1014   
1015   \headdecl{sys/types.h} 
1016   
1017   \funcdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
1018     char *buffer, size\_t buflen, struct passwd **result)}
1019   
1020   \funcdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
1021     *password, char *buffer, size\_t buflen, struct passwd **result)}
1022
1023   Restituiscono le informazioni relative all'utente specificato.
1024   
1025   \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1026     altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
1027 \end{functions}
1028
1029 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
1030 la memoria necessaria a contenere le informazioni. In particolare i valori
1031 della struttura \struct{passwd} saranno restituiti all'indirizzo
1032 \param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
1033 un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
1034 puntate dai campi di \param{password}. Infine all'indirizzo puntato da
1035 \param{result} viene restituito il puntatore ai dati ottenuti, cioè
1036 \param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti.  Qualora i
1037 dati non possano essere contenuti nei byte specificati da \param{buflen}, la
1038 funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
1039 impostato a \val{NULL}).
1040
1041 Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
1042 \funcd{getgrgid} (e le relative analoghe rientranti con la stessa estensione
1043 \code{\_r}) che permettono di leggere le informazioni relative ai gruppi, i
1044 loro prototipi sono:
1045 \begin{functions}
1046   \headdecl{grp.h} 
1047   \headdecl{sys/types.h} 
1048
1049   \funcdecl{struct group *getgrgid(gid\_t gid)} 
1050   
1051   \funcdecl{struct group *getgrnam(const char *name)} 
1052   
1053   \funcdecl{struct group *getpwuid\_r(gid\_t gid, struct group *password,
1054     char *buffer, size\_t buflen, struct group **result)}
1055   
1056   \funcdecl{struct group *getpwnam\_r(const char *name, struct group
1057     *password, char *buffer, size\_t buflen, struct group **result)}
1058
1059   Restituiscono le informazioni relative al gruppo specificato.
1060   
1061   \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1062     altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
1063 \end{functions}
1064
1065 Il comportamento di tutte queste funzioni è assolutamente identico alle
1066 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
1067 in questo caso le informazioni vengono restituite in una struttura di tipo
1068 \struct{group}, la cui definizione è riportata in
1069 fig.~\ref{fig:sys_group_struct}.
1070
1071 \begin{figure}[!htb]
1072   \footnotesize
1073   \centering
1074   \begin{minipage}[c]{15cm}
1075     \includestruct{listati/group.h}
1076   \end{minipage} 
1077   \normalsize 
1078   \caption{La struttura \structd{group} contenente le informazioni relative ad
1079     un gruppo del sistema.}
1080   \label{fig:sys_group_struct}
1081 \end{figure}
1082
1083 Le funzioni viste finora sono in grado di leggere le informazioni sia
1084 direttamente dal file delle password in \file{/etc/passwd} che tramite il
1085 sistema del \itindex{Name~Service~Switch}\textit{Name Service Switch} e
1086 sono completamente generiche. Si noti però che non c'è una funzione che
1087 permetta di impostare direttamente una password.\footnote{in realtà questo può
1088   essere fatto ricorrendo a PAM, ma questo è un altro discorso.} Dato che
1089 POSIX non prevede questa possibilità esiste un'altra interfaccia che lo fa,
1090 derivata da SVID le cui funzioni sono riportate in
1091 tab.~\ref{tab:sys_passwd_func}. Questa però funziona soltanto quando le
1092 informazioni sono mantenute su un apposito file di \textsl{registro} di utenti
1093 e gruppi, con il formato classico di \file{/etc/passwd} e \file{/etc/group}.
1094
1095 \begin{table}[htb]
1096   \footnotesize
1097   \centering
1098   \begin{tabular}[c]{|l|p{8cm}|}
1099     \hline
1100     \textbf{Funzione} & \textbf{Significato}\\
1101     \hline
1102     \hline
1103     \func{fgetpwent}   & Legge una voce dal file di registro degli utenti
1104                          specificato.\\
1105     \func{fgetpwent\_r}& Come la precedente, ma rientrante.\\
1106     \func{putpwent}    & Immette una voce in un file di registro degli
1107                          utenti.\\ 
1108     \func{getpwent}    & Legge una voce da \file{/etc/passwd}.\\
1109     \func{getpwent\_r} & Come la precedente, ma rientrante.\\
1110     \func{setpwent}    & Ritorna all'inizio di \file{/etc/passwd}.\\
1111     \func{endpwent}    & Chiude \file{/etc/passwd}.\\
1112     \func{fgetgrent}   & Legge una voce dal file di registro dei gruppi 
1113                          specificato.\\
1114     \func{fgetgrent\_r}& Come la precedente, ma rientrante.\\
1115     \func{putgrent}    & Immette una voce in un file di registro dei gruppi.\\
1116     \func{getgrent}    & Legge una voce da \file{/etc/group}.\\ 
1117     \func{getgrent\_r} & Come la precedente, ma rientrante.\\
1118     \func{setgrent}    & Ritorna all'inizio di \file{/etc/group}.\\
1119     \func{endgrent}    & Chiude \file{/etc/group}.\\
1120     \hline
1121   \end{tabular}
1122   \caption{Funzioni per la manipolazione dei campi di un file usato come
1123     registro per utenti o gruppi nel formato di \file{/etc/passwd} e
1124     \file{/etc/groups}.} 
1125   \label{tab:sys_passwd_func}
1126 \end{table}
1127
1128 Dato che oramai la gran parte delle distribuzioni di GNU/Linux utilizzano
1129 almeno le \textit{shadow password} (quindi con delle modifiche rispetto al
1130 formato classico del file \file{/etc/passwd}), si tenga presente che le
1131 funzioni di questa interfaccia che permettono di scrivere delle voci in un
1132 \textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
1133 hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
1134 questa estensione. Per questo motivo l'uso di queste funzioni è deprecato, in
1135 quanto comunque non funzionale, pertanto ci limiteremo a fornire soltanto
1136 l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
1137 ulteriore.  Chi volesse insistere ad usare questa interfaccia può fare
1138 riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
1139 delle \acr{glibc} per i dettagli del funzionamento.
1140
1141
1142
1143 \subsection{Il registro della \textsl{contabilità} degli utenti}
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 registro della
1148 cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti.  In esso
1149 vengono mantenute una serie di informazioni storiche relative sia agli utenti
1150 che si sono collegati al sistema, (tanto per quelli correntemente collegati,
1151 che per la registrazione degli accessi precedenti), sia relative all'intero
1152 sistema, come il momento di lancio di processi da parte di \cmd{init}, il
1153 cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
1154 della macchina.
1155
1156 I dati vengono usualmente\footnote{questa è la locazione specificata dal
1157   \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
1158   delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
1159 \file{/var/log/wtmp}. Quando un utente si collega viene aggiunta una voce a
1160 \file{/var/run/utmp} in cui viene memorizzato il nome di login, il terminale
1161 da cui ci si collega, l'\acr{uid} della shell di login, l'orario della
1162 connessione ed altre informazioni.  La voce resta nel file fino al logout,
1163 quando viene cancellata e spostata in \file{/var/log/wtmp}.
1164
1165 In questo modo il primo file viene utilizzato per registrare chi sta
1166 utilizzando il sistema al momento corrente, mentre il secondo mantiene la
1167 registrazione delle attività degli utenti. A quest'ultimo vengono anche
1168 aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
1169 come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
1170 informazioni sono descritte in dettaglio nel manuale delle \acr{glibc}.
1171
1172 Questi file non devono mai essere letti direttamente, ma le informazioni che
1173 contengono possono essere ricavate attraverso le opportune funzioni di
1174 libreria. Queste sono analoghe alle precedenti funzioni (vedi
1175 tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
1176 solo che in questo caso la struttura del registro della \textsl{contabilità} è
1177 molto più complessa, dato che contiene diversi tipi di informazione.
1178
1179 Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
1180 servono rispettivamente a aprire e a chiudere il file che contiene il
1181 registro, e a specificare su quale file esso viene mantenuto. I loro prototipi
1182 sono:
1183 \begin{functions}
1184   \headdecl{utmp.h} 
1185   
1186   \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
1187   registro.
1188   
1189   \funcdecl{void setutent(void)} Apre il file del registro, posizionandosi al
1190   suo inizio.
1191   
1192   \funcdecl{void endutent(void)} Chiude il file del registro.
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 registro per gli utenti correntemente
1202   collegati.
1203 \item[\const{\_PATH\_WTMP}] Specifica il registro per l'archivio storico degli
1204   utenti collegati.
1205 \end{basedescript}
1206 corrispondenti ai file \file{/var/run/utmp} e \file{/var/log/wtmp} visti in
1207 precedenza.
1208
1209 \begin{figure}[!htb]
1210   \footnotesize
1211   \centering
1212   \begin{minipage}[c]{15cm}
1213     \includestruct{listati/utmp.h}
1214   \end{minipage} 
1215   \normalsize 
1216   \caption{La struttura \structd{utmp} contenente le informazioni di una voce
1217     del registro di \textsl{contabilità}.}
1218   \label{fig:sys_utmp_struct}
1219 \end{figure}
1220
1221 Una volta aperto il file si può eseguire una scansione leggendo o scrivendo
1222 una voce con le funzioni \funcd{getutent}, \funcd{getutid}, \funcd{getutline}
1223 e \funcd{pututline}, i cui prototipi sono:
1224 \begin{functions}
1225   \headdecl{utmp.h} 
1226
1227   \funcdecl{struct utmp *getutent(void)} 
1228   Legge una voce dalla posizione corrente nel registro.
1229   
1230   \funcdecl{struct utmp *getutid(struct utmp *ut)} Ricerca una voce sul
1231   registro in base al contenuto di \param{ut}.
1232
1233   \funcdecl{struct utmp *getutline(struct utmp *ut)} 
1234   Ricerca nel registro la prima voce corrispondente ad un processo sulla linea
1235   di terminale specificata tramite \param{ut}.
1236
1237   \funcdecl{struct utmp *pututline(struct utmp *ut)} 
1238   Scrive una voce nel registro.
1239   
1240   \bodydesc{Le funzioni ritornano il puntatore ad una struttura \struct{utmp}
1241     in caso di successo e \val{NULL} in caso di errore.}
1242 \end{functions}
1243
1244 Tutte queste funzioni fanno riferimento ad una struttura di tipo
1245 \struct{utmp}, la cui definizione in Linux è riportata in
1246 fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
1247 voce dal registro; \func{getutent} legge semplicemente la prima voce
1248 disponibile; le altre due permettono di eseguire una ricerca.
1249
1250 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1251 campo \var{ut\_type} dell'argomento \param{ut}.  Questo può assumere i valori
1252 riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
1253 \const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
1254 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1255 invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
1256 \const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
1257 corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1258
1259 \begin{table}[htb]
1260   \footnotesize
1261   \centering
1262   \begin{tabular}[c]{|l|p{8cm}|}
1263     \hline
1264     \textbf{Valore} & \textbf{Significato}\\
1265     \hline
1266     \hline
1267     \const{EMPTY}         & Non contiene informazioni valide. \\
1268     \const{RUN\_LVL}      & Identica il runlevel del sistema. \\
1269     \const{BOOT\_TIME}    & Identifica il tempo di avvio del sistema \\
1270     \const{OLD\_TIME}     & Identifica quando è stato modificato l'orologio di
1271                             sistema. \\
1272     \const{NEW\_TIME}     & Identifica da quanto è stato modificato il 
1273                             sistema. \\
1274     \const{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}. \\
1275     \const{LOGIN\_PROCESS}& Identifica un processo di login. \\
1276     \const{USER\_PROCESS} & Identifica un processo utente. \\
1277     \const{DEAD\_PROCESS} & Identifica un processo terminato. \\
1278 %    \const{ACCOUNTING}    & ??? \\
1279     \hline
1280   \end{tabular}
1281   \caption{Classificazione delle voci del registro a seconda dei
1282     possibili valori del campo \var{ut\_type}.} 
1283   \label{tab:sys_ut_type}
1284 \end{table}
1285
1286 La funzione \func{getutline} esegue la ricerca sulle voci che hanno
1287 \var{ut\_type} uguale a \const{LOGIN\_PROCESS} o \const{USER\_PROCESS},
1288 restituendo la prima che corrisponde al valore di \var{ut\_line}, che
1289 specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
1290 terminale che interessa. Lo stesso criterio di ricerca è usato da
1291 \func{pututline} per trovare uno spazio dove inserire la voce specificata,
1292 qualora non sia trovata la voce viene aggiunta in coda al registro.
1293
1294 In generale occorre però tenere conto che queste funzioni non sono
1295 completamente standardizzate, e che in sistemi diversi possono esserci
1296 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1297 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1298 fornita dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1299 introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
1300 sono un sovrainsieme di \code{utmp}. 
1301
1302 Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
1303 inutili queste nuove strutture; pertanto esse e le relative funzioni di
1304 gestione (\func{getutxent}, \func{getutxid}, \func{getutxline},
1305 \func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
1306 sinonimi delle funzioni appena viste.
1307
1308 Come visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
1309 staticamente rende le funzioni di lettura non rientranti; per questo motivo le
1310 \acr{glibc} forniscono anche delle versioni rientranti: \func{getutent\_r},
1311 \func{getutid\_r}, \func{getutline\_r}, che invece di restituire un puntatore
1312 restituiscono un intero e prendono due argomenti aggiuntivi. Le funzioni si
1313 comportano esattamente come le analoghe non rientranti, solo che restituiscono
1314 il risultato all'indirizzo specificato dal primo argomento aggiuntivo (di tipo
1315 \code{struct utmp *buffer}) mentre il secondo (di tipo \code{struct utmp
1316   **result)} viene usato per restituire il puntatore allo stesso buffer.
1317
1318 Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
1319 in \file{wmtp} altre due funzioni, \funcd{updwtmp} e \funcd{logwtmp}, i cui
1320 prototipi sono:
1321 \begin{functions}
1322   \headdecl{utmp.h} 
1323   
1324   \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1325   Aggiunge la voce \param{ut} nel registro \file{wmtp}.
1326   
1327   \funcdecl{void logwtmp(const char *line, const char *name, const char
1328     *host)} Aggiunge nel registro una voce con i valori specificati.
1329 \end{functions}
1330
1331 La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
1332 direttamente una struttura \struct{utmp}, mentre la seconda utilizza gli
1333 argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
1334 poi aggiunge chiamando \func{updwtmp}.
1335
1336
1337 \section{Il controllo dell'uso delle risorse}
1338 \label{sec:sys_res_limits}
1339
1340
1341 Dopo aver esaminato le funzioni che permettono di controllare le varie
1342 caratteristiche, capacità e limiti del sistema a livello globale, in questa
1343 sezione tratteremo le varie funzioni che vengono usate per quantificare le
1344 risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
1345 permettono di imporre a ciascuno di essi vincoli e limiti di
1346 utilizzo. 
1347
1348
1349 \subsection{L'uso delle risorse}
1350 \label{sec:sys_resource_use}
1351
1352 Come abbiamo accennato in sez.~\ref{sec:proc_wait4} le informazioni riguardo
1353 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1354 di tipo \struct{rusage}, la cui definizione (che si trova in
1355 \file{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
1356
1357 \begin{figure}[!htb]
1358   \footnotesize
1359   \centering
1360   \begin{minipage}[c]{15cm}
1361     \includestruct{listati/rusage.h}
1362   \end{minipage} 
1363   \normalsize 
1364   \caption{La struttura \structd{rusage} per la lettura delle informazioni dei 
1365     delle risorse usate da un processo.}
1366   \label{fig:sys_rusage_struct}
1367 \end{figure}
1368
1369 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
1370 da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
1371   \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si trova
1372   nelle opzioni di compilazione del kernel (e di norma è disabilitato) che
1373   serve per mantenere una contabilità delle risorse usate da ciascun processo
1374   in maniera molto più dettagliata.} ma attualmente (con i kernel della serie
1375 2.4.x e 2.6.x) i soli campi che sono mantenuti sono: \var{ru\_utime},
1376 \var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I
1377 primi due indicano rispettivamente il tempo impiegato dal processo
1378 nell'eseguire le istruzioni in user space, e quello impiegato dal kernel nelle
1379 system call eseguite per conto del processo.
1380
1381 Gli altri tre campi servono a quantificare l'uso della memoria
1382 virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
1383 \textit{page fault}\itindex{page~fault} (vedi sez.~\ref{sec:proc_mem_gen})
1384 avvenuti senza richiedere I/O su disco (i cosiddetti \textit{minor page
1385   fault}), a quelli che invece han richiesto I/O su disco (detti invece
1386 \textit{major page fault}) ed al numero di volte che il processo è stato
1387 completamente tolto dalla memoria per essere inserito nello swap.
1388
1389 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
1390 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
1391 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
1392 ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
1393 \struct{timeval}.
1394
1395 Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
1396 visto in sez.~\ref{sec:proc_wait4}) per ricavare la quantità di risorse
1397 impiegate dal processo di cui si è letto lo stato di terminazione, ma essa può
1398 anche essere letta direttamente utilizzando la funzione \funcd{getrusage}, il
1399 cui prototipo è:
1400 \begin{functions}
1401   \headdecl{sys/time.h} 
1402   \headdecl{sys/resource.h} 
1403   \headdecl{unistd.h} 
1404   
1405   \funcdecl{int getrusage(int who, struct rusage *usage)} 
1406   Legge la quantità di risorse usate da un processo.
1407
1408
1409   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1410   nel qual caso \var{errno} può essere \errval{EINVAL} o \errval{EFAULT}.}
1411 \end{functions}
1412
1413 L'argomento \param{who} permette di specificare il processo di cui si vuole
1414 leggere l'uso delle risorse; esso può assumere solo i due valori
1415 \const{RUSAGE\_SELF} per indicare il processo corrente e
1416 \const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
1417 ricevuto lo stato di terminazione. 
1418
1419
1420 \subsection{Limiti sulle risorse}
1421 \label{sec:sys_resource_limit}
1422
1423 Come accennato nell'introduzione il kernel mette a disposizione delle
1424 funzionalità che permettono non solo di mantenere dati statistici relativi
1425 all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
1426 utilizzo da parte dei vari processi o degli utenti.
1427
1428 Per far questo esistono una serie di risorse e ad ogni processo vengono
1429 associati due diversi limiti per ciascuna di esse; questi sono il
1430 \textsl{limite corrente} (o \textit{current limit}) che esprime un valore
1431 massimo che il processo non può superare ad un certo momento, ed il
1432 \textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
1433 valore massimo che può assumere il \textsl{limite corrente}. In generale il
1434 primo viene chiamato anche \textit{soft limit} dato che il suo valore può
1435 essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
1436 fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
1437   limit}.
1438
1439 \begin{table}[htb]
1440   \footnotesize
1441   \centering
1442   \begin{tabular}[c]{|l|p{12cm}|}
1443     \hline
1444     \textbf{Valore} & \textbf{Significato}\\
1445     \hline
1446     \hline
1447     \const{RLIMIT\_AS}     &  La dimensione massima della memoria virtuale di
1448                               un processo, il cosiddetto \textit{Address
1449                                 Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se
1450                               il limite viene superato dall'uso di funzioni
1451                               come \func{brk}, \func{mremap} o \func{mmap}
1452                               esse falliranno con un errore di
1453                               \errcode{ENOMEM}, mentre se il superamento viene
1454                               causato dalla crescita dello \itindex{stack}
1455                               stack il processo riceverà un segnale di
1456                               \const{SIGSEGV}. \\  
1457     \const{RLIMIT\_CORE}   &  La massima dimensione per di un file di
1458                               \textit{core dump}\itindex{core~dump} (vedi
1459                               sez.~\ref{sec:sig_prog_error}) creato nella
1460                               terminazione di un processo; file di dimensioni 
1461                               maggiori verranno troncati a questo valore,
1462                               mentre con un valore si bloccherà la creazione
1463                               dei \textit{core dump}\itindex{core~dump}.\\ 
1464     \const{RLIMIT\_CPU}    &  Il massimo tempo di CPU (vedi
1465                               sez.~\ref{sec:sys_cpu_times}) che il processo può
1466                               usare. Il superamento del limite corrente
1467                               comporta l'emissione di un segnale di
1468                               \const{SIGXCPU} la cui azione predefinita (vedi
1469                               sez.~\ref{sec:sig_classification}) è terminare
1470                               il processo. Il superamento del limite massimo
1471                               comporta l'emissione di un segnale di
1472                               \const{SIGKILL}.\footnotemark\\
1473     \const{RLIMIT\_DATA}   &  La massima dimensione del \index{segmento!dati}
1474                               segmento dati di un 
1475                               processo (vedi sez.~\ref{sec:proc_mem_layout}).
1476                               Il tentativo di allocare più memoria di quanto
1477                               indicato dal limite corrente causa il fallimento
1478                               della funzione di allocazione (\func{brk} o
1479                               \func{sbrk}) con un errore di \errcode{ENOMEM}.\\
1480     \const{RLIMIT\_FSIZE}  &  La massima dimensione di un file che un processo
1481                               può creare. Se il processo cerca di scrivere
1482                               oltre questa dimensione riceverà un segnale di
1483                               \const{SIGXFSZ}, che di norma termina il
1484                               processo; se questo viene intercettato la
1485                               system call che ha causato l'errore fallirà con
1486                               un errore di \errcode{EFBIG}.\\
1487     \const{RLIMIT\_LOCKS}&    È un limite presente solo nelle prime versioni
1488                               del kernel 2.4 sul numero massimo di
1489                               \index{file!locking}\textit{file lock} (vedi
1490                               sez.~\ref{sec:file_locking}) che un
1491                               processo poteva effettuare.\\ 
1492     \const{RLIMIT\_MEMLOCK}&  L'ammontare massimo di memoria che può essere
1493                               bloccata in RAM da un processo (vedi
1494                               sez.~\ref{sec:proc_mem_lock}). Dal kernel 2.6.9
1495                               questo limite comprende anche la memoria che può
1496                               essere bloccata da ciascun utente nell'uso della
1497                               memoria condivisa (vedi
1498                               sez.~\ref{sec:ipc_sysv_shm}) che viene
1499                               contabilizzata separatamente ma sulla quale
1500                               viene applicato questo stesso limite.\\ 
1501     \const{RLIMIT\_NOFILE} &  Il numero massimo di file che il processo può
1502                               aprire. L'apertura di un ulteriore file farà
1503                               fallire la funzione (\func{open}, \func{dup} o
1504                               \func{pipe}) con un errore \errcode{EMFILE}.\\
1505     \const{RLIMIT\_NPROC}  &  Il numero massimo di processi che possono essere
1506                               creati sullo stesso user id real. Se il limite
1507                               viene raggiunto \func{fork} fallirà con un
1508                               \errcode{EAGAIN}.\\
1509     \const{RLIMIT\_SIGPENDING}& Il numero massimo di segnali che possono
1510                               essere mantenuti in coda per ciascun utente,
1511                               considerando sia i segnali normali che real-time
1512                               (vedi sez.~\ref{sec:sig_real_time}). Il limite è
1513                               attivo solo per \func{sigqueue}, con \func{kill}
1514                               si potrà sempre inviare un segnale che non sia
1515                               già presente su una coda.\footnotemark\\
1516     \const{RLIMIT\_STACK}  &  La massima dimensione dello \itindex{stack}
1517                               stack del 
1518                               processo. Se il processo esegue operazioni che
1519                               estendano lo stack oltre questa dimensione
1520                               riceverà un segnale di \const{SIGSEGV}.\\
1521     \const{RLIMIT\_RSS}    &  L'ammontare massimo di pagine di memoria dato al
1522                               \index{segmento!testo} testo del processo. Il
1523                               limite è solo una indicazione per il kernel,
1524                               qualora ci fosse un surplus di memoria questa
1525                               verrebbe assegnata.\\ 
1526 % TODO integrare con la roba di madvise
1527     \hline
1528   \end{tabular}
1529   \caption{Valori possibili dell'argomento \param{resource} delle funzioni
1530     \func{getrlimit} e \func{setrlimit}.} 
1531   \label{tab:sys_rlimit_values}
1532 \end{table}
1533
1534 \footnotetext[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
1535   oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
1536   avviene quando viene superato il \textit{soft limit}; perciò per avere
1537   operazioni portabili è sempre opportuno intercettare \const{SIGXCPU} e
1538   terminare in maniera ordinata il processo.}
1539
1540 \footnotetext{il limite su questa risorsa è stato introdotto con il kernel
1541   2.6.8.}
1542
1543 In generale il superamento di un limite corrente\footnote{di norma quanto
1544   riportato in tab.~\ref{tab:sys_rlimit_values} fa riferimento a quanto
1545   avviene al superamento del limite corrente, con l'eccezione
1546   \const{RLIMIT\_CPU} in cui si ha in comportamento diverso per il superamento
1547   dei due limiti.}  comporta o l'emissione di un segnale o il fallimento della
1548 system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
1549   \const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
1550   creazione) dei file di \itindex{core~dump}\textit{core dump}.} per
1551 permettere di leggere e di impostare i limiti di utilizzo delle risorse da
1552 parte di un processo sono previste due funzioni, \funcd{getrlimit} e
1553 \funcd{setrlimit}, i cui prototipi sono:
1554 \begin{functions}
1555   \headdecl{sys/time.h} 
1556   \headdecl{sys/resource.h} 
1557   \headdecl{unistd.h} 
1558   
1559   \funcdecl{int getrlimit(int resource, struct rlimit *rlim)} 
1560
1561   Legge il limite corrente per la risorsa \param{resource}.
1562   
1563   \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)} 
1564   
1565   Imposta il limite per la risorsa \param{resource}.
1566   
1567   \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
1568     errore, nel qual caso \var{errno} assumerà uno dei valori:
1569     \begin{errlist}
1570     \item[\errcode{EINVAL}] I valori per \param{resource} non sono validi.
1571     \item[\errcode{EPERM}] Un processo senza i privilegi di amministratore ha
1572     cercato di innalzare i propri limiti.
1573     \end{errlist}
1574   ed \errval{EFAULT}.}
1575 \end{functions}
1576
1577
1578 Entrambe le funzioni permettono di specificare, attraverso l'argomento
1579 \param{resource}, su quale risorsa si vuole operare: i possibili valori di
1580 questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
1581 (rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
1582 poi effettuato attraverso la struttura \struct{rlimit} puntata da
1583 \param{rlim}, la cui definizione è riportata in
1584 fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
1585 limite corrente e limite massimo.
1586
1587
1588 \begin{figure}[!htb]
1589   \footnotesize
1590   \centering
1591   \begin{minipage}[c]{15cm}
1592     \includestruct{listati/rlimit.h}
1593   \end{minipage} 
1594   \normalsize 
1595   \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo 
1596     delle risorse usate da un processo.}
1597   \label{fig:sys_rlimit_struct}
1598 \end{figure}
1599
1600
1601 Nello specificare un limite, oltre a fornire dei valori specifici, si può
1602 anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
1603 di una risorsa; ma si ricordi che solo un processo con i privilegi di
1604 amministratore\footnote{per essere precisi in questo caso quello che serve è
1605   la \itindex{capabilities}\textit{capability} \const{CAP\_SYS\_RESOURCE}.}
1606 può innalzare un limite al di sopra del valore corrente del limite massimo ed
1607 usare un valore qualsiasi per entrambi i limiti. Si tenga conto infine che
1608 tutti i limiti vengono ereditati dal processo padre attraverso una \func{fork}
1609 (vedi sez.~\ref{sec:proc_fork}) e mantenuti per gli altri programmi eseguiti
1610 attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
1611
1612
1613 \subsection{Le risorse di memoria e processore}
1614 \label{sec:sys_memory_res}
1615
1616 La gestione della memoria è già stata affrontata in dettaglio in
1617 sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1618 meccanismo della memoria virtuale\index{memoria~virtuale} attraverso la
1619 divisione della memoria fisica in pagine.
1620
1621 In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
1622 casi, come per l'I/O mappato in memoria (vedi sez.~\ref{sec:file_memory_map})
1623 che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
1624 dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
1625 gestire in maniera ottimale l'interazione della memoria che si sta allocando
1626 con il meccanismo della paginazione\index{paginazione}.
1627
1628 Di solito la dimensione delle pagine di memoria è fissata dall'architettura
1629 hardware, per cui il suo valore di norma veniva mantenuto in una costante che
1630 bastava utilizzare in fase di compilazione, ma oggi, con la presenza di alcune
1631 architetture (ad esempio Sun Sparc) che permettono di variare questa
1632 dimensione, per non dover ricompilare i programmi per ogni possibile modello e
1633 scelta di dimensioni, è necessario poter utilizzare una funzione.
1634
1635 Dato che si tratta di una caratteristica generale del sistema, questa
1636 dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
1637 \func{sysconf}, \footnote{nel caso specifico si dovrebbe utilizzare il
1638   parametro \const{\_SC\_PAGESIZE}.}  ma in BSD 4.2 è stata introdotta una
1639 apposita funzione, \funcd{getpagesize}, che restituisce la dimensione delle
1640 pagine di memoria; il suo prototipo è:
1641 \begin{prototype}{unistd.h}{int getpagesize(void)}
1642   Legge le dimensioni delle pagine di memoria.
1643   
1644   \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
1645     sono previsti errori.}
1646 \end{prototype}
1647
1648 La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
1649 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1650 ha eliminata. In Linux è implementata come una system call nelle architetture
1651 in cui essa è necessaria, ed in genere restituisce il valore del simbolo
1652 \const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
1653 se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
1654 implementavano questa funzione restituendo sempre un valore statico.
1655
1656 % TODO verificare meglio la faccenda di const{PAGE\_SIZE} 
1657
1658 Le \textsl{glibc} forniscono, come specifica estensione GNU, altre due
1659 funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
1660 di ottenere informazioni riguardo la memoria; i loro prototipi sono:
1661 \begin{functions}
1662   \headdecl{sys/sysinfo.h} 
1663   
1664   \funcdecl{long int get\_phys\_pages(void)} 
1665
1666   Legge il numero totale di pagine di memoria disponibili per il sistema.
1667   
1668   \funcdecl{long int get\_avphys\_pages(void)} 
1669   
1670   Legge il numero di pagine di memoria disponibili nel sistema. 
1671   
1672   \bodydesc{Le funzioni restituiscono un numero di pagine.}
1673 \end{functions}
1674
1675 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1676 rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
1677 \const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1678 corrispondenti alla RAM della macchina; la seconda invece la memoria
1679 effettivamente disponibile per i processi.
1680
1681 Le \acr{glibc} supportano inoltre, come estensioni GNU, due funzioni che
1682 restituiscono il numero di processori della macchina (e quello dei processori
1683 attivi); anche queste sono informazioni comunque ottenibili attraverso
1684 \func{sysconf} utilizzando rispettivamente i parametri
1685 \const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
1686
1687 Infine le \acr{glibc} riprendono da BSD la funzione \funcd{getloadavg} che
1688 permette di ottenere il carico di processore della macchina, in questo modo è
1689 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1690 Il suo prototipo è:
1691 \begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
1692   Legge il carico medio della macchina.
1693   
1694   \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
1695     errore.}
1696 \end{prototype}
1697
1698 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1699 di processi attivi sulla coda dello scheduler\itindex{scheduler}, calcolato su
1700 diversi intervalli di tempo.  Il numero di intervalli che si vogliono
1701 leggere è specificato da \param{nelem}, dato che nel caso di Linux il carico
1702 viene valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti),
1703 questo è anche il massimo valore che può essere assegnato a questo argomento.
1704
1705
1706 \subsection{La \textsl{contabilità} in stile BSD}
1707 \label{sec:sys_bsd_accounting}
1708
1709 Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
1710 kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
1711   compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
1712 cosiddetto \textit{BSD accounting}, che consente di registrare su file una
1713 serie di informazioni\footnote{contenute nella struttura \texttt{acct}
1714   definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
1715 riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
1716 che viene terminato.
1717
1718 Linux consente di salvare la contabilità delle informazioni relative alle
1719 risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
1720 prototipo è:
1721 \begin{prototype}{unistd.h}{int acct(const char *filename)}
1722   Abilita il \textit{BSD accounting}.
1723   
1724   \bodydesc{La funzione ritorna 0 in caso di successo o $-1$ in caso di
1725     errore, nel qual caso \var{errno} assumerà uno dei valori:
1726     \begin{errlist}
1727     \item[\errcode{EACCESS}] non si hanno i permessi per accedere a
1728       \param{pathname}.
1729     \item[\errcode{EPERM}] Il processo non ha privilegi sufficienti ad
1730       abilitare il \textit{BSD accounting}.
1731     \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
1732     \item[\errcode{EUSER}] non sono disponibili nel kernel strutture per il
1733       file o si è finita la memoria.
1734     \end{errlist}
1735     ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
1736     \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
1737     \errval{ENOTDIR}, \errval{EROFS}.}
1738 \end{prototype}
1739
1740 La funzione attiva il salvataggio dei dati sul file indicato dal pathname
1741 contenuti nella stringa puntata da \param{filename}; la funzione richiede che
1742 il processo abbia i privilegi di amministratore (è necessaria la
1743 \itindex{capabilities} capability \const{CAP\_SYS\_PACCT}, vedi
1744 sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \const{NULL} per
1745 \param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
1746 semplice esempio per l'uso di questa funzione è riportato nel programma
1747 \texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
1748
1749 Quando si attiva la contabilità, il file che si indica deve esistere; esso
1750 verrà aperto in sola scrittura;\footnote{si applicano al pathname indicato da
1751   \param{filename} tutte le restrizioni viste in cap.~\ref{cha:file_intro}.}
1752 le informazioni verranno registrate in \itindex{append~mode} \textit{append}
1753 in coda al file tutte le volte che un processo termina. Le informazioni
1754 vengono salvate in formato binario, e corrispondono al contenuto della
1755 apposita struttura dati definita all'interno del kernel.
1756
1757 Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
1758 parametro di sistema, modificabile attraverso \file{/proc/sys/kernel/acct} (o
1759 tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi, il
1760 primo indica la percentuale di spazio disco libero sopra il quale viene
1761 ripresa una registrazione che era stata sospesa per essere scesi sotto il
1762 minimo indicato dal secondo valore (sempre in percentuale di spazio disco
1763 libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
1764 essere controllata detta percentuale.
1765
1766
1767
1768
1769 \section{La gestione dei tempi del sistema}
1770 \label{sec:sys_time}
1771
1772 In questa sezione, una volta introdotti i concetti base della gestione dei
1773 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
1774 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
1775 veri tempi di sistema associati ai processi, a quelle per convertire i vari
1776 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
1777 gestione di data e ora.
1778
1779
1780 \subsection{La misura del tempo in Unix}
1781 \label{sec:sys_unix_time}
1782
1783 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
1784 dati per la misure dei tempi all'interno del sistema: essi sono
1785 rispettivamente chiamati \itindend{calendar~time} \textit{calendar time} e
1786 \itindex{process~time} \textit{process time}, secondo le definizioni:
1787 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1788 \item[\textit{calendar time}] \itindend{calendar~time} detto anche
1789   \textsl{tempo di calendario}. È il numero di secondi dalla mezzanotte del
1790   primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
1791   usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
1792     Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
1793   dato che l'UTC corrisponde all'ora locale di Greenwich.  È il tempo su cui
1794   viene mantenuto l'orologio del kernel, e viene usato ad esempio per indicare
1795   le date di modifica dei file o quelle di avvio dei processi. Per memorizzare
1796   questo tempo è stato riservato il tipo primitivo \type{time\_t}.
1797 \item[\textit{process time}] \itindex{process~time} detto talvolta
1798   \textsl{tempo di processore}.  Viene misurato in \textit{clock tick}. Un
1799   tempo questo corrispondeva al numero di interruzioni effettuate dal timer di
1800   sistema, adesso lo standard POSIX richiede che esso sia pari al valore della
1801   costante \const{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000,
1802   qualunque sia la risoluzione reale dell'orologio di sistema e la frequenza
1803   delle interruzioni del timer.\footnote{quest'ultima, come accennato in
1804     sez.~\ref{sec:proc_hierarchy}, è invece data dalla costante \const{HZ}.}
1805   Il dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi
1806   una risoluzione del microsecondo. Il numero di tick al secondo può essere
1807   ricavato anche attraverso \func{sysconf} (vedi sez.~\ref{sec:sys_sysconf}).
1808   Il vecchio simbolo \const{CLK\_TCK} definito in \file{time.h} è ormai
1809   considerato obsoleto.
1810 \end{basedescript}
1811
1812 In genere si usa il \itindend{calendar~time} \textit{calendar time} per
1813 esprimere le date dei file e le informazioni analoghe che riguardano i
1814 cosiddetti \textsl{tempi di orologio}, che vengono usati ad esempio per i
1815 demoni che compiono lavori amministrativi ad ore definite, come \cmd{cron}.
1816
1817 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
1818 tempo locale, utilizzando le opportune informazioni di localizzazione
1819 (specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
1820 mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
1821 dall'orologio hardware del calcolatore.
1822
1823 Anche il \itindex{process~time} \textit{process time} di solito si esprime in
1824 secondi, ma provvede una precisione ovviamente superiore al \textit{calendar
1825   time} (che è mantenuto dal sistema con una granularità di un secondo) e
1826 viene usato per tenere conto dei tempi di esecuzione dei processi. Per ciascun
1827 processo il kernel calcola tre tempi diversi:
1828 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1829 \item[\textit{clock time}] il tempo \textsl{reale} (viene chiamato anche
1830   \textit{wall clock time} o \textit{elapsed time}) passato dall'avvio del
1831   processo. Chiaramente tale tempo dipende anche dal carico del sistema e da
1832   quanti altri processi stavano girando nello stesso periodo.
1833   
1834 \item[\textit{user time}] il tempo effettivo che il processore ha impiegato
1835   nell'esecuzione delle istruzioni del processo in user space. È quello
1836   riportato nella risorsa \var{ru\_utime} di \struct{rusage} vista in
1837   sez.~\ref{sec:sys_resource_use}.
1838   
1839 \item[\textit{system time}] il tempo effettivo che il processore ha impiegato
1840   per eseguire codice delle system call nel kernel per conto del processo.  È
1841   quello riportato nella risorsa \var{ru\_stime} di \struct{rusage} vista in
1842   sez.~\ref{sec:sys_resource_use}.
1843 \end{basedescript}
1844
1845 In genere la somma di \textit{user time} e \textit{system time} indica il
1846 tempo di processore totale che il sistema ha effettivamente utilizzato per
1847 eseguire un certo processo, questo viene chiamato anche \textit{CPU time} o
1848 \textsl{tempo di CPU}. Si può ottenere un riassunto dei valori di questi tempi
1849 quando si esegue un qualsiasi programma lanciando quest'ultimo come argomento
1850 del comando \cmd{time}.
1851
1852
1853
1854 \subsection{La gestione del \textit{process time}}
1855 \label{sec:sys_cpu_times}
1856
1857 \itindbeg{process~time}
1858
1859 Di norma tutte le operazioni del sistema fanno sempre riferimento al
1860 \itindend{calendar~time} \textit{calendar time}, l'uso del \textit{process
1861   time} è riservato a quei casi in cui serve conoscere i tempi di esecuzione
1862 di un processo (ad esempio per valutarne l'efficienza). In tal caso infatti
1863 fare ricorso al \textit{calendar time} è inutile in quanto il tempo può essere
1864 trascorso mentre un altro processo era in esecuzione o in attesa del risultato
1865 di una operazione di I/O.
1866
1867 La funzione più semplice per leggere il \textit{process time} di un processo è
1868 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
1869 utilizzato dallo stesso; il suo prototipo è:
1870 \begin{prototype}{time.h}{clock\_t clock(void)}
1871   Legge il valore corrente del tempo di CPU.
1872   
1873   \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
1874     caso di errore.}
1875 \end{prototype}
1876
1877 La funzione restituisce il tempo in tick, quindi se si vuole il tempo in
1878 secondi occorre dividere il risultato per la costante
1879 \const{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
1880   POSIX richiede che \const{CLOCKS\_PER\_SEC} sia definito pari a 1000000
1881   indipendentemente dalla risoluzione del timer di sistema.} In genere
1882 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
1883 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
1884 riprenderà lo stesso valore iniziale.
1885
1886 Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di CPU è la somma di
1887 altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
1888 quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
1889 possono essere letti attraverso la funzione \funcd{times}, il cui prototipo è:
1890 \begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
1891   Legge in \param{buf} il valore corrente dei tempi di processore.
1892   
1893   \bodydesc{La funzione ritorna il numero di clock tick dall'avvio del sistema
1894     in caso di successo e -1 in caso di errore.}
1895 \end{prototype}
1896
1897 La funzione restituisce i valori di \textit{process time} del processo
1898 corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
1899 in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
1900 due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
1901 \textit{system time} del processo, così come definiti in
1902 sez.~\ref{sec:sys_unix_time}.
1903
1904 \begin{figure}[!htb]
1905   \footnotesize
1906   \centering
1907   \begin{minipage}[c]{15cm}
1908     \includestruct{listati/tms.h}
1909   \end{minipage} 
1910   \normalsize 
1911   \caption{La struttura \structd{tms} dei tempi di processore associati a un
1912     processo.} 
1913   \label{fig:sys_tms_struct}
1914 \end{figure}
1915
1916 Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
1917   time} ed del \textit{system time} di tutti i processi figli che sono
1918 terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
1919 \var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
1920 ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.
1921
1922 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
1923 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
1924 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
1925 lo stato di terminazione di tutti i suoi figli, questi processi
1926 ``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi.
1927
1928 \itindend{process~time}
1929
1930
1931 \subsection{Le funzioni per il \textit{calendar time}}
1932 \label{sec:sys_time_base}
1933
1934 \itindbeg{calendar~time}
1935
1936 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
1937 mantenuto dal kernel in una variabile di tipo \type{time\_t}, che usualmente
1938 corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
1939 che di norma corrisponde a 32 bit).  Il valore corrente del \textit{calendar
1940   time}, che indicheremo come \textsl{tempo di sistema}, può essere ottenuto
1941 con la funzione \funcd{time} che lo restituisce nel suddetto formato; il suo
1942 prototipo è:
1943 \begin{prototype}{time.h}{time\_t time(time\_t *t)}
1944   Legge il valore corrente del \textit{calendar time}.
1945   
1946   \bodydesc{La funzione ritorna il valore del \textit{calendar time} in caso
1947     di successo e -1 in caso di errore, che può essere solo \errval{EFAULT}.}
1948 \end{prototype}
1949 \noindent dove \param{t}, se non nullo, deve essere  l'indirizzo di una
1950 variabile su cui duplicare il valore di ritorno.
1951
1952 Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
1953 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
1954 sia necessario; il suo prototipo è:
1955 \begin{prototype}{time.h}{int stime(time\_t *t)}
1956   Imposta a \param{t} il valore corrente del \textit{calendar time}.
1957   
1958   \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1959     che può essere \errval{EFAULT} o \errval{EPERM}.}
1960 \end{prototype}
1961 \noindent dato che modificare l'ora ha un impatto su tutto il sistema 
1962 il cambiamento dell'orologio è una operazione privilegiata e questa funzione
1963 può essere usata solo da un processo con i privilegi di amministratore,
1964 altrimenti la chiamata fallirà con un errore di \errcode{EPERM}.
1965
1966 Data la scarsa precisione nell'uso di \type{time\_t} (che ha una risoluzione
1967 massima di un secondo) quando si devono effettuare operazioni sui tempi di
1968 norma l'uso delle funzioni precedenti è sconsigliato, ed esse sono di solito
1969 sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le due
1970   funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
1971   \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
1972   in BSD4.3 sono indicate come sostitute delle precedenti.} i cui prototipi
1973 sono:
1974 \begin{functions}
1975   \headdecl{sys/time.h}
1976   \headdecl{time.h}
1977   
1978   \funcdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)} 
1979
1980   Legge il tempo corrente del sistema.
1981   
1982   \funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
1983     *tz)}
1984   
1985   Imposta il tempo di sistema.
1986   
1987   \bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
1988     caso di errore, nel qual caso \var{errno} può assumere i valori
1989     \errval{EINVAL} \errval{EFAULT} e per \func{settimeofday} anche
1990     \errval{EPERM}.}
1991 \end{functions}
1992
1993 Queste funzioni utilizzano una struttura di tipo \struct{timeval}, la cui
1994 definizione, insieme a quella della analoga \struct{timespec}, è riportata in
1995 fig.~\ref{fig:sys_timeval_struct}. Le \acr{glibc} infatti forniscono queste due
1996 rappresentazioni alternative del \textit{calendar time} che rispetto a
1997 \type{time\_t} consentono rispettivamente precisioni del microsecondo e del
1998 nanosecondo.\footnote{la precisione è solo teorica, la precisione reale della
1999   misura del tempo dell'orologio di sistema non dipende dall'uso di queste
2000   strutture.}
2001
2002 \begin{figure}[!htb]
2003   \footnotesize \centering
2004   \begin{minipage}[c]{15cm}
2005     \includestruct{listati/timeval.h}
2006   \end{minipage} 
2007   \normalsize 
2008   \caption{Le strutture \structd{timeval} e \structd{timespec} usate per una
2009     rappresentazione ad alta risoluzione del \textit{calendar time}.}
2010   \label{fig:sys_timeval_struct}
2011 \end{figure}
2012
2013 Come nel caso di \func{stime} anche \func{settimeofday} (la cosa continua a
2014 valere per qualunque funzione che vada a modificare l'orologio di sistema,
2015 quindi anche per quelle che tratteremo in seguito) può essere utilizzata solo
2016 da un processo coi privilegi di amministratore.
2017
2018 Il secondo argomento di entrambe le funzioni è una struttura
2019 \struct{timezone}, che storicamente veniva utilizzata per specificare appunto
2020 la \textit{time zone}, cioè l'insieme del fuso orario e delle convenzioni per
2021 l'ora legale che permettevano il passaggio dal tempo universale all'ora
2022 locale. Questo argomento oggi è obsoleto ed in Linux non è mai stato
2023 utilizzato; esso non è supportato né dalle vecchie \textsl{libc5}, né dalle
2024 \textsl{glibc}: pertanto quando si chiama questa funzione deve essere sempre
2025 impostato a \val{NULL}.
2026
2027 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
2028 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
2029 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
2030 conseguenze indesiderate.  Ad esempio se si porta avanti l'orologio si possono
2031 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
2032 saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
2033 delle operazioni previste nell'intervallo di tempo che viene ripetuto. 
2034
2035 Per questo motivo la modalità più corretta per impostare l'ora è quella di
2036 usare la funzione \funcd{adjtime}, il cui prototipo è:
2037 \begin{prototype}{sys/time.h}
2038 {int adjtime(const struct timeval *delta, struct timeval *olddelta)} 
2039   
2040   Aggiusta del valore \param{delta} l'orologio di sistema.
2041   
2042   \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
2043     errore, nel qual caso \var{errno} assumerà il valore \errcode{EPERM}.}
2044 \end{prototype}
2045
2046 Questa funzione permette di avere un aggiustamento graduale del tempo di
2047 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
2048 di \param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
2049 positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
2050 il tempo richiesto, altrimenti sarà rallentato. Il secondo argomento viene
2051 usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
2052 effettuato.
2053
2054
2055 \begin{figure}[!htb]
2056   \footnotesize \centering
2057   \begin{minipage}[c]{15cm}
2058     \includestruct{listati/timex.h}
2059   \end{minipage} 
2060   \normalsize 
2061   \caption{La struttura \structd{timex} per il controllo dell'orologio di
2062     sistema.} 
2063   \label{fig:sys_timex_struct}
2064 \end{figure}
2065
2066 Linux poi prevede un'altra funzione, che consente un aggiustamento molto più
2067 dettagliato del tempo, permettendo ad esempio anche di modificare anche la
2068 velocità dell'orologio di sistema.  La funzione è \funcd{adjtimex} ed il suo
2069 prototipo è:
2070 \begin{prototype}{sys/timex.h}
2071 {int adjtimex(struct timex *buf)} 
2072   
2073   Aggiusta del valore \param{delta} l'orologio di sistema.
2074   
2075   \bodydesc{La funzione restituisce lo stato dell'orologio (un valore $>0$) in
2076     caso di successo e -1 in caso di errore, nel qual caso \var{errno}
2077     assumerà i valori \errval{EFAULT}, \errval{EINVAL} ed \errval{EPERM}.}
2078 \end{prototype}
2079
2080 La funzione richiede una struttura di tipo \struct{timex}, la cui definizione,
2081 così come effettuata in \file{sys/timex.h}, è riportata in
2082 fig.~\ref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore del
2083 campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
2084 specificato in un opportuno campo di \struct{timex}, deve essere impostato. Un
2085 valore nullo serve per leggere i parametri correnti; i valori diversi da zero
2086 devono essere specificati come OR binario delle costanti riportate in
2087 tab.~\ref{tab:sys_timex_mode}.
2088
2089 La funzione utilizza il meccanismo di David L. Mills, descritto
2090 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
2091 protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
2092 portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
2093 \func{ntp\_adjtime}.  La trattazione completa di questa funzione necessita di
2094 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
2095 a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
2096 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
2097 campi della struttura \struct{timex} può essere ritrovato in \cite{glibc}.
2098
2099 \begin{table}[!htb]
2100   \footnotesize
2101   \centering
2102   \begin{tabular}[c]{|l|c|p{8.5cm}|}
2103     \hline
2104     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2105     \hline
2106     \hline
2107     \const{ADJ\_OFFSET}         & 0x0001 & Imposta la differenza fra il tempo
2108                                            reale e l'orologio di sistema: 
2109                                            deve essere indicata in microsecondi
2110                                            nel campo \var{offset} di
2111                                            \struct{timex}.\\ 
2112     \const{ADJ\_FREQUENCY}      & 0x0002 & Imposta la differenze in frequenza
2113                                            fra il tempo reale e l'orologio di
2114                                            sistema: deve essere indicata
2115                                            in parti per milione nel campo
2116                                            \var{frequency} di \struct{timex}.\\
2117     \const{ADJ\_MAXERROR}       & 0x0004 & Imposta il valore massimo 
2118                                            dell'errore
2119                                            sul tempo, espresso in microsecondi 
2120                                            nel campo \var{maxerror} di
2121                                            \struct{timex}.\\ 
2122     \const{ADJ\_ESTERROR}       & 0x0008 & Imposta la stima dell'errore
2123                                            sul tempo, espresso in microsecondi 
2124                                            nel campo \var{esterror} di
2125                                            \struct{timex}.\\
2126     \const{ADJ\_STATUS}         & 0x0010 & Imposta alcuni
2127                                            valori di stato interni usati dal
2128                                            sistema nella gestione
2129                                            dell'orologio specificati nel campo
2130                                            \var{status} di \struct{timex}.\\ 
2131     \const{ADJ\_TIMECONST}      & 0x0020 & Imposta la larghezza di banda del 
2132                                            PLL implementato dal kernel,
2133                                            specificato nel campo
2134                                            \var{constant} di \struct{timex}.\\ 
2135     \const{ADJ\_TICK}           & 0x4000 & Imposta il valore dei tick del timer
2136                                            in microsecondi, espresso nel campo
2137                                            \var{tick} di \struct{timex}.\\ 
2138     \const{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Imposta uno spostamento una tantum 
2139                                            dell'orologio secondo il valore del
2140                                            campo \var{offset} simulando il
2141                                            comportamento di \func{adjtime}.\\ 
2142     \hline
2143   \end{tabular}
2144   \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
2145     struttura \struct{timex}.} 
2146   \label{tab:sys_timex_mode}
2147 \end{table}
2148
2149 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
2150 sintassi specificata per la forma equivalente di questa funzione definita come
2151 \func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
2152 \code{ADJ}.
2153
2154 \begin{table}[htb]
2155   \footnotesize
2156   \centering
2157   \begin{tabular}[c]{|l|c|l|}
2158     \hline
2159     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2160     \hline
2161     \hline
2162     \const{TIME\_OK}   & 0 & L'orologio è sincronizzato.\\ 
2163     \const{TIME\_INS}  & 1 & insert leap second.\\ 
2164     \const{TIME\_DEL}  & 2 & delete leap second.\\ 
2165     \const{TIME\_OOP}  & 3 & leap second in progress.\\ 
2166     \const{TIME\_WAIT} & 4 & leap second has occurred.\\ 
2167     \const{TIME\_BAD}  & 5 & L'orologio non è sincronizzato.\\ 
2168     \hline
2169   \end{tabular}
2170   \caption{Possibili valori di ritorno di \func{adjtimex}.} 
2171   \label{tab:sys_adjtimex_return}
2172 \end{table}
2173
2174 La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
2175 sistema; questo può assumere i valori riportati in
2176 tab.~\ref{tab:sys_adjtimex_return}.  Un valore di -1 viene usato per riportare
2177 un errore; al solito se si cercherà di modificare l'orologio di sistema
2178 (specificando un \var{mode} diverso da zero) senza avere i privilegi di
2179 amministratore si otterrà un errore di \errcode{EPERM}.
2180
2181
2182
2183 \subsection{La gestione delle date.}
2184 \label{sec:sys_date}
2185
2186 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
2187 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
2188 illustrate, se han senso per specificare un intervallo, non sono molto
2189 intuitive quando si deve esprimere un'ora o una data.  Per questo motivo è
2190 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2191   time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2192   time} usuale in ore, minuti, secondi, ecc.
2193
2194 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
2195 definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
2196 struttura che si utilizza quando si deve specificare un tempo a partire dai
2197 dati naturali (ora e data), dato che essa consente anche di trattare la
2198 gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
2199   \var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste da BSD e dalle
2200   \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
2201   fig.~\ref{fig:sys_tm_struct}.}
2202
2203 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2204 da quelle usate per convertire gli altri formati in questo, usando o meno
2205 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2206 tempo in una stringa contenente data ed ora, i loro prototipi sono:
2207 \begin{functions}
2208   \headdecl{time.h}
2209   \funcdecl{char *\funcd{asctime}(const struct tm *tm)} 
2210   Produce una stringa con data e ora partendo da un valore espresso in
2211   \textit{broken-down time}.
2212
2213   \funcdecl{char *\funcd{ctime}(const time\_t *timep)} 
2214   Produce una stringa con data e ora partendo da un valore espresso in
2215   in formato \type{time\_t}.
2216   
2217   \funcdecl{struct tm *\funcd{gmtime}(const time\_t *timep)} 
2218   Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2219   \textit{broken-down time} espresso in UTC.
2220
2221   \funcdecl{struct tm *\funcd{localtime}(const time\_t *timep)} 
2222   Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2223   \textit{broken-down time} espresso nell'ora locale.
2224
2225   \funcdecl{time\_t \funcd{mktime}(struct tm *tm)}   
2226   Converte il \textit{broken-down time} in formato \type{time\_t}.
2227   
2228   \bodydesc{Tutte le funzioni restituiscono un puntatore al risultato in caso
2229   di successo e \val{NULL} in caso di errore, tranne che \func{mktime} che
2230   restituisce direttamente il valore o -1 in caso di errore.}
2231 \end{functions}
2232
2233 \begin{figure}[!htb]
2234   \footnotesize \centering
2235   \begin{minipage}[c]{15cm}
2236     \includestruct{listati/tm.h}
2237   \end{minipage} 
2238   \normalsize 
2239   \caption{La struttura \structd{tm} per una rappresentazione del tempo in
2240     termini di ora, minuti, secondi, ecc.}
2241   \label{fig:sys_tm_struct}
2242 \end{figure}
2243
2244
2245
2246 Le prime due funzioni, \func{asctime} e \func{ctime} servono per poter
2247 stampare in forma leggibile un tempo; esse restituiscono il puntatore ad una
2248 stringa, allocata staticamente, nella forma:
2249 \begin{verbatim}
2250 "Wed Jun 30 21:49:08 1993\n"
2251 \end{verbatim}
2252 e impostano anche la variabile \var{tzname} con l'informazione della
2253 \textit{time zone} corrente; \func{ctime} è banalmente definita in termini di
2254 \func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
2255 statica rende le funzioni non rientranti POSIX.1c e SUSv2 prevedono due
2256 sostitute rientranti, il cui nome è al solito ottenuto aggiungendo un
2257 \code{\_r}, che prendono un secondo argomento \code{char *buf}, in cui
2258 l'utente deve specificare il buffer su cui la stringa deve essere copiata
2259 (deve essere di almeno 26 caratteri).
2260
2261 Le altre tre funzioni, \func{gmtime}, \func{localtime} e \func{mktime} servono
2262 per convertire il tempo dal formato \type{time\_t} a quello di \struct{tm} e
2263 viceversa; \func{gmtime} effettua la conversione usando il tempo coordinato
2264 universale (UTC), cioè l'ora di Greenwich; mentre \func{localtime} usa l'ora
2265 locale; \func{mktime} esegue la conversione inversa.  
2266
2267 Anche in questo caso le prime due funzioni restituiscono l'indirizzo di una
2268 struttura allocata staticamente, per questo sono state definite anche altre
2269 due versioni rientranti (con la solita estensione \code{\_r}), che prevedono
2270 un secondo argomento \code{struct tm *result}, fornito dal chiamante, che deve
2271 preallocare la struttura su cui sarà restituita la conversione.
2272
2273 Come mostrato in fig.~\ref{fig:sys_tm_struct} il \textit{broken-down time}
2274 permette di tenere conto anche della differenza fra tempo universale e ora
2275 locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
2276 variabili globali mostrate in fig.~\ref{fig:sys_tzname}, cui si accede quando
2277 si include \file{time.h}. Queste variabili vengono impostate quando si chiama
2278 una delle precedenti funzioni di conversione, oppure invocando direttamente la
2279 funzione \funcd{tzset}, il cui prototipo è:
2280 \begin{prototype}{sys/timex.h}
2281 {void tzset(void)} 
2282   
2283   Imposta le variabili globali della \textit{time zone}.
2284   
2285   \bodydesc{La funzione non ritorna niente e non dà errori.}
2286 \end{prototype}
2287
2288 La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire dal
2289 valore della variabile di ambiente \const{TZ}, se quest'ultima non è definita
2290 verrà usato il file \file{/etc/localtime}.
2291
2292 \begin{figure}[!htb]
2293   \footnotesize
2294   \centering
2295   \begin{minipage}[c]{15cm}
2296     \includestruct{listati/time_zone_var.c}
2297   \end{minipage} 
2298   \normalsize 
2299   \caption{Le variabili globali usate per la gestione delle \textit{time
2300       zone}.}  
2301   \label{fig:sys_tzname}
2302 \end{figure}
2303
2304 La variabile \var{tzname} contiene due stringhe, che indicano i due nomi
2305 standard della \textit{time zone} corrente. La prima è il nome per l'ora
2306 solare, la seconda per l'ora legale.\footnote{anche se sono indicati come
2307   \code{char *} non è il caso di modificare queste stringhe.} La variabile
2308 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2309 \var{daylight} indica se è attiva o meno l'ora legale. 
2310
2311 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2312 stampare un tempo o una data, la flessibilità non fa parte delle sue
2313 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2314 giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
2315 il cui prototipo è:
2316 \begin{prototype}{time.h}
2317 {size\_t strftime(char *s, size\_t max, const char *format, 
2318   const struct tm *tm)}
2319   
2320 Stampa il tempo \param{tm} nella stringa \param{s} secondo il formato
2321 \param{format}.
2322   
2323   \bodydesc{La funzione ritorna il numero di caratteri stampati in \param{s},
2324   altrimenti restituisce 0.}
2325 \end{prototype}
2326
2327 La funzione converte opportunamente il tempo \param{tm} in una stringa di
2328 testo da salvare in \param{s}, purché essa sia di dimensione, indicata da
2329 \param{size}, sufficiente. I caratteri generati dalla funzione vengono
2330 restituiti come valore di ritorno, ma non tengono conto del terminatore
2331 finale, che invece viene considerato nel computo della dimensione; se
2332 quest'ultima è eccessiva viene restituito 0 e lo stato di \param{s} è
2333 indefinito.
2334
2335 \begin{table}[htb]
2336   \footnotesize
2337   \centering
2338   \begin{tabular}[c]{|c|l|p{6cm}|}
2339     \hline
2340     \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2341     \hline
2342     \hline
2343     \var{\%a}&\texttt{Wed}        & Nome del giorno, abbreviato.\\ 
2344     \var{\%A}&\texttt{Wednesday}  & Nome del giorno, completo.\\ 
2345     \var{\%b}&\texttt{Apr}        & Nome del mese, abbreviato.\\ 
2346     \var{\%B}&\texttt{April}      & Nome del mese, completo.\\ 
2347     \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\ 
2348     \var{\%d}&\texttt{24}         & Giorno del mese.\\ 
2349     \var{\%H}&\texttt{18}         & Ora del giorno, da 0 a 24.\\ 
2350     \var{\%I}&\texttt{06}         & Ora del giorno, da 0 a 12.\\ 
2351     \var{\%j}&\texttt{114}        & Giorno dell'anno.\\ 
2352     \var{\%m}&\texttt{04}         & Mese dell'anno.\\ 
2353     \var{\%M}&\texttt{40}         & Minuto.\\ 
2354     \var{\%p}&\texttt{PM}         & AM/PM.\\ 
2355     \var{\%S}&\texttt{50}         & Secondo.\\ 
2356     \var{\%U}&\texttt{16}         & Settimana dell'anno (partendo dalla
2357                                     domenica).\\ 
2358     \var{\%w}&\texttt{3}          & Giorno della settimana.  \\ 
2359     \var{\%W}&\texttt{16}         & Settimana dell'anno (partendo dal
2360                                     lunedì).\\ 
2361     \var{\%x}&\texttt{04/24/02}   & La data.\\ 
2362     \var{\%X}&\texttt{18:40:50}   & L'ora.\\ 
2363     \var{\%y}&\texttt{02}         & Anno nel secolo.\\ 
2364     \var{\%Y}&\texttt{2002}       & Anno.\\ 
2365     \var{\%Z}&\texttt{CEST}       & Nome della \textit{timezone}.\\ 
2366     \var{\%\%}&\texttt{\%}        & Il carattere \%.\\ 
2367     \hline
2368   \end{tabular}
2369   \caption{Valori previsti dallo standard ANSI C per modificatore della
2370     stringa di formato di \func{strftime}.}  
2371   \label{tab:sys_strftime_format}
2372 \end{table}
2373
2374 Il risultato della funzione è controllato dalla stringa di formato
2375 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2376 viene utilizzato come modificatore; alcuni\footnote{per la precisione quelli
2377   definiti dallo standard ANSI C, che sono anche quelli riportati da POSIX.1;
2378   le \acr{glibc} provvedono tutte le estensioni introdotte da POSIX.2 per il
2379   comando \cmd{date}, i valori introdotti da SVID3 e ulteriori estensioni GNU;
2380   l'elenco completo dei possibili valori è riportato nella pagina di manuale
2381   della funzione.} dei possibili valori che esso può assumere sono riportati
2382 in tab.~\ref{tab:sys_strftime_format}. La funzione tiene conto anche della
2383 presenza di una localizzazione per stampare in maniera adeguata i vari nomi.
2384
2385 \itindend{calendar~time}
2386
2387
2388 \section{La gestione degli errori}
2389 \label{sec:sys_errors}
2390
2391 In questa sezione esamineremo le caratteristiche principali della gestione
2392 degli errori in un sistema unix-like. Infatti a parte il caso particolare di
2393 alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
2394 unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
2395 un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
2396 semplicemente usando un opportuno valore di ritorno della funzione invocata.
2397 Inoltre il sistema di classificazione degli errori è basato sull'architettura
2398 a processi, e presenta una serie di problemi nel caso lo si debba usare con i
2399 thread.
2400
2401
2402 \subsection{La variabile \var{errno}}
2403 \label{sec:sys_errno}
2404
2405 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2406 riportare condizioni di errore, ed è una norma fondamentale di buona
2407 programmazione controllare \textbf{sempre} che le funzioni chiamate si siano
2408 concluse correttamente.
2409
2410 In genere le funzioni di libreria usano un valore speciale per indicare che
2411 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
2412 costante \val{EOF} (a seconda della funzione); ma questo valore segnala solo
2413 che c'è stato un errore, non il tipo di errore.
2414
2415 Per riportare il tipo di errore il sistema usa la variabile globale
2416 \var{errno},\footnote{L'uso di una variabile globale può comportare alcuni
2417   problemi (ad esempio nel caso dei thread) ma lo standard ISO C consente
2418   anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
2419   può anche usare una macro, e questo è infatti il modo usato da Linux per
2420   renderla locale ai singoli thread.} definita nell'header \file{errno.h}; la
2421 variabile è in genere definita come \direct{volatile} dato che può essere
2422 cambiata in modo asincrono da un segnale (si veda sez.~\ref{sec:sig_sigchld}
2423 per un esempio, ricordando quanto trattato in sez.~\ref{sec:proc_race_cond}),
2424 ma dato che un gestore di segnale scritto bene salva e ripristina il valore
2425 della variabile, di questo non è necessario preoccuparsi nella programmazione
2426 normale.
2427
2428 I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
2429 nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
2430 costanti numeriche che identificano i vari errori; essi iniziano tutti per
2431 \val{E} e si possono considerare come nomi riservati. In seguito faremo
2432 sempre riferimento a tali valori, quando descriveremo i possibili errori
2433 restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
2434 codice relativo ad un valore numerico con l'opzione \cmd{-l}.
2435
2436 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
2437 programma, gran parte delle funzioni di libreria impostano \var{errno} ad un
2438 valore diverso da zero in caso di errore. Il valore è invece indefinito in
2439 caso di successo, perché anche se una funzione ha successo, può chiamarne
2440 altre al suo interno che falliscono, modificando così \var{errno}.
2441
2442 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
2443 essere il risultato di un errore precedente) e non lo si può usare per
2444 determinare quando o se una chiamata a funzione è fallita.  La procedura da
2445 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
2446 verificato il fallimento della funzione attraverso il suo codice di ritorno.
2447
2448
2449 \subsection{Le funzioni \func{strerror} e \func{perror}}
2450 \label{sec:sys_strerror}
2451
2452 Benché gli errori siano identificati univocamente dal valore numerico di
2453 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
2454 riportare in opportuni messaggi le condizioni di errore verificatesi.  La
2455 prima funzione che si può usare per ricavare i messaggi di errore è
2456 \funcd{strerror}, il cui prototipo è:
2457 \begin{prototype}{string.h}{char *strerror(int errnum)} 
2458   Restituisce una stringa con il messaggio di errore relativo ad
2459   \param{errnum}.
2460   
2461   \bodydesc{La funzione ritorna il puntatore ad una stringa di errore.}
2462 \end{prototype}
2463
2464
2465 La funzione ritorna il puntatore alla stringa contenente il messaggio di
2466 errore corrispondente al valore di \param{errnum}, se questo non è un valore
2467 valido verrà comunque restituita una stringa valida contenente un messaggio
2468 che dice che l'errore è sconosciuto, e \var{errno} verrà modificata assumendo
2469 il valore \errval{EINVAL}.
2470
2471 In generale \func{strerror} viene usata passando \var{errno} come argomento,
2472 ed il valore di quest'ultima non verrà modificato. La funzione inoltre tiene
2473 conto del valore della variabile di ambiente \val{LC\_MESSAGES} per usare le
2474 appropriate traduzioni dei messaggi d'errore nella localizzazione presente.
2475
2476 La funzione utilizza una stringa statica che non deve essere modificata dal
2477 programma; essa è utilizzabile solo fino ad una chiamata successiva a
2478 \func{strerror} o \func{perror}, nessun'altra funzione di libreria tocca
2479 questa stringa. In ogni caso l'uso di una stringa statica rende la funzione
2480 non rientrante, per cui nel caso si usino i thread le librerie
2481 forniscono\footnote{questa funzione è la versione prevista dalle \acr{glibc},
2482   ed effettivamente definita in \file{string.h}, ne esiste una analoga nello
2483   standard SUSv3 (quella riportata dalla pagina di manuale), che restituisce
2484   \code{int} al posto di \code{char *}, e che tronca la stringa restituita a
2485   \param{size}.}  una apposita versione rientrante \func{strerror\_r}, il cui
2486 prototipo è:
2487 \begin{prototype}{string.h}
2488   {char * strerror\_r(int errnum, char *buf, size\_t size)} 
2489   
2490   Restituisce una stringa con il messaggio di errore relativo ad
2491   \param{errnum}.
2492  
2493   \bodydesc{La funzione restituisce l'indirizzo del messaggio in caso di
2494     successo e \val{NULL} in caso di errore; nel qual caso \var{errno}
2495     assumerà i valori:
2496   \begin{errlist}
2497   \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
2498     valido.
2499   \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
2500     contenere la stringa di errore.
2501   \end{errlist}}
2502 \end{prototype}
2503 \noindent
2504
2505 La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
2506 nel buffer \param{buf} che il singolo thread deve allocare autonomamente per
2507 evitare i problemi connessi alla condivisione del buffer statico. Il messaggio
2508 è copiato fino alla dimensione massima del buffer, specificata dall'argomento
2509 \param{size}, che deve comprendere pure il carattere di terminazione;
2510 altrimenti la stringa viene troncata.
2511
2512 Una seconda funzione usata per riportare i codici di errore in maniera
2513 automatizzata sullo standard error (vedi sez.~\ref{sec:file_std_descr}) è
2514 \funcd{perror}, il cui prototipo è:
2515 \begin{prototype}{stdio.h}{void perror(const char *message)} 
2516   Stampa il messaggio di errore relativo al valore corrente di \var{errno}
2517   sullo standard error; preceduto dalla stringa \param{message}.
2518 \end{prototype}
2519
2520 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
2521 in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
2522 riferiscono all'ultimo errore avvenuto. La stringa specificata con
2523 \param{message} viene stampato prima del messaggio d'errore, seguita dai due
2524 punti e da uno spazio, il messaggio è terminato con un a capo.
2525
2526 Il messaggio può essere riportato anche usando le due variabili globali:
2527 \includecodesnip{listati/errlist.c} 
2528 dichiarate in \file{errno.h}. La prima contiene i puntatori alle stringhe di
2529 errore indicizzati da \var{errno}; la seconda esprime il valore più alto per
2530 un codice di errore, l'utilizzo di questa stringa è sostanzialmente
2531 equivalente a quello di \func{strerror}.
2532
2533 \begin{figure}[!htb]
2534   \footnotesize \centering
2535   \begin{minipage}[c]{15cm}
2536     \includecodesample{listati/errcode_mess.c}
2537   \end{minipage}
2538   \normalsize
2539   \caption{Codice per la stampa del messaggio di errore standard.}
2540   \label{fig:sys_err_mess}
2541 \end{figure}
2542
2543 In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
2544 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
2545 errore e le costanti usate per identificare i singoli errori; il sorgente
2546 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
2547 gestione delle opzioni e tutte le definizioni necessarie ad associare il
2548 valore numerico alla costante simbolica. In particolare si è riportata la
2549 sezione che converte la stringa passata come argomento in un intero
2550 (\texttt{\small 1--2}), controllando con i valori di ritorno di \func{strtol}
2551 che la conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi
2552 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
2553   11--14}) o la macro (\texttt{\small 15--17}) associate a quel codice.
2554
2555
2556
2557 \subsection{Alcune estensioni GNU}
2558 \label{sec:sys_err_GNU}
2559
2560 Le precedenti funzioni sono quelle definite ed usate nei vari standard; le
2561 \acr{glibc} hanno però introdotto una serie di estensioni ``GNU'' che
2562 forniscono alcune funzionalità aggiuntive per una gestione degli errori
2563 semplificata e più efficiente. 
2564
2565 La prima estensione consiste in due variabili, \code{char *
2566   program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
2567 servono per ricavare il nome del programma; queste sono utili quando si deve
2568 aggiungere il nome del programma (cosa comune quando si ha un programma che
2569 non viene lanciato da linea di comando e salva gli errori in un file di log)
2570 al messaggio d'errore. La prima contiene il nome usato per lanciare il
2571 programma (ed è equivalente ad \code{argv[0]}); la seconda mantiene solo il
2572 nome del programma (senza eventuali directory in testa).
2573
2574 Uno dei problemi che si hanno con l'uso di \func{perror} è che non c'è
2575 flessibilità su quello che si può aggiungere al messaggio di errore, che può
2576 essere solo una stringa. In molte occasioni invece serve poter scrivere dei
2577 messaggi con maggiore informazione; ad esempio negli standard di
2578 programmazione GNU si richiede che ogni messaggio di errore sia preceduto dal
2579 nome del programma, ed in generale si può voler stampare il contenuto di
2580 qualche variabile; per questo le \acr{glibc} definiscono la funzione
2581 \funcd{error}, il cui prototipo è:
2582 \begin{prototype}{stdio.h}
2583 {void error(int status, int errnum, const char *format, ...)} 
2584
2585 Stampa un messaggio di errore formattato.
2586
2587 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2588 \end{prototype}
2589
2590 La funzione fa parte delle estensioni GNU per la gestione degli errori,
2591 l'argomento \param{format} prende la stessa sintassi di \func{printf}, ed i
2592 relativi argomenti devono essere forniti allo stesso modo, mentre
2593 \param{errnum} indica l'errore che si vuole segnalare (non viene quindi usato
2594 il valore corrente di \var{errno}); la funzione stampa sullo standard error il
2595 nome del programma, come indicato dalla variabile globale \var{program\_name},
2596 seguito da due punti ed uno spazio, poi dalla stringa generata da
2597 \param{format} e dagli argomenti seguenti, seguita da due punti ed uno spazio
2598 infine il messaggio di errore relativo ad \param{errnum}, il tutto è terminato
2599 da un a capo.
2600
2601 Il comportamento della funzione può essere ulteriormente controllato se si
2602 definisce una variabile \var{error\_print\_progname} come puntatore ad una
2603 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
2604 il nome del programma. 
2605
2606 L'argomento \param{status} può essere usato per terminare direttamente il
2607 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
2608 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
2609 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
2610 un'altra variabile globale, \var{error\_message\_count}, che tiene conto di
2611 quanti errori ci sono stati.
2612
2613 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
2614 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
2615 l'errore è \funcd{error\_at\_line}; il suo prototipo è:
2616 \begin{prototype}{stdio.h}
2617 {void error\_at\_line(int status, int errnum, const char *fname, 
2618   unsigned int lineno, const char *format, ...)} 
2619
2620 Stampa un messaggio di errore formattato.
2621
2622 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2623 \end{prototype}
2624 \noindent ed il suo comportamento è identico a quello di \func{error} se non
2625 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
2626 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
2627 stampa del nome del programma. Inoltre essa usa un'altra variabile globale,
2628 \var{error\_one\_per\_line}, che impostata ad un valore diverso da zero fa si
2629 che errori relativi alla stessa linea non vengano ripetuti.
2630
2631
2632
2633
2634 %%% Local Variables: 
2635 %%% mode: latex
2636 %%% TeX-master: "gapil"
2637 %%% End: 
2638
2639 % LocalWords:  filesystem like kernel saved header limits sysconf sez tab float
2640 % LocalWords:  FOPEN stdio MB LEN CHAR char UCHAR unsigned SCHAR MIN signed INT
2641 % LocalWords:  SHRT short USHRT int UINT LONG long ULONG LLONG ULLONG POSIX ARG
2642 % LocalWords:  Stevens exec CHILD STREAM stream TZNAME timezone NGROUPS SSIZE
2643 % LocalWords:  ssize LISTIO JOB CONTROL job control IDS VERSION YYYYMML bits bc
2644 % LocalWords:  dall'header posix lim nell'header glibc run unistd name errno SC
2645 % LocalWords:  NGROUP CLK TCK clock tick process PATH pathname BUF CANON path
2646 % LocalWords:  pathconf fpathconf descriptor fd uname sys struct utsname info
2647 % LocalWords:  EFAULT fig SOURCE NUL LENGTH DOMAIN NMLN UTSLEN system call proc
2648 % LocalWords:  domainname sysctl BSD nlen void oldval size oldlenp newval EPERM
2649 % LocalWords:  newlen ENOTDIR EINVAL ENOMEM linux l'array oldvalue paging stack
2650 % LocalWords:  TCP shell Documentation ostype hostname osrelease version mount
2651 % LocalWords:  const source filesystemtype mountflags ENODEV ENOTBLK block read
2652 % LocalWords:  device EBUSY only superblock point EACCES NODEV ENXIO major xC
2653 % LocalWords:  number EMFILE dummy ENAMETOOLONG ENOENT ELOOP virtual devfs MGC
2654 % LocalWords:  magic MSK RDONLY NOSUID suid sgid NOEXEC SYNCHRONOUS REMOUNT MNT
2655 % LocalWords:  MANDLOCK mandatory locking WRITE APPEND append IMMUTABLE NOATIME
2656 % LocalWords:  access NODIRATIME BIND MOVE umount flags FORCE statfs fstatfs ut
2657 % LocalWords:  buf ENOSYS EIO EBADF type fstab mntent home shadow username uid
2658 % LocalWords:  passwd PAM Pluggable Authentication Method Service Switch pwd ru
2659 % LocalWords:  getpwuid getpwnam NULL buflen result ERANGE getgrnam getgrgid AS
2660 % LocalWords:  grp group gid SVID fgetpwent putpwent getpwent setpwent endpwent
2661 % LocalWords:  fgetgrent putgrent getgrent setgrent endgrent accounting init HZ
2662 % LocalWords:  runlevel Hierarchy logout setutent endutent utmpname utmp paths
2663 % LocalWords:  WTMP getutent getutid getutline pututline LVL OLD DEAD EMPTY dev
2664 % LocalWords:  line libc XPG utmpx getutxent getutxid getutxline pututxline who
2665 % LocalWords:  setutxent endutxent wmtp updwtmp logwtmp wtmp host rusage utime
2666 % LocalWords:  minflt majflt nswap fault swap timeval wait getrusage usage SELF
2667 % LocalWords:  CHILDREN current limit soft RLIMIT Address brk mremap mmap dump
2668 % LocalWords:  SIGSEGV SIGXCPU SIGKILL sbrk FSIZE SIGXFSZ EFBIG LOCKS lock dup
2669 % LocalWords:  MEMLOCK NOFILE NPROC fork EAGAIN SIGPENDING sigqueue kill RSS tv
2670 % LocalWords:  resource getrlimit setrlimit rlimit rlim INFINITY capabilities
2671 % LocalWords:  capability CAP l'I Sun Sparc PAGESIZE getpagesize SVr SUSv get
2672 % LocalWords:  phys pages avphys NPROCESSORS CONF ONLN getloadavg stdlib double
2673 % LocalWords:  loadavg nelem scheduler CONFIG ACCT acct filename EACCESS EUSER
2674 % LocalWords:  ENFILE EROFS PACCT AcctCtrl cap calendar UTC Jan the Epoch GMT
2675 % LocalWords:  Greenwich Mean l'UTC timer CLOCKS SEC cron wall elapsed times tz
2676 % LocalWords:  tms dell' cutime cstime waitpid gettimeofday settimeofday timex
2677 % LocalWords:  timespec adjtime olddelta adjtimex David Mills nell' RFC NTP ntp
2678 % LocalWords:  nell'RFC ADJ FREQUENCY frequency MAXERROR maxerror ESTERROR PLL
2679 % LocalWords:  esterror TIMECONST constant SINGLESHOT MOD INS insert leap OOP
2680 % LocalWords:  second delete progress has occurred BAD broken tm gmtoff asctime
2681 % LocalWords:  ctime timep gmtime localtime mktime tzname tzset daylight format
2682 % LocalWords:  strftime thread EOF modifiable lvalue app errcode strerror LC at
2683 % LocalWords:  perror string errnum MESSAGES error message ErrCode strtol log
2684 % LocalWords:  program invocation argv printf print progname exit count fname
2685 % LocalWords:  lineno one  standardese