aa305f2329d0cec1ebe2f0fa86d4dc8a31d35a3e
[gapil.git] / system.tex
1 %% system.tex
2 %%
3 %% Copyright (C) 2000-2019 Simone Piccardi.  Permission is granted to
4 %% copy, distribute and/or modify this document under the terms of the GNU Free
5 %% Documentation License, Version 1.1 or any later version published by the
6 %% Free Software Foundation; with the Invariant Sections being "Un preambolo",
7 %% with no Front-Cover Texts, and with no Back-Cover Texts.  A copy of the
8 %% license is included in the section entitled "GNU Free Documentation
9 %% License".
10 %%
11
12 \chapter{La gestione del sistema, del tempo e degli errori}
13 \label{cha:system}
14
15 In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
16 generali del sistema, come quelle per la gestione dei parametri e della
17 configurazione dello stesso, quelle per la lettura dei limiti e delle
18 caratteristiche, quelle per il controllo dell'uso delle risorse dei processi,
19 quelle per la gestione ed il controllo dei filesystem, degli utenti, dei tempi
20 e degli errori.
21
22
23 \section{La gestione di caratteristiche e parametri 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, e, per quelle per
28 cui è possibile, sul come modificarle. Ogni sistema unix-like infatti è
29 contraddistinto da un gran numero di limiti e costanti che lo caratterizzano,
30 e che possono dipendere da fattori molteplici, come l'architettura hardware,
31 l'implementazione del kernel e delle librerie, le opzioni di
32 configurazione. Il kernel inoltre mette a disposizione l'accesso ad alcuni
33 parametri che possono modificarne il comportamento.
34
35 La definizione di queste caratteristiche ed il tentativo di provvedere dei
36 meccanismi generali che i programmi possono usare per ricavarle è uno degli
37 aspetti più complessi e controversi con cui le diverse standardizzazioni si
38 sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
39 Daremo comunque una descrizione dei principali metodi previsti dai vari
40 standard per ricavare sia le caratteristiche specifiche del sistema, che
41 quelle della gestione dei file e prenderemo in esame le modalità con cui è
42 possibile intervenire sui parametri del kernel.
43
44 \subsection{Limiti e caratteristiche del sistema}
45 \label{sec:sys_limits}
46
47 Quando si devono determinare le caratteristiche generali del sistema ci si
48 trova di fronte a diverse possibilità; alcune di queste infatti possono
49 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
50 interi), o dal sistema operativo (come la presenza o meno del gruppo degli
51 identificatori \textit{saved}), altre invece possono dipendere dalle opzioni
52 con cui si è costruito il sistema (ad esempio da come si è compilato il
53 kernel), o dalla configurazione del medesimo; per questo motivo in generale
54 sono necessari due tipi diversi di funzionalità:
55 \begin{itemize*}
56 \item la possibilità di determinare limiti ed opzioni al momento della
57   compilazione.
58 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
59 \end{itemize*}
60
61 La prima funzionalità si può ottenere includendo gli opportuni header file che
62 contengono le costanti necessarie definite come macro di preprocessore, per la
63 seconda invece sono ovviamente necessarie delle funzioni. La situazione è
64 complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
65 sono fissi in un'implementazione mentre possono variare in un altra: tutto
66 questo crea una ambiguità che non è sempre possibile risolvere in maniera
67 chiara. In generale quello che succede è che quando i limiti del sistema sono
68 fissi essi vengono definiti come macro di preprocessore nel file
69 \headfile{limits.h}, se invece possono variare, il loro valore sarà ottenibile
70 tramite la funzione \func{sysconf} (che esamineremo a breve).
71
72 \begin{table}[htb]
73   \centering
74   \footnotesize
75   \begin{tabular}[c]{|l|r|l|}
76     \hline
77     \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
78     \hline
79     \hline
80     \constd{MB\_LEN\_MAX}&       16  & Massima dimensione di un 
81                                        carattere esteso.\\
82     \constd{CHAR\_BIT} &          8  & Numero di bit di \ctyp{char}.\\
83     \constd{UCHAR\_MAX}&        255  & Massimo di \ctyp{unsigned char}.\\
84     \constd{SCHAR\_MIN}&       -128  & Minimo di \ctyp{signed char}.\\
85     \constd{SCHAR\_MAX}&        127  & Massimo di \ctyp{signed char}.\\
86     \constd{CHAR\_MIN} &   0 o -128  & Minimo di \ctyp{char}.\footnotemark\\
87     \constd{CHAR\_MAX} &  127 o 255  & Massimo di \ctyp{char}.\footnotemark\\
88     \constd{SHRT\_MIN} &     -32768  & Minimo di \ctyp{short}.\\
89     \constd{SHRT\_MAX} &      32767  & Massimo di \ctyp{short}.\\
90     \constd{USHRT\_MAX}&      65535  & Massimo di \ctyp{unsigned short}.\\
91     \constd{INT\_MAX}  & 2147483647  & Minimo di \ctyp{int}.\\
92     \constd{INT\_MIN}  &-2147483648  & Minimo di \ctyp{int}.\\
93     \constd{UINT\_MAX} & 4294967295  & Massimo di \ctyp{unsigned int}.\\
94     \constd{LONG\_MAX} & 2147483647  & Massimo di \ctyp{long}.\\
95     \constd{LONG\_MIN} &-2147483648  & Minimo di \ctyp{long}.\\
96     \constd{ULONG\_MAX}& 4294967295  & Massimo di \ctyp{unsigned long}.\\
97     \hline                
98   \end{tabular}
99   \caption{Costanti definite in \headfile{limits.h} in conformità allo standard
100     ANSI C.}
101   \label{tab:sys_ansic_macro}
102 \end{table}
103
104 \footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
105   sistema usi caratteri con segno o meno.} 
106
107 \footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
108   a seconda che il sistema usi caratteri con segno o meno.}
109
110 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
111 saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
112 da \headfile{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si
113 può vedere per la maggior parte questi limiti attengono alle dimensioni dei
114 dati interi, che sono in genere fissati dall'architettura hardware, le
115 analoghe informazioni per i dati in virgola mobile sono definite a parte, ed
116 accessibili includendo \headfiled{float.h}. 
117
118 \begin{table}[htb]
119   \centering
120   \footnotesize
121   \begin{tabular}[c]{|l|r|l|}
122     \hline
123     \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
124     \hline
125     \hline
126     \constd{LLONG\_MAX} & 9223372036854775807& Massimo di \ctyp{long long}.\\
127     \constd{LLONG\_MIN} &-9223372036854775808& Minimo di \ctyp{long long}.\\
128     \constd{ULLONG\_MAX}&18446744073709551615& Massimo di \ctyp{unsigned long
129                                                long}.\\ 
130     \hline                
131   \end{tabular}
132   \caption{Macro definite in \headfile{limits.h} in conformità allo standard
133     ISO C90.}
134   \label{tab:sys_isoc90_macro}
135 \end{table}
136
137 Lo standard prevede anche un'altra costante, \constd{FOPEN\_MAX}, che può non
138 essere fissa e che pertanto non è definita in \headfile{limits.h}, essa deve
139 essere definita in \headfile{stdio.h} ed avere un valore minimo di 8. A questi
140 valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo \ctyp{long
141   long} introdotto con il nuovo standard, i relativi valori sono in
142 tab.~\ref{tab:sys_isoc90_macro}.
143
144 Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
145 delle caratteristiche del sistema; mancano completamente tutte quelle che
146 dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
147 sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
148 limiti relativi alle caratteristiche dei file che vedremo in
149 sez.~\ref{sec:sys_file_limits}.
150
151 \begin{table}[htb]
152   \centering
153   \footnotesize
154   \begin{tabular}[c]{|l|r|p{8cm}|}
155     \hline
156     \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
157     \hline
158     \hline
159     \constd{ARG\_MAX} &131072& Dimensione massima degli argomenti
160                                passati ad una funzione della famiglia
161                                \func{exec}.\\ 
162     \constd{CHILD\_MAX} & 999& Numero massimo di processi contemporanei
163                                che un utente può eseguire.\\
164     \constd{OPEN\_MAX}  & 256& Numero massimo di file che un processo
165                                può mantenere aperti in contemporanea.\\
166     \constd{STREAM\_MAX}&   8& Massimo numero di stream aperti per
167                                processo in contemporanea.\\
168     \constd{TZNAME\_MAX}&   6& Dimensione massima del nome di una
169                                \textit{timezone} (vedi
170                                sez.~\ref{sec:sys_time_base})).\\  
171     \constd{NGROUPS\_MAX}& 32& Numero di gruppi supplementari per
172                                processo (vedi sez.~\ref{sec:proc_access_id}).\\
173     \constd{SSIZE\_MAX}&32767& Valore massimo del tipo \type{ssize\_t}.\\
174     \hline
175   \end{tabular}
176   \caption{Costanti per i limiti del sistema.}
177   \label{tab:sys_generic_macro}
178 \end{table}
179
180 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
181 meno chiare, tanto che Stevens, in \cite{APUE}, la porta come esempio di
182 ``\textsl{standardese}''. Lo standard prevede che ci siano 13 macro che
183 descrivono le caratteristiche del sistema: 7 per le caratteristiche generiche,
184 riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
185 file, riportate in tab.~\ref{tab:sys_file_macro}.
186
187 \begin{table}[htb]
188   \centering
189   \footnotesize
190   \begin{tabular}[c]{|l|r|p{8cm}|}
191     \hline
192     \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
193     \hline
194     \hline
195     \macrod{\_POSIX\_ARG\_MAX}   & 4096& Dimensione massima degli argomenti
196                                          passati ad una funzione della famiglia
197                                          \func{exec}.\\ 
198     \macrod{\_POSIX\_CHILD\_MAX} &    6& Numero massimo di processi
199                                          contemporanei che un utente può 
200                                          eseguire.\\
201     \macrod{\_POSIX\_OPEN\_MAX}  &   16& Numero massimo di file che un processo
202                                          può mantenere aperti in 
203                                          contemporanea.\\
204     \macrod{\_POSIX\_STREAM\_MAX}&    8& Massimo numero di stream aperti per
205                                          processo in contemporanea.\\
206     \macrod{\_POSIX\_TZNAME\_MAX}&    6& Dimensione massima del nome di una
207                                          \textit{timezone}
208                                          (vedi sez.~\ref{sec:sys_date}). \\ 
209     \macrod{\_POSIX\_RTSIG\_MAX} &    8& Numero massimo di segnali
210                                          \textit{real-time} (vedi
211                                          sez.~\ref{sec:sig_real_time}).\\
212     \macrod{\_POSIX\_NGROUPS\_MAX}&   0& Numero di gruppi supplementari per
213                                          processo (vedi 
214                                          sez.~\ref{sec:proc_access_id}).\\
215     \macrod{\_POSIX\_SSIZE\_MAX} &32767& Valore massimo del tipo 
216                                          \type{ssize\_t}.\\
217     % \macrod{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
218     % \macrod{\_POSIX\_AIO\_MAX}    &    1& \\
219     \hline                
220   \end{tabular}
221   \caption{Macro dei valori minimi di alcune caratteristiche generali del
222     sistema per la conformità allo standard POSIX.1.}
223   \label{tab:sys_posix1_general}
224 \end{table}
225
226 Lo standard dice che queste macro devono essere definite in
227 \headfile{limits.h} quando i valori a cui fanno riferimento sono fissi, e
228 altrimenti devono essere lasciate indefinite, ed i loro valori dei limiti
229 devono essere accessibili solo attraverso \func{sysconf}.  In realtà queste
230 vengono sempre definite ad un valore generico. Si tenga presente poi che
231 alcuni di questi limiti possono assumere valori molto elevati (come
232 \const{CHILD\_MAX}), e non è pertanto il caso di utilizzarli per allocare
233 staticamente della memoria.
234
235 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
236 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
237 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
238 implementazione possa dichiararsi conforme allo standard, alcuni dei questi
239 valori sono riportati in tab.~\ref{tab:sys_posix1_general}.
240
241 In genere questi valori non servono a molto, la loro unica utilità è quella di
242 indicare un limite superiore che assicura la portabilità senza necessità di
243 ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
244 i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
245 valori ottenuti da \func{sysconf}.
246
247 \begin{table}[htb]
248   \centering
249   \footnotesize
250   \begin{tabular}[c]{|l|p{8cm}|}
251     \hline
252     \textbf{Macro}&\textbf{Significato}\\
253     \hline
254     \hline
255     \macrod{\_POSIX\_JOB\_CONTROL}& Il sistema supporta il 
256                                     \textit{job control} (vedi 
257                                     sez.~\ref{sec:sess_job_control}).\\
258     \macrod{\_POSIX\_SAVED\_IDS}  & Il sistema supporta gli identificatori del 
259                                     gruppo \textit{saved} (vedi 
260                                     sez.~\ref{sec:proc_access_id})
261                                     per il controllo di accesso dei processi.\\
262     \macrod{\_POSIX\_VERSION}     & Fornisce la versione dello standard POSIX.1
263                                     supportata nel formato YYYYMML (ad esempio 
264                                     199009L).\\
265     \hline
266   \end{tabular}
267   \caption{Alcune macro definite in \headfile{limits.h} in conformità allo
268     standard POSIX.1.}
269   \label{tab:sys_posix1_other}
270 \end{table}
271
272 Oltre ai precedenti valori e a quelli relativi ai file elencati in
273 tab.~\ref{tab:sys_posix1_file}, che devono essere obbligatoriamente definiti,
274 lo standard POSIX.1 ne prevede molti altri. La lista completa si trova
275 dall'header file \file{bits/posix1\_lim.h}, da non usare mai direttamente (è
276 incluso automaticamente all'interno di \headfile{limits.h}). Di questi vale la
277 pena menzionarne alcune macro di uso comune, riportate in
278 tab.~\ref{tab:sys_posix1_other}, che non indicano un valore specifico, ma
279 denotano la presenza di alcune funzionalità nel sistema, come il supporto del
280 \textit{job control} o degli identificatori del gruppo \textit{saved}.
281
282 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
283 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
284 alle applicazioni di sistema presenti, come quelli su alcuni parametri delle
285 espressioni regolari o del comando \cmd{bc}, non li tratteremo esplicitamente,
286 se ne trova una menzione completa nell'header file \file{bits/posix2\_lim.h},
287 e alcuni di loro sono descritti nella pagina di manuale di \func{sysconf} e
288 nel manuale della \acr{glibc}.
289
290 Quando uno dei limiti o delle caratteristiche del sistema può variare, per non
291 dover essere costretti a ricompilare un programma tutte le volte che si
292 cambiano le opzioni con cui è compilato il kernel, o alcuni dei parametri
293 modificabili al momento dell'esecuzione, è necessario ottenerne il valore
294 attraverso la funzione \funcd{sysconf}, cui prototipo è:
295
296 \begin{funcproto}{
297 \fhead{unistd.h}
298 \fdecl{long sysconf(int name)}
299 \fdesc{Restituisce il valore di un parametro di sistema.} 
300 }
301
302 {La funzione ritorna in caso di successo il valore del parametro richiesto, o
303   1 se si tratta di un'opzione disponibile, 0 se l'opzione non è disponibile e
304   $-1$ per un errore, nel qual caso però \var{errno} non viene impostata.}  
305 \end{funcproto}
306
307 La funzione prende come argomento un intero che specifica quale dei limiti si
308 vuole conoscere. Uno specchietto contenente i principali valori disponibili in
309 Linux è riportato in tab.~\ref{tab:sys_sysconf_par}, l'elenco completo è
310 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
311 relative spiegazioni, si può trovare nel manuale della \acr{glibc}.
312
313 \begin{table}[htb]
314   \centering
315   \footnotesize
316     \begin{tabular}[c]{|l|l|p{8cm}|}
317       \hline
318       \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
319       \hline
320       \hline
321       \texttt{\_SC\_ARG\_MAX}   & \const{ARG\_MAX}&
322                                   La dimensione massima degli argomenti passati
323                                   ad una funzione della famiglia \func{exec}.\\
324       \texttt{\_SC\_CHILD\_MAX} & \const{CHILD\_MAX}&
325                                   Il numero massimo di processi contemporanei
326                                   che un utente può eseguire.\\
327       \texttt{\_SC\_OPEN\_MAX}  & \const{OPEN\_MAX}&
328                                   Il numero massimo di file che un processo può
329                                   mantenere aperti in contemporanea.\\
330       \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
331                                   Il massimo numero di stream che un processo
332                                   può mantenere aperti in contemporanea. Questo
333                                   limite è previsto anche dallo standard ANSI C,
334                                   che specifica la macro \const{FOPEN\_MAX}.\\
335       \texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
336                                   La dimensione massima di un nome di una
337                                   \texttt{timezone} (vedi
338                                   sez.~\ref{sec:sys_date}).\\
339       \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
340                                   Massimo numero di gruppi supplementari che
341                                   può avere un processo (vedi
342                                   sez.~\ref{sec:proc_access_id}).\\
343       \texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}& 
344                                   Valore massimo del tipo di dato
345                                   \type{ssize\_t}.\\ 
346       \texttt{\_SC\_CLK\_TCK}   & \const{CLK\_TCK} &
347                                   Il numero di \textit{clock tick} al secondo, 
348                                   cioè l'unità di misura del
349                                   \textit{process time} (vedi
350                                   sez.~\ref{sec:sys_unix_time}).\\  
351       \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
352                                   Indica se è supportato il \textit{job
353                                     control} (vedi
354                                   sez.~\ref{sec:sess_job_control}) in stile
355                                   POSIX.\\ 
356       \texttt{\_SC\_SAVED\_IDS} & \macro{\_POSIX\_SAVED\_IDS}&
357                                   Indica se il sistema supporta i
358                                   \textit{saved id} (vedi
359                                   sez.~\ref{sec:proc_access_id}).\\  
360       \texttt{\_SC\_VERSION}    & \macro{\_POSIX\_VERSION} &
361                                   Indica il mese e l'anno di approvazione
362                                   della revisione dello standard POSIX.1 a cui
363                                   il sistema fa riferimento, nel formato
364                                   YYYYMML, la revisione più recente è 199009L,
365                                   che indica il Settembre 1990.\\ 
366      \hline
367     \end{tabular}
368   \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
369   \label{tab:sys_sysconf_par}
370 \end{table}
371
372 In generale ogni limite o caratteristica del sistema per cui è definita una
373 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
374 essere ottenuto attraverso una chiamata a \func{sysconf}. Il nome della
375 costante da utilizzare come valore dell'argomento \param{name} si otterrà
376 aggiungendo \code{\_SC\_} ai nomi delle costanti definite dai primi due
377 standard (quelle di tab.~\ref{tab:sys_generic_macro}), o sostituendolo a
378 \code{\_POSIX\_} per le costanti definite dagli altri due standard (quelle di
379 tab.~\ref{tab:sys_posix1_general}).
380
381 In linea teorica si dovrebbe fare uso di \func{sysconf} solo quando la
382 relativa costante di sistema non è definita, quindi con un codice analogo al
383 seguente:
384 \includecodesnip{listati/get_child_max.c}
385 ma in realtà con Linux queste costanti sono comunque definite, indicando però
386 un limite generico che non è detto sia corretto; per questo motivo è sempre
387 meglio usare i valori restituiti da \func{sysconf}.
388
389
390 \subsection{Limiti e caratteristiche dei file}
391 \label{sec:sys_file_limits}
392
393 Come per le caratteristiche generali del sistema anche per i file esistono una
394 serie di limiti (come la lunghezza del nome del file o il numero massimo di
395 link) che dipendono sia dall'implementazione che dal filesystem in uso. Anche
396 in questo caso lo standard prevede alcune macro che ne specificano il valore,
397 riportate in tab.~\ref{tab:sys_file_macro}.
398
399 \begin{table}[htb]
400   \centering
401   \footnotesize
402   \begin{tabular}[c]{|l|r|l|}
403     \hline
404     \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
405     \hline
406     \hline                
407     \constd{LINK\_MAX}   &8 & Numero massimo di link a un file.\\
408     \constd{NAME\_MAX}&  14 & Lunghezza in byte di un nome di file. \\
409     \constd{PATH\_MAX}& 256 & Lunghezza in byte di un \textit{pathname}.\\
410     \constd{PIPE\_BUF}&4096 & Byte scrivibili atomicamente in una \textit{pipe}
411                               (vedi sez.~\ref{sec:ipc_pipes}).\\
412     \constd{MAX\_CANON}&255 & Dimensione di una riga di terminale in modo 
413                               canonico (vedi sez.~\ref{sec:term_io_design}).\\
414     \constd{MAX\_INPUT}&255 & Spazio disponibile nella coda di input 
415                               del terminale (vedi 
416                               sez.~\ref{sec:term_io_design}).\\
417     \hline                
418   \end{tabular}
419   \caption{Costanti per i limiti sulle caratteristiche dei file.}
420   \label{tab:sys_file_macro}
421 \end{table}
422
423 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
424 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
425 conforme deve rispettare. Le relative macro sono riportate in
426 tab.~\ref{tab:sys_posix1_file} e per esse vale lo stesso discorso fatto per le
427 analoghe di tab.~\ref{tab:sys_posix1_general}.
428
429 \begin{table}[htb]
430   \centering
431   \footnotesize
432   \begin{tabular}[c]{|l|r|l|}
433     \hline
434     \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
435     \hline
436     \hline
437     \macrod{\_POSIX\_LINK\_MAX}   &8 & Numero massimo di link a un file.\\
438     \macrod{\_POSIX\_NAME\_MAX}&  14 & Lunghezza in byte di un nome di file.\\
439     \macrod{\_POSIX\_PATH\_MAX}& 256 & Lunghezza in byte di un 
440                                        \textit{pathname}.\\
441     \macrod{\_POSIX\_PIPE\_BUF}& 512 & Byte scrivibili atomicamente in una
442                                        \textit{pipe}.\\
443     \macrod{\_POSIX\_MAX\_CANON}&255 & Dimensione di una riga di
444                                        terminale in modo canonico.\\
445     \macrod{\_POSIX\_MAX\_INPUT}&255 & Spazio disponibile nella coda di input 
446                                        del terminale.\\
447 %    \macrod{\_POSIX\_MQ\_OPEN\_MAX}&  8& \\
448 %    \macrod{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
449 %    \macrod{\_POSIX\_FD\_SETSIZE}& 16 & \\
450 %    \macrod{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
451     \hline
452   \end{tabular}
453   \caption{Costanti dei valori minimi delle caratteristiche dei file per la
454     conformità allo standard POSIX.1.}
455   \label{tab:sys_posix1_file}
456 \end{table}
457
458 Tutti questi limiti sono definiti in \headfile{limits.h}; come nel caso
459 precedente il loro uso è di scarsa utilità in quanto ampiamente superati in
460 tutte le implementazioni moderne. In generale i limiti per i file sono molto
461 più soggetti ad essere variabili rispetto ai limiti generali del sistema; ad
462 esempio parametri come la lunghezza del nome del file o il numero di link
463 possono variare da filesystem a filesystem.
464
465 Per questo motivo quando si ha a che fare con limiti relativi ai file questi
466 devono essere sempre controllati con la funzione \funcd{pathconf}, il cui
467 prototipo è:
468
469 \begin{funcproto}{
470 \fhead{unistd.h}
471 \fdecl{long pathconf(char *path, int name)}
472 \fdesc{Restituisce il valore di un parametro dei file.} 
473 }
474
475 {La funzione ritorna il valore del parametro richiesto in caso di successo e
476   $-1$ per un errore, nel qual caso \var{errno} viene impostata ad uno degli
477   errori possibili relativi all'accesso a \param{path}.}
478 \end{funcproto}
479
480 La funzione richiede che si specifichi il limite che si vuole controllare con
481 l'argomento \param{name}, per il quale si deve usare la relativa costante
482 identificativa, il cui nome si ottiene da quelle descritte in
483 tab.~\ref{tab:sys_file_macro} e tab.~\ref{tab:sys_posix1_file} con la stessa
484 convenzione già vista con \func{sysconf}, ma un questo caso con l'uso del
485 suffisso ``\texttt{\_PC\_}''.
486
487 In questo caso la funzione richiede anche un secondo argomento \param{path}
488 che specifichi a quale file si fa riferimento, dato che il valore del limite
489 cercato può variare a seconda del filesystem su cui si trova il file. Una
490 seconda versione della funzione, \funcd{fpathconf}, opera su un file
491 descriptor invece che su un \textit{pathname}, il suo prototipo è:
492
493 \begin{funcproto}{
494 \fhead{unistd.h}
495 \fdecl{long fpathconf(int fd, int name)}
496 \fdesc{Restituisce il valore di un parametro dei file.} 
497 }
498
499 {È identica a \func{pathconf} solo che utilizza un file descriptor invece di
500   un \textit{pathname}; pertanto gli errori restituiti in \var{errno} cambiano
501   di conseguenza.}
502 \end{funcproto}
503 \noindent ed il suo comportamento è identico a quello di \func{pathconf} a
504 parte quello di richiedere l'indicazione di un file descriptor
505 nell'argomento \param{fd}.
506
507
508
509 \subsection{I parametri del kernel ed il filesystem \texttt{/proc}}
510 \label{sec:sys_sysctl}
511
512 Tradizionalmente la funzione che permette la lettura ed l'impostazione dei
513 parametri del sistema è \funcm{sysctl}. Si tratta di una funzione derivata da
514 BSD4.4 ed introdotta su Linux a partire dal kernel 1.3.57, ma oggi il suo uso
515 è totalmente deprecato.  Una \textit{system call} \funcm{\_sysctl} continua ad
516 esistere, ma non dispone più di una interfaccia nella \acr{glibc} ed il suo
517 utilizzo può essere effettuato solo tramite \func{syscall}, ma di nuovo questo
518 viene sconsigliato in quanto la funzionalità non è più mantenuta e molto
519 probabilmente sarà rimossa nel prossimo futuro. Per questo motivo eviteremo di
520 trattarne i particolari.
521
522 Lo scopo di \funcm{sysctl} era quello di fornire ai programmi una modalità per
523 modificare i parametri di sistema. Questi erano organizzati in maniera
524 gerarchica all'interno di un albero e per accedere a ciascuno di essi
525 occorreva specificare un percorso attraverso i vari nodi dell'albero, in
526 maniera analoga a come avviene per la risoluzione di un \textit{pathname}.
527
528 I parametri accessibili e modificabili attraverso questa funzione sono
529 moltissimi, dipendendo anche dallo stato corrente del kernel, ad esempio dai
530 moduli che sono stati caricati nel sistema. Inoltre non essendo standardizzati
531 i loro nomi possono variare da una versione di kernel all'altra, alcuni esempi
532 di questi parametri sono:
533 \begin{itemize*}
534 \item il nome di dominio
535 \item i parametri del meccanismo di \textit{paging}.
536 \item il filesystem montato come radice
537 \item la data di compilazione del kernel
538 \item i parametri dello stack TCP
539 \item il numero massimo di file aperti
540 \end{itemize*}
541
542
543
544 \index{file!filesystem~\texttt  {/proc}!definizione|(}
545
546 Dato che fin dall'inizio i parametri erano organizzati in una struttura
547 albero, è parso naturale rimappare questa organizzazione utilizzando il
548 filesystem \file{/proc}. Questo è un filesystem completamente virtuale, il cui
549 contenuto è generato direttamente dal kernel, che non fa riferimento a nessun
550 dispositivo fisico, ma presenta in forma di file e directory i dati di alcune
551 delle strutture interne del kernel stesso. Il suo utilizzo principale, come
552 denuncia il nome stesso, è quello di fornire una interfaccia per ottenere i
553 dati relativi ai processi (venne introdotto a questo scopo su BSD), ma nel
554 corso del tempo il suo uso è stato ampliato.
555
556 All'interno di questo filesystem sono pertanto presenti una serie di file che
557 riflettono il contenuto dei parametri del kernel (molti dei quali accessibili
558 in sola lettura) e in altrettante directory, nominate secondo il relativo
559 \ids{PID}, vengono mantenute le informazioni relative a ciascun processo
560 attivo nel sistema.
561
562 In particolare l'albero dei valori dei parametri di sistema impostabili con
563 \func{sysctl} viene presentato in forma di una gerarchia di file e directory a
564 partire dalla directory \file{/proc/sys}, cosicché è possibile accedere al
565 valore di un parametro del kernel tramite il \textit{pathname} ad un file
566 sotto \file{/proc/sys} semplicemente leggendone il contenuto, così come si può
567 modificare un parametro scrivendo sul file ad esso corrispondente.
568
569 Il kernel si occupa di generare al volo il contenuto ed i nomi dei file
570 corrispondenti ai vari parametri che sono presenti, e questo ha il grande
571 vantaggio di rendere accessibili gli stessi ad un qualunque comando di shell e
572 di permettere la navigazione dell'albero in modo da riconoscere quali
573 parametri sono presenti senza dover cercare un valore all'interno di una
574 pagina di manuale.
575
576 Inizialmente l'uso del filesystem \file{/proc} serviva soltanto a replicare
577 l'accesso, con altrettante corrispondenze ai file presenti in
578 \file{/proc/sys}, ai parametri impostabili tradizionalmente con \func{sysctl},
579 ma vista la assoluta naturalità dell'interfaccia, e la sua maggiore
580 efficienza, nelle versioni più recenti del kernel questa è diventata la
581 modalità canonica per modificare i parametri del kernel, evitando di dover
582 ricorrere all'uso di una \textit{system call} specifica che pur essendo ancora
583 presente, prima o poi verrà eliminata.
584
585 Nonostante la semplificazione nella gestione ottenuta con l'uso di
586 \file{/proc/sys} resta il problema generale di conoscere il significato di
587 ciascuno degli innumerevoli parametri che vi si trovano. Purtroppo la
588 documentazione degli stessi spesso risulta incompleta e non aggiornata, ma
589 buona parte di quelli può importanti sono descritti dalla documentazione
590 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
591
592 Ma oltre alle informazioni che sostituiscono quelle ottenibili dalla ormai
593 deprecata \func{sysctl} dentro \file{/proc} sono disponibili moltissime altre
594 informazioni, fra cui ad esempio anche quelle fornite dalla funzione di
595 sistema \funcd{uname},\footnote{con Linux ci sono in realtà 3 \textit{system
596     call} diverse per le dimensioni delle stringhe restituite, le prime due
597   usano rispettivamente delle lunghezze di 9 e 65 byte, la terza usa anch'essa
598   65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con una
599   lunghezza di 257 byte, la \acr{glibc} provvede a mascherare questi dettagli
600   usando la versione più recente disponibile.} il cui prototipo è:
601
602 \begin{funcproto}{
603 \fhead{sys/utsname.h}
604 \fdecl{int uname(struct utsname *info)}
605 \fdesc{Restituisce informazioni generali sul sistema.} 
606 }
607
608 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
609   caso \var{errno} può assumere solo il valore \errval{EFAULT}.}  
610 \end{funcproto}
611
612 La funzione, che viene usata dal comando \cmd{uname}, restituisce una serie di
613 informazioni relative al sistema nelle stringhe che costituiscono i campi
614 della struttura \struct{utsname} (la cui definizione è riportata in
615 fig.~\ref{fig:sys_utsname}) che viene scritta nel buffer puntato
616 dall'argomento \param{info}.
617
618 \begin{figure}[!ht!b]
619   \footnotesize \centering
620   \begin{minipage}[c]{0.85\textwidth}
621     \includestruct{listati/ustname.h}
622   \end{minipage}
623   \normalsize 
624   \caption{La struttura \structd{utsname}.} 
625   \label{fig:sys_utsname}
626 \end{figure}
627
628 Si noti come in fig.~\ref{fig:sys_utsname} le dimensioni delle stringhe di
629 \struct{utsname} non sono specificate.  Il manuale della \acr{glibc} indica
630 due costanti per queste dimensioni, \constd{\_UTSNAME\_LENGTH} per i campi
631 standard e \constd{\_UTSNAME\_DOMAIN\_LENGTH} per quello relativo al nome di
632 dominio, altri sistemi usano nomi diversi come \constd{SYS\_NMLN} o
633 \constd{\_SYS\_NMLN} o \constd{UTSLEN} che possono avere valori diversi. Dato
634 che il buffer per \struct{utsname} deve essere preallocato l'unico modo per
635 farlo in maniera sicura è allora usare come dimensione il valore ottenuto con
636 \code{sizeof(utsname)}.
637
638 Le informazioni vengono restituite in ciascuno dei singoli campi di
639 \struct{utsname} in forma di stringhe terminate dal carattere NUL. In
640 particolare dette informazioni sono:
641 \begin{itemize*}
642 \item il nome del sistema operativo;
643 \item il nome della macchine (l'\textit{hostname});
644 \item il nome della release del kernel;
645 \item il nome della versione del kernel;
646 \item il tipo di hardware della macchina;
647 \item il nome del domino (il \textit{domainname});
648 \end{itemize*}
649 ma l'ultima di queste informazioni è stata aggiunta di recente e non è
650 prevista dallo standard POSIX, per questo essa è accessibile, come mostrato in
651 fig.~\ref{fig:sys_utsname}, solo se si è definita la macro
652 \macro{\_GNU\_SOURCE}.
653
654 Come accennato queste stesse informazioni, anche se a differenza di
655 \func{sysctl} la funzione continua ad essere mantenuta, si possono ottenere
656 direttamente tramite il filesystem \file{/proc}, esse infatti sono mantenute
657 rispettivamente nei file \sysctlrelfiled{kernel}{ostype},
658 \sysctlrelfiled{kernel}{hostname}, \sysctlrelfiled{kernel}{osrelease},
659 \sysctlrelfiled{kernel}{version} e \sysctlrelfiled{kernel}{domainname} che si
660 trovano sotto la directory \file{/proc/sys/kernel/}.
661
662 \index{file!filesystem~\texttt  {/proc}!definizione|)}
663
664
665
666 \section{La gestione del sistema}
667 \label{sec:sys_management}
668
669 In questa sezione prenderemo in esame le interfacce di programmazione messe a
670 disposizione per affrontare una serie di tematiche attinenti la gestione
671 generale del sistema come quelle relative alla gestione di utenti e gruppi, al
672 trattamento delle informazioni relative ai collegamenti al sistema, alle
673 modalità per effettuare lo spegnimento o il riavvio di una macchina.
674
675
676 \subsection{La gestione delle informazioni su utenti e gruppi}
677 \label{sec:sys_user_group}
678
679 Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
680 (password, corrispondenze fra nomi simbolici e \ids{UID} numerici, home
681 directory, ecc.)  venivano registrate all'interno dei due file di testo
682 \conffiled{/etc/passwd} ed \conffiled{/etc/group}, il cui formato è descritto
683 dalle relative pagine del manuale\footnote{nella quinta sezione, quella dei
684   file di configurazione (esistono comandi corrispondenti), una trattazione
685   sistemistica dell'intero argomento coperto in questa sezione si consulti
686   sez.~4.3 di \cite{AGL}.} e tutte le funzioni che richiedevano l'accesso a
687 queste informazione andavano a leggere direttamente il contenuto di questi
688 file.
689
690 In realtà oltre a questi due file da molto tempo gran parte dei sistemi
691 unix-like usano il cosiddetto sistema delle \textit{shadow password} che
692 prevede anche i due file \conffiled{/etc/shadow} e \conffiled{/etc/gshadow}, in
693 cui sono state spostate le informazioni di autenticazione (ed inserite alcune
694 estensioni di gestione avanzata) per toglierle dagli altri file che devono
695 poter essere letti da qualunque processo per poter effettuare l'associazione
696 fra username e \ids{UID}.
697
698 Col tempo però questa impostazione ha incominciato a mostrare dei limiti. Da
699 una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
700 la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
701 che sta per \textit{Pluggable Authentication Method}) che fornisce una
702 interfaccia comune per i processi di autenticazione, svincolando completamente
703 le singole applicazioni dai dettagli del come questa viene eseguita e di dove
704 vengono mantenuti i dati relativi. Si tratta di un sistema modulare, in cui è
705 possibile utilizzare anche più meccanismi insieme, diventa così possibile
706 avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
707 diversi formati per le password e diversi supporti per le informazioni. Il
708 tutto avviene in maniera trasparente per le applicazioni purché per ciascun
709 meccanismo si disponga della opportuna libreria che implementa l'interfaccia
710 di PAM.
711
712 Dall'altra parte, il diffondersi delle reti e la necessità di centralizzare le
713 informazioni degli utenti e dei gruppi per insiemi di macchine e servizi
714 all'interno di una stessa organizzazione, in modo da mantenere coerenti i
715 dati, ha portato anche alla necessità di poter recuperare e memorizzare dette
716 informazioni su supporti diversi dai file citati, introducendo il sistema del
717 \textit{Name Service Switch} (che tratteremo brevemente in
718 sez.~\ref{sec:sock_resolver}) dato che la sua applicazione è cruciale nella
719 procedura di risoluzione di nomi di rete.
720
721 In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
722 per la lettura delle informazioni relative a utenti e gruppi tralasciando
723 completamente quelle relative all'autenticazione. 
724 %  Per questo non tratteremo
725 % affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
726 % \textit{Name Service Switch}, un meccanismo messo a disposizione dalla
727 % \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
728 % necessario trovare una corrispondenza fra un nome ed un numero (od altra
729 % informazione) ad esso associato, come appunto, quella fra uno username ed un
730 % \ids{UID} o fra un \ids{GID} ed il nome del gruppo corrispondente.
731 Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
732 queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
733   Service Switch}, per cui sono in grado di ricevere informazioni qualunque
734 sia il supporto su cui esse vengono mantenute.  Per leggere le informazioni
735 relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
736 \funcd{getpwnam}, i cui prototipi sono:
737
738 \begin{funcproto}{
739 \fhead{pwd.h} 
740 \fhead{sys/types.h} 
741 \fdecl{struct passwd *getpwuid(uid\_t uid)}
742 \fdecl{struct passwd *getpwnam(const char *name)} 
743 \fdesc{Restituiscono le informazioni relative all'utente specificato.} 
744 }
745
746 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
747   in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
748   utente corrispondente a quanto specificato, nel qual caso \var{errno}
749   assumerà il valore riportato dalle funzioni di sistema sottostanti.}
750 \end{funcproto}
751
752 Le due funzioni forniscono le informazioni memorizzate nel registro degli
753 utenti (che nelle versioni più recenti per la parte di credenziali di
754 autenticazione vengono ottenute attraverso PAM) relative all'utente
755 specificato attraverso il suo \ids{UID} o il nome di login. Entrambe le
756 funzioni restituiscono un puntatore ad una struttura di tipo \struct{passwd}
757 la cui definizione (anch'essa eseguita in \headfiled{pwd.h}) è riportata in
758 fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente illustrato il
759 significato dei vari campi.
760
761 \begin{figure}[!htb]
762   \footnotesize
763   \centering
764   \begin{minipage}[c]{0.8\textwidth}
765     \includestruct{listati/passwd.h}
766   \end{minipage} 
767   \normalsize 
768   \caption{La struttura \structd{passwd} contenente le informazioni relative
769     ad un utente del sistema.}
770   \label{fig:sys_passwd_struct}
771 \end{figure}
772
773 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
774 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
775 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
776 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
777 essere rientranti; per questo motivo ne esistono anche due versioni
778 alternative (denotate dalla solita estensione \code{\_r}), i cui prototipi
779 sono:
780
781 \begin{funcproto}{
782 \fhead{pwd.h} 
783 \fhead{sys/types.h} 
784 \fdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
785     char *buffer,\\
786 \phantom{struct passwd *getpwuid\_r(}size\_t buflen, struct passwd **result)}
787 \fdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
788     *password, char *buffer,\\
789 \phantom{struct passwd *getpwnam\_r(}size\_t buflen, struct passwd **result)}
790 \fdesc{Restituiscono le informazioni relative all'utente specificato.} 
791 }
792
793 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
794   caso \var{errno} assumerà il valore riportato dalle di sistema funzioni
795   sottostanti.}
796 \end{funcproto}
797
798 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
799 la memoria necessaria a contenere le informazioni. In particolare i valori
800 della struttura \struct{passwd} saranno restituiti all'indirizzo
801 \param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
802 un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
803 puntate dai campi di \param{password}. Infine all'indirizzo puntato da
804 \param{result} viene restituito il puntatore ai dati ottenuti, cioè
805 \param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti.  Qualora i
806 dati non possano essere contenuti nei byte specificati da \param{buflen}, la
807 funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
808 impostato a \val{NULL}).
809
810 Sia queste versioni rientranti che precedenti gli errori eventualmente
811 riportati in \var{errno} in caso di fallimento dipendono dalla sottostanti
812 funzioni di sistema usate per ricavare le informazioni (si veda quanto
813 illustrato in sez.~\ref{sec:sys_errno}) per cui se lo si vuole utilizzare è
814 opportuno inizializzarlo a zero prima di invocare le funzioni per essere
815 sicuri di non avere un residuo di errore da una chiamata precedente. Il non
816 aver trovato l'utente richiesto infatti può essere dovuto a diversi motivi (a
817 partire dal fatto che non esista) per cui si possono ottenere i valori di
818 errore più vari a seconda dei casi.
819
820 Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
821 \funcd{getgrgid} che permettono di leggere le informazioni relative ai gruppi,
822 i loro prototipi sono:
823
824 \begin{funcproto}{
825 \fhead{grp.h}
826 \fhead{sys/types.h}
827 \fdecl{struct group *getgrgid(gid\_t gid)} 
828 \fdecl{struct group *getgrnam(const char *name)} 
829 \fdesc{Restituiscono le informazioni relative al gruppo specificato.} 
830 }
831
832 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
833   in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
834   utente corrispondente a quanto specificato, nel qual caso \var{errno}
835   assumerà il valore riportato dalle funzioni di sistema sottostanti.}
836 \end{funcproto}
837
838 Come per le precedenti per gli utenti esistono anche le analoghe versioni
839 rientranti che di nuovo utilizzano la stessa estensione \code{\_r}; i loro
840 prototipi sono:
841
842 \begin{funcproto}{
843 \fhead{grp.h}
844 \fhead{sys/types.h}
845 \fdecl{int getgrgid\_r(gid\_t gid, struct group *grp, char *buf, 
846   size\_t buflen,\\
847 \phantom{int getgrgid\_r(}struct group **result)}
848 \fdecl{int getgrnam\_r(const char *name, struct group *grp, char *buf, 
849   size\_t buflen,\\
850 \phantom{int getgrnam\_r(}struct group **result)}
851 \fdesc{Restituiscono le informazioni relative al gruppo specificato.} 
852 }
853
854 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
855   caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
856   sottostanti.}
857 \end{funcproto}
858
859 Il comportamento di tutte queste funzioni è assolutamente identico alle
860 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
861 in questo caso le informazioni vengono restituite in una struttura di tipo
862 \struct{group}, la cui definizione è riportata in
863 fig.~\ref{fig:sys_group_struct}.
864
865 \begin{figure}[!htb]
866   \footnotesize
867   \centering
868   \begin{minipage}[c]{0.8\textwidth}
869     \includestruct{listati/group.h}
870   \end{minipage} 
871   \normalsize 
872   \caption{La struttura \structd{group} contenente le informazioni relative ad
873     un gruppo del sistema.}
874   \label{fig:sys_group_struct}
875 \end{figure}
876
877 Le funzioni viste finora sono in grado di leggere le informazioni sia
878 direttamente dal file delle password in \conffile{/etc/passwd} che tramite il
879 sistema del \textit{Name Service Switch} e sono completamente generiche. Si
880 noti però che non c'è una funzione che permetta di impostare direttamente una
881 password.\footnote{in realtà questo può essere fatto ricorrendo alle funzioni
882   della libreria PAM, ma questo non è un argomento che tratteremo qui.} Dato
883 che POSIX non prevede questa possibilità esiste un'altra interfaccia che lo
884 fa, derivata da SVID le cui funzioni sono riportate in
885 tab.~\ref{tab:sys_passwd_func}. Questa interfaccia però funziona soltanto
886 quando le informazioni sono mantenute su un apposito file di \textsl{registro}
887 di utenti e gruppi, con il formato classico di \conffile{/etc/passwd} e
888 \conffile{/etc/group}.
889
890 \begin{table}[htb]
891   \footnotesize
892   \centering
893   \begin{tabular}[c]{|l|p{8cm}|}
894     \hline
895     \textbf{Funzione} & \textbf{Significato}\\
896     \hline
897     \hline
898     \funcm{fgetpwent}   & Legge una voce dal file di registro degli utenti
899                           specificato.\\
900     \funcm{fgetpwent\_r}& Come la precedente, ma rientrante.\\ 
901     \funcm{putpwent}    & Immette una voce in un file di registro degli
902                           utenti.\\ 
903     \funcm{getpwent}    & Legge una voce da \conffile{/etc/passwd}.\\
904     \funcm{getpwent\_r} & Come la precedente, ma rientrante.\\ 
905     \funcm{setpwent}    & Ritorna all'inizio di \conffile{/etc/passwd}.\\
906     \funcm{endpwent}    & Chiude \conffile{/etc/passwd}.\\
907     \funcm{fgetgrent}   & Legge una voce dal file di registro dei gruppi 
908                          specificato.\\
909     \funcm{fgetgrent\_r}& Come la precedente, ma rientrante.\\
910     \funcm{putgrent}    & Immette una voce in un file di registro dei gruppi.\\
911     \funcm{getgrent}    & Legge una voce da \conffile{/etc/group}.\\ 
912     \funcm{getgrent\_r} & Come la precedente, ma rientrante.\\
913     \funcm{setgrent}    & Ritorna all'inizio di \conffile{/etc/group}.\\
914     \funcm{endgrent}    & Chiude \conffile{/etc/group}.\\
915     \hline
916   \end{tabular}
917   \caption{Funzioni per la manipolazione dei campi di un file usato come
918     registro per utenti o gruppi nel formato di \conffile{/etc/passwd} e
919     \conffile{/etc/group}.} 
920   \label{tab:sys_passwd_func}
921 \end{table}
922
923 % TODO mancano i prototipi di alcune delle funzioni
924
925 Dato che oramai tutte le distribuzioni di GNU/Linux utilizzano le
926 \textit{shadow password} (quindi con delle modifiche rispetto al formato
927 classico del file \conffile{/etc/passwd}), si tenga presente che le funzioni
928 di questa interfaccia che permettono di scrivere delle voci in un
929 \textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
930 hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
931 questa estensione.
932
933 Per questo motivo l'uso di queste funzioni è deprecato, in quanto comunque non
934 funzionale rispetto ad un sistema attuale, pertanto ci limiteremo a fornire
935 soltanto l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
936 ulteriore.  Chi volesse insistere ad usare questa interfaccia può fare
937 riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
938 della \acr{glibc} per i dettagli del funzionamento.
939
940
941
942 \subsection{Il registro della \textsl{contabilità} degli utenti}
943 \label{sec:sys_accounting}
944
945 Un altro insieme di funzioni relative alla gestione del sistema che
946 esamineremo è quello che permette di accedere ai dati del registro della
947 cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti.  In esso
948 vengono mantenute una serie di informazioni storiche relative sia agli utenti
949 che si sono collegati al sistema, tanto per quelli correntemente collegati,
950 che per la registrazione degli accessi precedenti, sia relative all'intero
951 sistema, come il momento di lancio di processi da parte di \cmd{init}, il
952 cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
953 della macchina.
954
955 I dati vengono usualmente memorizzati nei due file \file{/var/run/utmp} e
956 \file{/var/log/wtmp}. che sono quelli previsti dal \textit{Linux Filesystem
957   Hierarchy Standard}, adottato dalla gran parte delle distribuzioni.  Quando
958 un utente si collega viene aggiunta una voce a \file{/var/run/utmp} in cui
959 viene memorizzato il nome di login, il terminale da cui ci si collega,
960 l'\ids{UID} della shell di login, l'orario della connessione ed altre
961 informazioni.  La voce resta nel file fino al logout, quando viene cancellata
962 e spostata in \file{/var/log/wtmp}.
963
964 In questo modo il primo file viene utilizzato per registrare chi sta
965 utilizzando il sistema al momento corrente, mentre il secondo mantiene la
966 registrazione delle attività degli utenti. A quest'ultimo vengono anche
967 aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
968 come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
969 informazioni sono descritte in dettaglio nel manuale della \acr{glibc}.
970
971 Questi file non devono mai essere letti direttamente, ma le informazioni che
972 contengono possono essere ricavate attraverso le opportune funzioni di
973 libreria. Queste sono analoghe alle precedenti funzioni (vedi
974 tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
975 solo che in questo caso la struttura del registro della \textsl{contabilità} è
976 molto più complessa, dato che contiene diversi tipi di informazione.
977
978 Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
979 servono rispettivamente a aprire e a chiudere il file che contiene il registro
980 della \textsl{contabilità} degli, e a specificare su quale file esso viene
981 mantenuto. I loro prototipi sono:
982
983 \begin{funcproto}{
984 \fhead{utmp.h} 
985 \fdecl{void utmpname(const char *file)}
986 \fdesc{Specifica il file da usare come registro.} 
987 \fdecl{void setutent(void)}
988 \fdesc{Apre il file del registro.} 
989 \fdecl{void endutent(void)}
990 \fdesc{Chiude il file del registro.} 
991 }
992
993 {Le funzioni non ritornano nulla.}  
994 \end{funcproto}
995
996 Si tenga presente che le funzioni non restituiscono nessun valore, pertanto
997 non è possibile accorgersi di eventuali errori, ad esempio se si è impostato
998 un nome di file sbagliato con \func{utmpname}.
999
1000 Nel caso non si sia utilizzata \func{utmpname} per specificare un file di
1001 registro alternativo, sia \func{setutent} che \func{endutent} operano usando
1002 il default che è \sysfile{/var/run/utmp} il cui nome, così come una serie di
1003 altri valori di default per i \textit{pathname} di uso più comune, viene
1004 mantenuto nei valori di una serie di costanti definite includendo
1005 \headfiled{paths.h}, in particolare quelle che ci interessano sono:
1006 \begin{basedescript}{\desclabelwidth{2.0cm}}
1007 \item[\constd{\_PATH\_UTMP}] specifica il file che contiene il registro per
1008   gli utenti correntemente collegati, questo è il valore che viene usato se
1009   non si è utilizzato \func{utmpname} per modificarlo;
1010 \item[\constd{\_PATH\_WTMP}] specifica il file che contiene il registro per
1011   l'archivio storico degli utenti collegati;
1012 \end{basedescript}
1013 che nel caso di Linux hanno un valore corrispondente ai file
1014 \sysfile{/var/run/utmp} e \sysfile{/var/log/wtmp} citati in precedenza.
1015
1016 Una volta aperto il file del registro degli utenti si può eseguire una
1017 scansione leggendo o scrivendo una voce con le funzioni \funcd{getutent},
1018 \funcd{getutid}, \funcd{getutline} e \funcd{pututline}, i cui prototipi sono:
1019
1020
1021 \begin{funcproto}{
1022 \fhead{utmp.h}
1023 \fdecl{struct utmp *getutent(void)}
1024 \fdesc{Legge una voce dalla posizione corrente nel registro.} 
1025 \fdecl{struct utmp *getutid(struct utmp *ut)}
1026 \fdesc{Ricerca una voce sul registro.} 
1027 \fdecl{struct utmp *getutline(struct utmp *ut)}
1028 \fdesc{Ricerca una voce sul registro attinente a un terminale.} 
1029 \fdecl{struct utmp *pututline(struct utmp *ut)}
1030 \fdesc{Scrive una voce nel registro.} 
1031 }
1032
1033 {Le funzioni ritornano il puntatore ad una struttura \struct{utmp} in caso di
1034   successo e \val{NULL} in caso di errore, nel qual caso \var{errno} assumerà
1035   il valore riportato dalle funzioni di sistema sottostanti.}
1036 \end{funcproto}
1037
1038 Tutte queste funzioni fanno riferimento ad una struttura di tipo
1039 \struct{utmp}, la cui definizione in Linux è riportata in
1040 fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
1041 voce dal registro: \func{getutent} legge semplicemente la prima voce
1042 disponibile, le altre due permettono di eseguire una ricerca. Aprendo il
1043 registro con \func{setutent} ci si posiziona al suo inizio, ogni chiamata di
1044 queste funzioni eseguirà la lettura sulle voci seguenti, pertanto la posizione
1045 sulla voce appena letta, in modo da consentire una scansione del file. Questo
1046 vale anche per \func{getutid} e \func{getutline}, il che comporta che queste
1047 funzioni effettuano comunque una ricerca ``\textsl{in avanti}''.
1048
1049 \begin{figure}[!htb]
1050   \footnotesize
1051   \centering
1052   \begin{minipage}[c]{0.9\textwidth}
1053     \includestruct{listati/utmp.h}
1054   \end{minipage} 
1055   \normalsize 
1056   \caption{La struttura \structd{utmp} contenente le informazioni di una voce
1057     del registro di \textsl{contabilità}.}
1058   \label{fig:sys_utmp_struct}
1059 \end{figure}
1060
1061 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1062 campo \var{ut\_type} dell'argomento \param{ut}.  Questo può assumere i valori
1063 riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
1064 \const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
1065 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1066 invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
1067 \const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
1068 corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1069
1070 \begin{table}[htb]
1071   \footnotesize
1072   \centering
1073   \begin{tabular}[c]{|l|p{8cm}|}
1074     \hline
1075     \textbf{Valore} & \textbf{Significato}\\
1076     \hline
1077     \hline
1078     \constd{EMPTY}         & Non contiene informazioni valide.\\
1079     \constd{RUN\_LVL}      & Identica il runlevel del sistema.\\
1080     \constd{BOOT\_TIME}    & Identifica il tempo di avvio del sistema.\\
1081     \constd{OLD\_TIME}     & Identifica quando è stato modificato l'orologio di
1082                              sistema.\\
1083     \constd{NEW\_TIME}     & Identifica da quanto è stato modificato il 
1084                              sistema.\\
1085     \constd{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
1086     \constd{LOGIN\_PROCESS}& Identifica un processo di login.\\
1087     \constd{USER\_PROCESS} & Identifica un processo utente.\\
1088     \constd{DEAD\_PROCESS} & Identifica un processo terminato.\\
1089 %    \constd{ACCOUNTING}    & ??? \\
1090     \hline
1091   \end{tabular}
1092   \caption{Classificazione delle voci del registro a seconda dei
1093     possibili valori del campo \var{ut\_type}.} 
1094   \label{tab:sys_ut_type}
1095 \end{table}
1096
1097 La funzione \func{getutline} esegue la ricerca sulle voci che hanno un
1098 \var{ut\_type} con valore uguale a \const{LOGIN\_PROCESS} o
1099 \const{USER\_PROCESS}, restituendo la prima che corrisponde al valore di
1100 \var{ut\_line}, che specifica il dispositivo di terminale che interessa, da
1101 indicare senza il \file{/dev/} iniziale. Lo stesso criterio di ricerca è usato
1102 da \func{pututline} per trovare uno spazio dove inserire la voce specificata;
1103 qualora questo spazio non venga trovato la voce viene aggiunta in coda al
1104 registro.
1105
1106 In generale occorre però tenere conto che queste funzioni non sono
1107 completamente standardizzate, e che in sistemi diversi possono esserci
1108 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1109 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1110 fornita dalla \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1111 introdotto delle nuove strutture (e relativi file) di tipo \struct{utmpx}, che
1112 sono un sovrainsieme della \struct{utmp} usata tradizionalmente ed altrettante
1113 funzioni che le usano al posto di quelle citate.
1114
1115 La \acr{glibc} utilizzava già una versione estesa di \struct{utmp}, che
1116 rende inutili queste nuove strutture, per questo su Linux \struct{utmpx} viene
1117 definita esattamente come \struct{utmp}, con gli stessi campi di
1118 fig.~\ref{fig:sys_utmp_struct}. Altrettanto dicasi per le nuove funzioni di
1119 gestione previste dallo standard: \funcm{getutxent}, \funcm{getutxid},
1120 \funcm{getutxline}, \funcm{pututxline}, \funcm{setutxent} e \funcm{endutxent}.
1121
1122 Tutte queste funzioni, definite con \struct{utmpx} dal file di dichiarazione
1123 \headfile{utmpx.h}, su Linux sono ridefinite come sinonimi delle funzioni
1124 appena viste, con argomento di tipo \struct{utmpx} anziché \struct{utmp} ed
1125 hanno lo stesso identico comportamento. Per completezza viene definita anche
1126 \funcm{utmpxname} che non è prevista da POSIX.1-2001.
1127
1128 Come già visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
1129 staticamente rende le funzioni di lettura dei dati appena illustrate non
1130 rientranti. Per questo motivo la \acr{glibc} fornisce anche delle versioni
1131 rientranti: \func{getutent\_r}, \func{getutid\_r}, \func{getutline\_r}, che
1132 invece di restituire un puntatore restituiscono un intero e prendono due
1133 argomenti aggiuntivi, i rispettivi prototipi sono:
1134
1135 \begin{funcproto}{
1136 \fhead{utmp.h}
1137 \fdecl{int *getutent\_r(struct utmp *buffer, struct utmp **result)}
1138 \fdesc{Legge una voce dalla posizione corrente nel registro.} 
1139 \fdecl{int *getutid\_r(struct utmp *buffer, struct utmp **result, struct utmp
1140   *ut)} 
1141 \fdesc{Ricerca una voce sul registro.} 
1142 \fdecl{int *getutline\_r(struct utmp *buffer, struct utmp **result, struct utmp
1143   *ut)} 
1144 \fdesc{Ricerca una voce sul registro attinente a un terminale.}
1145 }
1146
1147 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
1148   caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
1149   sottostanti.}
1150 \end{funcproto}
1151
1152 Le funzioni si comportano esattamente come le precedenti analoghe non
1153 rientranti, solo che restituiscono il risultato all'indirizzo specificato dal
1154 primo argomento aggiuntivo \param{buffer} mentre il secondo, \param{result)}
1155 viene usato per restituire il puntatore al buffer stesso.
1156
1157 Infine la \acr{glibc} fornisce altre due funzioni, \funcd{updwtmp} e
1158 \funcd{logwtmp}, come estensione per scrivere direttamente delle voci nel file
1159 sul registro storico \sysfile{/var/log/wtmp}; i rispettivi prototipi sono:
1160
1161 \begin{funcproto}{
1162 \fhead{utmp.h}
1163 \fdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1164 \fdesc{Aggiunge una voce in coda al registro.} 
1165 \fdecl{void logwtmp(const char *line, const char *name, const char *host)}
1166 \fdesc{Aggiunge nel registro una voce con i valori specificati.} 
1167 }
1168
1169 {Le funzioni non restituiscono nulla.}
1170 \end{funcproto}
1171
1172 La prima funzione permette l'aggiunta di una voce in coda al file del registro
1173 storico, indicato dal primo argomento, specificando direttamente una struttura
1174 \struct{utmp}.  La seconda invece utilizza gli argomenti \param{line},
1175 \param{name} e \param{host} per costruire la voce che poi aggiunge chiamando
1176 \func{updwtmp}.
1177
1178 Queste funzioni non sono previste da POSIX.1-2001, anche se sono presenti in
1179 altri sistemi (ad esempio Solaris e NetBSD), per mantenere una coerenza con le
1180 altre funzioni definite nello standard che usano la struttura \struct{utmpx}
1181 la \acr{glibc} definisce anche una funzione \funcm{updwtmpx}, che come in
1182 precedenza è identica a \func{updwtmp} con la sola differenza di richiedere
1183 l'uso di \headfiled{utmpx.h} e di una struttura \struct{utmpx} come secondo
1184 argomento. 
1185
1186
1187 \subsection{La gestione dello spegnimento e del riavvio}
1188 \label{sec:sys_reboot}
1189
1190 Una delle operazioni di gestione generale del sistema è quella che attiene
1191 alle modalità con cui se ne può gestire lo spegnimento ed il riavvio.  Perché
1192 questo avvenga in maniera corretta, in particolare per le parti che comportano
1193 lo spegnimento effettivo della macchina, occorre che il kernel effettui le
1194 opportune operazioni interagendo con il BIOS ed i dispositivi che controllano
1195 l'erogazione della potenza.
1196
1197 La funzione di sistema che controlla lo spegnimento ed il riavvio (ed altri
1198 aspetti della relativa procedura) è \funcd{reboot},\footnote{la funzione
1199   illustrata è quella fornita dalla \acr{glibc} che maschera i dettagli di
1200   basso livello della \textit{system call} la quale richiede attualmente tre
1201   argomenti; fino al kernel 2.1.30 la \textit{system call} richiedeva un
1202   ulteriore quarto argomento, i primi due indicano dei \textit{magic number}
1203   interi che possono assumere solo alcuni valori predefiniti, il terzo un
1204   comando, corrispondente all'unico argomento della funzione della \acr{glibc}
1205   ed il quarto argomento aggiuntivo, ora ignorato, un puntatore generico ad
1206   ulteriori dati.}  il cui prototipo è:
1207
1208 \begin{funcproto}{
1209 \fhead{unistd.h}
1210 \fhead{sys/reboot.h}
1211 \fdecl{int reboot(int cmd)}
1212 \fdesc{Controlla il riavvio o l'arresto della macchina.}
1213 }
1214
1215 {La funzione non ritorna o ritorna $0$ in caso di successo e $-1$ per un
1216   errore, nel qual caso \var{errno} assumerà uno dei valori:
1217   \begin{errlist}
1218   \item[\errcode{EFAULT}] c'è un indirizzo non valido nel passaggio degli
1219     argomenti con il comando \const{LINUX\_REBOOT\_CMD\_RESTART2} (obsoleto).
1220   \item[\errcode{EINVAL}] si sono specificati valori non validi per gli
1221     argomenti.
1222   \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
1223     \textit{capability} \const{CAP\_SYS\_BOOT}).
1224   \end{errlist}
1225 }  
1226 \end{funcproto}
1227
1228 La funzione, oltre al riavvio ed allo spegnimento, consente anche di
1229 controllare l'uso della combinazione di tasti tradizionalmente usata come
1230 scorciatoia da tastiera per richiedere il riavvio (\texttt{Ctrl-Alt-Del},
1231 denominata in breve nella documentazione CAD) ed i suoi effetti specifici
1232 dipendono dalla architettura hardware. Se si è richiesto un riavvio o uno
1233 spegnimento in caso di successo la funzione, non esistendo più il programma,
1234 ovviamente non ritorna, pertanto bisogna avere cura di aver effettuato tutte
1235 le operazioni preliminari allo spegnimento prima di eseguirla.
1236
1237 Il comportamento della funzione viene controllato dall'argomento \param{cmd}
1238 e deve assumere indicato con una delle costanti seguente elenco, che
1239 illustra i comandi attualmente disponibili:
1240
1241 \begin{basedescript}{\desclabelwidth{2.cm}\desclabelstyle{\nextlinelabel}}
1242 \item[\constd{LINUX\_REBOOT\_CMD\_CAD\_OFF}] Disabilita l'uso diretto della
1243   combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce nell'invio
1244   del segnale \signal{SIGINT} a \texttt{init} (o più in generale al processo
1245   con \ids{PID} 1) il cui effetto dipende dalla configurazione di
1246   quest'ultimo.
1247 \item[\constd{LINUX\_REBOOT\_CMD\_CAD\_ON}] Attiva l'uso diretto della
1248   combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce
1249   nell'esecuzione dell'azione che si avrebbe avuto chiamando \func{reboot} con
1250   il comando \const{LINUX\_REBOOT\_CMD\_RESTART}.
1251 \item[\constd{LINUX\_REBOOT\_CMD\_HALT}] Viene inviato sulla console il
1252   messaggio ``\textit{System halted.}'' l'esecuzione viene bloccata
1253   immediatamente ed il controllo passato al monitor nella ROM (se esiste e
1254   l'architettura lo consente). Se non si è eseguita una sincronizzazione dei
1255   dati su disco con \func{sync} questi saranno perduti.
1256 \item[\constd{LINUX\_REBOOT\_CMD\_KEXEC}] viene eseguito direttamente il nuovo
1257   kernel che è stato opportunamente caricato in memoria da una
1258   \func{kexec\_load} (che tratteremo a breve) eseguita in precedenza. La
1259   funzionalità è disponibile solo a partire dal kernel 2.6.13 e se il kernel
1260   corrente è stato compilato includendo il relativo supporto.\footnote{deve
1261     essere stata abilitata l'opzione di compilazione \texttt{CONFIG\_KEXEC}.}
1262   Questo meccanismo consente di eseguire una sorta di riavvio rapido che evita
1263   di dover ripassare dalla inizializzazione da parte del BIOS ed il lancio del
1264   kernel attraverso un bootloader. Se non si è eseguita una sincronizzazione
1265   dei dati su disco con \func{sync} questi saranno perduti.
1266 \item[\constd{LINUX\_REBOOT\_CMD\_POWER\_OFF}] Viene inviato sulla console il
1267   messaggio ``\textit{Power down.}'' l'esecuzione viene bloccata
1268   immediatamente e la macchina, se possibile, viene spenta.  Se non si è
1269   eseguita una sincronizzazione dei dati su disco con \func{sync} questi
1270   saranno perduti.
1271 \item[\constd{LINUX\_REBOOT\_CMD\_RESTART}] Viene inviato sulla console il
1272   messaggio ``\textit{Restarting system.}'' ed avviata immediatamente la
1273   procedura di riavvio ordinaria. Se non si è eseguita una sincronizzazione
1274   dei dati su disco con \func{sync} questi saranno perduti.
1275 \item[\constd{LINUX\_REBOOT\_CMD\_RESTART2}] Viene inviato sulla console il
1276   messaggio ``\textit{Restarting system with command '\%s'.}'' ed avviata
1277   immediatamente la procedura di riavvio usando il comando fornito
1278   nell'argomento \param{arg} che viene stampato al posto di \textit{'\%s'}
1279   (veniva usato per lanciare un altro programma al posto di \cmd{init}). Nelle
1280   versioni recenti questo argomento viene ignorato ed il riavvio può essere
1281   controllato dall'argomento di avvio del kernel \texttt{reboot=...}  Se non
1282   si è eseguita una sincronizzazione dei dati su disco con \func{sync} questi
1283   saranno perduti.
1284 \end{basedescript}
1285
1286
1287 Come appena illustrato usando il comando \const{LINUX\_REBOOT\_CMD\_KEXEC} si
1288 può eseguire un riavvio immediato pre-caricando una immagine del kernel, che
1289 verrà eseguita direttamente. Questo meccanismo consente di evitare la
1290 reinizializzazione della macchina da parte del BIOS, ed oltre a velocizzare un
1291 eventuale riavvio, ha il vantaggio poter accedere allo stato corrente della
1292 macchina e della memoria, per cui viene usato spesso per installare un kernel
1293 di emergenza da eseguire in caso di crollo del sistema per recuperare il
1294 maggior numero di informazioni possibili.
1295
1296 La funzione di sistema che consente di caricare questa immagine del kernel è
1297 \funcd{kexec\_load}, la funzione non viene definita nella \acr{glibc} e deve
1298 pertanto essere invocata con \func{syscall}, il suo prototipo è:
1299
1300 \begin{funcproto}{
1301 \fhead{linux/kexec.h}
1302 \fdecl{long kexec\_load(unsigned long entry, unsigned long nr\_segments,
1303 struct kexec\_segment\\
1304 \phantom{long kexec\_load(}*segments, unsigned long flags)} 
1305
1306 \fdesc{Carica un kernel per un riavvio immediato.}
1307 }
1308
1309 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1310   caso \var{errno} assumerà uno dei valori:
1311   \begin{errlist}
1312   \item[\errcode{EBUSY}] c'è già un caricamento in corso, o un altro kernel è
1313     già in uso.
1314   \item[\errcode{EINVAL}] il valore di \param{flags} non è valido o si è
1315     indicato un valore eccessivo per \param{nr\_segments}.
1316   \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
1317     \textit{capability} \const{CAP\_SYS\_BOOT}).
1318   \end{errlist}
1319 }  
1320 \end{funcproto}
1321
1322 Il primo argomento indica l'indirizzo fisico di esecuzione del nuovo kernel
1323 questo viene caricato usando un vettore di strutture \struct{kexec\_segment}
1324 (la cui definizione è riportata in fig.~\ref{fig:kexec_segment}) che
1325 contengono i singoli segmenti dell'immagine. I primi due campi indicano
1326 indirizzo e dimensione del segmento di memoria in \textit{user space}, i
1327 secondi indirizzo e dimensione in \textit{kernel space}. 
1328
1329
1330 \begin{figure}[!htb]
1331   \footnotesize
1332   \centering
1333   \begin{minipage}[c]{0.8\textwidth}
1334     \includestruct{listati/kexec_segment.h}
1335   \end{minipage} 
1336   \normalsize 
1337   \caption{La struttura \structd{kexec\_segment} per il caricamento di un
1338     segmento di immagine del kernel.}
1339   \label{fig:kexec_segment}
1340 \end{figure}
1341
1342 L'argomento \param{flags} è una maschera binaria contenente i flag che
1343 consentono di indicare le modalità con cui dovrà essere eseguito il nuovo
1344 kernel. La parte meno significativa viene usata per impostare l'architettura
1345 di esecuzione. Il valore \const{KEXEC\_ARCH\_DEFAULT} indica l'architettura
1346 corrente, ma se ne può specificare anche una diversa, con i valori della
1347 seconda parte di tab.~\ref{tab:kexec_load_flags}, e questa verrà usato posto
1348 che sia effettivamente eseguibile sul proprio processore.
1349
1350 \begin{table}[htb]
1351   \footnotesize
1352   \centering
1353   \begin{tabular}[c]{|l|p{8cm}|}
1354     \hline
1355     \textbf{Valore} & \textbf{Significato}\\
1356     \hline
1357     \hline
1358     \constd{KEXEC\_ON\_CRASH}        & Il kernel caricato sarà eseguito
1359                                       automaticamente in caso di crollo del
1360                                       sistema.\\
1361     \constd{KEXEC\_PRESERVE\_CONTEXT}& Viene preservato lo stato dei programmi 
1362                                       e dei dispositivi prima dell'esecuzione
1363                                       del nuovo kernel. Viene usato
1364                                       principalmente per l'ibernazione del
1365                                       sistema ed ha senso solo se si è
1366                                       indicato un numero di segmento maggiore
1367                                       di zero.\\
1368     \hline
1369     \constd{KEXEC\_ARCH\_DEFAULT}    & Il kernel caricato verrà eseguito nella
1370                                       architettura corrente. \\
1371     \texttt{KEXEC\_ARCH\_XXX}       & Il kernel caricato verrà eseguito nella
1372                                       architettura indicata (con \texttt{XXX}
1373                                       che può essere: \texttt{386},
1374                                       \texttt{X86\_64}, \texttt{PPC}, 
1375                                       \texttt{PPC64}, \texttt{IA\_64},
1376                                       \texttt{ARM}, \texttt{S390},
1377                                       \texttt{SH}\texttt{MIPS}
1378                                       e \texttt{MIPS\_LE}).\\ 
1379 %    \const{}    &  \\
1380     \hline
1381   \end{tabular}
1382   \caption{Valori per l'argomento \param{flags} di \func{kexec\_load}.} 
1383   \label{tab:kexec_load_flags}
1384 \end{table}
1385
1386 I due valori più importanti sono però quelli della parte più significativa
1387 (riportati nella prima sezione di tab.~\ref{tab:kexec_load_flags}). Il primo,
1388 \const{KEXEC\_ON\_CRASH}, consente di impostare l'esecuzione automatica del
1389 nuovo kernel caricato in caso di crollo del sistema, e viene usato quando si
1390 carica un kernel di emergenza da utilizzare per poter raccogliere informazioni
1391 diagnostiche che altrimenti verrebbero perdute non essendo il kernel ordinario
1392 più in grado di essere eseguito in maniera coerente.  Il secondo valore,
1393 \const{KEXEC\_PRESERVE\_CONTEXT}, indica invece di preservare lo stato dei
1394 programmi e dei dispositivi, e viene in genere usato per realizzare la
1395 cosiddetta ibernazione in RAM.
1396
1397 % TODO: introdotta con il kernel 3.17 è stata introdotta
1398 % kexec_file_load, per caricare immagine firmate per il secure boot,
1399 % vedi anche http://lwn.net/Articles/603116/
1400
1401 % TODO documentare keyctl ????
1402 % (fare sezione dedicata ????)
1403
1404 % TODO documentare la Crypto API del kernel
1405
1406 % TODO documentare la syscall getrandom, introdotta con il kernel 3.17, vedi
1407 % http://lwn.net/Articles/606141/, ed introdotta con le glibc solo con la
1408 % versione 2.25, vedi https://lwn.net/Articles/711013/
1409
1410 %\subsection{La gestione delle chiavi crittografiche}
1411 %\label{sec:keyctl_management}
1412
1413 %TODO non è chiaro se farlo qui, ma documentare la syscall bpf aggiunta con il
1414 % kernel 3.18, vedi http://lwn.net/Articles/612878/; al riguardo vedi anche
1415 % https://lwn.net/Articles/660331/ 
1416
1417 \section{Il controllo dell'uso delle risorse}
1418 \label{sec:sys_res_limits}
1419
1420
1421 Dopo aver esaminato in sez.~\ref{sec:sys_management} le funzioni che
1422 permettono di controllare le varie caratteristiche, capacità e limiti del
1423 sistema a livello globale, in questa sezione tratteremo le varie funzioni che
1424 vengono usate per quantificare le risorse (CPU, memoria, ecc.) utilizzate da
1425 ogni singolo processo e quelle che permettono di imporre a ciascuno di essi
1426 vincoli e limiti di utilizzo.
1427
1428
1429 \subsection{L'uso delle risorse}
1430 \label{sec:sys_resource_use}
1431
1432 Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
1433 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1434 di tipo \struct{rusage}, la cui definizione (che si trova in
1435 \headfiled{sys/resource.h}) è riportata in
1436 fig.~\ref{fig:sys_rusage_struct}. Si ricordi che questa è una delle
1437 informazioni preservate attraverso una \func{exec}.
1438
1439 \begin{figure}[!htb]
1440   \footnotesize
1441   \centering
1442   \begin{minipage}[c]{0.8\textwidth}
1443     \includestruct{listati/rusage.h}
1444   \end{minipage} 
1445   \normalsize 
1446   \caption{La struttura \structd{rusage} per la lettura delle informazioni dei 
1447     delle risorse usate da un processo.}
1448   \label{fig:sys_rusage_struct}
1449 \end{figure}
1450
1451 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
1452 da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
1453   \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si
1454   trova nelle opzioni di compilazione del kernel (e di norma è disabilitato)
1455   che serve per mantenere una contabilità delle risorse usate da ciascun
1456   processo in maniera molto più dettagliata.} ma attualmente solo alcuni dei
1457 campi definiti sono effettivamente mantenuti. Con i kernel della serie 2.4 i
1458 soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
1459 \var{ru\_minflt} e \var{ru\_majflt}. Con i kernel della serie 2.6 si
1460 aggiungono anche \var{ru\_nvcsw} e \var{ru\_nivcsw}, a partire dal 2.6.22
1461 anche \var{ru\_inblock} e \var{ru\_oublock} e dal 2.6.32 anche
1462 \var{ru\_maxrss}.
1463
1464 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
1465 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
1466 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
1467 ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
1468 \struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
1469
1470 La struttura \struct{rusage} è la struttura utilizzata da \func{wait4} (si
1471 ricordi quando visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di
1472 risorse impiegate dal processo di cui si è letto lo stato di terminazione, ma
1473 essa può anche essere letta direttamente utilizzando la funzione di sistema
1474 \funcd{getrusage}, il cui prototipo è:
1475
1476 \begin{funcproto}{
1477 \fhead{sys/time.h}
1478 \fhead{sys/resource.h}
1479 \fhead{unistd.h}
1480 \fdecl{int getrusage(int who, struct rusage *usage)}
1481
1482 \fdesc{Legge la quantità di risorse usate da un processo.}
1483 }
1484
1485 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1486   caso \var{errno} assumerà uno dei valori:
1487   \begin{errlist}
1488   \item[\errcode{EINVAL}] l'argomento \param{who} non è valido
1489   \end{errlist}
1490   ed inoltre \errval{EFAULT} nel suo significato generico.
1491 }  
1492 \end{funcproto}
1493
1494 La funzione ritorna i valori per l'uso delle risorse nella struttura
1495 \struct{rusage} puntata dall'argomento \param{usage}.  L'argomento \param{who}
1496 permette di specificare il soggetto di cui si vuole leggere l'uso delle
1497 risorse; esso può assumere solo i valori illustrati in
1498 tab.~\ref{tab:getrusage_who}, di questi \const{RUSAGE\_THREAD} è specifico di
1499 Linux ed è disponibile solo a partire dal kernel 2.6.26. La funzione è stata
1500 recepita nello standard POSIX.1-2001, che però indica come campi di
1501 \struct{rusage} soltanto \var{ru\_utime} e \var{ru\_stime}.
1502
1503 \begin{table}[htb]
1504   \footnotesize
1505   \centering
1506   \begin{tabular}[c]{|l|p{8cm}|}
1507     \hline
1508     \textbf{Valore} & \textbf{Significato}\\
1509     \hline
1510     \hline
1511     \constd{RUSAGE\_SELF}     & Ritorna l'uso delle risorse del processo
1512                                corrente, che in caso di uso dei
1513                                \textit{thread} ammonta alla somma delle 
1514                                risorse utilizzate da tutti i \textit{thread}
1515                                del processo.\\ 
1516     \constd{RUSAGE\_CHILDREN} & Ritorna l'uso delle risorse dell'insieme dei
1517                                processi figli di cui è ricevuto lo stato di
1518                                terminazione, che a loro volta comprendono
1519                                quelle dei loro figli e così via.\\ 
1520     \constd{RUSAGE\_THREAD}   & Ritorna l'uso delle risorse del \textit{thread}
1521                                chiamante.\\ 
1522     \hline
1523   \end{tabular}
1524   \caption{Valori per l'argomento \param{who} di \func{getrusage}.} 
1525   \label{tab:getrusage_who}
1526 \end{table}
1527
1528 I campi più utilizzati sono comunque \var{ru\_utime} e \var{ru\_stime} che
1529 indicano rispettivamente il tempo impiegato dal processo nell'eseguire le
1530 istruzioni in \textit{user space}, e quello impiegato dal kernel nelle
1531 \textit{system call} eseguite per conto del processo (vedi
1532 sez.~\ref{sec:sys_unix_time}). I campi \var{ru\_minflt} e \var{ru\_majflt}
1533 servono a quantificare l'uso della memoria virtuale e corrispondono
1534 rispettivamente al numero di \textit{page fault} (vedi
1535 sez.~\ref{sec:proc_mem_gen}) avvenuti senza richiedere I/O su disco (i
1536 cosiddetti \textit{minor page fault}), a quelli che invece han richiesto I/O
1537 su disco (detti invece \textit{major page
1538   fault}).% mentre \var{ru\_nswap} ed al numero di volte che
1539 % il processo è stato completamente tolto dalla memoria per essere inserito
1540 % nello swap.
1541 % TODO verificare \var{ru\_nswap} non citato nelle pagine di manuali recenti e
1542 % dato per non utilizzato.
1543
1544 I campi \var{ru\_nvcsw} e \var{ru\_nivcsw} indicano il numero di volte che un
1545 processo ha subito un \textit{context switch} da parte dello
1546 \textit{scheduler} rispettivamente nel caso un cui questo avviene prima
1547 dell'esaurimento della propria \textit{time-slice} (in genere a causa di una
1548 \textit{system call} bloccante), o per averla esaurita o essere stato
1549 interrotto da un processo a priorità maggiore. I campi \var{ru\_inblock} e
1550 \var{ru\_oublock} indicano invece il numero di volte che è stata eseguita una
1551 attività di I/O su un filesystem (rispettivamente in lettura e scrittura) ed
1552 infine \var{ru\_maxrss} indica il valore più alto della \textit{Resident Set
1553   Size} raggiunto dal processo stesso o, nel caso sia stato usato
1554 \const{RUSAGE\_CHILDREN}, da uno dei suoi figli.
1555  
1556 Si tenga conto che per un errore di implementazione nei i kernel precedenti il
1557 2.6.9, nonostante questo fosse esplicitamente proibito dallo standard POSIX.1,
1558 l'uso di \const{RUSAGE\_CHILDREN} comportava l'inserimento dell'ammontare
1559 delle risorse usate dai processi figli anche quando si era impostata una
1560 azione di \const{SIG\_IGN} per il segnale \signal{SIGCHLD} (per i segnali si
1561 veda cap.~\ref{cha:signals}). Il comportamento è stato corretto per aderire
1562 allo standard a partire dal kernel 2.6.9.
1563
1564
1565 \subsection{Limiti sulle risorse}
1566 \label{sec:sys_resource_limit}
1567
1568 Come accennato nell'introduzione il kernel mette a disposizione delle
1569 funzionalità che permettono non solo di mantenere dati statistici relativi
1570 all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
1571 utilizzo da parte sia dei singoli processi che degli utenti.
1572
1573 Per far questo sono definite una serie di risorse e ad ogni processo vengono
1574 associati due diversi limiti per ciascuna di esse; questi sono il
1575 \textsl{limite corrente} (o \textit{current limit}) che esprime un valore
1576 massimo che il processo non può superare ad un certo momento, ed il
1577 \textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
1578 valore massimo che può assumere il \textsl{limite corrente}. In generale il
1579 primo viene chiamato anche \textit{soft limit} dato che il suo valore può
1580 essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
1581 fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
1582   limit}.
1583
1584 In generale il superamento di un limite corrente comporta o l'emissione di uno
1585 specifico segnale o il fallimento della \textit{system call} che lo ha
1586 provocato. A questo comportamento generico fanno eccezione \const{RLIMIT\_CPU}
1587 in cui si ha in comportamento diverso per il superamento dei due limiti e
1588 \const{RLIMIT\_CORE} che influenza soltanto la dimensione o l'eventuale
1589 creazione dei file di \textit{core dump} (vedi sez.~\ref{sec:sig_standard}).
1590
1591 Per permettere di leggere e di impostare i limiti di utilizzo delle risorse da
1592 parte di un processo sono previste due funzioni di sistema, \funcd{getrlimit}
1593 e \funcd{setrlimit}, i cui prototipi sono:
1594
1595 \begin{funcproto}{
1596 \fhead{sys/time.h}
1597 \fhead{sys/resource.h}
1598 \fhead{unistd.h}
1599 \fdecl{int getrlimit(int resource, struct rlimit *rlim)}
1600 \fdesc{Legge i limiti di una risorsa.}
1601 \fdecl{int setrlimit(int resource, const struct rlimit *rlim)}
1602 \fdesc{Imposta i limiti di una risorsa.}
1603 }
1604
1605 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
1606   caso \var{errno} assumerà uno dei valori:
1607   \begin{errlist}
1608   \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
1609     nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
1610     \var{rlim->rlim\_max}.
1611     \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1612     cercato di innalzare i propri limiti.
1613   \end{errlist}
1614   ed inoltre \errval{EFAULT} nel suo significato generico.  
1615 }  
1616 \end{funcproto}
1617
1618 Entrambe le funzioni permettono di specificare attraverso l'argomento
1619 \param{resource} su quale risorsa si vuole operare. L'accesso (rispettivamente
1620 in lettura e scrittura) ai valori effettivi dei limiti viene poi effettuato
1621 attraverso la struttura \struct{rlimit} puntata da
1622 \param{rlim}, la cui definizione è riportata in
1623 fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
1624 limite corrente e limite massimo.
1625
1626 \begin{figure}[!htb]
1627   \footnotesize
1628   \centering
1629   \begin{minipage}[c]{0.8\textwidth}
1630     \includestruct{listati/rlimit.h}
1631   \end{minipage} 
1632   \normalsize 
1633   \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo 
1634     delle risorse usate da un processo.}
1635   \label{fig:sys_rlimit_struct}
1636 \end{figure}
1637
1638 Come accennato processo ordinario può alzare il proprio limite corrente fino
1639 al valore del limite massimo, può anche ridurre, irreversibilmente, il valore
1640 di quest'ultimo.  Nello specificare un limite, oltre a fornire dei valori
1641 specifici, si può anche usare la costante \const{RLIM\_INFINITY} che permette
1642 di sbloccare completamente l'uso di una risorsa. Si ricordi però che solo un
1643 processo con i privilegi di amministratore\footnote{per essere precisi in
1644   questo caso quello che serve è la \textit{capability}
1645   \const{CAP\_SYS\_RESOURCE} (vedi sez.~\ref{sec:proc_capabilities}).} può
1646 innalzare un limite al di sopra del valore corrente del limite massimo ed
1647 usare un valore qualsiasi per entrambi i limiti.
1648
1649 Ciascuna risorsa su cui si possono applicare dei limiti è identificata da uno
1650 specifico valore dell'argomento \param{resource}, i valori possibili per
1651 questo argomento, ed il significato della risorsa corrispondente, dei
1652 rispettivi limiti e gli effetti causati dal superamento degli stessi sono
1653 riportati nel seguente elenco:
1654
1655 \begin{basedescript}{\desclabelwidth{2.2cm}}%\desclabelstyle{\nextlinelabel}}
1656 \item[\constd{RLIMIT\_AS}] Questa risorsa indica, in byte, la dimensione
1657   massima consentita per la memoria virtuale di un processo, il cosiddetto
1658   \textit{Address Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se il limite
1659   viene superato dall'uso di funzioni come \func{brk}, \func{mremap} o
1660   \func{mmap} esse falliranno con un errore di \errcode{ENOMEM}, mentre se il
1661   superamento viene causato dalla crescita dello \textit{stack} il processo
1662   riceverà un segnale di \signal{SIGSEGV}. Dato che il valore usato è un
1663   intero di tipo \ctyp{long} nelle macchine a 32 bit questo può assumere un
1664   valore massimo di 2Gb (anche se la memoria disponibile può essere maggiore),
1665   in tal caso il limite massimo indicabile resta 2Gb, altrimenti la risorsa si
1666   dà per non limitata.
1667
1668 \item[\constd{RLIMIT\_CORE}] Questa risorsa indica, in byte, la massima
1669   dimensione per un file di \textit{core dump} (vedi
1670   sez.~\ref{sec:sig_standard}) creato nella terminazione di un processo. File
1671   di dimensioni maggiori verranno troncati a questo valore, mentre con un
1672   valore nullo si bloccherà la creazione dei \textit{core dump}.
1673
1674 \item[\constd{RLIMIT\_CPU}] Questa risorsa indica, in secondi, il massimo tempo
1675   di CPU (vedi sez.~\ref{sec:sys_cpu_times}) che il processo può usare. Il
1676   superamento del limite corrente comporta l'emissione di un segnale di
1677   \signal{SIGXCPU}, la cui azione predefinita (vedi
1678   sez.~\ref{sec:sig_classification}) è terminare il processo. Il segnale però
1679   può essere intercettato e ignorato, in tal caso esso verrà riemesso una
1680   volta al secondo fino al raggiungimento del limite massimo. Il superamento
1681   del limite massimo comporta comunque l'emissione di un segnale di
1682   \signal{SIGKILL}. Si tenga presente che questo è il comportamento presente
1683   su Linux dai kernel della serie 2.2 ad oggi, altri kernel possono avere
1684   comportamenti diversi per quanto avviene quando viene superato il
1685   \textit{soft limit}, pertanto per avere operazioni portabili è suggerito di
1686   intercettare sempre \signal{SIGXCPU} e terminare in maniera ordinata il
1687   processo con la prima ricezione.
1688
1689 \item[\constd{RLIMIT\_DATA}] Questa risorsa indica, in byte, la massima
1690   dimensione del segmento dati di un processo (vedi
1691   sez.~\ref{sec:proc_mem_layout}).  Il tentativo di allocare più memoria di
1692   quanto indicato dal limite corrente causa il fallimento della funzione di
1693   allocazione eseguita (\func{brk} o \func{sbrk}) con un errore di
1694   \errcode{ENOMEM}.
1695
1696 \item[\constd{RLIMIT\_FSIZE}] Questa risorsa indica, in byte, la massima
1697   dimensione di un file che un processo può usare. Se il processo cerca di
1698   scrivere o di estendere il file oltre questa dimensione riceverà un segnale
1699   di \signal{SIGXFSZ}, che di norma termina il processo. Se questo segnale
1700   viene intercettato la \textit{system call} che ha causato l'errore fallirà
1701   con un errore di \errcode{EFBIG}.
1702
1703 \item[\constd{RLIMIT\_LOCKS}] Questa risorsa indica il numero massimo di
1704   \textit{file lock} (vedi sez.~\ref{sec:file_locking}) e di \textit{file
1705     lease} (vedi sez.~\ref{sec:file_asyncronous_lease}) che un processo poteva
1706   effettuare.  È un limite presente solo nelle prime versioni del kernel 2.4,
1707   pertanto non deve essere più utilizzato.
1708
1709 \item[\constd{RLIMIT\_MEMLOCK}] Questa risorsa indica, in byte, l'ammontare
1710   massimo di memoria che può essere bloccata in RAM da un processo (vedi
1711   sez.~\ref{sec:proc_mem_lock}). Dato che il \textit{memory locking} viene
1712   effettuato sulle pagine di memoria, il valore indicato viene automaticamente
1713   arrotondato al primo multiplo successivo della dimensione di una pagina di
1714   memoria. Il limite comporta il fallimento delle \textit{system call} che
1715   eseguono il \textit{memory locking} (\func{mlock}, \func{mlockall} ed anche,
1716   vedi sez.~\ref{sec:file_memory_map}, \func{mmap} con l'operazione
1717   \const{MAP\_LOCKED}).
1718
1719   Dal kernel 2.6.9 questo limite comprende anche la memoria che può essere
1720   bloccata da ciascun utente nell'uso della memoria condivisa (vedi
1721   sez.~\ref{sec:ipc_sysv_shm}) con \func{shmctl}, che viene contabilizzata
1722   separatamente ma sulla quale viene applicato questo stesso limite. In
1723   precedenza invece questo limite veniva applicato sulla memoria condivisa per
1724   processi con privilegi amministrativi, il limite su questi è stato rimosso e
1725   la semantica della risorsa cambiata.
1726
1727
1728 \item[\constd{RLIMIT\_MSGQUEUE}] Questa risorsa indica il numero massimo di
1729   byte che possono essere utilizzati da un utente, identificato con
1730   l'\ids{UID} reale del processo chiamante, per le code di messaggi POSIX
1731   (vedi sez.~\ref{sec:ipc_posix_mq}). Per ciascuna coda che viene creata viene
1732   calcolata un'occupazione pari a:
1733 \includecodesnip{listati/mq_occupation.c}
1734 dove \var{attr} è la struttura \struct{mq\_attr} (vedi
1735 fig.~\ref{fig:ipc_mq_attr}) usata nella creazione della coda. Il primo addendo
1736 consente di evitare la creazione di una coda con un numero illimitato di
1737 messaggi vuoti che comunque richiede delle risorse di gestione. Questa risorsa
1738 è stata introdotta con il kernel 2.6.8.
1739
1740 \item[\constd{RLIMIT\_NICE}] Questa risorsa indica il numero massimo a cui può
1741   essere il portato il valore di \textit{nice} (vedi
1742   sez.~\ref{sec:proc_sched_stand}). Dato che non possono essere usati numeri
1743   negativi per specificare un limite, il valore di \textit{nice} viene
1744   calcolato come \code{20-rlim\_cur}. Questa risorsa è stata introdotta con il
1745   kernel 2.6.12.
1746
1747 \item[\constd{RLIMIT\_NOFILE}] Questa risorsa indica il numero massimo di file
1748   che un processo può aprire. Il tentativo di creazione di un ulteriore file
1749   descriptor farà fallire la funzione (\func{open}, \func{dup}, \func{pipe},
1750   ecc.) con un errore \errcode{EMFILE}.
1751
1752 \item[\constd{RLIMIT\_NPROC}] Questa risorsa indica il numero massimo di
1753   processi che possono essere creati dallo stesso utente, che viene
1754   identificato con l'\ids{UID} reale (vedi sez.~\ref{sec:proc_access_id}) del
1755   processo chiamante. Se il limite viene raggiunto \func{fork} fallirà con un
1756   \errcode{EAGAIN}.
1757
1758 \item[\constd{RLIMIT\_RSS}] Questa risorsa indica, in pagine di memoria, la
1759   dimensione massima della memoria residente (il cosiddetto RSS
1760   \itindex{Resident~Set~Size~(RSS)} \textit{Resident Set Size}) cioè
1761   l'ammontare della memoria associata al processo che risiede effettivamente
1762   in RAM e non a quella eventualmente portata sulla \textit{swap} o non ancora
1763   caricata dal filesystem per il segmento testo del programma.  Ha effetto
1764   solo sulle chiamate a \func{madvise} con \const{MADV\_WILLNEED} (vedi
1765   sez.~\ref{sec:file_memory_map}). Presente solo sui i kernel precedenti il
1766   2.4.30.
1767
1768 \item[\constd{RLIMIT\_RTPRIO}] Questa risorsa indica il valore massimo della
1769   priorità statica che un processo può assegnarsi o assegnare con
1770   \func{sched\_setscheduler} e \func{sched\_setparam} (vedi
1771   sez.~\ref{sec:proc_real_time}). Il limite è stato introdotto a partire dal
1772   kernel 2.6.12 (ma per un bug è effettivo solo a partire dal 2.6.13). In
1773   precedenza solo i processi con privilegi amministrativi potevano avere una
1774   priorità statica ed utilizzare una politica di \textit{scheduling} di tipo
1775   \textit{real-time}.
1776
1777 \item[\constd{RLIMIT\_RTTIME}] Questa risorsa indica, in microsecondi, il tempo
1778   massimo di CPU che un processo eseguito con una priorità statica può
1779   consumare. Il superamento del limite corrente comporta l'emissione di un
1780   segnale di \signal{SIGXCPU}, e quello del limite massimo di \signal{SIGKILL}
1781   con le stesse regole viste \const{RLIMIT\_CPU}: se \signal{SIGXCPU} viene
1782   intercettato ed ignorato il segnale verrà riemesso ogni secondo fino al
1783   superamento del limite massimo. Questo limite è stato introdotto con il
1784   kernel 2.6.25 per impedire che un processo \textit{real-time} possa bloccare
1785   il sistema.
1786
1787 \item[\constd{RLIMIT\_SIGPENDING}] Questa risorsa indica il numero massimo di
1788   segnali che possono essere mantenuti in coda per ciascun utente,
1789   identificato per \ids{UID} reale. Il limite comprende sia i segnali normali
1790   che quelli \textit{real-time} (vedi sez.~\ref{sec:sig_real_time}) ed è
1791   attivo solo per \func{sigqueue}, con \func{kill} si potrà sempre inviare un
1792   segnale che non sia già presente su una coda. Questo limite è stato
1793   introdotto con il kernel 2.6.8.
1794
1795 \item[\constd{RLIMIT\_STACK}] Questa risorsa indica, in byte, la massima
1796   dimensione dello \textit{stack} del processo. Se il processo esegue
1797   operazioni che estendano lo \textit{stack} oltre questa dimensione riceverà
1798   un segnale di \signal{SIGSEGV}.
1799
1800   A partire dal kernel 2.6.23 questo stesso limite viene applicato per la gran
1801   parte delle architetture anche ai dati che possono essere passati come
1802   argomenti e variabili di ambiente ad un programma posto in esecuzione con
1803   \func{execve}, nella misura di un quarto del valore indicato per lo
1804   \textit{stack}.  Questo valore in precedenza era fisso e pari a 32 pagine di
1805   memoria, corrispondenti per la gran parte delle architetture a 128kb di
1806   dati, dal 2.6.25, per evitare problemi di compatibilità quando
1807   \const{RLIMIT\_STACK} è molto basso, viene comunque garantito uno spazio
1808   base di 32 pagine qualunque sia l'architettura.
1809
1810 \end{basedescript}
1811
1812 Si tenga conto infine che tutti i limiti eventualmente presenti su un processo
1813 vengono ereditati dai figli da esso creati attraverso una \func{fork} (vedi
1814 sez.~\ref{sec:proc_fork}) e mantenuti invariati per i programmi messi in
1815 esecuzione attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
1816
1817 Si noti come le due funzioni \func{getrlimit} e \func{setrlimit} consentano di
1818 operare solo sul processo corrente. Per questo motivo a partire dal kernel
1819 2.6.36 (e dalla \acr{glibc} 2.13) è stata introdotta un'altra funzione di
1820 sistema \funcd{prlimit} il cui scopo è quello di estendere e sostituire le
1821 precedenti.  Il suo prototipo è:
1822
1823 \begin{funcproto}{
1824 \fhead{sys/resource.h}
1825 \fdecl{int prlimit(pid\_t pid, int resource, const struct rlimit *new\_limit,\\
1826 \phantom{int prlimit(}struct rlimit *old\_limit}
1827 \fdesc{Legge e imposta i limiti di una risorsa.} 
1828 }
1829
1830 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1831   caso \var{errno} assumerà uno dei valori:
1832   \begin{errlist}
1833   \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
1834     nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
1835     \var{rlim->rlim\_max}.
1836   \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1837     cercato di innalzare i propri limiti o si è cercato di modificare i limiti
1838     di un processo di un altro utente.
1839   \item [\errcode{ESRCH}] il process \param{pid} non esiste.
1840   \end{errlist}
1841   ed inoltre \errval{EFAULT} nel suo significato generico.
1842 }
1843 \end{funcproto}
1844
1845 La funzione è specifica di Linux e non portabile; per essere usata richiede
1846 che sia stata definita la macro \macro{\_GNU\_SOURCE}. Il primo argomento
1847 indica il \ids{PID} del processo di cui si vogliono cambiare i limiti e si può
1848 usare un valore nullo per indicare il processo chiamante.  Per modificare i
1849 limiti di un altro processo, a meno di non avere privilegi
1850 amministrativi,\footnote{anche in questo caso la \textit{capability}
1851   necessaria è \const{CAP\_SYS\_RESOURCE} (vedi
1852   sez.~\ref{sec:proc_capabilities}).}  l'\ids{UID} ed il \ids{GID} reale del
1853 chiamante devono coincidere con \ids{UID} e \ids{GID} del processo indicato
1854 per i tre gruppi reale, effettivo e salvato.
1855
1856 Se \param{new\_limit} non è \val{NULL} verrà usato come puntatore alla
1857 struttura \struct{rlimit} contenente i valori dei nuovi limiti da impostare,
1858 mentre se \param{old\_limit} non è \val{NULL} verranno letti i valori correnti
1859 del limiti nella struttura \struct{rlimit} da esso puntata. In questo modo è
1860 possibile sia leggere che scrivere, anche in contemporanea, i valori dei
1861 limiti. Il significato dell'argomento \param{resource} resta identico rispetto
1862 a \func{getrlimit} e \func{setrlimit}, così come i restanti requisiti. 
1863
1864
1865 \subsection{Le informazioni sulle risorse di memoria e processore}
1866 \label{sec:sys_memory_res}
1867
1868 La gestione della memoria è già stata affrontata in dettaglio in
1869 sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1870 meccanismo della memoria virtuale attraverso la divisione della memoria fisica
1871 in pagine.  In genere tutto ciò è del tutto trasparente al singolo processo,
1872 ma in certi casi, come per l'I/O mappato in memoria (vedi
1873 sez.~\ref{sec:file_memory_map}) che usa lo stesso meccanismo per accedere ai
1874 file, è necessario conoscere le dimensioni delle pagine usate dal kernel. Lo
1875 stesso vale quando si vuole gestire in maniera ottimale l'interazione della
1876 memoria che si sta allocando con il meccanismo della paginazione.
1877
1878 Un tempo la dimensione delle pagine di memoria era fissata una volta per tutte
1879 dall'architettura hardware, per cui il relativo valore veniva mantenuto in una
1880 costante che bastava utilizzare in fase di compilazione. Oggi invece molte
1881 architetture permettono di variare questa dimensione (ad esempio sui PC
1882 recenti si possono usare pagine di 4kb e di 4 Mb) per cui per non dover
1883 ricompilare i programmi per ogni possibile caso e relativa scelta di
1884 dimensioni, è necessario poter utilizzare una funzione che restituisca questi
1885 valori quando il programma viene eseguito.
1886
1887 Dato che si tratta di una caratteristica generale del sistema come abbiamo
1888 visto in sez.~\ref{sec:sys_characteristics} questa dimensione può essere
1889 ottenuta come tutte le altre attraverso una chiamata a \func{sysconf}, nel
1890 caso specifico si dovrebbe utilizzare il parametro \const{\_SC\_PAGESIZE}. Ma
1891 in BSD 4.2 è stata introdotta una apposita funzione di sistema
1892 \funcd{getpagesize} che restituisce la dimensione delle pagine di memoria. La
1893 funzione è disponibile anche su Linux (ma richiede che sia definita la macro
1894 \macro{\_BSD\_SOURCE}) ed il suo prototipo è:
1895
1896 \begin{funcproto}{
1897 \fhead{unistd.h}
1898 \fdecl{int getpagesize(void)}
1899 \fdesc{Legge la dimensione delle pagine di memoria.} 
1900 }
1901
1902 {La funzione ritorna la dimensione di una pagina in byte, e non sono previsti
1903   errori.}
1904 \end{funcproto}
1905
1906 La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
1907 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1908 ha eliminata, ed i programmi che intendono essere portabili devono ricorrere
1909 alla chiamata a \func{sysconf}. 
1910
1911 In Linux è implementata come una \textit{system call} nelle architetture in
1912 cui essa è necessaria, ed in genere restituisce il valore del simbolo
1913 \const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
1914 se le versioni delle librerie del C precedenti la \acr{glibc} 2.1
1915 implementavano questa funzione restituendo sempre un valore statico.
1916
1917 % TODO verificare meglio la faccenda di const{PAGE\_SIZE} 
1918
1919 La \textsl{glibc} fornisce, come specifica estensione GNU, altre due
1920 funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
1921 di ottenere informazioni riguardo le pagine di memoria; i loro prototipi sono:
1922
1923 \begin{funcproto}{
1924 \fhead{sys/sysinfo.h} 
1925 \fdecl{long int get\_phys\_pages(void)}
1926 \fdesc{Legge il numero totale di pagine di memoria.} 
1927 \fdecl{long int get\_avphys\_pages(void)} 
1928 \fdesc{Legge il numero di pagine di memoria disponibili nel sistema.} 
1929 }
1930
1931 {La funzioni ritornano il numero di pagine, e non sono previsti
1932   errori.}  
1933 \end{funcproto}
1934
1935 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1936 rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
1937 \const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1938 corrispondenti alla RAM della macchina; la seconda invece la memoria
1939 effettivamente disponibile per i processi.
1940
1941 La \acr{glibc} supporta inoltre, come estensioni GNU, due funzioni che
1942 restituiscono il numero di processori della macchina (e quello dei processori
1943 attivi); anche queste sono informazioni comunque ottenibili attraverso
1944 \func{sysconf} utilizzando rispettivamente i parametri
1945 \const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
1946
1947 Infine la \acr{glibc} riprende da BSD la funzione \funcd{getloadavg} che
1948 permette di ottenere il carico di processore della macchina, in questo modo è
1949 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1950 Il suo prototipo è:
1951
1952 \begin{funcproto}{
1953 \fhead{stdlib.h}
1954 \fdecl{int getloadavg(double loadavg[], int nelem)}
1955 \fdesc{Legge il carico medio della macchina.} 
1956 }
1957
1958 {La funzione ritorna il numero di campionamenti restituiti e $-1$ se non
1959   riesce ad ottenere il carico medio, \var{errno} non viene modificata.}
1960 \end{funcproto}
1961
1962 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1963 di processi attivi sulla coda dello \textit{scheduler}, calcolato su diversi
1964 intervalli di tempo.  Il numero di intervalli che si vogliono leggere è
1965 specificato da \param{nelem}, dato che nel caso di Linux il carico viene
1966 valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti), questo è
1967 anche il massimo valore che può essere assegnato a questo argomento.
1968
1969
1970 \subsection{La \textsl{contabilità} in stile BSD}
1971 \label{sec:sys_bsd_accounting}
1972
1973 Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
1974 kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
1975   compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
1976 cosiddetto \textit{BSD accounting}, che consente di registrare su file una
1977 serie di informazioni\footnote{contenute nella struttura \texttt{acct}
1978   definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
1979 riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
1980 che viene terminato.
1981
1982 Linux consente di salvare la contabilità delle informazioni relative alle
1983 risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
1984 prototipo è:
1985
1986 \begin{funcproto}{
1987 \fhead{unistd.h}
1988 \fdecl{int acct(const char *filename)}
1989 \fdesc{Abilita il \textit{BSD accounting}.} 
1990 }
1991
1992 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1993   caso \var{errno} assumerà uno dei valori: 
1994   \begin{errlist}
1995     \item[\errcode{EACCES}] non si hanno i permessi per accedere a
1996       \param{pathname}.
1997     \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
1998     \item[\errcode{EPERM}] il processo non ha privilegi sufficienti ad
1999       abilitare il \textit{BSD accounting}.
2000     \item[\errcode{EUSERS}] non sono disponibili nel kernel strutture per il
2001       file o si è finita la memoria.
2002     \end{errlist}
2003     ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
2004     \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
2005     \errval{ENOTDIR}, \errval{EROFS} nel loro significato generico.}
2006 \end{funcproto}
2007
2008 La funzione attiva il salvataggio dei dati sul file indicato dal
2009 \textit{pathname} contenuti nella stringa puntata da \param{filename}; la
2010 funzione richiede che il processo abbia i privilegi di amministratore (è
2011 necessaria la \textit{capability} \const{CAP\_SYS\_PACCT}, vedi
2012 sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \val{NULL} per
2013 \param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
2014 semplice esempio per l'uso di questa funzione è riportato nel programma
2015 \texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
2016
2017 Quando si attiva la contabilità, il file che si indica deve esistere; esso
2018 verrà aperto in sola scrittura e le informazioni verranno registrate in
2019 \textit{append} in coda al file tutte le volte che un processo termina. Le
2020 informazioni vengono salvate in formato binario, e corrispondono al contenuto
2021 della apposita struttura dati definita all'interno del kernel.
2022
2023 Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
2024 parametro di sistema, modificabile attraverso \sysctlfiled{kernel/acct} (o
2025 tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi, il
2026 primo indica la percentuale di spazio disco libero sopra il quale viene
2027 ripresa una registrazione che era stata sospesa per essere scesi sotto il
2028 minimo indicato dal secondo valore (sempre in percentuale di spazio disco
2029 libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
2030 essere controllata detta percentuale.
2031
2032 % TODO: bassa priorità, trattare la lettura del file di accounting, da
2033 % programma, vedi man 5 acct
2034
2035
2036 \section{La gestione dei tempi del sistema}
2037 \label{sec:sys_time}
2038
2039 In questa sezione, una volta introdotti i concetti base della gestione dei
2040 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
2041 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
2042 veri tempi di sistema associati ai processi, a quelle per convertire i vari
2043 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
2044 gestione di data e ora.
2045
2046
2047 \subsection{La misura del tempo in Unix}
2048 \label{sec:sys_unix_time}
2049
2050 \itindbeg{calendar~time}
2051 \itindbeg{process~time}
2052
2053 Tradizionalmente nei sistemi unix-like sono sempre stati previsti due tipi
2054 distinti di tempi, caratterizzati da altrettante modalità di misura ed
2055 espressi con diversi tipi di dati, chiamati rispettivamente \textit{calendar
2056   time} e \textit{process time}, secondo le seguenti definizioni:
2057 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
2058
2059 \item[\textit{calendar time}] detto anche \textsl{tempo di calendario}, 
2060   \textsl{tempo d'orologio} o \textit{tempo reale}. Si tratta di un
2061   tempo assoluto o di un intervallo di tempo come lo intende
2062   normalmente per le misure fatte con un orologio. Per esprimere
2063   questo tempo è stato riservato il tipo \type{time\_t}, e viene
2064   tradizionalmente misurato in secondi a partire dalla mezzanotte del
2065   primo gennaio 1970, data che viene chiamata \textit{the Epoch}.
2066
2067 \item[\textit{process time}] detto anche \textsl{tempo di processore} o
2068   \textsl{tempo di CPU}. Si tratta del tempo impiegato da un processore
2069   nell'esecuzione del codice di un programma all'interno di un processo. Per
2070   esprimere questo tempo è stato riservato il tipo \type{clock\_t}, e viene
2071   misurato nei cosiddetti \textit{clock tick}, tradizionalmente corrispondenti
2072   al numero di interruzioni del processore da parte del timer di sistema. A
2073   differenza del precedente indica soltanto un intervallo di durata.
2074 \end{basedescript}
2075
2076 Il \textit{calendar time} viene sempre mantenuto facendo riferimento
2077 al cosiddetto \textit{tempo universale coordinato} UTC, anche se
2078 talvolta viene usato il cosiddetto GMT (\textit{Greenwich Mean Time})
2079 dato che l'UTC corrisponde all'ora locale di Greenwich. Si tratta del
2080 tempo su cui viene mantenuto il cosiddetto \textsl{orologio di
2081   sistema}, e viene usato per indicare i tempi dei file (quelli di
2082 sez.~\ref{sec:file_file_times}) o le date di avvio dei processi, ed è
2083 il tempo che viene usato dai demoni che compiono lavori amministrativi
2084 ad orari definito, come \cmd{cron}.
2085
2086 Si tenga presente che questo tempo è mantenuto dal kernel e non è detto che
2087 corrisponda al tempo misurato dall'orologio hardware presente su praticamente
2088 tutte le piastre madri dei computer moderni (il cosiddetto \textit{hardware
2089   clock}), il cui valore viene gestito direttamente dall'hardware in maniera
2090 indipendente e viene usato dal kernel soltanto all'avvio per impostare un
2091 valore iniziale dell'orologio di sistema. La risoluzione tradizionale data dal
2092 tipo di dato \type{time\_t} è di un secondo, ma nei sistemi più recenti sono
2093 disponibili altri tipi di dati con precisioni maggiori.
2094
2095 Si tenga presente inoltre che a differenza di quanto avviene con altri sistemi
2096 operativi,\footnote{è possibile, ancorché assolutamente sconsigliabile,
2097   forzare l'orologio di sistema all'ora locale per compatibilità con quei
2098   sistemi operativi che han fatto questa deprecabile scelta.}  l'orologio di
2099 sistema viene mantenuto sempre in UTC e che la conversione all'ora locale del
2100 proprio fuso orario viene effettuata dalle funzioni di libreria utilizzando le
2101 opportune informazioni di localizzazione (specificate in
2102 \conffiled{/etc/timezone}). In questo modo si ha l'assicurazione che l'orologio
2103 di sistema misuri sempre un tempo monotono crescente come nella realtà, anche
2104 in presenza di cambi di fusi orari.
2105
2106 \itindend{calendar~time}
2107
2108 Il \textit{process time} invece indica sempre una misura di un lasso di tempo
2109 e viene usato per tenere conto dei tempi di esecuzione dei processi. Esso
2110 viene sempre diviso in \textit{user time} e \textit{system time}, per misurare
2111 la durata di ciascun processo il kernel infatti calcola tre tempi:
2112 \begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
2113 \item[\textit{clock time}] il tempo \textsl{reale}, viene chiamato anche
2114   \textit{wall clock time} o \textit{elapsed time}, passato dall'avvio del
2115   processo. Questo tempo fa riferimento al 
2116   \textit{calendar time} e dice la durata effettiva dell'esecuzione del
2117   processo, ma chiaramente dipende dal carico del sistema e da quanti altri
2118   processi stanno girando nello stesso momento.
2119   
2120 \item[\textit{user time}] il tempo effettivo che il processore ha impiegato
2121   nell'esecuzione delle istruzioni del programma in \textit{user space}. È
2122   anche quello riportato nella risorsa \var{ru\_utime} di \struct{rusage}
2123   vista in sez.~\ref{sec:sys_resource_use}.
2124   
2125 \item[\textit{system time}] il tempo effettivo che il processore ha impiegato
2126   per eseguire codice delle \textit{system call} nel kernel per conto del
2127   processo.  È anche quello riportato nella risorsa \var{ru\_stime} di
2128   \struct{rusage} vista in sez.~\ref{sec:sys_resource_use}.
2129 \end{basedescript}
2130
2131 La somma di \textit{user time} e \textit{system time} indica il
2132 \textit{process time}, vale a dire il tempo di processore totale che il
2133 sistema ha effettivamente utilizzato per eseguire il programma di un certo
2134 processo. Si può ottenere un riassunto dei valori di questi tempi quando si
2135 esegue un qualsiasi programma lanciando quest'ultimo come argomento del
2136 comando \cmd{time}.
2137
2138 \itindend{process~time}
2139 \itindbeg{clock~tick}
2140
2141 Come accennato il \textit{process time} viene misurato nei cosiddetti
2142 \textit{clock tick}. Un tempo questo corrispondeva al numero di interruzioni
2143 effettuate dal timer di sistema, oggi lo standard POSIX richiede che esso sia
2144 espresso come multiplo della costante \constd{CLOCKS\_PER\_SEC} che deve
2145 essere definita come 1000000, qualunque sia la risoluzione reale dell'orologio
2146 di sistema e la frequenza delle interruzioni del timer che, come accennato in
2147 sez.~\ref{sec:proc_hierarchy} e come vedremo a breve, è invece data dalla
2148 costante \const{HZ}.
2149
2150 Il tipo di dato usato per questo tempo, \type{clock\_t}, con questa
2151 convenzione ha una risoluzione del microsecondo. Ma non tutte le funzioni di
2152 sistema come vedremo seguono questa convenzione, in tal caso il numero di
2153 \textit{clock tick} al secondo può essere ricavato anche attraverso
2154 \func{sysconf} richiedendo il valore della costante \const{\_SC\_CLK\_TCK}
2155 (vedi sez.~\ref{sec:sys_limits}).  Il vecchio simbolo \const{CLK\_TCK}
2156 definito in \headfile{time.h} è ormai considerato obsoleto e non deve essere
2157 usato.
2158
2159 \constbeg{HZ}
2160
2161 In realtà tutti calcoli dei tempi vengono effettuati dal kernel per il
2162 cosiddetto \textit{software clock}, utilizzando il \textit{timer di sistema} e
2163 facendo i conti in base al numero delle interruzioni generate dello stesso, i
2164 cosiddetti \itindex{jiffies} ``\textit{jiffies}''. La durata di un
2165 ``\textit{jiffy}'' è determinata dalla frequenza di interruzione del timer,
2166 indicata in Hertz, come accennato in sez.~\ref{sec:proc_hierarchy}, dal valore
2167 della costante \const{HZ} del kernel, definita in \file{asm/param.h}.
2168
2169 Fino al kernel 2.4 il valore di \const{HZ} era 100 su tutte le architetture
2170 tranne l'alpha, per cui era 1000. Con il 2.6.0 è stato portato a 1000 su tutte
2171 le architetture, ma dal 2.6.13 il valore è diventato una opzione di
2172 compilazione del kernel, con un default di 250 e valori possibili di 100, 250,
2173 1000. Dal 2.6.20 è stato aggiunto anche il valore 300 che è divisibile per le
2174 frequenze di refresh della televisione (50 o 60 Hz). Si può pensare che questi
2175 valori determinino anche la corrispondente durata dei \textit{clock tick}, ma
2176 in realtà questa granularità viene calcolata in maniera indipendente usando la
2177 costante del kernel \const{USER\_HZ}.
2178
2179 \constend{HZ}
2180
2181 Fino al kernel 2.6.21 la durata di un \textit{jiffy} costituiva la risoluzione
2182 massima ottenibile nella misura dei tempi impiegabile in una \textit{system
2183   call} (ad esempio per i timeout). Con il 2.6.21 e l'introduzione degli
2184 \textit{high-resolution timers} (HRT) è divenuto possibile ottenere, per le
2185 funzioni di attesa ed i timer, la massima risoluzione possibile fornita
2186 dall'hardware. Torneremo su questo in sez.~\ref{sec:sig_timer_adv}.
2187
2188 \itindend{clock~tick}
2189
2190
2191 \subsection{La gestione del \textit{process time}}
2192 \label{sec:sys_cpu_times}
2193
2194 Di norma tutte le operazioni del sistema fanno sempre riferimento al
2195 \textit{calendar time}, l'uso del \textit{process time} è riservato a
2196 quei casi in cui serve conoscere i tempi di esecuzione di un processo
2197 (ad esempio per valutarne l'efficienza). In tal caso infatti fare
2198 ricorso al \textit{calendar time} è inutile in quanto il tempo può
2199 essere trascorso mentre un altro processo era in esecuzione o in
2200 attesa del risultato di una operazione di I/O.
2201
2202 La funzione più semplice per leggere il \textit{process time} di un processo è
2203 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
2204 utilizzato dallo stesso; il suo prototipo è:
2205
2206 \begin{funcproto}{
2207 \fhead{time.h}
2208 \fdecl{clock\_t clock(void)}
2209 \fdesc{Legge il valore corrente del tempo di CPU.} 
2210 }
2211
2212 {La funzione ritorna il tempo di CPU in caso di successo e $-1$ se questo non
2213   è ottenibile o rappresentabile in un valore di tipo \type{clock\_t},
2214   \var{errno} non viene usata.}  
2215 \end{funcproto}
2216
2217 La funzione restituisce il tempo in \textit{clock tick} ma la \acr{glibc}
2218 segue lo standard POSIX e quindi se si vuole il tempo in secondi occorre
2219 dividere il risultato per la costante \const{CLOCKS\_PER\_SEC}. In genere
2220 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
2221 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
2222 riprenderà lo stesso valore iniziale.
2223
2224 La funzione è presente anche nello standard ANSI C, ma in tal caso non è
2225 previsto che il valore ritornato indichi un intervallo di tempo ma solo un
2226 valore assoluto, per questo se si vuole la massima portabilità anche al di
2227 fuori di kernel unix-like, può essere opportuno chiamare la funzione
2228 all'inizio del programma ed ottenere il valore del tempo con una differenza.
2229
2230 Si tenga presente inoltre che con altri kernel unix-like il valore riportato
2231 dalla funzione può includere anche il tempo di processore usato dai processi
2232 figli di cui si è ricevuto lo stato di terminazione con \func{wait} e
2233 affini. Questo non vale per Linux, in cui questa informazione deve essere
2234 ottenuta separatamente.
2235
2236 Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di processore è la
2237 somma di altri due tempi, l'\textit{user time} ed il \textit{system time}, che
2238 sono quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
2239 possono essere letti separatamente attraverso la funzione \funcd{times}, il
2240 cui prototipo è:
2241
2242 \begin{funcproto}{
2243 \fhead{sys/times.h}
2244 \fdecl{clock\_t times(struct tms *buf)}
2245 \fdesc{Legge il valore corrente dei tempi di processore.} 
2246 }
2247
2248 {La funzione ritorna un numero di \textit{clock tick} in caso di successo e
2249   $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il valore
2250   \errval{EFAULT} nel suo significato generico.}
2251 \end{funcproto} 
2252
2253 La funzione restituisce i valori di \textit{process time} del processo
2254 corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
2255 in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
2256 due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
2257 \textit{system time} del processo, così come definiti in
2258 sez.~\ref{sec:sys_unix_time}.  Gli altri due campi, \var{tms\_cutime} e
2259 \var{tms\_cstime}, riportano la somma dell'\textit{user time} e del
2260 \textit{system time} di tutti processi figli di cui si è ricevuto lo stato di
2261 terminazione. 
2262
2263 \begin{figure}[!htb]
2264   \footnotesize
2265   \centering
2266   \begin{minipage}[c]{0.8\textwidth}
2267     \includestruct{listati/tms.h}
2268   \end{minipage} 
2269   \normalsize 
2270   \caption{La struttura \structd{tms} dei tempi di processore associati a un
2271     processo.} 
2272   \label{fig:sys_tms_struct}
2273 \end{figure}
2274
2275
2276 Si tenga presente che i tempi di processore dei processi figli di un processo
2277 vengono sempre sommati al valore corrente ogni volta che se ne riceve lo stato
2278 di terminazione, e detto valore è quello che viene a sua volta ottenuto dal
2279 processo padre. Pertanto nei campi \var{tms\_cutime} e \var{tms\_cstime} si
2280 sommano anche i tempi di ulteriori discendenti di cui i rispettivi genitori
2281 abbiano ricevuto lo stato di terminazione.
2282
2283 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
2284 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
2285 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
2286 lo stato di terminazione di tutti i suoi figli, questi processi
2287 ``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi e
2288 così via per i relativi ``\textsl{discendenti}''. 
2289
2290 Come accennato in sez.~\ref{sec:sys_resource_use} per i kernel precedenti la
2291 versione 2.6.9 il tempo di processore dei processi figli veniva sommato
2292 comunque chiedendo di ignorare \signal{SIGCHLD} anche se lo standard POSIX
2293 richiede esplicitamente che questo avvenga solo quando si riceve lo stato di
2294 uscita con una funzione della famiglia delle \func{wait}, anche in questo caso
2295 il comportamento è stato adeguato allo standard a partire dalla versione
2296 2.6.9.
2297
2298 A differenza di quanto avviene per \func{clock} i valori restituiti nei campi
2299 di una struttura \struct{tms} sono misurati in numero di \textit{clock tick}
2300 effettivi e non in multipli di \const{CLOCKS\_PER\_SEC}, pertanto per ottenere
2301 il valore effettivo del tempo in secondi occorrerà dividere per il risultato
2302 di \code{sysconf(\_SC\_CLK\_TCK)}.
2303
2304 Lo stesso vale per il valore di ritorno della funzione, il cui significato fa
2305 riferimento ad un tempo relativo ad un certo punto nel passato la cui
2306 definizione dipende dalle diverse implementazioni, e varia anche fra diverse
2307 versioni del kernel. Fino al kernel 2.4 si faceva infatti riferimento al
2308 momento dell'avvio del kernel. Con il kernel 2.6 si fa riferimento a
2309 $2^{32}/\mathtt{HZ}-300$ secondi prima dell'avvio. 
2310
2311 Considerato che il numero dei \textit{clock tick} per un kernel che è attivo
2312 da molto tempo può eccedere le dimensioni per il tipo \type{clock\_t} il
2313 comportamento più opportuno per i programmi è di ignorare comunque il valore
2314 di ritorno della funzione e ricorrere alle funzioni per il tempo di calendario
2315 del prossimo paragrafo qualora si voglia calcolare il tempo effettivamente
2316 trascorso dall'inizio del programma.
2317
2318 Infine si tenga presente che per dei limiti nelle convenzioni per il ritorno
2319 dei valori delle \textit{system call} su alcune architetture hardware (ed in
2320 particolare la \texttt{i386} dei PC a 32 bit) nel kernel della serie 2.6 il
2321 valore di ritorno della funzione può risultare erroneamente uguale a $-1$,
2322 indicando un errore, nei primi secondi dopo il boot (per la precisione nei
2323 primi 41 secondi) e se il valore del contatore eccede le dimensione del tipo
2324 \type{clock\_t}.
2325
2326
2327 \subsection{Le funzioni per il \textit{calendar time}}
2328 \label{sec:sys_time_base}
2329
2330 \itindbeg{calendar~time}
2331
2332 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time}
2333 viene espresso normalmente con una variabile di tipo \type{time\_t}, che
2334 usualmente corrisponde ad un tipo elementare; in Linux è definito come
2335 \ctyp{long int}, che di norma corrisponde a 32 bit. Il valore corrente del
2336 \textit{calendar time}, che indicheremo come \textsl{tempo di sistema}, può
2337 essere ottenuto con la funzione \funcd{time} che lo restituisce nel suddetto
2338 formato, il suo prototipo è:
2339
2340 \begin{funcproto}{
2341 \fhead{time.h}
2342 \fdecl{time\_t time(time\_t *t)}
2343 \fdesc{Legge il valore corrente del \textit{calendar time}.} 
2344 }
2345
2346 {La funzione ritorna il valore del \textit{calendar time} in caso di successo
2347   e $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il
2348   valore \errval{EFAULT} nel suo significato generico.}
2349 \end{funcproto}
2350
2351 L'argomento \param{t}, se non nullo, deve essere l'indirizzo di una variabile
2352 su cui duplicare il valore di ritorno.
2353
2354 Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
2355 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
2356 sia necessario; il suo prototipo è:
2357
2358 \begin{funcproto}{
2359 \fhead{time.h}
2360 \fdecl{int stime(time\_t *t)}
2361 \fdesc{Imposta il valore corrente del \textit{calendar time}.} 
2362 }
2363
2364 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
2365   caso \var{errno} assumerà uno dei valori: 
2366   \begin{errlist}
2367   \item[\errcode{EPERM}] non si hanno i permessi di amministrazione.
2368   \end{errlist}
2369   ed inoltre \errval{EFAULT} nel suo significato generico.}
2370 \end{funcproto}
2371
2372
2373 Dato che modificare l'ora ha un impatto su tutto il sistema il cambiamento
2374 dell'orologio è una operazione privilegiata e questa funzione può essere usata
2375 solo da un processo con i privilegi di amministratore (per la precisione la
2376 \textit{capability} \const{CAP\_SYS\_TIME}), altrimenti la chiamata fallirà
2377 con un errore di \errcode{EPERM}.
2378
2379 Data la scarsa precisione nell'uso di \type{time\_t}, che ha una risoluzione
2380 massima di un secondo, quando si devono effettuare operazioni sui tempi di
2381 norma l'uso delle due funzioni precedenti è sconsigliato, ed esse sono di
2382 solito sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le
2383   due funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
2384   \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
2385   in BSD4.3 sono indicate come sostitute delle precedenti, \func{gettimeofday}
2386   viene descritta anche in POSIX.1-2001.} i cui prototipi sono:
2387
2388 \begin{funcproto}{
2389 \fhead{sys/time.h}
2390 \fhead{time.h}
2391 \fdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)} 
2392 \fdesc{Legge il tempo corrente del sistema.}
2393 \fdecl{int settimeofday(const struct timeval *tv, const struct timezone *tz)} 
2394 \fdesc{Imposta il tempo di sistema.} 
2395 }
2396
2397 {La funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
2398   caso \var{errno} assumerà i valori \errval{EINVAL}, \errval{EFAULT} e per
2399   \func{settimeofday} anche \errval{EPERM}, nel loro significato generico.}
2400 \end{funcproto}
2401
2402
2403 Si noti come queste funzioni utilizzino per indicare il tempo una struttura di
2404 tipo \struct{timeval}, la cui definizione si è già vista in
2405 fig.~\ref{fig:sys_timeval_struct}, questa infatti permette una espressione
2406 alternativa dei valori del \textit{calendar time}, con una precisione,
2407 rispetto a \type{time\_t}, fino al microsecondo, ma la precisione è solo
2408 teorica, e la precisione reale della misura del tempo dell'orologio di sistema
2409 non dipende dall'uso di queste strutture.
2410
2411 Come nel caso di \func{stime} anche \func{settimeofday} può essere utilizzata
2412 solo da un processo coi privilegi di amministratore e più precisamente con la
2413 capacità \const{CAP\_SYS\_TIME}. Si tratta comunque di una condizione generale
2414 che continua a valere per qualunque funzione che vada a modificare l'orologio
2415 di sistema, comprese tutte quelle che tratteremo in seguito.
2416
2417 \itindbeg{timezone}
2418
2419 Il secondo argomento di entrambe le funzioni è una struttura
2420 \struct{timezone}, che storicamente veniva utilizzata per specificare appunto
2421 la cosiddetta \textit{timezone}, cioè l'insieme del fuso orario e delle
2422 convenzioni per l'ora legale che permettevano il passaggio dal tempo
2423 universale all'ora locale. Questo argomento oggi è obsoleto ed in Linux non è
2424 mai stato utilizzato; esso non è supportato né dalla vecchia \textsl{libc5},
2425 né dalla \textsl{glibc}: pertanto quando si chiama questa funzione deve essere
2426 sempre impostato a \val{NULL}.
2427
2428 \itindbeg{timezone}
2429
2430 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
2431 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
2432 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
2433 conseguenze indesiderate.  Ad esempio se si porta avanti l'orologio si possono
2434 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
2435 saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
2436 delle operazioni previste nell'intervallo di tempo che viene ripetuto. 
2437
2438 Per questo motivo la modalità più corretta per impostare l'ora è quella di
2439 usare la funzione \funcd{adjtime}, il cui prototipo è:
2440
2441 \begin{funcproto}{
2442 \fhead{sys/time.h}
2443 \fdecl{int adjtime(const struct timeval *delta, struct timeval *olddelta)}
2444 \fdesc{Aggiusta l'orologio di sistema.} 
2445 }
2446
2447 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
2448   caso \var{errno} assumerà uno dei valori: 
2449   \begin{errlist}
2450   \item[\errcode{EINVAL}] il valore di \param{delta} eccede il massimo
2451     consentito.
2452   \item[\errcode{EPERM}] il processo non i privilegi di amministratore.
2453   \end{errlist}
2454 }  
2455 \end{funcproto}
2456
2457
2458 Questa funzione permette di avere un aggiustamento graduale del tempo di
2459 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
2460 indicato nella struttura \struct{timeval} puntata da \param{delta} esprime il
2461 valore di cui si vuole spostare l'orologio. Se è positivo l'orologio sarà
2462 accelerato per un certo tempo in modo da guadagnare il tempo richiesto,
2463 altrimenti sarà rallentato. 
2464
2465 La funzione è intesa per piccoli spostamenti del tempo di sistema, ed esistono
2466 pertanto dei limiti massimi per i valori che si possono specificare
2467 per \param{delta}. La \acr{glibc} impone un intervallo compreso fra
2468 \code{INT\_MIN/1000000 + 2} e \code{INT\_MAX/1000000 - 2}, corrispondente, su
2469 una architettura PC ordinaria a 32 bit, ad un valore compreso fra $-2145$ e
2470 $2145$ secondi.
2471
2472 Inoltre se si invoca la funzione prima che una precedente richiesta di
2473 aggiustamento sia stata completata, specificando un altro valore, il
2474 precedente aggiustamento viene interrotto, ma la parte dello stesso che è già
2475 stata completata non viene rimossa. Però è possibile in questo caso farsi
2476 restituire nella struttura puntata da \param{olddelta} il tempo restante della
2477 precedente richiesta. Fino al kernel 2.6.26 ed alla \acr{glibc} 2.8 questo
2478 però era possibile soltanto specificando un diverso aggiustamento
2479 per \param{delta}, il bug è stato corretto a partire dalle versioni citate e
2480 si può ottenere l'informazione relativa alla frazione di aggiustamento
2481 mancante usando il valore \val{NULL} per \param{delta}.
2482
2483 Linux poi prevede una specifica funzione di sistema che consente un
2484 aggiustamento molto più dettagliato del tempo, permettendo ad esempio anche di
2485 regolare anche la velocità e le derive dell'orologio di sistema.  La funzione
2486 è \funcd{adjtimex} ed il suo prototipo è:
2487
2488 \begin{funcproto}{
2489 \fhead{sys/timex.h}
2490 \fdecl{int adjtimex(struct timex *buf)} 
2491 \fdesc{Regola l'orologio di sistema.} 
2492 }
2493
2494 {La funzione ritorna lo stato dell'orologio (un valore $\ge 0$) in caso di
2495   successo e $-1$ per un errore, nel qual caso \var{errno} assumerà uno dei
2496   valori:
2497   \begin{errlist}
2498   \item[\errcode{EINVAL}] si sono indicati valori fuori dall'intervallo
2499     consentito per qualcuno dei campi di \param{buf}.
2500   \item[\errcode{EPERM}] si è richiesta una modifica dei parametri ed il
2501     processo non ha i privilegi di amministratore.
2502   \end{errlist}
2503   ed inoltre \errval{EFAULT} nel suo significato generico.}
2504 \end{funcproto}
2505
2506 In caso di successo la funzione restituisce un valore numerico non negativo
2507 che indica lo stato dell'orologio, che può essere controllato con i valori
2508 delle costanti elencate in tab.~\ref{tab:adjtimex_return}.
2509
2510 \begin{table}[!htb]
2511   \footnotesize
2512   \centering
2513   \begin{tabular}[c]{|l|c|l|}
2514     \hline
2515     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2516     \hline
2517     \hline
2518     \constd{TIME\_OK}   & 0 & Orologio sincronizzato.\\ 
2519     \constd{TIME\_INS}  & 1 & Inserimento di un \textit{leap second}.\\ 
2520     \constd{TIME\_DEL}  & 2 & Cancellazione di un \textit{leap second}.\\ 
2521     \constd{TIME\_OOP}  & 3 & \textit{leap second} in corso.\\ 
2522     \constd{TIME\_WAIT} & 4 & \textit{leap second} avvenuto.\\ 
2523     \constd{TIME\_BAD}  & 5 & Orologio non sincronizzato.\\ 
2524     \hline
2525   \end{tabular}
2526   \caption{Possibili valori ritornati da \func{adjtimex} in caso di successo.} 
2527   \label{tab:adjtimex_return}
2528 \end{table}
2529
2530 La funzione richiede come argomento il puntatore ad una struttura di tipo
2531 \struct{timex}, la cui definizione, effettuata in \headfiled{sys/timex.h}, è
2532 riportata in fig.~\ref{fig:sys_timex_struct} per i campi che interessano la
2533 possibilità di essere modificati documentati anche nella pagina di manuale. In
2534 realtà la struttura è stata estesa con ulteriori campi, i cui valori sono
2535 utilizzabili solo in lettura, la cui definizione si può trovare direttamente
2536
2537 \begin{figure}[!htb]
2538   \footnotesize \centering
2539   \begin{minipage}[c]{\textwidth}
2540     \includestruct{listati/timex.h}
2541   \end{minipage} 
2542   \normalsize 
2543   \caption{La struttura \structd{timex} per il controllo dell'orologio di
2544     sistema.} 
2545   \label{fig:sys_timex_struct}
2546 \end{figure}
2547
2548 L'azione della funzione dipende dal valore del campo \var{mode}
2549 di \param{buf}, che specifica quale parametro dell'orologio di sistema,
2550 specificato nel corrispondente campo di \struct{timex}, deve essere
2551 impostato. Un valore nullo serve per leggere i parametri correnti, i valori
2552 diversi da zero devono essere specificati come OR binario delle costanti
2553 riportate in tab.~\ref{tab:sys_timex_mode}.
2554
2555 \begin{table}[!htb]
2556   \footnotesize
2557   \centering
2558   \begin{tabular}[c]{|l|c|p{8cm}|}
2559     \hline
2560     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2561     \hline
2562     \hline
2563     \constd{ADJ\_OFFSET}        & 0x0001 & Imposta la differenza fra il tempo
2564                                            reale e l'orologio di sistema: 
2565                                            deve essere indicata in microsecondi
2566                                            nel campo \var{offset} di
2567                                            \struct{timex}.\\ 
2568     \constd{ADJ\_FREQUENCY}     & 0x0002 & Imposta la differenza in frequenza
2569                                            fra il tempo reale e l'orologio di
2570                                            sistema: deve essere indicata
2571                                            in parti per milione nel campo
2572                                            \var{frequency} di \struct{timex}.\\
2573     \constd{ADJ\_MAXERROR}      & 0x0004 & Imposta il valore massimo 
2574                                            dell'errore sul tempo, espresso in
2575                                            microsecondi nel campo
2576                                            \var{maxerror} di \struct{timex}.\\ 
2577     \constd{ADJ\_ESTERROR}      & 0x0008 & Imposta la stima dell'errore
2578                                            sul tempo, espresso in microsecondi 
2579                                            nel campo \var{esterror} di
2580                                            \struct{timex}.\\
2581     \constd{ADJ\_STATUS}        & 0x0010 & Imposta alcuni valori di stato
2582                                            interni usati dal 
2583                                            sistema nella gestione
2584                                            dell'orologio specificati nel campo
2585                                            \var{status} di \struct{timex}.\\ 
2586     \constd{ADJ\_TIMECONST}     & 0x0020 & Imposta la larghezza di banda del 
2587                                            PLL implementato dal kernel,
2588                                            specificato nel campo
2589                                            \var{constant} di \struct{timex}.\\ 
2590     \constd{ADJ\_TICK}          & 0x4000 & Imposta il valore dei \textit{tick}
2591                                            del timer in
2592                                            microsecondi, espresso nel campo
2593                                            \var{tick} di \struct{timex}.\\  
2594     \constd{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Chiede uno spostamento una tantum 
2595                                            dell'orologio secondo il valore del
2596                                            campo \var{offset} simulando il
2597                                            comportamento di \func{adjtime}.\\ 
2598     \hline
2599   \end{tabular}
2600   \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
2601     struttura \struct{timex}.} 
2602   \label{tab:sys_timex_mode}
2603 \end{table}
2604
2605 La funzione utilizza il meccanismo di David L. Mills, descritto
2606 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
2607 protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
2608 portabilità è un requisito, la \acr{glibc} provvede anche un suo omonimo
2609 \func{ntp\_adjtime}.  La trattazione completa di questa funzione necessita di
2610 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
2611 a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
2612 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
2613 campi della struttura \struct{timex} può essere ritrovato in \cite{GlibcMan}.
2614
2615 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
2616 sintassi specificata per la forma equivalente di questa funzione definita come
2617 \func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
2618 \code{ADJ}.
2619
2620 Si tenga presente infine che con l'introduzione a partire dal kernel 2.6.21
2621 degli \textit{high-resolution timer} ed il supporto per i cosiddetti POSIX
2622 \textit{real-time clock}, si può ottenere il \textit{calendar time}
2623 direttamente da questi, come vedremo in sez.~\ref{sec:sig_timer_adv}, con la
2624 massima risoluzione possibile per l'hardware della macchina.
2625
2626
2627
2628 \subsection{La gestione delle date.}
2629 \label{sec:sys_date}
2630
2631 \itindbeg{broken-down~time}
2632
2633 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
2634 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
2635 illustrate, se han senso per specificare un intervallo, non sono molto
2636 intuitive quando si deve esprimere un'ora o una data.  Per questo motivo è
2637 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2638   time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2639   time} usuale in ore, minuti, secondi, ecc. e  viene usata tenendo conto
2640 anche dell'eventuale utilizzo di un fuso orario.
2641
2642 \begin{figure}[!htb]
2643   \footnotesize \centering
2644   \begin{minipage}[c]{.8\textwidth}
2645     \includestruct{listati/tm.h}
2646   \end{minipage} 
2647   \normalsize 
2648   \caption{La struttura \structd{tm} per una rappresentazione del tempo in
2649     termini di ora, minuti, secondi, ecc.}
2650   \label{fig:sys_tm_struct}
2651 \end{figure}
2652
2653 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
2654 definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
2655 struttura che si utilizza quando si deve specificare un tempo a partire dai
2656 dati naturali (ora e data), dato che essa consente anche di tenere conto della
2657 gestione del fuso orario e dell'ora legale. In particolare gli ultimi due
2658 campi, \var{tm\_gmtoff} e \var{tm\_zone}, sono estensioni previste da BSD e
2659 supportate dalla \acr{glibc} quando è definita la macro \macro{\_BSD\_SOURCE}.
2660
2661 Ciascuno dei campi di \struct{tm} ha dei precisi intervalli di valori
2662 possibili, con convenzioni purtroppo non troppo coerenti. Ad esempio
2663 \var{tm\_sec} che indica i secondi deve essere nell'intervallo da 0 a 59, ma è
2664 possibile avere anche il valore 60 per un cosiddetto \textit{leap second} (o
2665 \textsl{secondo intercalare}), cioè uno di quei secondi aggiunti al calcolo
2666 dell'orologio per effettuare gli aggiustamenti del calendario per tenere conto
2667 del disallineamento con il tempo solare.\footnote{per dettagli si consulti
2668   \url{http://it.wikipedia.org/wiki/Leap_second}.}
2669
2670 I campi \var{tm\_min} e\var{tm\_hour} che indicano rispettivamente minuti ed
2671 ore hanno valori compresi rispettivamente fra 0 e 59 e fra 0 e 23. Il campo
2672 \var{tm\_mday} che indica il giorno del mese prevede invece un valore compreso
2673 fra 1 e 31, ma la \acr{glibc} supporta pure il valore 0 come indicazione
2674 dell'ultimo giorno del mese precedente. Il campo \var{tm\_mon} indica il mese
2675 dell'anno a partire da gennaio con valori compresi fra 0 e 11.
2676
2677 I campi \var{tm\_wday} e \var{tm\_yday} indicano invece rispettivamente il
2678 giorno della settimana, a partire dalla Domenica, ed il giorno dell'anno, a
2679 partire del primo gennaio, ed hanno rispettivamente valori compresi fra 0 e 6
2680 e fra 0 e 365. L'anno espresso da \var{tm\_year} viene contato come numero di
2681 anni a partire dal 1900. Infine \var{tm\_isdst} è un valore che indica se per
2682 gli altri campi si intende come attiva l'ora legale ed influenza il
2683 comportamento di \func{mktime}.
2684
2685
2686 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2687 da quelle usate per convertire gli altri formati in questo, usando o meno
2688 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2689 tempo in una stringa contenente data ed ora. Le prime due funzioni,
2690 \funcd{asctime} e \funcd{ctime} servono per poter stampare in forma leggibile
2691 un tempo, i loro prototipi sono:
2692
2693 \begin{funcproto}{
2694 \fhead{time.h}
2695 \fdecl{char * asctime(const struct tm *tm)}
2696 \fdesc{Converte un \textit{broken-down time} in una stringa.} 
2697 \fdecl{char * ctime(const time\_t *timep)}
2698 \fdesc{Converte un \textit{calendar time} in una stringa.} 
2699 }
2700
2701 {Le funzioni ritornano un puntatore al risultato in caso di successo e
2702   \val{NULL} per un errore, \var{errno} non viene modificata.}
2703 \end{funcproto}
2704
2705 Le funzioni prendono rispettivamente come argomenti i puntatori ad una
2706 struttura \struct{tm} contenente un \textit{broken-down time} o ad una
2707 variabile di tipo \type{time\_t} che esprime il \textit{calendar time},
2708 restituendo il puntatore ad una stringa che esprime la data, usando le
2709 abbreviazioni standard di giorni e mesi in inglese, nella forma:
2710 \begin{Example}
2711 Sun Apr 29 19:47:44 2012\n"
2712 \end{Example}
2713
2714 Nel caso di \func{ctime} la funzione tiene conto della eventuale impostazione
2715 di una \textit{timezone} e effettua una chiamata preventiva a \func{tzset}
2716 (che vedremo a breve), in modo che la data espressa tenga conto del fuso
2717 orario. In realtà \func{ctime} è banalmente definita in termini di
2718 \func{asctime} come \code{asctime(localtime(t)}.
2719
2720 Dato che l'uso di una stringa statica rende le funzioni non rientranti
2721 POSIX.1c e SUSv2 prevedono due sostitute rientranti, il cui nome è al solito
2722 ottenuto aggiungendo un \code{\_r}, che prendono un secondo argomento
2723 \code{char *buf}, in cui l'utente deve specificare il buffer su cui la stringa
2724 deve essere copiata (deve essere di almeno 26 caratteri).
2725
2726 Per la conversione fra \textit{broken-down time} e \textit{calendar time} sono
2727 invece disponibili altre tre funzioni, \funcd{gmtime}, \funcd{localtime} e
2728 \funcd{mktime} i cui prototipi sono:
2729
2730 \begin{funcproto}{
2731 \fdecl{struct tm * gmtime(const time\_t *timep)}
2732 \fdesc{Converte un \textit{calendar time} in un \textit{broken-down time} in
2733   UTC.}  
2734 \fdecl{struct tm * localtime(const time\_t *timep)}
2735 \fdesc{Converte un \textit{calendar time} in un \textit{broken-down time}
2736   nell'ora locale.} 
2737 \fdecl{time\_t mktime(struct tm *tm)} 
2738 \fdesc{Converte un \textit{broken-down time} in un \textit{calendar time}.} 
2739
2740 }
2741
2742 {Le funzioni ritornano un puntatore al risultato in caso di successo e
2743   \val{NULL} per un errore, tranne che \func{mktime} che restituisce
2744   direttamente il valore o $-1$ in caso di errore, \var{errno} non viene
2745   modificata.}
2746 \end{funcproto}
2747
2748 Le le prime funzioni, \func{gmtime}, \func{localtime} servono per convertire
2749 il tempo in \textit{calendar time} specificato da un argomento di tipo
2750 \type{time\_t} restituendo un \textit{broken-down time} con il puntatore ad
2751 una struttura \struct{tm}. La prima effettua la conversione senza tenere conto
2752 del fuso orario, esprimendo la data in tempo coordinato universale (UTC), cioè
2753 l'ora di Greenwich, mentre \func{localtime} usa l'ora locale e per questo
2754 effettua una chiamata preventiva a \func{tzset}.
2755
2756 Anche in questo caso le due funzioni restituiscono l'indirizzo di una
2757 struttura allocata staticamente, per questo sono state definite anche altre
2758 due versioni rientranti (con la solita estensione \code{\_r}), che prevedono
2759 un secondo argomento \code{struct tm *result}, fornito dal chiamante, che deve
2760 preallocare la struttura su cui sarà restituita la conversione. La versione
2761 rientrante di \func{localtime} però non effettua la chiamata preventiva a
2762 \func{tzset} che deve essere eseguita a cura dell'utente.
2763
2764 Infine \func{mktime} esegue la conversione di un \textit{broken-down time} a
2765 partire da una struttura \struct{tm} restituendo direttamente un valore di
2766 tipo \type{time\_t} con il \textit{calendar time}. La funzione ignora i campi
2767 \var{tm\_wday} e \var{tm\_yday} e per gli altri campi normalizza eventuali
2768 valori fuori degli intervalli specificati in precedenza: se cioè si indica un
2769 12 per \var{tm\_mon} si prenderà il gennaio dell'anno successivo. Inoltre la
2770 funzione tiene conto del valore di \var{tm\_isdst} per effettuare le
2771 correzioni relative al fuso orario: un valore positivo indica che deve essere
2772 tenuta in conto l'ora legale, un valore nullo che non deve essere applicata
2773 nessuna correzione, un valore negativo che si deve far ricorso alle
2774 informazioni relative al proprio fuso orario per determinare lo stato dell'ora
2775 legale.  
2776
2777 La funzione inoltre modifica i valori della struttura \struct{tm} in forma di
2778 \textit{value result argument}, normalizzando i valori dei vari campi,
2779 impostando i valori risultanti per \var{tm\_wday} e \var{tm\_yday} e
2780 assegnando a \var{tm\_isdst} il valore (positivo o nullo) corrispondente allo
2781 stato dell'ora legale. La funzione inoltre provvede ad impostare il valore
2782 della variabile globale \var{tzname}.
2783
2784 \itindend{calendar~time}
2785
2786 \begin{figure}[!htb]
2787   \footnotesize
2788   \centering
2789   \begin{minipage}[c]{.75\textwidth}
2790     \includestruct{listati/time_zone_var.c}
2791   \end{minipage} 
2792   \normalsize 
2793   \caption{Le variabili globali usate per la gestione delle
2794     \textit{timezone}.}
2795   \label{fig:sys_tzname}
2796 \end{figure}
2797
2798 Come accennato l'uso del \textit{broken-down time} permette di tenere conto
2799 anche della differenza fra tempo universale e ora locale, compresa l'eventuale
2800 ora legale.  Questo viene fatto dalle funzioni di conversione grazie alle
2801 informazioni riguardo la propria \textit{timezone} mantenute nelle tre
2802 variabili globali mostrate in fig.~\ref{fig:sys_tzname}, cui si può accedere
2803 direttamente includendo \headfile{time.h}. Come illustrato queste variabili
2804 vengono impostate internamente da alcune delle precedenti funzioni di
2805 conversione, ma lo si può fare esplicitamente chiamando direttamente la
2806 funzione \funcd{tzset}, il cui prototipo è:
2807
2808 \begin{funcproto}{
2809 \fhead{time.h}
2810 \fdecl{void tzset(void)} 
2811 \fdesc{Imposta le variabili globali della \textit{timezone}.} 
2812 }
2813
2814 {La funzione non ritorna niente e non dà errori.}  
2815 \end{funcproto}
2816
2817 La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire
2818 dal valore della variabile di ambiente \envvar{TZ}, se quest'ultima non è
2819 definita verrà usato il file \conffiled{/etc/localtime}. La variabile
2820 \var{tzname} contiene due stringhe, che indicano i due nomi standard della
2821 \textit{timezone} corrente. La prima è il nome per l'ora solare, la seconda
2822 per l'ora legale. Anche se in fig.~\ref{fig:sys_tzname} sono indicate come
2823 \code{char *} non è il caso di modificare queste stringhe. La variabile
2824 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2825 \var{daylight} indica se è attiva o meno l'ora legale.
2826
2827 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2828 stampare un tempo o una data, la flessibilità non fa parte delle sue
2829 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2830 giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
2831 il cui prototipo è:
2832
2833 \begin{funcproto}{
2834 \fhead{time.h}
2835 \fdecl{size\_t strftime(char *s, size\_t max, const char *format, 
2836   const struct tm *tm)}
2837 \fdesc{Crea una stringa con una data secondo il formato indicato.} 
2838 }
2839
2840 {La funzione ritorna il numero di caratteri inseriti nella stringa \param{s}
2841   oppure $0$, \var{errno} non viene modificata.}  
2842 \end{funcproto}
2843
2844
2845 La funzione converte il \textit{broken-down time} indicato nella struttura
2846 puntata dall'argomento \param{tm} in una stringa di testo da salvare
2847 all'indirizzo puntato dall'argomento \param{s}, purché essa sia di dimensione
2848 inferiore al massimo indicato dall'argomento \param{max}. Il numero di
2849 caratteri generati dalla funzione viene restituito come valore di ritorno,
2850 senza tener però conto del terminatore finale, che invece viene considerato
2851 nel computo della dimensione. Se quest'ultima è eccessiva viene restituito 0 e
2852 lo stato di \param{s} è indefinito.
2853
2854 \begin{table}[htb]
2855   \footnotesize
2856   \centering
2857   \begin{tabular}[c]{|c|l|p{6cm}|}
2858     \hline
2859     \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2860     \hline
2861     \hline
2862     \var{\%a}&\texttt{Wed}        & Nome del giorno, abbreviato.\\ 
2863     \var{\%A}&\texttt{Wednesday}  & Nome del giorno, completo.\\ 
2864     \var{\%b}&\texttt{Apr}        & Nome del mese, abbreviato.\\ 
2865     \var{\%B}&\texttt{April}      & Nome del mese, completo.\\ 
2866     \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\ 
2867     \var{\%d}&\texttt{24}         & Giorno del mese.\\ 
2868     \var{\%H}&\texttt{18}         & Ora del giorno, da 0 a 24.\\ 
2869     \var{\%I}&\texttt{06}         & Ora del giorno, da 0 a 12.\\ 
2870     \var{\%j}&\texttt{114}        & Giorno dell'anno.\\ 
2871     \var{\%m}&\texttt{04}         & Mese dell'anno.\\ 
2872     \var{\%M}&\texttt{40}         & Minuto.\\ 
2873     \var{\%p}&\texttt{PM}         & AM/PM.\\ 
2874     \var{\%S}&\texttt{50}         & Secondo.\\ 
2875     \var{\%U}&\texttt{16}         & Settimana dell'anno (partendo dalla
2876                                     domenica).\\ 
2877     \var{\%w}&\texttt{3}          & Giorno della settimana.\\ 
2878     \var{\%W}&\texttt{16}         & Settimana dell'anno (partendo dal
2879                                     lunedì).\\ 
2880     \var{\%x}&\texttt{04/24/02}   & La data.\\ 
2881     \var{\%X}&\texttt{18:40:50}   & L'ora.\\ 
2882     \var{\%y}&\texttt{02}         & Anno nel secolo.\\ 
2883     \var{\%Y}&\texttt{2002}       & Anno.\\ 
2884     \var{\%Z}&\texttt{CEST}       & Nome della \textit{timezone}.\\  
2885     \var{\%\%}&\texttt{\%}        & Il carattere \%.\\ 
2886     \hline
2887   \end{tabular}
2888   \caption{Valori previsti dallo standard ANSI C per modificatore della
2889     stringa di formato di \func{strftime}.}  
2890   \label{tab:sys_strftime_format}
2891 \end{table}
2892
2893 Il risultato della funzione è controllato dalla stringa di formato
2894 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2895 viene utilizzato come modificatore. Alcuni dei possibili valori che esso può
2896 assumere sono riportati in tab.~\ref{tab:sys_strftime_format}.\footnote{per la
2897   precisione si sono riportati definiti dallo standard ANSI C, che sono anche
2898   quelli ripresi in POSIX.1; la \acr{glibc} fornisce anche le estensioni
2899   introdotte da POSIX.2 per il comando \cmd{date}, i valori introdotti da
2900   SVID3 e ulteriori estensioni GNU; l'elenco completo dei possibili valori è
2901   riportato nella pagina di manuale della funzione.} La funzione tiene conto
2902 anche delle eventuali impostazioni di localizzazione per stampare i vari nomi
2903 in maniera adeguata alla lingua scelta, e con le convenzioni nazionali per i
2904 formati di data ed ora.
2905
2906 Infine per effettuare l'operazione di conversione inversa, da una stringa ad
2907 un \textit{broken-down time}, si può utilizzare la funzione \funcd{strptime},
2908 il cui prototipo è:
2909
2910 \begin{funcproto}{
2911 \fhead{time.h}
2912 \fdecl{char *strptime(const char *s, const char *format, struct tm *tm)}
2913 \fdesc{Converte una stringa con in un \textit{broken-down time} secondo un
2914   formato.} 
2915 }
2916
2917 {La funzione ritorna il puntatore al primo carattere non processato della
2918   stringa o al terminatore finale qualora questa sia processata interamente,
2919   \var{errno} non viene modificata.}
2920 \end{funcproto}
2921
2922 La funzione processa la stringa puntata dall'argomento \param{s} da sinistra a
2923 destra, utilizzando il formato contenuto nella stringa puntata
2924 dall'argomento \param{format}, avvalorando volta volta i corrispondenti campi
2925 della struttura puntata dall'argomento \param{tm}. La scansione si interrompe
2926 immediatamente in caso di mancata corrispondenza a quanto indicato nella
2927 stringa di formato, che usa una sintassi analoga a quella già vista per
2928 \func{strftime}. La funzione supporta i modificatori di
2929 tab.~\ref{tab:sys_strftime_format} più altre estensioni, ma per i dettagli a
2930 questo riguardo si rimanda alla lettura della pagina di manuale.
2931
2932 Si tenga presente comunque che anche in caso di scansione completamente
2933 riuscita la funzione sovrascrive soltanto i campi di \param{tm} indicati dal
2934 formato, la struttura originaria infatti non viene inizializzati e gli altri
2935 campi restano ai valori che avevano in precedenza.
2936
2937
2938 \itindend{broken-down~time}
2939
2940 \section{La gestione degli errori}
2941 \label{sec:sys_errors}
2942
2943 In questa sezione esamineremo le caratteristiche principali della gestione
2944 degli errori in un sistema unix-like. Infatti a parte il caso particolare di
2945 alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
2946 unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
2947 un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
2948 semplicemente usando un opportuno valore di ritorno della funzione invocata.
2949 Inoltre il sistema di classificazione degli errori è stato progettato
2950 sull'architettura a processi, e presenta una serie di problemi nel caso lo si
2951 debba usare con i \textit{thread}.
2952
2953
2954 \subsection{La variabile \var{errno}}
2955 \label{sec:sys_errno}
2956
2957 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2958 riportare condizioni di errore, ed è una norma fondamentale di buona
2959 programmazione controllare \textsl{sempre} che le funzioni chiamate si siano
2960 concluse correttamente.
2961
2962 In genere le funzioni di libreria usano un valore speciale per indicare che
2963 c'è stato un errore. Di solito questo valore, a seconda della funzione, è $-1$
2964 o un puntatore nullo o la costante \val{EOF}; ma questo valore segnala solo
2965 che c'è stato un errore, e non il tipo di errore.
2966
2967 Per riportare il tipo di errore il sistema usa la variabile globale
2968 \var{errno}, definita nell'header \headfile{errno.h}.  Come accennato l'uso di
2969 una variabile globale può comportare problemi nel caso dei \textit{thread}, ma
2970 lo standard ISO C consente anche di definire \var{errno} come un cosiddetto
2971 ``\textit{modifiable lvalue}'', cosa che consente di usare anche una macro, e
2972 questo è infatti il metodo usato da Linux per renderla locale ai singoli
2973 \textit{thread}.
2974
2975 La variabile è in genere definita come \dirct{volatile} dato che può essere
2976 cambiata in modo asincrono da un segnale, per un esempio si veda
2977 sez.~\ref{sec:sig_sigchld} ricordando quanto trattato in
2978 sez.~\ref{sec:proc_race_cond}). Dato che un gestore di segnale scritto bene si
2979 cura di salvare e ripristinare il valore della variabile all'uscita, nella
2980 programmazione normale, quando si può fare l'assunzione che i gestori di
2981 segnali siano ben scritti, di questo non è necessario preoccuparsi.
2982
2983 I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
2984 nell'header \headfile{errno.h} sono anche definiti i nomi simbolici per le
2985 costanti numeriche che identificano i vari errori che abbiamo citato fin
2986 dall'inizio nelle descrizioni delle funzioni.  Essi iniziano tutti per \val{E}
2987 e si possono considerare come nomi riservati, per questo abbiamo sempre fatto
2988 riferimento a questi nomi, e lo faremo più avanti quando descriveremo i
2989 possibili errori restituiti dalle funzioni. Il programma di esempio
2990 \cmd{errcode} stampa il codice relativo ad un valore numerico con l'opzione
2991 \cmd{-l}.
2992
2993 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
2994 programma, e la gran parte delle funzioni di libreria impostano \var{errno} ad
2995 un valore diverso da zero in caso di errore. Il valore è invece indefinito in
2996 caso di successo, perché anche se una funzione di libreria ha successo,
2997 potrebbe averne chiamate altre al suo interno che potrebbero essere fallite
2998 anche senza compromettere il risultato finale, modificando però \var{errno}.
2999
3000 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
3001 essere il risultato di un errore precedente) e non lo si può usare per
3002 determinare quando o se una chiamata a funzione è fallita.  La procedura
3003 corretta da seguire per identificare un errore è sempre quella di controllare
3004 \var{errno} immediatamente dopo aver verificato il fallimento della funzione
3005 attraverso il suo codice di ritorno.
3006
3007
3008 \subsection{Le funzioni \func{strerror} e \func{perror}}
3009 \label{sec:sys_strerror}
3010
3011 Benché gli errori siano identificati univocamente dal valore numerico di
3012 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
3013 riportare in opportuni messaggi le condizioni di errore verificatesi.  La
3014 prima funzione che si può usare per ricavare i messaggi di errore è
3015 \funcd{strerror}, il cui prototipo è:
3016
3017 \begin{funcproto}{
3018 \fhead{string.h}
3019 \fdecl{char *strerror(int errnum)} 
3020 \fdesc{Restituisce una stringa con un messaggio di errore.} 
3021 }
3022
3023 {La funzione ritorna il puntatore alla stringa con il messaggio di errore,
3024   \var{errno} non viene modificato.}
3025 \end{funcproto}
3026
3027 La funzione ritorna il puntatore alla stringa contenente il messaggio di
3028 errore corrispondente al valore di \param{errnum}, se questo non è un valore
3029 valido verrà comunque restituita una stringa valida contenente un messaggio
3030 che dice che l'errore è sconosciuto nella forma. La versione della \acr{glibc}
3031 non modifica il valore di \var{errno} in caso di errore, ma questo non è detto
3032 valga per altri sistemi in quanto lo standard POSIX.1-2001 permette che ciò
3033 avvenga. Non si faccia affidamento su questa caratteristica se si vogliono
3034 scrivere programmi portabili.
3035
3036 In generale \func{strerror} viene usata passando direttamente \var{errno} come
3037 argomento, ed il valore di quest'ultima non verrà modificato. La funzione
3038 inoltre tiene conto del valore della variabile di ambiente
3039 \envvar{LC\_MESSAGES} per usare le appropriate traduzioni dei messaggi
3040 d'errore nella localizzazione presente.
3041
3042 La funzione \func{strerror} utilizza una stringa statica che non deve essere
3043 modificata dal programma; essa è utilizzabile solo fino ad una chiamata
3044 successiva a \func{strerror} o \func{perror} e nessun'altra funzione di
3045 libreria tocca questa stringa. In ogni caso l'uso di una stringa statica rende
3046 la funzione non rientrante, per cui nel caso si usino i \textit{thread} la
3047 \acr{glibc} fornisce una apposita versione rientrante \funcd{strerror\_r}, il
3048 cui prototipo è:
3049
3050 \begin{funcproto}{
3051 \fhead{string.h}
3052 \fdecl{char * strerror\_r(int errnum, char *buf, size\_t size)} 
3053 \fdesc{Restituisce una stringa con un messaggio di errore.} 
3054 }
3055
3056 {La funzione ritorna l'indirizzo del messaggio in caso di successo e
3057   \val{NULL} per un errore, nel qual caso \var{errno} assumerà uno dei valori:
3058   \begin{errlist}
3059   \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
3060     valido.
3061   \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
3062     contenere la stringa di errore.
3063   \end{errlist}
3064 }  
3065 \end{funcproto}
3066
3067 Si tenga presente che questa è la versione prevista normalmente nella
3068 \acr{glibc}, ed effettivamente definita in \headfile{string.h}, ne esiste una
3069 analoga nello standard SUSv3 (riportata anche nella pagina di manuale), che
3070 restituisce \code{int} al posto di \code{char *}, e che tronca la stringa
3071 restituita a \param{size}, a cui si accede definendo le opportune macro (per
3072 le quali si rimanda alla lettura della pagina di manuale). 
3073
3074 La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
3075 nel buffer \param{buf} che il singolo \textit{thread} deve allocare
3076 autonomamente per evitare i problemi connessi alla condivisione del buffer
3077 statico. Il messaggio è copiato fino alla dimensione massima del buffer,
3078 specificata dall'argomento \param{size}, che deve comprendere pure il
3079 carattere di terminazione; altrimenti la stringa risulterà troncata.
3080
3081 Una seconda funzione usata per riportare i codici di errore in maniera
3082 automatizzata sullo standard error è \funcd{perror}, il cui prototipo è:
3083
3084 \begin{funcproto}{
3085 \fhead{stdio.h}
3086 \fdecl{void perror(const char *message)}
3087 \fdesc{Stampa un messaggio di errore personalizzato.} 
3088 }
3089
3090 {La funzione non ritorna nulla e non modifica \var{errno}.}
3091 \end{funcproto}
3092
3093
3094 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
3095 in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
3096 riferiscono all'ultimo errore avvenuto. La stringa specificata con
3097 \param{message} viene stampata prima del messaggio d'errore, consentono una
3098 personalizzazione (ad esempio l'indicazione del contesto in cui si è
3099 verificato), seguita dai due punti e da uno spazio, il messaggio è terminato
3100 con un a capo.  Il messaggio può essere riportato anche usando le due
3101 variabili globali:
3102 \includecodesnip{listati/errlist.c} 
3103 dichiarate in \headfile{errno.h}. La prima contiene i puntatori alle stringhe
3104 di errore indicizzati da \var{errno}; la seconda esprime il valore più alto
3105 per un codice di errore, l'utilizzo di una di queste stringhe è
3106 sostanzialmente equivalente a quello di \func{strerror}.
3107
3108 \begin{figure}[!htbp]
3109   \footnotesize \centering
3110   \begin{minipage}[c]{\codesamplewidth}
3111     \includecodesample{listati/errcode_mess.c}
3112   \end{minipage}
3113   \normalsize
3114   \caption{Codice per la stampa del messaggio di errore standard.}
3115   \label{fig:sys_err_mess}
3116 \end{figure}
3117
3118 In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
3119 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
3120 errore e le costanti usate per identificare i singoli errori. Il sorgente
3121 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
3122 gestione delle opzioni e tutte le definizioni necessarie ad associare il
3123 valore numerico alla costante simbolica. In particolare si è riportata la
3124 sezione che converte la stringa passata come argomento in un intero
3125 (\texttt{\small 1-2}), controllando con i valori di ritorno di \funcm{strtol}
3126 che la conversione sia avvenuta correttamente (\texttt{\small 4-10}), e poi
3127 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
3128   11-14}) o la macro (\texttt{\small 15-17}) associate a quel codice.
3129
3130
3131
3132 \subsection{Alcune estensioni GNU}
3133 \label{sec:sys_err_GNU}
3134
3135 Le precedenti funzioni sono quelle definite ed usate nei vari standard; la
3136 \acr{glibc} ha però introdotto una serie di estensioni ``GNU'' che
3137 forniscono alcune funzionalità aggiuntive per una gestione degli errori
3138 semplificata e più efficiente. 
3139
3140 La prima estensione consiste in due variabili, \code{char *
3141   program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
3142 che consentono di ricavare il nome del proprio programma.  Queste sono utili
3143 quando si deve aggiungere il nome del programma al messaggio d'errore, cosa
3144 comune quando si ha un programma che non viene lanciato da linea di comando e
3145 salva gli errori in un file di log. La prima contiene il nome usato per
3146 lanciare il programma dalla shell ed in sostanza è equivalente ad
3147 \code{argv[0]}; la seconda mantiene solo il nome del programma eliminando
3148 eventuali directory qualora questo sia stato lanciato con un
3149 \textit{pathname}.
3150
3151 Una seconda estensione cerca di risolvere uno dei problemi che si hanno con
3152 l'uso di \func{perror}, dovuto al fatto che non c'è flessibilità su quello che
3153 si può aggiungere al messaggio di errore, che può essere solo una stringa. In
3154 molte occasioni invece serve poter scrivere dei messaggi con maggiori
3155 informazioni. Ad esempio negli standard di programmazione GNU si richiede che
3156 ogni messaggio di errore sia preceduto dal nome del programma, ed in generale
3157 si può voler stampare il contenuto di qualche variabile per facilitare la
3158 comprensione di un eventuale problema. Per questo la \acr{glibc} definisce
3159 la funzione \funcd{error}, il cui prototipo è:
3160
3161 \begin{funcproto}{
3162 \fhead{stdio.h}
3163 \fdecl{void error(int status, int errnum, const char *format, ...)}
3164 \fdesc{Stampa un messaggio di errore formattato.} 
3165 }
3166
3167 {La funzione non ritorna nulla e non riporta errori.}  
3168 \end{funcproto}
3169
3170 La funzione fa parte delle estensioni GNU per la gestione degli errori,
3171 l'argomento \param{format} segue la stessa sintassi di \func{printf} (vedi
3172 sez.~\ref{sec:file_formatted_io}), ed i relativi argomenti devono essere
3173 forniti allo stesso modo, mentre \param{errnum} indica l'errore che si vuole
3174 segnalare (non viene quindi usato il valore corrente di \var{errno}).
3175
3176 La funzione stampa sullo \textit{standard error} il nome del programma, come
3177 indicato dalla variabile globale \var{program\_name}, seguito da due punti ed
3178 uno spazio, poi dalla stringa generata da \param{format} e dagli argomenti
3179 seguenti, seguita da due punti ed uno spazio infine il messaggio di errore
3180 relativo ad \param{errnum}, il tutto è terminato da un a capo.
3181
3182 Il comportamento della funzione può essere ulteriormente controllato se si
3183 definisce una variabile \var{error\_print\_progname} come puntatore ad una
3184 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
3185 il nome del programma. 
3186
3187 L'argomento \param{status} può essere usato per terminare direttamente il
3188 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
3189 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
3190 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
3191 un'altra variabile globale, \var{error\_message\_count}, che tiene conto di
3192 quanti errori ci sono stati.
3193
3194 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
3195 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
3196 l'errore è \funcd{error\_at\_line}; il suo prototipo è:
3197
3198 \begin{funcproto}{
3199 \fhead{stdio.h}
3200 \fdecl{void error\_at\_line(int status, int errnum, const char *fname, 
3201   unsigned int lineno, \\
3202 \phantom{void error\_at\_line(}const char *format, ...)}
3203 \fdesc{Stampa un messaggio di errore formattato.} 
3204 }
3205
3206 {La funzione non ritorna nulla e non riporta errori.}  
3207 \end{funcproto}
3208
3209 \noindent ed il suo comportamento è identico a quello di \func{error} se non
3210 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
3211 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
3212 stampa del nome del programma. Inoltre essa usa un'altra variabile globale,
3213 \var{error\_one\_per\_line}, che impostata ad un valore diverso da zero fa sì
3214 che errori relativi alla stessa linea non vengano ripetuti.
3215
3216
3217 % LocalWords:  filesystem like kernel saved header limits sysconf sez tab float
3218 % LocalWords:  FOPEN stdio MB LEN CHAR char UCHAR unsigned SCHAR MIN signed INT
3219 % LocalWords:  SHRT short USHRT int UINT LONG long ULONG LLONG ULLONG POSIX ARG
3220 % LocalWords:  Stevens exec CHILD STREAM stream TZNAME timezone NGROUPS SSIZE
3221 % LocalWords:  ssize LISTIO JOB CONTROL job control IDS VERSION YYYYMML bits bc
3222 % LocalWords:  dall'header posix lim nell'header glibc run unistd name errno SC
3223 % LocalWords:  NGROUP CLK TCK clock tick process PATH pathname BUF CANON path
3224 % LocalWords:  pathconf fpathconf descriptor fd uname sys struct utsname info
3225 % LocalWords:  EFAULT fig SOURCE NUL LENGTH DOMAIN NMLN UTSLEN system call proc
3226 % LocalWords:  domainname sysctl BSD nlen void oldval size oldlenp newval EPERM
3227 % LocalWords:  newlen ENOTDIR EINVAL ENOMEM linux array oldvalue paging stack
3228 % LocalWords:  TCP shell Documentation ostype hostname osrelease version mount
3229 % LocalWords:  const source filesystemtype mountflags ENODEV ENOTBLK block read
3230 % LocalWords:  device EBUSY only EACCES NODEV ENXIO major RTSIG syscall PID 
3231 % LocalWords:  number EMFILE dummy ENAMETOOLONG ENOENT ELOOP virtual devfs MGC
3232 % LocalWords:  magic MSK RDONLY NOSUID suid sgid NOEXEC SYNCHRONOUS REMOUNT MNT
3233 % LocalWords:  MANDLOCK mandatory locking WRITE APPEND append IMMUTABLE NOATIME
3234 % LocalWords:  access NODIRATIME BIND MOVE umount flags FORCE statfs fstatfs ut
3235 % LocalWords:  buf ENOSYS EIO EBADF type fstab mntent home shadow username uid
3236 % LocalWords:  passwd PAM Pluggable Authentication Method Service Switch pwd ru
3237 % LocalWords:  getpwuid getpwnam NULL buflen result ERANGE getgrnam getgrgid AS
3238 % LocalWords:  grp group gid SVID fgetpwent putpwent getpwent setpwent endpwent
3239 % LocalWords:  fgetgrent putgrent getgrent setgrent endgrent accounting init HZ
3240 % LocalWords:  runlevel Hierarchy logout setutent endutent utmpname utmp paths
3241 % LocalWords:  WTMP getutent getutid getutline pututline LVL OLD DEAD EMPTY dev
3242 % LocalWords:  line libc XPG utmpx getutxent getutxid getutxline pututxline who
3243 % LocalWords:  setutxent endutxent wmtp updwtmp logwtmp wtmp host rusage utime
3244 % LocalWords:  minflt majflt nswap fault swap timeval wait getrusage usage SELF
3245 % LocalWords:  CHILDREN current limit soft RLIMIT address brk mremap mmap dump
3246 % LocalWords:  SIGSEGV SIGXCPU SIGKILL sbrk FSIZE SIGXFSZ EFBIG LOCKS lock dup
3247 % LocalWords:  MEMLOCK NOFILE NPROC fork EAGAIN SIGPENDING sigqueue kill RSS tv
3248 % LocalWords:  resource getrlimit setrlimit rlimit rlim INFINITY capabilities
3249 % LocalWords:  capability CAP Sun Sparc PAGESIZE getpagesize SVr SUSv get IGN
3250 % LocalWords:  phys pages avphys NPROCESSORS CONF ONLN getloadavg stdlib double
3251 % LocalWords:  loadavg nelem scheduler CONFIG ACCT acct filename EUSER sizeof
3252 % LocalWords:  ENFILE EROFS PACCT AcctCtrl cap calendar UTC Jan the Epoch GMT
3253 % LocalWords:  Greenwich Mean l'UTC timer CLOCKS SEC cron wall elapsed times tz
3254 % LocalWords:  tms cutime cstime waitpid gettimeofday settimeofday timex NetBSD
3255 % LocalWords:  timespec adjtime olddelta adjtimex David Mills RFC NTP ntp cmd
3256 % LocalWords:  nell'RFC ADJ FREQUENCY frequency MAXERROR maxerror ESTERROR PLL
3257 % LocalWords:  esterror TIMECONST constant SINGLESHOT MOD INS insert leap OOP
3258 % LocalWords:  second delete progress has occurred BAD broken tm gmtoff asctime
3259 % LocalWords:  ctime timep gmtime localtime mktime tzname tzset daylight format
3260 % LocalWords:  strftime thread EOF modifiable lvalue app errcode strerror LC at
3261 % LocalWords:  perror string errnum MESSAGES error message strtol log jiffy asm
3262 % LocalWords:  program invocation argv printf print progname exit count fname
3263 % LocalWords:  lineno one standardese Di page Wed Wednesday Apr April PM AM CAD
3264 % LocalWords:  CEST utmpxname Solaris updwtmpx reboot RESTART Ctrl OFF SIGINT
3265 % LocalWords:  HALT halted sync KEXEC kexec load bootloader POWER Power with nr
3266 % LocalWords:  Restarting command arg entry segments segment ARCH CRASH CONTEXT
3267 % LocalWords:  PRESERVE PPC IA ARM SH MIPS nvcsw nivcsw inblock oublock maxrss
3268 % LocalWords:  context switch slice Resident SIG SIGCHLD cur Gb lease mlock Hz
3269 % LocalWords:  memory mlockall MAP LOCKED shmctl MSGQUEUE attr NICE nice MADV
3270 % LocalWords:  madvise WILLNEED RTPRIO sched setscheduler setparam scheduling
3271 % LocalWords:  RTTIME execve kb prlimit pid new old ESRCH EUSERS refresh high
3272 % LocalWords:  resolution HRT jiffies strptime
3273
3274 %%% Local Variables: 
3275 %%% mode: latex
3276 %%% TeX-master: "gapil"
3277 %%% End: