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