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