3 %% Copyright (C) 2000-2012 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
12 \chapter{La gestione del sistema, del tempo e degli errori}
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
24 \section{Capacità e caratteristiche del sistema}
25 \label{sec:sys_characteristics}
27 In questa sezione tratteremo le varie modalità con cui un programma può
28 ottenere informazioni riguardo alle capacità del sistema. Ogni sistema
29 unix-like infatti è contraddistinto da un gran numero di limiti e costanti che
30 lo caratterizzano, e che possono dipendere da fattori molteplici, come
31 l'architettura hardware, l'implementazione del kernel e delle librerie, le
32 opzioni di configurazione.
34 La definizione di queste caratteristiche ed il tentativo di provvedere dei
35 meccanismi generali che i programmi possono usare per ricavarle è uno degli
36 aspetti più complessi e controversi con cui le diverse standardizzazioni si
37 sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
38 Daremo comunque una descrizione dei principali metodi previsti dai vari
39 standard per ricavare sia le caratteristiche specifiche del sistema, che
40 quelle della gestione dei file.
43 \subsection{Limiti e parametri di sistema}
44 \label{sec:sys_limits}
46 Quando si devono determinare le caratteristiche generali del sistema ci si
47 trova di fronte a diverse possibilità; alcune di queste infatti possono
48 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
49 interi), o dal sistema operativo (come la presenza o meno del gruppo degli
50 identificatori \textit{saved}), altre invece possono dipendere dalle opzioni
51 con cui si è costruito il sistema (ad esempio da come si è compilato il
52 kernel), o dalla configurazione del medesimo; per questo motivo in generale
53 sono necessari due tipi diversi di funzionalità:
55 \item la possibilità di determinare limiti ed opzioni al momento della
57 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
60 La prima funzionalità si può ottenere includendo gli opportuni header file che
61 contengono le costanti necessarie definite come macro di preprocessore, per la
62 seconda invece sono ovviamente necessarie delle funzioni. La situazione è
63 complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
64 sono fissi in un'implementazione mentre possono variare in un altra. Tutto
65 questo crea una ambiguità che non è sempre possibile risolvere in maniera
66 chiara; in generale quello che succede è che quando i limiti del sistema sono
67 fissi essi vengono definiti come macro di preprocessore nel file
68 \headfile{limits.h}, se invece possono variare, il loro valore sarà ottenibile
69 tramite la funzione \func{sysconf} (che esamineremo in
70 sez.~\ref{sec:sys_sysconf}).
72 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
73 saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
74 da \headfile{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si
75 può vedere per la maggior parte questi limiti attengono alle dimensioni dei
76 dati interi, che sono in genere fissati dall'architettura hardware (le
77 analoghe informazioni per i dati in virgola mobile sono definite a parte, ed
78 accessibili includendo \headfile{float.h}). Lo standard prevede anche un'altra
79 costante, \const{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
80 definita in \headfile{limits.h}; essa deve essere definita in
81 \headfile{stdio.h} ed avere un valore minimo di 8.
86 \begin{tabular}[c]{|l|r|l|}
88 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
91 \const{MB\_LEN\_MAX}& 16 & Massima dimensione di un
93 \const{CHAR\_BIT} & 8 & Numero di bit di \ctyp{char}.\\
94 \const{UCHAR\_MAX}& 255 & Massimo di \ctyp{unsigned char}.\\
95 \const{SCHAR\_MIN}& -128 & Minimo di \ctyp{signed char}.\\
96 \const{SCHAR\_MAX}& 127 & Massimo di \ctyp{signed char}.\\
97 \const{CHAR\_MIN} &\footnotemark& Minimo di \ctyp{char}.\\
98 \const{CHAR\_MAX} &\footnotemark& Massimo di \ctyp{char}.\\
99 \const{SHRT\_MIN} & -32768 & Minimo di \ctyp{short}.\\
100 \const{SHRT\_MAX} & 32767 & Massimo di \ctyp{short}.\\
101 \const{USHRT\_MAX}& 65535 & Massimo di \ctyp{unsigned short}.\\
102 \const{INT\_MAX} & 2147483647 & Minimo di \ctyp{int}.\\
103 \const{INT\_MIN} &-2147483648 & Minimo di \ctyp{int}.\\
104 \const{UINT\_MAX} & 4294967295 & Massimo di \ctyp{unsigned int}.\\
105 \const{LONG\_MAX} & 2147483647 & Massimo di \ctyp{long}.\\
106 \const{LONG\_MIN} &-2147483648 & Minimo di \ctyp{long}.\\
107 \const{ULONG\_MAX}& 4294967295 & Massimo di \ctyp{unsigned long}.\\
110 \caption{Costanti definite in \headfile{limits.h} in conformità allo standard
112 \label{tab:sys_ansic_macro}
115 \footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
116 sistema usi caratteri con segno o meno.}
118 \footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
119 a seconda che il sistema usi caratteri con segno o meno.}
121 A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
122 \ctyp{long long} introdotto con il nuovo standard, i relativi valori sono in
123 tab.~\ref{tab:sys_isoc90_macro}.
128 \begin{tabular}[c]{|l|r|l|}
130 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
133 \const{LLONG\_MAX}& 9223372036854775807& Massimo di \ctyp{long long}.\\
134 \const{LLONG\_MIN}&-9223372036854775808& Minimo di \ctyp{long long}.\\
135 \const{ULLONG\_MAX}&18446744073709551615&
136 Massimo di \ctyp{unsigned long long}.\\
139 \caption{Macro definite in \headfile{limits.h} in conformità allo standard
141 \label{tab:sys_isoc90_macro}
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}.
151 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
152 meno chiare\footnote{tanto che Stevens, in \cite{APUE}, la porta come esempio
153 di ``\textsl{standardese}''.}. Lo standard prevede che ci siano 13 macro che
154 descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
155 riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
156 file, riportate in tab.~\ref{tab:sys_file_macro}).
161 \begin{tabular}[c]{|l|r|p{7cm}|}
163 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
166 \const{ARG\_MAX} &131072& Dimensione massima degli argomenti
167 passati ad una funzione della famiglia
169 \const{CHILD\_MAX} & 999& Numero massimo di processi contemporanei
170 che un utente può eseguire.\\
171 \const{OPEN\_MAX} & 256& Numero massimo di file che un processo
172 può mantenere aperti in contemporanea.\\
173 \const{STREAM\_MAX}& 8& Massimo numero di stream aperti per
174 processo in contemporanea.\\
175 \const{TZNAME\_MAX}& 6& Dimensione massima del nome di una
176 \texttt{timezone} (vedi
177 sez.~\ref{sec:sys_time_base})).\\
178 \const{NGROUPS\_MAX}& 32& Numero di gruppi supplementari per
179 processo (vedi sez.~\ref{sec:proc_access_id}).\\
180 \const{SSIZE\_MAX}&32767& Valore massimo del tipo \type{ssize\_t}.\\
183 \caption{Costanti per i limiti del sistema.}
184 \label{tab:sys_generic_macro}
187 Lo standard dice che queste macro devono essere definite in
188 \headfile{limits.h} quando i valori a cui fanno riferimento sono fissi, e
189 altrimenti devono essere lasciate indefinite, ed i loro valori dei limiti
190 devono essere accessibili solo attraverso \func{sysconf}. In realtà queste
191 vengono sempre definite ad un valore generico. Si tenga presente poi che
192 alcuni di questi limiti possono assumere valori molto elevati (come
193 \const{CHILD\_MAX}), e non è pertanto il caso di utilizzarli per allocare
194 staticamente della memoria.
196 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
197 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
198 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
199 implementazione possa dichiararsi conforme allo standard; detti valori sono
200 riportati in tab.~\ref{tab:sys_posix1_general}.
205 \begin{tabular}[c]{|l|r|p{7cm}|}
207 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
210 \const{\_POSIX\_ARG\_MAX} & 4096& Dimensione massima degli argomenti
211 passati ad una funzione della famiglia
213 \const{\_POSIX\_CHILD\_MAX} & 6& Numero massimo di processi
214 contemporanei che un utente può
216 \const{\_POSIX\_OPEN\_MAX} & 16& Numero massimo di file che un processo
217 può mantenere aperti in
219 \const{\_POSIX\_STREAM\_MAX} & 8& Massimo numero di stream aperti per
220 processo in contemporanea.\\
221 \const{\_POSIX\_TZNAME\_MAX} & & Dimensione massima del nome di una
222 \textit{timezone} (vedi
223 sez.~\ref{sec:sys_date}). \\
224 \const{\_POSIX\_NGROUPS\_MAX}& 0& Numero di gruppi supplementari per
226 sez.~\ref{sec:proc_access_id}).\\
227 \const{\_POSIX\_SSIZE\_MAX} &32767& Valore massimo del tipo
229 \const{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
230 \const{\_POSIX\_AIO\_MAX} & 1& \\
233 \caption{Macro dei valori minimi delle caratteristiche generali del sistema
234 per la conformità allo standard POSIX.1.}
235 \label{tab:sys_posix1_general}
238 In genere questi valori non servono a molto, la loro unica utilità è quella di
239 indicare un limite superiore che assicura la portabilità senza necessità di
240 ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
241 i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
242 valori ottenuti da \func{sysconf}.
247 \begin{tabular}[c]{|l|p{8cm}|}
249 \textbf{Macro}&\textbf{Significato}\\
252 \macro{\_POSIX\_JOB\_CONTROL}& Il sistema supporta il
253 \textit{job control} (vedi
254 sez.~\ref{sec:sess_job_control}).\\
255 \macro{\_POSIX\_SAVED\_IDS} & Il sistema supporta gli identificatori del
256 gruppo \textit{saved} (vedi
257 sez.~\ref{sec:proc_access_id})
258 per il controllo di accesso dei processi\\
259 \const{\_POSIX\_VERSION} & Fornisce la versione dello standard POSIX.1
260 supportata nel formato YYYYMML (ad esempio
264 \caption{Alcune macro definite in \headfile{limits.h} in conformità allo
266 \label{tab:sys_posix1_other}
269 Oltre ai precedenti valori (e a quelli relativi ai file elencati in
270 tab.~\ref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
271 lo standard POSIX.1 ne prevede parecchi altri. La lista completa si trova
272 dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
273 incluso automaticamente all'interno di \headfile{limits.h}). Di questi vale la
274 pena menzionare alcune macro di uso comune, (riportate in
275 tab.~\ref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
276 denotano la presenza di alcune funzionalità nel sistema (come il supporto del
277 \textit{job control} o degli identificatori del gruppo \textit{saved}).
279 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
280 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
281 alle applicazioni di sistema presenti (come quelli su alcuni parametri delle
282 espressioni regolari o del comando \cmd{bc}), non li tratteremo
283 esplicitamente, se ne trova una menzione completa nell'header file
284 \file{bits/posix2\_lim.h}, e alcuni di loro sono descritti nella pagina di
285 manuale di \func{sysconf} e nel manuale delle \acr{glibc}.
288 \subsection{La funzione \func{sysconf}}
289 \label{sec:sys_sysconf}
291 Come accennato in sez.~\ref{sec:sys_limits} quando uno dei limiti o delle
292 caratteristiche del sistema può variare, per non dover essere costretti a
293 ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
294 compilato il kernel, o alcuni dei parametri modificabili a run time, è
295 necessario ottenerne il valore attraverso la funzione \funcd{sysconf}. Il
296 prototipo di questa funzione è:
297 \begin{prototype}{unistd.h}{long sysconf(int name)}
298 Restituisce il valore del parametro di sistema \param{name}.
300 \bodydesc{La funzione restituisce indietro il valore del parametro
301 richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
302 è disponibile e -1 in caso di errore (ma \var{errno} non viene impostata).}
305 La funzione prende come argomento un intero che specifica quale dei limiti si
306 vuole conoscere; uno specchietto contenente i principali valori disponibili in
307 Linux è riportato in tab.~\ref{tab:sys_sysconf_par}; l'elenco completo è
308 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
309 relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
314 \begin{tabular}[c]{|l|l|p{9cm}|}
316 \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
319 \texttt{\_SC\_ARG\_MAX} & \const{ARG\_MAX}&
320 La dimensione massima degli argomenti passati
321 ad una funzione della famiglia \func{exec}.\\
322 \texttt{\_SC\_CHILD\_MAX} & \const{\_CHILD\_MAX}&
323 Il numero massimo di processi contemporanei
324 che un utente può eseguire.\\
325 \texttt{\_SC\_OPEN\_MAX} & \const{\_OPEN\_MAX}&
326 Il numero massimo di file che un processo può
327 mantenere aperti in contemporanea.\\
328 \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
329 Il massimo numero di stream che un processo
330 può mantenere aperti in contemporanea. Questo
331 limite previsto anche dallo standard ANSI C,
332 che specifica la macro {FOPEN\_MAX}.\\
333 \texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
334 La dimensione massima di un nome di una
335 \texttt{timezone} (vedi
336 sez.~\ref{sec:sys_date}).\\
337 \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
338 Massimo numero di gruppi supplementari che
339 può avere un processo (vedi
340 sez.~\ref{sec:proc_access_id}).\\
341 \texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}&
342 Valore massimo del tipo di dato
344 \texttt{\_SC\_CLK\_TCK} & \const{CLK\_TCK} &
345 Il numero di \itindex{clock~tick}
346 \textit{clock tick} al secondo,
347 cioè l'unità di misura del
348 \itindex{process~time} \textit{process
350 sez.~\ref{sec:sys_unix_time}).\\
351 \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
352 Indica se è supportato il \textit{job
354 sez.~\ref{sec:sess_job_control}) in stile
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} & \const{\_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.\\
368 \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
369 \label{tab:sys_sysconf_par}
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 valore si otterrà
375 specificando come valore dell'argomento \param{name} il nome ottenuto
376 aggiungendo \code{\_SC\_} ai nomi delle macro definite dai primi due, o
377 sostituendolo a \code{\_POSIX\_} per le macro definite dagli gli altri due.
379 In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
380 macro non è definita, quindi con un codice analogo al seguente:
381 \includecodesnip{listati/get_child_max.c}
382 ma in realtà in Linux queste macro sono comunque definite, indicando però un
383 limite generico. Per questo motivo è sempre meglio usare i valori restituiti
387 \subsection{I limiti dei file}
388 \label{sec:sys_file_limits}
390 Come per le caratteristiche generali del sistema anche per i file esistono una
391 serie di limiti (come la lunghezza del nome del file o il numero massimo di
392 link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
393 in questo caso lo standard prevede alcune macro che ne specificano il valore,
394 riportate in tab.~\ref{tab:sys_file_macro}.
399 \begin{tabular}[c]{|l|r|l|}
401 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
404 \const{LINK\_MAX} &8 & Numero massimo di link a un file.\\
405 \const{NAME\_MAX}& 14 & Lunghezza in byte di un nome di file. \\
406 \const{PATH\_MAX}& 256 & Lunghezza in byte di un
407 \itindex{pathname} \textit{pathname}.\\
408 \const{PIPE\_BUF}&4096 & Byte scrivibili atomicamente in una pipe
409 (vedi sez.~\ref{sec:ipc_pipes}).\\
410 \const{MAX\_CANON}&255 & Dimensione di una riga di terminale in modo
411 canonico (vedi sez.~\ref{sec:term_design}).\\
412 \const{MAX\_INPUT}&255 & Spazio disponibile nella coda di input
414 sez.~\ref{sec:term_design}).\\
417 \caption{Costanti per i limiti sulle caratteristiche dei file.}
418 \label{tab:sys_file_macro}
421 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
422 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
423 conforme deve rispettare; le relative macro sono riportate in
424 tab.~\ref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per
425 le analoghe di tab.~\ref{tab:sys_posix1_general}.
430 \begin{tabular}[c]{|l|r|l|}
432 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
435 \const{\_POSIX\_LINK\_MAX} &8 & Numero massimo di link a un file.\\
436 \const{\_POSIX\_NAME\_MAX}& 14 & Lunghezza in byte di un nome di file.\\
437 \const{\_POSIX\_PATH\_MAX}& 256 & Lunghezza in byte di un
438 \itindex{pathname} \textit{pathname}.\\
439 \const{\_POSIX\_PIPE\_BUF}& 512 & Byte scrivibili atomicamente in una
441 \const{\_POSIX\_MAX\_CANON}&255 & Dimensione di una riga di
442 terminale in modo canonico.\\
443 \const{\_POSIX\_MAX\_INPUT}&255 & Spazio disponibile nella coda di input
445 % \const{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
446 % \const{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
447 % \const{\_POSIX\_FD\_SETSIZE}& 16 & \\
448 % \const{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
451 \caption{Costanti dei valori minimi delle caratteristiche dei file per la
452 conformità allo standard POSIX.1.}
453 \label{tab:sys_posix1_file}
456 Tutti questi limiti sono definiti in \headfile{limits.h}; come nel caso
457 precedente il loro uso è di scarsa utilità in quanto ampiamente superati in
458 tutte le implementazioni moderne.
461 \subsection{La funzione \func{pathconf}}
462 \label{sec:sys_pathconf}
464 In generale i limiti per i file sono molto più soggetti ad essere variabili
465 rispetto ai limiti generali del sistema; ad esempio parametri come la
466 lunghezza del nome del file o il numero di link possono variare da filesystem
467 a filesystem; per questo motivo questi limiti devono essere sempre controllati
468 con la funzione \funcd{pathconf}, il cui prototipo è:
469 \begin{prototype}{unistd.h}{long pathconf(char *path, int name)}
470 Restituisce il valore del parametro \param{name} per il file \param{path}.
472 \bodydesc{La funzione restituisce indietro il valore del parametro
473 richiesto, o -1 in caso di errore (ed \var{errno} viene impostata ad uno
474 degli errori possibili relativi all'accesso a \param{path}).}
477 E si noti come la funzione in questo caso richieda un argomento che specifichi
478 a quale file si fa riferimento, dato che il valore del limite cercato può
479 variare a seconda del filesystem. Una seconda versione della funzione,
480 \funcd{fpathconf}, opera su un file descriptor invece che su un
481 \itindex{pathname} \textit{pathname}. Il suo prototipo è:
482 \begin{prototype}{unistd.h}{long fpathconf(int fd, int name)}
483 Restituisce il valore del parametro \param{name} per il file \param{fd}.
485 \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
486 invece di un \itindex{pathname} \textit{pathname}; pertanto gli errori
487 restituiti cambiano di conseguenza.}
489 \noindent ed il suo comportamento è identico a quello di \func{pathconf}.
492 \subsection{La funzione \func{uname}}
493 \label{sec:sys_uname}
495 Un'altra funzione che si può utilizzare per raccogliere informazioni sia
496 riguardo al sistema che al computer su cui esso sta girando è \funcd{uname};
498 \begin{prototype}{sys/utsname.h}{int uname(struct utsname *info)}
499 Restituisce informazioni sul sistema nella struttura \param{info}.
501 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
502 fallimento, nel qual caso \var{errno} assumerà il valore \errval{EFAULT}.}
505 La funzione, che viene usata dal comando \cmd{uname}, restituisce le
506 informazioni richieste nella struttura \param{info}; anche questa struttura è
507 definita in \headfile{sys/utsname.h}, secondo quanto mostrato in
508 fig.~\ref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
509 indicano rispettivamente:
511 \item il nome del sistema operativo;
512 \item il nome della release del kernel;
513 \item il nome della versione del kernel;
514 \item il tipo di macchina in uso;
515 \item il nome della stazione;
516 \item il nome del domino.
518 l'ultima informazione è stata aggiunta di recente e non è prevista dallo
519 standard POSIX, essa è accessibile, come mostrato in
520 fig.~\ref{fig:sys_utsname}, solo definendo \macro{\_GNU\_SOURCE}.
523 \footnotesize \centering
524 \begin{minipage}[c]{\textwidth}
525 \includestruct{listati/ustname.h}
528 \caption{La struttura \structd{utsname}.}
529 \label{fig:sys_utsname}
532 In generale si tenga presente che le dimensioni delle stringhe di una
533 struttura \struct{utsname} non è specificata, e che esse sono sempre terminate
534 con NUL; il manuale delle \acr{glibc} indica due diverse dimensioni,
535 \const{\_UTSNAME\_LENGTH} per i campi standard e
536 \const{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
537 altri sistemi usano nomi diversi come \const{SYS\_NMLN} o \const{\_SYS\_NMLN}
538 o \const{UTSLEN} che possono avere valori diversi.\footnote{nel caso di Linux
539 \func{uname} corrisponde in realtà a 3 system call diverse, le prime due
540 usano rispettivamente delle lunghezze delle stringhe di 9 e 65 byte; la
541 terza usa anch'essa 65 byte, ma restituisce anche l'ultimo campo,
542 \var{domainname}, con una lunghezza di 257 byte.}
545 \section{Opzioni e configurazione del sistema}
546 \label{sec:sys_config}
548 Come abbiamo accennato nella sezione precedente, non tutti i limiti che
549 caratterizzano il sistema sono fissi, o perlomeno non lo sono in tutte le
550 implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
551 di esaminare il meccanismo che permette, quando questi possono variare durante
552 l'esecuzione del sistema, di modificarli.
554 Inoltre, al di la di quelli che possono essere limiti caratteristici previsti
555 da uno standard, ogni sistema può avere una sua serie di altri parametri di
556 configurazione, che, non essendo mai fissi e variando da sistema a sistema,
557 non sono stati inclusi nella standardizzazione della sezione precedente. Per
558 questi occorre, oltre al meccanismo di impostazione, pure un meccanismo di
559 lettura. Affronteremo questi argomenti in questa sezione, insieme alle
560 funzioni che si usano per il controllo di altre caratteristiche generali del
561 sistema, come quelle per la gestione dei filesystem e di utenti e gruppi.
563 % TODO ristrutturare ?
565 \subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
566 \label{sec:sys_sysctl}
568 La funzione che permette la lettura ed l'impostazione dei parametri del
569 sistema è \funcd{sysctl}; è una funzione derivata da BSD4.4, ma
570 l'implementazione è specifica di Linux; il suo prototipo è:
573 \funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
574 *newval, size\_t newlen)}
576 Legge o scrive uno dei parametri di sistema.
578 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
579 errore, nel qual caso \var{errno} assumerà uno dei valori:
581 \item[\errcode{EPERM}] non si ha il permesso di accedere ad uno dei
582 componenti nel cammino specificato per il parametro, o di accedere al
583 parametro nella modalità scelta.
584 \item[\errcode{ENOTDIR}] non esiste un parametro corrispondente al nome
586 % \item[\errcode{EFAULT}] si è specificato \param{oldlenp} zero quando
587 % \param{oldval} è non nullo.
588 \item[\errcode{EINVAL}] o si è specificato un valore non valido per il
589 parametro che si vuole impostare o lo spazio provvisto per il ritorno di un
590 valore non è delle giuste dimensioni.
591 \item[\errcode{ENOMEM}] talvolta viene usato più correttamente questo errore
592 quando non si è specificato sufficiente spazio per ricevere il valore di un
595 ed inoltre \errval{EFAULT}.
599 I parametri a cui la funzione permettere di accedere sono organizzati in
600 maniera gerarchica all'interno di un albero;\footnote{si tenga presente che
601 includendo solo \headfile{unistd.h}, saranno definiti solo i parametri
602 generici; dato che ce ne sono molti specifici dell'implementazione, nel caso
603 di Linux occorrerà includere anche i file \file{linux/unistd.h} e
604 \file{linux/sysctl.h}.} per accedere ad uno di essi occorre specificare un
605 cammino attraverso i vari nodi dell'albero, in maniera analoga a come avviene
606 per la risoluzione di un \itindex{pathname} \textit{pathname} (da cui l'uso
607 alternativo del filesystem \file{/proc}, che vedremo dopo).
609 Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
610 arriva ad identificare un parametro specifico è passato alla funzione
611 attraverso l'array \param{name}, di lunghezza \param{nlen}, che contiene la
612 sequenza dei vari nodi da attraversare. Ogni parametro ha un valore in un
613 formato specifico che può essere un intero, una stringa o anche una struttura
614 complessa, per questo motivo i valori vengono passati come puntatori
617 L'indirizzo a cui il valore corrente del parametro deve essere letto è
618 specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
619 \param{oldlenp} (passato come puntatore per avere indietro la dimensione
620 effettiva di quanto letto); il valore che si vuole impostare nel sistema è
621 passato in \param{newval} e la sua dimensione in \param{newlen}.
623 Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
624 valore letto restituito dalla funzione è quello precedente alla scrittura.
626 I parametri accessibili attraverso questa funzione sono moltissimi, e possono
627 essere trovati in \headfile{sysctl.h}, essi inoltre dipendono anche dallo
628 stato corrente del kernel (ad esempio dai moduli che sono stati caricati nel
629 sistema) e in genere i loro nomi possono variare da una versione di kernel
630 all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
631 quando esistono modalità alternative per ottenere le stesse informazioni.
632 Alcuni esempi di parametri ottenibili sono:
634 \item il nome di dominio
635 \item i parametri del meccanismo di \textit{paging}.
636 \item il filesystem montato come radice
637 \item la data di compilazione del kernel
638 \item i parametri dello stack TCP
639 \item il numero massimo di file aperti
642 Come accennato in Linux si ha una modalità alternativa per accedere alle
643 stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
644 \file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
645 kernel, che non fa riferimento a nessun dispositivo fisico, ma presenta in
646 forma di file alcune delle strutture interne del kernel stesso.
648 In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
649 di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
650 specificando un \itindex{pathname} \textit{pathname} e leggendo e scrivendo sul
651 file corrispondente al parametro scelto. Il kernel si occupa di generare al
652 volo il contenuto ed i nomi dei file corrispondenti, e questo ha il grande
653 vantaggio di rendere accessibili i vari parametri a qualunque comando di shell
654 e di permettere la navigazione dell'albero dei valori.
656 Alcune delle corrispondenze dei file presenti in \file{/proc/sys} con i valori
657 di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
658 in \file{linux/sysctl.h},\footnote{indicando un file di definizioni si fa
659 riferimento alla directory standard dei file di include, che in ogni
660 distribuzione che si rispetti è \file{/usr/include}.} la informazione
661 disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
662 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
664 Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc} sono
665 disponibili moltissime altre informazioni, fra cui ad esempio anche quelle
666 fornite da \func{uname} (vedi sez.~\ref{sec:sys_uname}) che sono mantenute nei
667 file \sysctlrelfile{kernel}{ostype}, \sysctlrelfile{kernel}{hostname},
668 \sysctlrelfile{kernel}{osrelease}, \sysctlrelfile{kernel}{version} e
669 \sysctlrelfile{kernel}{domainname} di \file{/proc/sys/kernel/}.
673 % TODO documentare keyctl ????
674 % (fare sezione dedicata ????)
675 %\subsection{La gestione delle chiavi crittografiche}
676 %\label{sec:keyctl_management}
679 % \subsection{La gestione dello spegnimento e del riavvio}
680 %\label{sec:sys_reboot}
681 % TODO trattare reboot, kexec_load, ...
684 \subsection{La gestione delle informazioni su utenti e gruppi}
685 \label{sec:sys_user_group}
687 Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
688 (password, corrispondenze fra nomi simbolici e user-id, home directory, ecc.)
689 venivano registrate all'interno dei due file di testo \conffile{/etc/passwd}
690 ed \conffile{/etc/group},\footnote{in realtà oltre a questi nelle
691 distribuzioni più recenti è stato introdotto il sistema delle \textit{shadow
692 password} che prevede anche i due file \conffile{/etc/shadow} e
693 \conffile{/etc/gshadow}, in cui sono state spostate le informazioni di
694 autenticazione (ed inserite alcune estensioni) per toglierle dagli altri
695 file che devono poter essere letti per poter effettuare l'associazione fra
696 username e \ids{UID}.} il cui formato è descritto dalle relative pagine del
697 manuale\footnote{nella quinta sezione, quella dei file di configurazione,
698 occorre cioè usare \cmd{man 5 passwd} dato che altrimenti si avrebbe la
699 pagina di manuale del comando \cmd{passwd}.} e tutte le funzioni che
700 richiedevano l'accesso a queste informazione andavano a leggere direttamente
701 il contenuto di questi file.
703 Col tempo però questa impostazione ha incominciato a mostrare dei limiti: da
704 una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
705 la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
706 che sta per \textit{Pluggable Authentication Method}) che fornisce una
707 interfaccia comune per i processi di autenticazione,\footnote{il
708 \textit{Pluggable Authentication Method} è un sistema modulare, in cui è
709 possibile utilizzare anche più meccanismi insieme, diventa così possibile
710 avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
711 diversi formati per le password e diversi supporti per le informazioni, il
712 tutto in maniera trasparente per le applicazioni purché per ciascun
713 meccanismo si disponga della opportuna libreria che implementa l'interfaccia
714 di PAM.} svincolando completamente le singole applicazione dai dettagli del
715 come questa viene eseguita e di dove vengono mantenuti i dati relativi;
716 dall'altra con il diffondersi delle reti la necessità di centralizzare le
717 informazioni degli utenti e dei gruppi per insiemi di macchine, in modo da
718 mantenere coerenti i dati, ha portato anche alla necessità di poter recuperare
719 e memorizzare dette informazioni su supporti diversi, introducendo il sistema
720 del \itindex{Name~Service~Switch} \textit{Name Service Switch} che tratteremo
721 brevemente più avanti (in sez.~\ref{sec:sock_resolver}) dato che la maggior
722 parte delle sua applicazioni sono relative alla risoluzioni di nomi di rete.
724 In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
725 per la lettura delle informazioni relative a utenti e gruppi tralasciando
726 completamente quelle relative all'autenticazione.
727 % Per questo non tratteremo
728 % affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
729 % \textit{Name Service Switch}, un meccanismo messo a disposizione dalle
730 % \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
731 % necessario trovare una corrispondenza fra un nome ed un numero (od altra
732 % informazione) ad esso associato, come appunto, quella fra uno username ed un
733 % \ids{UID} o fra un \ids{GID} ed il nome del gruppo corrispondente.
734 Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
735 queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
736 Service Switch}, per cui sono in grado di ricevere informazioni qualunque
737 sia il supporto su cui esse vengono mantenute. Per leggere le informazioni
738 relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
739 \funcd{getpwnam}, i cui prototipi sono:
742 \headdecl{sys/types.h}
743 \funcdecl{struct passwd *getpwuid(uid\_t uid)}
745 \funcdecl{struct passwd *getpwnam(const char *name)}
747 Restituiscono le informazioni relative all'utente specificato.
749 \bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
750 informazioni in caso di successo e \val{NULL} nel caso non sia stato
751 trovato nessun utente corrispondente a quanto specificato.}
754 Le due funzioni forniscono le informazioni memorizzate nel registro degli
755 utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
756 relative all'utente specificato attraverso il suo \ids{UID} o il nome di
757 login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
758 tipo \struct{passwd} la cui definizione (anch'essa eseguita in
759 \headfile{pwd.h}) è riportata in fig.~\ref{fig:sys_passwd_struct}, dove è pure
760 brevemente illustrato il significato dei vari campi.
765 \begin{minipage}[c]{\textwidth}
766 \includestruct{listati/passwd.h}
769 \caption{La struttura \structd{passwd} contenente le informazioni relative ad
770 un utente del sistema.}
771 \label{fig:sys_passwd_struct}
774 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
775 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
776 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
777 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
778 essere \index{funzioni!rientranti} rientranti; per questo motivo ne esistono
779 anche due versioni alternative (denotate dalla solita estensione \code{\_r}),
780 i cui prototipi sono:
784 \headdecl{sys/types.h}
786 \funcdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
787 char *buffer, size\_t buflen, struct passwd **result)}
789 \funcdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
790 *password, char *buffer, size\_t buflen, struct passwd **result)}
792 Restituiscono le informazioni relative all'utente specificato.
794 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
795 altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
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}).
810 Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
811 \funcd{getgrgid} (e le relative analoghe \index{funzioni!rientranti}
812 rientranti con la stessa estensione \code{\_r}) che permettono di leggere le
813 informazioni relative ai gruppi, i loro prototipi sono:
816 \headdecl{sys/types.h}
818 \funcdecl{struct group *getgrgid(gid\_t gid)}
820 \funcdecl{struct group *getgrnam(const char *name)}
822 \funcdecl{struct group *getpwuid\_r(gid\_t gid, struct group *password,
823 char *buffer, size\_t buflen, struct group **result)}
825 \funcdecl{struct group *getpwnam\_r(const char *name, struct group
826 *password, char *buffer, size\_t buflen, struct group **result)}
828 Restituiscono le informazioni relative al gruppo specificato.
830 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
831 altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
834 Il comportamento di tutte queste funzioni è assolutamente identico alle
835 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
836 in questo caso le informazioni vengono restituite in una struttura di tipo
837 \struct{group}, la cui definizione è riportata in
838 fig.~\ref{fig:sys_group_struct}.
843 \begin{minipage}[c]{\textwidth}
844 \includestruct{listati/group.h}
847 \caption{La struttura \structd{group} contenente le informazioni relative ad
848 un gruppo del sistema.}
849 \label{fig:sys_group_struct}
852 Le funzioni viste finora sono in grado di leggere le informazioni sia
853 direttamente dal file delle password in \conffile{/etc/passwd} che tramite il
854 sistema del \itindex{Name~Service~Switch} \textit{Name Service Switch} e sono
855 completamente generiche. Si noti però che non c'è una funzione che permetta di
856 impostare direttamente una password.\footnote{in realtà questo può essere
857 fatto ricorrendo a PAM, ma questo è un altro discorso.} Dato che POSIX non
858 prevede questa possibilità esiste un'altra interfaccia che lo fa, derivata da
859 SVID le cui funzioni sono riportate in tab.~\ref{tab:sys_passwd_func}. Questa
860 però funziona soltanto quando le informazioni sono mantenute su un apposito
861 file di \textsl{registro} di utenti e gruppi, con il formato classico di
862 \conffile{/etc/passwd} e \conffile{/etc/group}.
867 \begin{tabular}[c]{|l|p{8cm}|}
869 \textbf{Funzione} & \textbf{Significato}\\
872 \func{fgetpwent} & Legge una voce dal file di registro degli utenti
874 \func{fgetpwent\_r}& Come la precedente, ma \index{funzioni!rientranti}
876 \func{putpwent} & Immette una voce in un file di registro degli
878 \func{getpwent} & Legge una voce da \conffile{/etc/passwd}.\\
879 \func{getpwent\_r} & Come la precedente, ma \index{funzioni!rientranti}
881 \func{setpwent} & Ritorna all'inizio di \conffile{/etc/passwd}.\\
882 \func{endpwent} & Chiude \conffile{/etc/passwd}.\\
883 \func{fgetgrent} & Legge una voce dal file di registro dei gruppi
885 \func{fgetgrent\_r}& Come la precedente, ma \index{funzioni!rientranti}
887 \func{putgrent} & Immette una voce in un file di registro dei gruppi.\\
888 \func{getgrent} & Legge una voce da \conffile{/etc/group}.\\
889 \func{getgrent\_r} & Come la precedente, ma \index{funzioni!rientranti}
891 \func{setgrent} & Ritorna all'inizio di \conffile{/etc/group}.\\
892 \func{endgrent} & Chiude \conffile{/etc/group}.\\
895 \caption{Funzioni per la manipolazione dei campi di un file usato come
896 registro per utenti o gruppi nel formato di \conffile{/etc/passwd} e
897 \conffile{/etc/group}.}
898 \label{tab:sys_passwd_func}
901 Dato che oramai la gran parte delle distribuzioni di GNU/Linux utilizzano
902 almeno le \textit{shadow password} (quindi con delle modifiche rispetto al
903 formato classico del file \conffile{/etc/passwd}), si tenga presente che le
904 funzioni di questa interfaccia che permettono di scrivere delle voci in un
905 \textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
906 hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
907 questa estensione. Per questo motivo l'uso di queste funzioni è deprecato, in
908 quanto comunque non funzionale, pertanto ci limiteremo a fornire soltanto
909 l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
910 ulteriore. Chi volesse insistere ad usare questa interfaccia può fare
911 riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
912 delle \acr{glibc} per i dettagli del funzionamento.
916 \subsection{Il registro della \textsl{contabilità} degli utenti}
917 \label{sec:sys_accounting}
919 L'ultimo insieme di funzioni relative alla gestione del sistema che
920 esamineremo è quello che permette di accedere ai dati del registro della
921 cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti. In esso
922 vengono mantenute una serie di informazioni storiche relative sia agli utenti
923 che si sono collegati al sistema, (tanto per quelli correntemente collegati,
924 che per la registrazione degli accessi precedenti), sia relative all'intero
925 sistema, come il momento di lancio di processi da parte di \cmd{init}, il
926 cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
929 I dati vengono usualmente\footnote{questa è la locazione specificata dal
930 \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
931 delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
932 \file{/var/log/wtmp}.\footnote{non si confonda quest'ultimo con il simile
933 \file{/var/log/btmp} dove invece vengono memorizzati dal programma di login
934 tutti tentativi di accesso fallito.} Quando un utente si collega viene
935 aggiunta una voce a \file{/var/run/utmp} in cui viene memorizzato il nome di
936 login, il terminale da cui ci si collega, l'\ids{UID} della shell di login,
937 l'orario della connessione ed altre informazioni. La voce resta nel file fino
938 al logout, quando viene cancellata e spostata in \file{/var/log/wtmp}.
940 In questo modo il primo file viene utilizzato per registrare chi sta
941 utilizzando il sistema al momento corrente, mentre il secondo mantiene la
942 registrazione delle attività degli utenti. A quest'ultimo vengono anche
943 aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
944 come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
945 informazioni sono descritte in dettaglio nel manuale delle \acr{glibc}.
947 Questi file non devono mai essere letti direttamente, ma le informazioni che
948 contengono possono essere ricavate attraverso le opportune funzioni di
949 libreria. Queste sono analoghe alle precedenti funzioni (vedi
950 tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
951 solo che in questo caso la struttura del registro della \textsl{contabilità} è
952 molto più complessa, dato che contiene diversi tipi di informazione.
954 Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
955 servono rispettivamente a aprire e a chiudere il file che contiene il
956 registro, e a specificare su quale file esso viene mantenuto. I loro prototipi
961 \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
964 \funcdecl{void setutent(void)} Apre il file del registro, posizionandosi al
967 \funcdecl{void endutent(void)} Chiude il file del registro.
969 \bodydesc{Le funzioni non ritornano codici di errore.}
971 e si tenga presente che le funzioni non restituiscono nessun valore, pertanto
972 non è possibile accorgersi di eventuali errori (ad esempio se si è impostato
973 un nome di file sbagliato con \func{utmpname}).
975 Nel caso non si sia utilizzata \func{utmpname} per specificare un file di
976 registro alternativo, sia \func{setutent} che \func{endutent} operano usando
977 il default che è \sysfile{/var/run/utmp}. Il nome di questo file, così come
978 una serie di altri valori di default per i \textit{pathname} di uso più
979 comune, viene mantenuto nei valori di una serie di costanti definite
980 includendo \headfile{paths.h}, in particolare quelle che ci interessano sono:
981 \begin{basedescript}{\desclabelwidth{2.0cm}}
982 \item[\const{\_PATH\_UTMP}] specifica il file che contiene il registro per gli
983 utenti correntemente collegati; questo è il valore che viene usato se non si
984 è utilizzato \func{utmpname} per modificarlo.
985 \item[\const{\_PATH\_WTMP}] specifica il file che contiene il registro per
986 l'archivio storico degli utenti collegati.
988 che nel caso di Linux hanno un valore corrispondente ai file
989 \sysfile{/var/run/utmp} e \sysfile{/var/log/wtmp} citati in precedenza.
991 Una volta aperto il file del registro degli utenti si può eseguire una
992 scansione leggendo o scrivendo una voce con le funzioni \funcd{getutent},
993 \funcd{getutid}, \funcd{getutline} e \funcd{pututline}, i cui prototipi sono:
997 \funcdecl{struct utmp *getutent(void)}
998 Legge una voce dalla posizione corrente nel registro.
1000 \funcdecl{struct utmp *getutid(struct utmp *ut)} Ricerca una voce sul
1001 registro in base al contenuto di \param{ut}.
1003 \funcdecl{struct utmp *getutline(struct utmp *ut)}
1004 Ricerca nel registro la prima voce corrispondente ad un processo sulla linea
1005 di terminale specificata tramite \param{ut}.
1007 \funcdecl{struct utmp *pututline(struct utmp *ut)}
1008 Scrive una voce nel registro.
1010 \bodydesc{Le funzioni ritornano il puntatore ad una struttura \struct{utmp}
1011 in caso di successo e \val{NULL} in caso di errore.}
1014 Tutte queste funzioni fanno riferimento ad una struttura di tipo
1015 \struct{utmp}, la cui definizione in Linux è riportata in
1016 fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
1017 voce dal registro; \func{getutent} legge semplicemente la prima voce
1018 disponibile; le altre due permettono di eseguire una ricerca.
1021 \begin{figure}[!htb]
1024 \begin{minipage}[c]{\textwidth}
1025 \includestruct{listati/utmp.h}
1028 \caption{La struttura \structd{utmp} contenente le informazioni di una voce
1029 del registro di \textsl{contabilità}.}
1030 \label{fig:sys_utmp_struct}
1033 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1034 campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
1035 riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
1036 \const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
1037 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1038 invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
1039 \const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
1040 corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1045 \begin{tabular}[c]{|l|p{8cm}|}
1047 \textbf{Valore} & \textbf{Significato}\\
1050 \const{EMPTY} & Non contiene informazioni valide.\\
1051 \const{RUN\_LVL} & Identica il runlevel del sistema.\\
1052 \const{BOOT\_TIME} & Identifica il tempo di avvio del sistema.\\
1053 \const{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
1055 \const{NEW\_TIME} & Identifica da quanto è stato modificato il
1057 \const{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
1058 \const{LOGIN\_PROCESS}& Identifica un processo di login.\\
1059 \const{USER\_PROCESS} & Identifica un processo utente.\\
1060 \const{DEAD\_PROCESS} & Identifica un processo terminato.\\
1061 % \const{ACCOUNTING} & ??? \\
1064 \caption{Classificazione delle voci del registro a seconda dei
1065 possibili valori del campo \var{ut\_type}.}
1066 \label{tab:sys_ut_type}
1069 La funzione \func{getutline} esegue la ricerca sulle voci che hanno
1070 \var{ut\_type} uguale a \const{LOGIN\_PROCESS} o \const{USER\_PROCESS},
1071 restituendo la prima che corrisponde al valore di \var{ut\_line}, che
1072 specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
1073 terminale che interessa. Lo stesso criterio di ricerca è usato da
1074 \func{pututline} per trovare uno spazio dove inserire la voce specificata,
1075 qualora non sia trovata la voce viene aggiunta in coda al registro.
1077 In generale occorre però tenere conto che queste funzioni non sono
1078 completamente standardizzate, e che in sistemi diversi possono esserci
1079 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1080 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1081 fornita dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1082 introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
1083 sono un sovrainsieme di \code{utmp}.
1085 Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
1086 inutili queste nuove strutture; pertanto esse e le relative funzioni di
1087 gestione (\func{getutxent}, \func{getutxid}, \func{getutxline},
1088 \func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
1089 sinonimi delle funzioni appena viste.
1091 Come visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
1092 staticamente rende le funzioni di lettura non \index{funzioni!rientranti}
1093 rientranti; per questo motivo le \acr{glibc} forniscono anche delle versioni
1094 \index{funzioni!rientranti} rientranti: \func{getutent\_r}, \func{getutid\_r},
1095 \func{getutline\_r}, che invece di restituire un puntatore restituiscono un
1096 intero e prendono due argomenti aggiuntivi. Le funzioni si comportano
1097 esattamente come le analoghe non \index{funzioni!rientranti} rientranti, solo
1098 che restituiscono il risultato all'indirizzo specificato dal primo argomento
1099 aggiuntivo (di tipo \code{struct utmp *buffer}) mentre il secondo (di tipo
1100 \code{struct utmp **result)} viene usato per restituire il puntatore allo
1103 Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
1104 in \file{wmtp} altre due funzioni, \funcd{updwtmp} e \funcd{logwtmp}, i cui
1109 \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1110 Aggiunge la voce \param{ut} nel registro \file{wmtp}.
1112 \funcdecl{void logwtmp(const char *line, const char *name, const char
1113 *host)} Aggiunge nel registro una voce con i valori specificati.
1116 La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
1117 direttamente una struttura \struct{utmp}, mentre la seconda utilizza gli
1118 argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
1119 poi aggiunge chiamando \func{updwtmp}.
1122 \section{Il controllo dell'uso delle risorse}
1123 \label{sec:sys_res_limits}
1126 Dopo aver esaminato le funzioni che permettono di controllare le varie
1127 caratteristiche, capacità e limiti del sistema a livello globale, in questa
1128 sezione tratteremo le varie funzioni che vengono usate per quantificare le
1129 risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
1130 permettono di imporre a ciascuno di essi vincoli e limiti di
1134 \subsection{L'uso delle risorse}
1135 \label{sec:sys_resource_use}
1137 Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
1138 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1139 di tipo \struct{rusage}, la cui definizione (che si trova in
1140 \headfile{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
1142 \begin{figure}[!htb]
1145 \begin{minipage}[c]{\textwidth}
1146 \includestruct{listati/rusage.h}
1149 \caption{La struttura \structd{rusage} per la lettura delle informazioni dei
1150 delle risorse usate da un processo.}
1151 \label{fig:sys_rusage_struct}
1154 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
1155 da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
1156 \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si trova
1157 nelle opzioni di compilazione del kernel (e di norma è disabilitato) che
1158 serve per mantenere una contabilità delle risorse usate da ciascun processo
1159 in maniera molto più dettagliata.} ma attualmente (con i kernel della serie
1160 2.4.x e 2.6.x) i soli campi che sono mantenuti sono: \var{ru\_utime},
1161 \var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I
1162 primi due indicano rispettivamente il tempo impiegato dal processo
1163 nell'eseguire le istruzioni in user space, e quello impiegato dal kernel nelle
1164 system call eseguite per conto del processo.
1166 Gli altri tre campi servono a quantificare l'uso della memoria
1167 virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
1168 \itindex{page~fault} \textit{page fault} (vedi sez.~\ref{sec:proc_mem_gen})
1169 avvenuti senza richiedere I/O su disco (i cosiddetti \textit{minor page
1170 fault}), a quelli che invece han richiesto I/O su disco (detti invece
1171 \textit{major page fault}) ed al numero di volte che il processo è stato
1172 completamente tolto dalla memoria per essere inserito nello swap.
1174 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
1175 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
1176 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
1177 ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
1178 \struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
1180 Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
1181 visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di risorse
1182 impiegate dal processo di cui si è letto lo stato di terminazione, ma essa può
1183 anche essere letta direttamente utilizzando la funzione \funcd{getrusage}, il
1186 \headdecl{sys/time.h}
1187 \headdecl{sys/resource.h}
1190 \funcdecl{int getrusage(int who, struct rusage *usage)}
1191 Legge la quantità di risorse usate da un processo.
1194 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1195 nel qual caso \var{errno} può essere \errval{EINVAL} o \errval{EFAULT}.}
1198 L'argomento \param{who} permette di specificare il processo di cui si vuole
1199 leggere l'uso delle risorse; esso può assumere solo i due valori
1200 \const{RUSAGE\_SELF} per indicare il processo corrente e
1201 \const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
1202 ricevuto lo stato di terminazione.
1204 % TODO previsto in futuro \const{RUSAGE\_THREAD}, verificare.
1206 \subsection{Limiti sulle risorse}
1207 \label{sec:sys_resource_limit}
1209 Come accennato nell'introduzione il kernel mette a disposizione delle
1210 funzionalità che permettono non solo di mantenere dati statistici relativi
1211 all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
1212 utilizzo da parte dei vari processi o degli utenti.
1214 Per far questo esistono una serie di risorse e ad ogni processo vengono
1215 associati due diversi limiti per ciascuna di esse; questi sono il
1216 \textsl{limite corrente} (o \textit{current limit}) che esprime un valore
1217 massimo che il processo non può superare ad un certo momento, ed il
1218 \textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
1219 valore massimo che può assumere il \textsl{limite corrente}. In generale il
1220 primo viene chiamato anche \textit{soft limit} dato che il suo valore può
1221 essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
1222 fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
1225 %TODO: tabella troppo grossa, trasformare in lista
1230 \begin{tabular}[c]{|l|p{12cm}|}
1232 \textbf{Valore} & \textbf{Significato}\\
1235 \const{RLIMIT\_AS} & La dimensione massima della memoria virtuale di
1236 un processo, il cosiddetto \textit{Address
1237 Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se
1238 il limite viene superato dall'uso di funzioni
1239 come \func{brk}, \func{mremap} o \func{mmap}
1240 esse falliranno con un errore di
1241 \errcode{ENOMEM}, mentre se il superamento viene
1242 causato dalla crescita dello \itindex{stack}
1243 \textit{stack} il processo riceverà un segnale di
1245 \const{RLIMIT\_CORE} & La massima dimensione per di un file di
1246 \itindex{core~dump} \textit{core dump} (vedi
1247 sez.~\ref{sec:sig_prog_error}) creato nella
1248 terminazione di un processo; file di dimensioni
1249 maggiori verranno troncati a questo valore,
1250 mentre con un valore si bloccherà la creazione
1251 dei \itindex{core~dump} \textit{core dump}.\\
1252 \const{RLIMIT\_CPU} & Il massimo tempo di CPU (vedi
1253 sez.~\ref{sec:sys_cpu_times}) che il processo può
1254 usare. Il superamento del limite corrente
1255 comporta l'emissione di un segnale di
1256 \signal{SIGXCPU}, la cui azione predefinita (vedi
1257 sez.~\ref{sec:sig_classification}) è terminare
1258 il processo, una volta al secondo fino al
1259 raggiungimento del limite massimo. Il
1260 superamento del limite massimo
1261 comporta l'emissione di un segnale di
1262 \signal{SIGKILL}.\footnotemark\\
1263 \const{RLIMIT\_DATA} & La massima dimensione del \index{segmento!dati}
1265 processo (vedi sez.~\ref{sec:proc_mem_layout}).
1266 Il tentativo di allocare più memoria di quanto
1267 indicato dal limite corrente causa il fallimento
1268 della funzione di allocazione (\func{brk} o
1269 \func{sbrk}) con un errore di \errcode{ENOMEM}.\\
1270 \const{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
1271 può creare. Se il processo cerca di scrivere
1272 oltre questa dimensione riceverà un segnale di
1273 \signal{SIGXFSZ}, che di norma termina il
1274 processo; se questo viene intercettato la
1275 system call che ha causato l'errore fallirà con
1276 un errore di \errcode{EFBIG}.\\
1277 \const{RLIMIT\_LOCKS}& È un limite presente solo nelle prime versioni
1278 del kernel 2.4 sul numero massimo di
1279 \itindex{file~locking} \textit{file lock} (vedi
1280 sez.~\ref{sec:file_locking}) che un
1281 processo poteva effettuare.\\
1282 \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
1283 bloccata in RAM da un processo (vedi
1284 sez.~\ref{sec:proc_mem_lock}). Dal kernel 2.6.9
1285 questo limite comprende anche la memoria che può
1286 essere bloccata da ciascun utente nell'uso della
1287 memoria condivisa (vedi
1288 sez.~\ref{sec:ipc_sysv_shm}) che viene
1289 contabilizzata separatamente ma sulla quale
1290 viene applicato questo stesso limite.\\
1291 % TODO trattare i seguenti...
1292 % \const{RLIMIT\_MSGQUEUE}& Il numero massimo di \\
1293 % \const{RLIMIT\_NICE}& Il numero massimo di \\
1294 % \const{RLIMIT\_RTPRIO}& Il numero massimo di \\
1295 % aggiungere i limiti che mancano come RLIMIT_RTTIME introdotto con il 2.6.25
1296 % vedi file include/asm-generic/resource.h
1297 \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
1298 aprire. L'apertura di un ulteriore file farà
1299 fallire la funzione (\func{open}, \func{dup} o
1300 \func{pipe}) con un errore \errcode{EMFILE}.\\
1301 \const{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
1302 creati sullo stesso user id real. Se il limite
1303 viene raggiunto \func{fork} fallirà con un
1305 \const{RLIMIT\_SIGPENDING}& Il numero massimo di segnali che possono
1306 essere mantenuti in coda per ciascun utente,
1307 considerando sia i segnali normali che real-time
1308 (vedi sez.~\ref{sec:sig_real_time}). Il limite è
1309 attivo solo per \func{sigqueue}, con \func{kill}
1310 si potrà sempre inviare un segnale che non sia
1311 già presente su una coda.\footnotemark\\
1312 \const{RLIMIT\_STACK} & La massima dimensione dello \itindex{stack}
1313 \textit{stack} del processo. Se il processo
1314 esegue operazioni che estendano lo
1315 \textit{stack} oltre questa dimensione
1316 riceverà un segnale di \signal{SIGSEGV}.\\
1317 % TODO dal 2.6.23 il significato è cambiato, vedi anche man execve
1318 \const{RLIMIT\_RSS} & L'ammontare massimo di pagine di memoria dato al
1319 \index{segmento!testo} testo del processo. Il
1320 limite è solo una indicazione per il kernel,
1321 qualora ci fosse un surplus di memoria questa
1322 verrebbe assegnata.\\
1323 % TODO: aggiungere a \const{RLIMIT\_STACK} i dati di execve:
1324 % Questi fino al kernel 2.6.23 erano fissi e costituiti da
1325 % 32 pagine di memoria (corrispondenti per la gran parte delle architetture a
1326 % 128kb di dati). Dal 2.6.23 su molte architettire il limite viene stabilito in
1327 % base al valore della risorsa \const{RLIMIT\_STACK} (vedi
1328 % sez.~\ref{sec:sys_resource_limit}), ad un quarto dello spazio da essa
1329 % indicato). Dal 2.6.25 viene comunque garantito uno spazio base di 32 pagine.
1331 % TODO integrare con la roba di madvise
1332 % TODO integrare con le ultime aggiunte, vedi pagina di manuale
1335 \caption{Valori possibili dell'argomento \param{resource} delle funzioni
1336 \func{getrlimit} e \func{setrlimit}.}
1337 \label{tab:sys_rlimit_values}
1340 \footnotetext[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
1341 oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
1342 avviene quando viene superato il \textit{soft limit}; perciò per avere
1343 operazioni portabili è sempre opportuno intercettare il primo
1344 \signal{SIGXCPU} e terminare in maniera ordinata il processo.}
1346 \footnotetext{il limite su questa risorsa è stato introdotto con il kernel
1349 % TODO trattare prlimit64 introdotta con il 2.6.36 che dovrebbe sostituire
1353 In generale il superamento di un limite corrente\footnote{di norma quanto
1354 riportato in tab.~\ref{tab:sys_rlimit_values} fa riferimento a quanto
1355 avviene al superamento del limite corrente, con l'eccezione
1356 \const{RLIMIT\_CPU} in cui si ha in comportamento diverso per il superamento
1357 dei due limiti.} comporta o l'emissione di un segnale o il fallimento della
1358 system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
1359 \const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
1360 creazione) dei file di \itindex{core~dump} \textit{core dump}.} per
1361 permettere di leggere e di impostare i limiti di utilizzo delle risorse da
1362 parte di un processo sono previste due funzioni, \funcd{getrlimit} e
1363 \funcd{setrlimit}, i cui prototipi sono:
1365 \headdecl{sys/time.h}
1366 \headdecl{sys/resource.h}
1369 \funcdecl{int getrlimit(int resource, struct rlimit *rlim)}
1371 Legge il limite corrente per la risorsa \param{resource}.
1373 \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)}
1375 Imposta il limite per la risorsa \param{resource}.
1377 \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
1378 errore, nel qual caso \var{errno} assumerà uno dei valori:
1380 \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi.
1381 \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1382 cercato di innalzare i propri limiti.
1384 ed \errval{EFAULT}.}
1388 Entrambe le funzioni permettono di specificare, attraverso l'argomento
1389 \param{resource}, su quale risorsa si vuole operare: i possibili valori di
1390 questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
1391 (rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
1392 poi effettuato attraverso la struttura \struct{rlimit} puntata da
1393 \param{rlim}, la cui definizione è riportata in
1394 fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
1395 limite corrente e limite massimo.
1398 \begin{figure}[!htb]
1401 \begin{minipage}[c]{\textwidth}
1402 \includestruct{listati/rlimit.h}
1405 \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
1406 delle risorse usate da un processo.}
1407 \label{fig:sys_rlimit_struct}
1411 Nello specificare un limite, oltre a fornire dei valori specifici, si può
1412 anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
1413 di una risorsa; ma si ricordi che solo un processo con i privilegi di
1414 amministratore\footnote{per essere precisi in questo caso quello che serve è
1415 la \itindex{capabilities} \textit{capability} \const{CAP\_SYS\_RESOURCE}
1416 (vedi sez.~\ref{sec:proc_capabilities}).} può innalzare un limite al di
1417 sopra del valore corrente del limite massimo ed usare un valore qualsiasi per
1418 entrambi i limiti. Si tenga conto infine che tutti i limiti vengono ereditati
1419 dal processo padre attraverso una \func{fork} (vedi sez.~\ref{sec:proc_fork})
1420 e mantenuti per gli altri programmi eseguiti attraverso una \func{exec} (vedi
1421 sez.~\ref{sec:proc_exec}).
1424 \subsection{Le risorse di memoria e processore}
1425 \label{sec:sys_memory_res}
1427 La gestione della memoria è già stata affrontata in dettaglio in
1428 sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1429 meccanismo della \index{memoria~virtuale} memoria virtuale attraverso la
1430 divisione della memoria fisica in pagine.
1432 In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
1433 casi, come per l'I/O mappato in memoria (vedi sez.~\ref{sec:file_memory_map})
1434 che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
1435 dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
1436 gestire in maniera ottimale l'interazione della memoria che si sta allocando
1437 con il meccanismo della \index{paginazione} paginazione.
1439 Di solito la dimensione delle pagine di memoria è fissata dall'architettura
1440 hardware, per cui il suo valore di norma veniva mantenuto in una costante che
1441 bastava utilizzare in fase di compilazione, ma oggi, con la presenza di alcune
1442 architetture (ad esempio Sun Sparc) che permettono di variare questa
1443 dimensione, per non dover ricompilare i programmi per ogni possibile modello e
1444 scelta di dimensioni, è necessario poter utilizzare una funzione.
1446 Dato che si tratta di una caratteristica generale del sistema, questa
1447 dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
1448 \func{sysconf}, \footnote{nel caso specifico si dovrebbe utilizzare il
1449 parametro \const{\_SC\_PAGESIZE}.} ma in BSD 4.2 è stata introdotta una
1450 apposita funzione, \funcd{getpagesize}, che restituisce la dimensione delle
1451 pagine di memoria; il suo prototipo è:
1452 \begin{prototype}{unistd.h}{int getpagesize(void)}
1453 Legge le dimensioni delle pagine di memoria.
1455 \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
1456 sono previsti errori.}
1459 La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
1460 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1461 ha eliminata. In Linux è implementata come una system call nelle architetture
1462 in cui essa è necessaria, ed in genere restituisce il valore del simbolo
1463 \const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
1464 se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
1465 implementavano questa funzione restituendo sempre un valore statico.
1467 % TODO verificare meglio la faccenda di const{PAGE\_SIZE}
1469 Le \textsl{glibc} forniscono, come specifica estensione GNU, altre due
1470 funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
1471 di ottenere informazioni riguardo la memoria; i loro prototipi sono:
1473 \headdecl{sys/sysinfo.h}
1475 \funcdecl{long int get\_phys\_pages(void)}
1477 Legge il numero totale di pagine di memoria disponibili per il sistema.
1479 \funcdecl{long int get\_avphys\_pages(void)}
1481 Legge il numero di pagine di memoria disponibili nel sistema.
1483 \bodydesc{Le funzioni restituiscono un numero di pagine.}
1486 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1487 rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
1488 \const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1489 corrispondenti alla RAM della macchina; la seconda invece la memoria
1490 effettivamente disponibile per i processi.
1492 Le \acr{glibc} supportano inoltre, come estensioni GNU, due funzioni che
1493 restituiscono il numero di processori della macchina (e quello dei processori
1494 attivi); anche queste sono informazioni comunque ottenibili attraverso
1495 \func{sysconf} utilizzando rispettivamente i parametri
1496 \const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
1498 Infine le \acr{glibc} riprendono da BSD la funzione \funcd{getloadavg} che
1499 permette di ottenere il carico di processore della macchina, in questo modo è
1500 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1502 \begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
1503 Legge il carico medio della macchina.
1505 \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
1509 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1510 di processi attivi sulla coda dello \itindex{scheduler} scheduler, calcolato
1511 su diversi intervalli di tempo. Il numero di intervalli che si vogliono
1512 leggere è specificato da \param{nelem}, dato che nel caso di Linux il carico
1513 viene valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti),
1514 questo è anche il massimo valore che può essere assegnato a questo argomento.
1517 \subsection{La \textsl{contabilità} in stile BSD}
1518 \label{sec:sys_bsd_accounting}
1520 Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
1521 kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
1522 compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
1523 cosiddetto \textit{BSD accounting}, che consente di registrare su file una
1524 serie di informazioni\footnote{contenute nella struttura \texttt{acct}
1525 definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
1526 riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
1527 che viene terminato.
1529 Linux consente di salvare la contabilità delle informazioni relative alle
1530 risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
1532 \begin{prototype}{unistd.h}{int acct(const char *filename)}
1533 Abilita il \textit{BSD accounting}.
1535 \bodydesc{La funzione ritorna 0 in caso di successo o $-1$ in caso di
1536 errore, nel qual caso \var{errno} assumerà uno dei valori:
1538 \item[\errcode{EACCES}] non si hanno i permessi per accedere a
1540 \item[\errcode{EPERM}] il processo non ha privilegi sufficienti ad
1541 abilitare il \textit{BSD accounting}.
1542 \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
1543 \item[\errcode{EUSERS}] non sono disponibili nel kernel strutture per il
1544 file o si è finita la memoria.
1546 ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
1547 \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
1548 \errval{ENOTDIR}, \errval{EROFS}.}
1551 La funzione attiva il salvataggio dei dati sul file indicato dal pathname
1552 contenuti nella stringa puntata da \param{filename}; la funzione richiede che
1553 il processo abbia i privilegi di amministratore (è necessaria la
1554 \itindex{capabilities} capability \const{CAP\_SYS\_PACCT}, vedi
1555 sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \val{NULL} per
1556 \param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
1557 semplice esempio per l'uso di questa funzione è riportato nel programma
1558 \texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
1560 Quando si attiva la contabilità, il file che si indica deve esistere; esso
1561 verrà aperto in sola scrittura; le informazioni verranno registrate in
1562 \itindex{append~mode} \textit{append} in coda al file tutte le volte che un
1563 processo termina. Le informazioni vengono salvate in formato binario, e
1564 corrispondono al contenuto della apposita struttura dati definita all'interno
1567 Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
1568 parametro di sistema, modificabile attraverso \sysctlfile{kernel/acct}
1569 (o tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi,
1570 il primo indica la percentuale di spazio disco libero sopra il quale viene
1571 ripresa una registrazione che era stata sospesa per essere scesi sotto il
1572 minimo indicato dal secondo valore (sempre in percentuale di spazio disco
1573 libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
1574 essere controllata detta percentuale.
1577 \section{La gestione dei tempi del sistema}
1578 \label{sec:sys_time}
1580 In questa sezione, una volta introdotti i concetti base della gestione dei
1581 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
1582 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
1583 veri tempi di sistema associati ai processi, a quelle per convertire i vari
1584 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
1585 gestione di data e ora.
1588 \subsection{La misura del tempo in Unix}
1589 \label{sec:sys_unix_time}
1591 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
1592 dati per la misure dei tempi all'interno del sistema: essi sono
1593 rispettivamente chiamati \itindex{calendar~time} \textit{calendar time} e
1594 \itindex{process~time} \textit{process time}, secondo le definizioni:
1595 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1596 \item[\textit{calendar time}] \itindex{calendar~time} detto anche
1597 \textsl{tempo di calendario}. È il numero di secondi dalla mezzanotte del
1598 primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
1599 usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
1600 Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
1601 dato che l'UTC corrisponde all'ora locale di Greenwich. È il tempo su cui
1602 viene mantenuto l'orologio del kernel, e viene usato ad esempio per indicare
1603 le date di modifica dei file o quelle di avvio dei processi. Per memorizzare
1604 questo tempo è stato riservato il tipo primitivo \type{time\_t}.
1605 \item[\textit{process time}] \itindex{process~time} detto talvolta
1606 \textsl{tempo di processore}. Viene misurato in \itindex{clock~tick}
1607 \textit{clock tick}. Un tempo questo corrispondeva al numero di interruzioni
1608 effettuate dal timer di sistema, adesso lo standard POSIX richiede che esso
1609 sia pari al valore della costante \const{CLOCKS\_PER\_SEC}, che deve essere
1610 definita come 1000000, qualunque sia la risoluzione reale dell'orologio di
1611 sistema e la frequenza delle interruzioni del timer.\footnote{quest'ultima,
1612 come accennato in sez.~\ref{sec:proc_hierarchy}, è invece data dalla
1613 costante \const{HZ}.} Il dato primitivo usato per questo tempo è
1614 \type{clock\_t}, che ha quindi una risoluzione del microsecondo. Il numero
1615 di \itindex{clock~tick} \textit{tick} al secondo può essere ricavato anche
1616 attraverso \func{sysconf} (vedi sez.~\ref{sec:sys_sysconf}). Il vecchio
1617 simbolo \const{CLK\_TCK} definito in \headfile{time.h} è ormai considerato
1621 In genere si usa il \itindex{calendar~time} \textit{calendar time} per
1622 esprimere le date dei file e le informazioni analoghe che riguardano i
1623 cosiddetti \textsl{tempi di orologio}, che vengono usati ad esempio per i
1624 demoni che compiono lavori amministrativi ad ore definite, come \cmd{cron}.
1626 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
1627 tempo locale, utilizzando le opportune informazioni di localizzazione
1628 (specificate in \conffile{/etc/timezone}). E da tenere presente che questo
1629 tempo è mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
1630 dall'orologio hardware del calcolatore.
1632 Anche il \itindex{process~time} \textit{process time} di solito si esprime in
1633 secondi, ma fornisce una precisione ovviamente superiore al \textit{calendar
1634 time} (che è mantenuto dal sistema con una granularità di un secondo) e
1635 viene usato per tenere conto dei tempi di esecuzione dei processi. Per ciascun
1636 processo il kernel calcola tre tempi diversi:
1637 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1638 \item[\textit{clock time}] il tempo \textsl{reale} (viene chiamato anche
1639 \textit{wall clock time} o \textit{elapsed time}) passato dall'avvio del
1640 processo. Chiaramente tale tempo dipende anche dal carico del sistema e da
1641 quanti altri processi stavano girando nello stesso periodo.
1643 \item[\textit{user time}] il tempo effettivo che il processore ha impiegato
1644 nell'esecuzione delle istruzioni del processo in user space. È quello
1645 riportato nella risorsa \var{ru\_utime} di \struct{rusage} vista in
1646 sez.~\ref{sec:sys_resource_use}.
1648 \item[\textit{system time}] il tempo effettivo che il processore ha impiegato
1649 per eseguire codice delle system call nel kernel per conto del processo. È
1650 quello riportato nella risorsa \var{ru\_stime} di \struct{rusage} vista in
1651 sez.~\ref{sec:sys_resource_use}.
1654 In genere la somma di \textit{user time} e \textit{system time} indica il
1655 tempo di processore totale che il sistema ha effettivamente utilizzato per
1656 eseguire un certo processo, questo viene chiamato anche \textit{CPU time} o
1657 \textsl{tempo di CPU}. Si può ottenere un riassunto dei valori di questi tempi
1658 quando si esegue un qualsiasi programma lanciando quest'ultimo come argomento
1659 del comando \cmd{time}.
1663 \subsection{La gestione del \textit{process time}}
1664 \label{sec:sys_cpu_times}
1666 \itindbeg{process~time}
1668 Di norma tutte le operazioni del sistema fanno sempre riferimento al
1669 \itindex{calendar~time} \textit{calendar time}, l'uso del \textit{process
1670 time} è riservato a quei casi in cui serve conoscere i tempi di esecuzione
1671 di un processo (ad esempio per valutarne l'efficienza). In tal caso infatti
1672 fare ricorso al \textit{calendar time} è inutile in quanto il tempo può essere
1673 trascorso mentre un altro processo era in esecuzione o in attesa del risultato
1674 di una operazione di I/O.
1676 La funzione più semplice per leggere il \textit{process time} di un processo è
1677 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
1678 utilizzato dallo stesso; il suo prototipo è:
1679 \begin{prototype}{time.h}{clock\_t clock(void)}
1680 Legge il valore corrente del tempo di CPU.
1682 \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
1686 La funzione restituisce il tempo in \itindex{clock~tick} \texttt{clock tick},
1687 quindi se si vuole il tempo in secondi occorre dividere il risultato per la
1688 costante \const{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard
1689 ANSI C, POSIX richiede che \const{CLOCKS\_PER\_SEC} sia definito pari a
1690 1000000 indipendentemente dalla risoluzione del timer di sistema.} In genere
1691 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
1692 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
1693 riprenderà lo stesso valore iniziale.
1695 % TODO questi valori sono obsoleti, verificare il tutto.
1697 Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di CPU è la somma di
1698 altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
1699 quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
1700 possono essere letti attraverso la funzione \funcd{times}, il cui prototipo è:
1701 \begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
1702 Legge in \param{buf} il valore corrente dei tempi di processore.
1704 \bodydesc{La funzione ritorna il numero di \itindex{clock~tick}
1705 \textit{clock tick} dall'avvio del sistema in caso di successo e -1 in
1709 La funzione restituisce i valori di \textit{process time} del processo
1710 corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
1711 in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
1712 due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
1713 \textit{system time} del processo, così come definiti in
1714 sez.~\ref{sec:sys_unix_time}.
1716 \begin{figure}[!htb]
1719 \begin{minipage}[c]{\textwidth}
1720 \includestruct{listati/tms.h}
1723 \caption{La struttura \structd{tms} dei tempi di processore associati a un
1725 \label{fig:sys_tms_struct}
1728 Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
1729 time} ed del \textit{system time} di tutti i processi figli che sono
1730 terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
1731 \var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
1732 ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.
1734 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
1735 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
1736 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
1737 lo stato di terminazione di tutti i suoi figli, questi processi
1738 ``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi.
1740 \itindend{process~time}
1743 \subsection{Le funzioni per il \textit{calendar time}}
1744 \label{sec:sys_time_base}
1746 \itindbeg{calendar~time}
1748 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
1749 mantenuto dal kernel in una variabile di tipo \type{time\_t},\footnote{in
1750 realtà il kernel usa una rappresentazione interna di che fornisce una
1751 precisione molto maggiore, e consente per questo anche di usare
1752 rappresentazioni diverse del \textit{calendar time}.} che usualmente
1753 corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
1754 che di norma corrisponde a 32 bit). Il valore corrente del \textit{calendar
1755 time}, che indicheremo come \textsl{tempo di sistema}, può essere ottenuto
1756 con la funzione \funcd{time} che lo restituisce nel suddetto formato; il suo
1758 \begin{prototype}{time.h}{time\_t time(time\_t *t)}
1759 Legge il valore corrente del \textit{calendar time}.
1761 \bodydesc{La funzione ritorna il valore del \textit{calendar time} in caso
1762 di successo e -1 in caso di errore, che può essere solo \errval{EFAULT}.}
1764 \noindent dove \param{t}, se non nullo, deve essere l'indirizzo di una
1765 variabile su cui duplicare il valore di ritorno.
1767 Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
1768 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
1769 sia necessario; il suo prototipo è:
1770 \begin{prototype}{time.h}{int stime(time\_t *t)}
1771 Imposta a \param{t} il valore corrente del \textit{calendar time}.
1773 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1774 che può essere \errval{EFAULT} o \errval{EPERM}.}
1776 \noindent dato che modificare l'ora ha un impatto su tutto il sistema
1777 il cambiamento dell'orologio è una operazione privilegiata e questa funzione
1778 può essere usata solo da un processo con i privilegi di amministratore,
1779 altrimenti la chiamata fallirà con un errore di \errcode{EPERM}.
1781 Data la scarsa precisione nell'uso di \type{time\_t} (che ha una risoluzione
1782 massima di un secondo) quando si devono effettuare operazioni sui tempi di
1783 norma l'uso delle funzioni precedenti è sconsigliato, ed esse sono di solito
1784 sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le due
1785 funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
1786 \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
1787 in BSD4.3 sono indicate come sostitute delle precedenti.} i cui prototipi
1790 \headdecl{sys/time.h}
1793 \funcdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
1795 Legge il tempo corrente del sistema.
1797 \funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
1800 Imposta il tempo di sistema.
1802 \bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
1803 caso di errore, nel qual caso \var{errno} può assumere i valori
1804 \errval{EINVAL} \errval{EFAULT} e per \func{settimeofday} anche
1808 Si noti come queste funzioni utilizzino per indicare il tempo una struttura di
1809 tipo \struct{timeval}, la cui definizione si è già vista in
1810 fig.~\ref{fig:sys_timeval_struct}, questa infatti permette una espressione
1811 alternativa dei valori del \textit{calendar time}, con una precisione,
1812 rispetto a \type{time\_t}, fino al microsecondo.\footnote{la precisione è solo
1813 teorica, la precisione reale della misura del tempo dell'orologio di sistema
1814 non dipende dall'uso di queste strutture.}
1816 Come nel caso di \func{stime} anche \func{settimeofday} (la cosa continua a
1817 valere per qualunque funzione che vada a modificare l'orologio di sistema,
1818 quindi anche per quelle che tratteremo in seguito) può essere utilizzata solo
1819 da un processo coi privilegi di amministratore.\footnote{più precisamente la
1820 capabitity \const{CAP\_SYS\_TIME}.}
1822 Il secondo argomento di entrambe le funzioni è una struttura
1823 \struct{timezone}, che storicamente veniva utilizzata per specificare appunto
1824 la \textit{time zone}, cioè l'insieme del fuso orario e delle convenzioni per
1825 l'ora legale che permettevano il passaggio dal tempo universale all'ora
1826 locale. Questo argomento oggi è obsoleto ed in Linux non è mai stato
1827 utilizzato; esso non è supportato né dalle vecchie \textsl{libc5}, né dalle
1828 \textsl{glibc}: pertanto quando si chiama questa funzione deve essere sempre
1829 impostato a \val{NULL}.
1831 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
1832 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
1833 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
1834 conseguenze indesiderate. Ad esempio se si porta avanti l'orologio si possono
1835 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
1836 saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
1837 delle operazioni previste nell'intervallo di tempo che viene ripetuto.
1839 Per questo motivo la modalità più corretta per impostare l'ora è quella di
1840 usare la funzione \funcd{adjtime}, il cui prototipo è:
1841 \begin{prototype}{sys/time.h}
1842 {int adjtime(const struct timeval *delta, struct timeval *olddelta)}
1844 Aggiusta del valore \param{delta} l'orologio di sistema.
1846 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
1847 errore, nel qual caso \var{errno} assumerà il valore \errcode{EPERM}.}
1850 Questa funzione permette di avere un aggiustamento graduale del tempo di
1851 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
1852 di \param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
1853 positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
1854 il tempo richiesto, altrimenti sarà rallentato. Il secondo argomento viene
1855 usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
1859 \begin{figure}[!htb]
1860 \footnotesize \centering
1861 \begin{minipage}[c]{\textwidth}
1862 \includestruct{listati/timex.h}
1865 \caption{La struttura \structd{timex} per il controllo dell'orologio di
1867 \label{fig:sys_timex_struct}
1870 Linux poi prevede un'altra funzione, che consente un aggiustamento molto più
1871 dettagliato del tempo, permettendo ad esempio anche di modificare anche la
1872 velocità dell'orologio di sistema. La funzione è \funcd{adjtimex} ed il suo
1874 \begin{prototype}{sys/timex.h}
1875 {int adjtimex(struct timex *buf)}
1877 Aggiusta del valore \param{delta} l'orologio di sistema.
1879 \bodydesc{La funzione restituisce lo stato dell'orologio (un valore $>0$) in
1880 caso di successo e -1 in caso di errore, nel qual caso \var{errno}
1881 assumerà i valori \errval{EFAULT}, \errval{EINVAL} ed \errval{EPERM}.}
1884 La funzione richiede una struttura di tipo \struct{timex}, la cui definizione,
1885 così come effettuata in \headfile{sys/timex.h}, è riportata in
1886 fig.~\ref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore
1887 del campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
1888 specificato in un opportuno campo di \struct{timex}, deve essere impostato. Un
1889 valore nullo serve per leggere i parametri correnti; i valori diversi da zero
1890 devono essere specificati come OR binario delle costanti riportate in
1891 tab.~\ref{tab:sys_timex_mode}.
1893 La funzione utilizza il meccanismo di David L. Mills, descritto
1894 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
1895 protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
1896 portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
1897 \func{ntp\_adjtime}. La trattazione completa di questa funzione necessita di
1898 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
1899 a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
1900 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
1901 campi della struttura \struct{timex} può essere ritrovato in \cite{glibc}.
1906 \begin{tabular}[c]{|l|c|p{8.5cm}|}
1908 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
1911 \const{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
1912 reale e l'orologio di sistema:
1913 deve essere indicata in microsecondi
1914 nel campo \var{offset} di
1916 \const{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenze in frequenza
1917 fra il tempo reale e l'orologio di
1918 sistema: deve essere indicata
1919 in parti per milione nel campo
1920 \var{frequency} di \struct{timex}.\\
1921 \const{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo
1923 sul tempo, espresso in microsecondi
1924 nel campo \var{maxerror} di
1926 \const{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
1927 sul tempo, espresso in microsecondi
1928 nel campo \var{esterror} di
1930 \const{ADJ\_STATUS} & 0x0010 & Imposta alcuni
1931 valori di stato interni usati dal
1932 sistema nella gestione
1933 dell'orologio specificati nel campo
1934 \var{status} di \struct{timex}.\\
1935 \const{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del
1936 PLL implementato dal kernel,
1937 specificato nel campo
1938 \var{constant} di \struct{timex}.\\
1939 \const{ADJ\_TICK} & 0x4000 & Imposta il valore dei \textit{tick}
1940 \itindex{clock~tick} del timer in
1941 microsecondi, espresso nel campo
1942 \var{tick} di \struct{timex}.\\
1943 \const{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Imposta uno spostamento una tantum
1944 dell'orologio secondo il valore del
1945 campo \var{offset} simulando il
1946 comportamento di \func{adjtime}.\\
1949 \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
1950 struttura \struct{timex}.}
1951 \label{tab:sys_timex_mode}
1954 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
1955 sintassi specificata per la forma equivalente di questa funzione definita come
1956 \func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
1962 \begin{tabular}[c]{|l|c|l|}
1964 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
1967 \const{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
1968 \const{TIME\_INS} & 1 & Insert leap second.\\
1969 \const{TIME\_DEL} & 2 & Delete leap second.\\
1970 \const{TIME\_OOP} & 3 & Leap second in progress.\\
1971 \const{TIME\_WAIT} & 4 & Leap second has occurred.\\
1972 \const{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
1975 \caption{Possibili valori di ritorno di \func{adjtimex}.}
1976 \label{tab:sys_adjtimex_return}
1979 La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
1980 sistema; questo può assumere i valori riportati in
1981 tab.~\ref{tab:sys_adjtimex_return}. Un valore di -1 viene usato per riportare
1982 un errore; al solito se si cercherà di modificare l'orologio di sistema
1983 (specificando un \var{mode} diverso da zero) senza avere i privilegi di
1984 amministratore si otterrà un errore di \errcode{EPERM}.
1988 \subsection{La gestione delle date.}
1989 \label{sec:sys_date}
1991 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
1992 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
1993 illustrate, se han senso per specificare un intervallo, non sono molto
1994 intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
1995 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
1996 time}, che permette appunto di \textsl{suddividere} il \textit{calendar
1997 time} usuale in ore, minuti, secondi, ecc.
1999 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
2000 definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
2001 struttura che si utilizza quando si deve specificare un tempo a partire dai
2002 dati naturali (ora e data), dato che essa consente anche di trattare la
2003 gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
2004 \var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste da BSD e dalle
2005 \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
2006 fig.~\ref{fig:sys_tm_struct}.}
2008 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2009 da quelle usate per convertire gli altri formati in questo, usando o meno
2010 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2011 tempo in una stringa contenente data ed ora, i loro prototipi sono:
2014 \funcdecl{char *\funcd{asctime}(const struct tm *tm)}
2015 Produce una stringa con data e ora partendo da un valore espresso in
2016 \textit{broken-down time}.
2018 \funcdecl{char *\funcd{ctime}(const time\_t *timep)}
2019 Produce una stringa con data e ora partendo da un valore espresso in
2020 in formato \type{time\_t}.
2022 \funcdecl{struct tm *\funcd{gmtime}(const time\_t *timep)}
2023 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2024 \textit{broken-down time} espresso in UTC.
2026 \funcdecl{struct tm *\funcd{localtime}(const time\_t *timep)}
2027 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2028 \textit{broken-down time} espresso nell'ora locale.
2030 \funcdecl{time\_t \funcd{mktime}(struct tm *tm)}
2031 Converte il \textit{broken-down time} in formato \type{time\_t}.
2033 \bodydesc{Tutte le funzioni restituiscono un puntatore al risultato in caso
2034 di successo e \val{NULL} in caso di errore, tranne che \func{mktime} che
2035 restituisce direttamente il valore o -1 in caso di errore.}
2038 \begin{figure}[!htb]
2039 \footnotesize \centering
2040 \begin{minipage}[c]{\textwidth}
2041 \includestruct{listati/tm.h}
2044 \caption{La struttura \structd{tm} per una rappresentazione del tempo in
2045 termini di ora, minuti, secondi, ecc.}
2046 \label{fig:sys_tm_struct}
2051 Le prime due funzioni, \func{asctime} e \func{ctime} servono per poter
2052 stampare in forma leggibile un tempo; esse restituiscono il puntatore ad una
2053 stringa, allocata staticamente, nella forma:
2055 "Wed Jun 30 21:49:08 1993\n"
2057 e impostano anche la variabile \var{tzname} con l'informazione della
2058 \textit{time zone} corrente; \func{ctime} è banalmente definita in termini di
2059 \func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
2060 statica rende le funzioni non \index{funzioni!rientranti} rientranti POSIX.1c
2061 e SUSv2 prevedono due sostitute \index{funzioni!rientranti} rientranti, il cui
2062 nome è al solito ottenuto aggiungendo un \code{\_r}, che prendono un secondo
2063 argomento \code{char *buf}, in cui l'utente deve specificare il buffer su cui
2064 la stringa deve essere copiata (deve essere di almeno 26 caratteri).
2066 Le altre tre funzioni, \func{gmtime}, \func{localtime} e \func{mktime} servono
2067 per convertire il tempo dal formato \type{time\_t} a quello di \struct{tm} e
2068 viceversa; \func{gmtime} effettua la conversione usando il tempo coordinato
2069 universale (UTC), cioè l'ora di Greenwich; mentre \func{localtime} usa l'ora
2070 locale; \func{mktime} esegue la conversione inversa.
2072 Anche in questo caso le prime due funzioni restituiscono l'indirizzo di una
2073 struttura allocata staticamente, per questo sono state definite anche altre
2074 due versioni \index{funzioni!rientranti} rientranti (con la solita estensione
2075 \code{\_r}), che prevedono un secondo argomento \code{struct tm *result},
2076 fornito dal chiamante, che deve preallocare la struttura su cui sarà
2077 restituita la conversione.
2079 Come mostrato in fig.~\ref{fig:sys_tm_struct} il \textit{broken-down time}
2080 permette di tenere conto anche della differenza fra tempo universale e ora
2081 locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
2082 \index{variabili!globali} variabili globali mostrate in
2083 fig.~\ref{fig:sys_tzname}, cui si accede quando si include
2084 \headfile{time.h}. Queste variabili vengono impostate quando si chiama una
2085 delle precedenti funzioni di conversione, oppure invocando direttamente la
2086 funzione \funcd{tzset}, il cui prototipo è:
2087 \begin{prototype}{sys/timex.h}
2090 Imposta le variabili globali della \textit{time zone}.
2092 \bodydesc{La funzione non ritorna niente e non dà errori.}
2095 La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire
2096 dal valore della variabile di ambiente \envvar{TZ}, se quest'ultima non è
2097 definita verrà usato il file \conffile{/etc/localtime}.
2099 \begin{figure}[!htb]
2102 \begin{minipage}[c]{\textwidth}
2103 \includestruct{listati/time_zone_var.c}
2106 \caption{Le \index{variabili!globali} variabili globali usate per la
2107 gestione delle \textit{time zone}.}
2108 \label{fig:sys_tzname}
2111 La variabile \var{tzname} contiene due stringhe, che indicano i due nomi
2112 standard della \textit{time zone} corrente. La prima è il nome per l'ora
2113 solare, la seconda per l'ora legale.\footnote{anche se sono indicati come
2114 \code{char *} non è il caso di modificare queste stringhe.} La variabile
2115 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2116 \var{daylight} indica se è attiva o meno l'ora legale.
2118 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2119 stampare un tempo o una data, la flessibilità non fa parte delle sue
2120 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2121 giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
2123 \begin{prototype}{time.h}
2124 {size\_t strftime(char *s, size\_t max, const char *format,
2125 const struct tm *tm)}
2127 Stampa il tempo \param{tm} nella stringa \param{s} secondo il formato
2130 \bodydesc{La funzione ritorna il numero di caratteri stampati in \param{s},
2131 altrimenti restituisce 0.}
2134 La funzione converte opportunamente il tempo \param{tm} in una stringa di
2135 testo da salvare in \param{s}, purché essa sia di dimensione, indicata da
2136 \param{size}, sufficiente. I caratteri generati dalla funzione vengono
2137 restituiti come valore di ritorno, ma non tengono conto del terminatore
2138 finale, che invece viene considerato nel computo della dimensione; se
2139 quest'ultima è eccessiva viene restituito 0 e lo stato di \param{s} è
2145 \begin{tabular}[c]{|c|l|p{6cm}|}
2147 \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2150 \var{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
2151 \var{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
2152 \var{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
2153 \var{\%B}&\texttt{April} & Nome del mese, completo.\\
2154 \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
2155 \var{\%d}&\texttt{24} & Giorno del mese.\\
2156 \var{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
2157 \var{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
2158 \var{\%j}&\texttt{114} & Giorno dell'anno.\\
2159 \var{\%m}&\texttt{04} & Mese dell'anno.\\
2160 \var{\%M}&\texttt{40} & Minuto.\\
2161 \var{\%p}&\texttt{PM} & AM/PM.\\
2162 \var{\%S}&\texttt{50} & Secondo.\\
2163 \var{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
2165 \var{\%w}&\texttt{3} & Giorno della settimana. \\
2166 \var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
2168 \var{\%x}&\texttt{04/24/02} & La data.\\
2169 \var{\%X}&\texttt{18:40:50} & L'ora.\\
2170 \var{\%y}&\texttt{02} & Anno nel secolo.\\
2171 \var{\%Y}&\texttt{2002} & Anno.\\
2172 \var{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
2173 \var{\%\%}&\texttt{\%} & Il carattere \%.\\
2176 \caption{Valori previsti dallo standard ANSI C per modificatore della
2177 stringa di formato di \func{strftime}.}
2178 \label{tab:sys_strftime_format}
2181 Il risultato della funzione è controllato dalla stringa di formato
2182 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2183 viene utilizzato come modificatore; alcuni\footnote{per la precisione quelli
2184 definiti dallo standard ANSI C, che sono anche quelli riportati da POSIX.1;
2185 le \acr{glibc} provvedono tutte le estensioni introdotte da POSIX.2 per il
2186 comando \cmd{date}, i valori introdotti da SVID3 e ulteriori estensioni GNU;
2187 l'elenco completo dei possibili valori è riportato nella pagina di manuale
2188 della funzione.} dei possibili valori che esso può assumere sono riportati
2189 in tab.~\ref{tab:sys_strftime_format}. La funzione tiene conto anche della
2190 presenza di una localizzazione per stampare in maniera adeguata i vari nomi.
2192 \itindend{calendar~time}
2195 \section{La gestione degli errori}
2196 \label{sec:sys_errors}
2198 In questa sezione esamineremo le caratteristiche principali della gestione
2199 degli errori in un sistema unix-like. Infatti a parte il caso particolare di
2200 alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
2201 unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
2202 un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
2203 semplicemente usando un opportuno valore di ritorno della funzione invocata.
2204 Inoltre il sistema di classificazione degli errori è basato sull'architettura
2205 a processi, e presenta una serie di problemi nel caso lo si debba usare con i
2206 \itindex{thread} \textit{thread}.
2209 \subsection{La variabile \var{errno}}
2210 \label{sec:sys_errno}
2212 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2213 riportare condizioni di errore, ed è una norma fondamentale di buona
2214 programmazione controllare \textbf{sempre} che le funzioni chiamate si siano
2215 concluse correttamente.
2217 In genere le funzioni di libreria usano un valore speciale per indicare che
2218 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
2219 costante \val{EOF} (a seconda della funzione); ma questo valore segnala solo
2220 che c'è stato un errore, non il tipo di errore.
2222 Per riportare il tipo di errore il sistema usa \index{variabili!globali} la
2223 variabile globale \var{errno},\footnote{l'uso di una variabile globale può
2224 comportare alcuni problemi (ad esempio nel caso dei \itindex{thread}
2225 \textit{thread}) ma lo standard ISO C consente anche di definire \var{errno}
2226 come un \textit{modifiable lvalue}, quindi si può anche usare una macro, e
2227 questo è infatti il modo usato da Linux per renderla locale ai singoli
2228 \itindex{thread} \textit{thread}.} definita nell'header \headfile{errno.h};
2229 la variabile è in genere definita come \direct{volatile} dato che può essere
2230 cambiata in modo asincrono da un segnale (si veda sez.~\ref{sec:sig_sigchld}
2231 per un esempio, ricordando quanto trattato in sez.~\ref{sec:proc_race_cond}),
2232 ma dato che un gestore di segnale scritto bene salva e ripristina il valore
2233 della variabile, di questo non è necessario preoccuparsi nella programmazione
2236 I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
2237 nell'header \headfile{errno.h} sono anche definiti i nomi simbolici per le
2238 costanti numeriche che identificano i vari errori; essi iniziano tutti per
2239 \val{E} e si possono considerare come nomi riservati. In seguito faremo sempre
2240 riferimento a tali valori, quando descriveremo i possibili errori restituiti
2241 dalle funzioni. Il programma di esempio \cmd{errcode} stampa il codice
2242 relativo ad un valore numerico con l'opzione \cmd{-l}.
2244 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
2245 programma, gran parte delle funzioni di libreria impostano \var{errno} ad un
2246 valore diverso da zero in caso di errore. Il valore è invece indefinito in
2247 caso di successo, perché anche se una funzione ha successo, può chiamarne
2248 altre al suo interno che falliscono, modificando così \var{errno}.
2250 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
2251 essere il risultato di un errore precedente) e non lo si può usare per
2252 determinare quando o se una chiamata a funzione è fallita. La procedura da
2253 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
2254 verificato il fallimento della funzione attraverso il suo codice di ritorno.
2257 \subsection{Le funzioni \func{strerror} e \func{perror}}
2258 \label{sec:sys_strerror}
2260 Benché gli errori siano identificati univocamente dal valore numerico di
2261 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
2262 riportare in opportuni messaggi le condizioni di errore verificatesi. La
2263 prima funzione che si può usare per ricavare i messaggi di errore è
2264 \funcd{strerror}, il cui prototipo è:
2265 \begin{prototype}{string.h}{char *strerror(int errnum)}
2266 Restituisce una stringa con il messaggio di errore relativo ad
2269 \bodydesc{La funzione ritorna il puntatore ad una stringa di errore.}
2273 La funzione ritorna il puntatore alla stringa contenente il messaggio di
2274 errore corrispondente al valore di \param{errnum}, se questo non è un valore
2275 valido verrà comunque restituita una stringa valida contenente un messaggio
2276 che dice che l'errore è sconosciuto, e \var{errno} verrà modificata assumendo
2277 il valore \errval{EINVAL}.
2279 In generale \func{strerror} viene usata passando \var{errno} come argomento,
2280 ed il valore di quest'ultima non verrà modificato. La funzione inoltre tiene
2281 conto del valore della variabile di ambiente \envvar{LC\_MESSAGES} per usare
2282 le appropriate traduzioni dei messaggi d'errore nella localizzazione presente.
2284 La funzione utilizza una stringa statica che non deve essere modificata dal
2285 programma; essa è utilizzabile solo fino ad una chiamata successiva a
2286 \func{strerror} o \func{perror}, nessun'altra funzione di libreria tocca
2287 questa stringa. In ogni caso l'uso di una stringa statica rende la funzione
2288 non \index{funzioni!rientranti} rientrante, per cui nel caso si usino i
2289 \itindex{thread} \textit{thread} le librerie forniscono\footnote{questa
2290 funzione è la versione prevista dalle \acr{glibc}, ed effettivamente
2291 definita in \headfile{string.h}, ne esiste una analoga nello standard SUSv3
2292 (quella riportata dalla pagina di manuale), che restituisce \code{int} al
2293 posto di \code{char *}, e che tronca la stringa restituita a
2294 \param{size}.} una apposita versione \index{funzioni!rientranti} rientrante
2295 \func{strerror\_r}, il cui prototipo è:
2296 \begin{prototype}{string.h}
2297 {char * strerror\_r(int errnum, char *buf, size\_t size)}
2299 Restituisce una stringa con il messaggio di errore relativo ad
2302 \bodydesc{La funzione restituisce l'indirizzo del messaggio in caso di
2303 successo e \val{NULL} in caso di errore; nel qual caso \var{errno}
2306 \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
2308 \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
2309 contenere la stringa di errore.
2314 La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
2315 nel buffer \param{buf} che il singolo \itindex{thread} \textit{thread} deve
2316 allocare autonomamente per evitare i problemi connessi alla condivisione del
2317 buffer statico. Il messaggio è copiato fino alla dimensione massima del
2318 buffer, specificata dall'argomento
2319 \param{size}, che deve comprendere pure il carattere di terminazione;
2320 altrimenti la stringa viene troncata.
2322 Una seconda funzione usata per riportare i codici di errore in maniera
2323 automatizzata sullo standard error (vedi sez.~\ref{sec:file_std_descr}) è
2324 \funcd{perror}, il cui prototipo è:
2325 \begin{prototype}{stdio.h}{void perror(const char *message)}
2326 Stampa il messaggio di errore relativo al valore corrente di \var{errno}
2327 sullo standard error; preceduto dalla stringa \param{message}.
2330 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
2331 in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
2332 riferiscono all'ultimo errore avvenuto. La stringa specificata con
2333 \param{message} viene stampato prima del messaggio d'errore, seguita dai due
2334 punti e da uno spazio, il messaggio è terminato con un a capo.
2336 Il messaggio può essere riportato anche usando le due
2337 \index{variabili!globali} variabili globali:
2338 \includecodesnip{listati/errlist.c}
2339 dichiarate in \headfile{errno.h}. La prima contiene i puntatori alle stringhe
2340 di errore indicizzati da \var{errno}; la seconda esprime il valore più alto
2341 per un codice di errore, l'utilizzo di questa stringa è sostanzialmente
2342 equivalente a quello di \func{strerror}.
2344 \begin{figure}[!htbp]
2345 \footnotesize \centering
2346 \begin{minipage}[c]{\codesamplewidth}
2347 \includecodesample{listati/errcode_mess.c}
2350 \caption{Codice per la stampa del messaggio di errore standard.}
2351 \label{fig:sys_err_mess}
2354 In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
2355 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
2356 errore e le costanti usate per identificare i singoli errori; il sorgente
2357 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
2358 gestione delle opzioni e tutte le definizioni necessarie ad associare il
2359 valore numerico alla costante simbolica. In particolare si è riportata la
2360 sezione che converte la stringa passata come argomento in un intero
2361 (\texttt{\small 1--2}), controllando con i valori di ritorno di \func{strtol}
2362 che la conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi
2363 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
2364 11--14}) o la macro (\texttt{\small 15--17}) associate a quel codice.
2368 \subsection{Alcune estensioni GNU}
2369 \label{sec:sys_err_GNU}
2371 Le precedenti funzioni sono quelle definite ed usate nei vari standard; le
2372 \acr{glibc} hanno però introdotto una serie di estensioni ``GNU'' che
2373 forniscono alcune funzionalità aggiuntive per una gestione degli errori
2374 semplificata e più efficiente.
2376 La prima estensione consiste in due variabili, \code{char *
2377 program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
2378 servono per ricavare il nome del programma; queste sono utili quando si deve
2379 aggiungere il nome del programma (cosa comune quando si ha un programma che
2380 non viene lanciato da linea di comando e salva gli errori in un file di log)
2381 al messaggio d'errore. La prima contiene il nome usato per lanciare il
2382 programma (ed è equivalente ad \code{argv[0]}); la seconda mantiene solo il
2383 nome del programma (senza eventuali directory in testa).
2385 Uno dei problemi che si hanno con l'uso di \func{perror} è che non c'è
2386 flessibilità su quello che si può aggiungere al messaggio di errore, che può
2387 essere solo una stringa. In molte occasioni invece serve poter scrivere dei
2388 messaggi con maggiore informazione; ad esempio negli standard di
2389 programmazione GNU si richiede che ogni messaggio di errore sia preceduto dal
2390 nome del programma, ed in generale si può voler stampare il contenuto di
2391 qualche variabile; per questo le \acr{glibc} definiscono la funzione
2392 \funcd{error}, il cui prototipo è:
2393 \begin{prototype}{stdio.h}
2394 {void error(int status, int errnum, const char *format, ...)}
2396 Stampa un messaggio di errore formattato.
2398 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2401 La funzione fa parte delle estensioni GNU per la gestione degli errori,
2402 l'argomento \param{format} prende la stessa sintassi di \func{printf}, ed i
2403 relativi argomenti devono essere forniti allo stesso modo, mentre
2404 \param{errnum} indica l'errore che si vuole segnalare (non viene quindi usato
2405 il valore corrente di \var{errno}); la funzione stampa sullo standard error il
2406 nome del programma, come indicato dalla \index{variabili!globali} variabile
2407 globale \var{program\_name}, seguito da due punti ed uno spazio, poi dalla
2409 \param{format} e dagli argomenti seguenti, seguita da due punti ed uno spazio
2410 infine il messaggio di errore relativo ad \param{errnum}, il tutto è terminato
2413 Il comportamento della funzione può essere ulteriormente controllato se si
2414 definisce una variabile \var{error\_print\_progname} come puntatore ad una
2415 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
2416 il nome del programma.
2418 L'argomento \param{status} può essere usato per terminare direttamente il
2419 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
2420 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
2421 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
2422 un'altra \index{variabili!globali} variabile globale,
2423 \var{error\_message\_count}, che tiene conto di quanti errori ci sono stati.
2425 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
2426 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
2427 l'errore è \funcd{error\_at\_line}; il suo prototipo è:
2428 \begin{prototype}{stdio.h}
2429 {void error\_at\_line(int status, int errnum, const char *fname,
2430 unsigned int lineno, const char *format, ...)}
2432 Stampa un messaggio di errore formattato.
2434 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2436 \noindent ed il suo comportamento è identico a quello di \func{error} se non
2437 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
2438 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
2439 stampa del nome del programma. Inoltre essa usa un'altra
2440 \index{variabili!globali} variabile globale, \var{error\_one\_per\_line}, che
2441 impostata ad un valore diverso da zero fa si che errori relativi alla stessa
2442 linea non vengano ripetuti.
2445 % LocalWords: filesystem like kernel saved header limits sysconf sez tab float
2446 % LocalWords: FOPEN stdio MB LEN CHAR char UCHAR unsigned SCHAR MIN signed INT
2447 % LocalWords: SHRT short USHRT int UINT LONG long ULONG LLONG ULLONG POSIX ARG
2448 % LocalWords: Stevens exec CHILD STREAM stream TZNAME timezone NGROUPS SSIZE
2449 % LocalWords: ssize LISTIO JOB CONTROL job control IDS VERSION YYYYMML bits bc
2450 % LocalWords: dall'header posix lim nell'header glibc run unistd name errno
2451 % LocalWords: NGROUP CLK TCK clock tick process PATH pathname BUF CANON path
2452 % LocalWords: pathconf fpathconf descriptor fd uname sys struct utsname info
2453 % LocalWords: EFAULT fig SOURCE NUL LENGTH DOMAIN NMLN UTSLEN system call proc
2454 % LocalWords: domainname sysctl BSD nlen void oldval size oldlenp newval EPERM
2455 % LocalWords: newlen ENOTDIR EINVAL ENOMEM linux array oldvalue paging stack
2456 % LocalWords: TCP shell Documentation ostype hostname osrelease version mount
2457 % LocalWords: const source filesystemtype mountflags ENODEV ENOTBLK block read
2458 % LocalWords: device EBUSY only EACCES NODEV ENXIO major
2459 % LocalWords: number EMFILE dummy ENAMETOOLONG ENOENT ELOOP virtual devfs MGC
2460 % LocalWords: magic MSK RDONLY NOSUID suid sgid NOEXEC SYNCHRONOUS REMOUNT MNT
2461 % LocalWords: MANDLOCK mandatory locking WRITE APPEND append IMMUTABLE NOATIME
2462 % LocalWords: access NODIRATIME BIND MOVE umount flags FORCE statfs fstatfs ut
2463 % LocalWords: buf ENOSYS EIO EBADF type fstab mntent home shadow username uid
2464 % LocalWords: passwd PAM Pluggable Authentication Method Service Switch pwd ru
2465 % LocalWords: getpwuid getpwnam NULL buflen result ERANGE getgrnam getgrgid AS
2466 % LocalWords: grp group gid SVID fgetpwent putpwent getpwent setpwent endpwent
2467 % LocalWords: fgetgrent putgrent getgrent setgrent endgrent accounting init HZ
2468 % LocalWords: runlevel Hierarchy logout setutent endutent utmpname utmp paths
2469 % LocalWords: WTMP getutent getutid getutline pututline LVL OLD DEAD EMPTY dev
2470 % LocalWords: line libc XPG utmpx getutxent getutxid getutxline pututxline who
2471 % LocalWords: setutxent endutxent wmtp updwtmp logwtmp wtmp host rusage utime
2472 % LocalWords: minflt majflt nswap fault swap timeval wait getrusage usage SELF
2473 % LocalWords: CHILDREN current limit soft RLIMIT address brk mremap mmap dump
2474 % LocalWords: SIGSEGV SIGXCPU SIGKILL sbrk FSIZE SIGXFSZ EFBIG LOCKS lock dup
2475 % LocalWords: MEMLOCK NOFILE NPROC fork EAGAIN SIGPENDING sigqueue kill RSS tv
2476 % LocalWords: resource getrlimit setrlimit rlimit rlim INFINITY capabilities
2477 % LocalWords: capability CAP l'I Sun Sparc PAGESIZE getpagesize SVr SUSv get
2478 % LocalWords: phys pages avphys NPROCESSORS CONF ONLN getloadavg stdlib double
2479 % LocalWords: loadavg nelem scheduler CONFIG ACCT acct filename EUSER
2480 % LocalWords: ENFILE EROFS PACCT AcctCtrl cap calendar UTC Jan the Epoch GMT
2481 % LocalWords: Greenwich Mean l'UTC timer CLOCKS SEC cron wall elapsed times tz
2482 % LocalWords: tms cutime cstime waitpid gettimeofday settimeofday timex
2483 % LocalWords: timespec adjtime olddelta adjtimex David Mills RFC NTP ntp
2484 % LocalWords: nell'RFC ADJ FREQUENCY frequency MAXERROR maxerror ESTERROR PLL
2485 % LocalWords: esterror TIMECONST constant SINGLESHOT MOD INS insert leap OOP
2486 % LocalWords: second delete progress has occurred BAD broken tm gmtoff asctime
2487 % LocalWords: ctime timep gmtime localtime mktime tzname tzset daylight format
2488 % LocalWords: strftime thread EOF modifiable lvalue app errcode strerror LC at
2489 % LocalWords: perror string errnum MESSAGES error message ErrCode strtol log
2490 % LocalWords: program invocation argv printf print progname exit count fname
2491 % LocalWords: lineno one standardese Di page Wed Wednesday Apr April PM AM
2495 %%% Local Variables:
2497 %%% TeX-master: "gapil"