1 \chapter{La gestione del sistema, delle risorse, e degli errori}
4 In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
5 generali del sistema, come quelle per la gestione di parametri e
6 configurazione, quelle per la lettura dei limiti e delle carattistiche dello
7 stesso, quelle per il controllo dell'uso delle risorse da parte dei processi,
8 quelle per la gestione dei tempi e degli errori.
11 \section{La lettura delle caratteristiche del sistema}
12 \label{sec:sys_characteristics}
14 In questa sezione tratteremo le varie modalità con cui un programma può
15 ottenere informazioni riguardo alle capacità del sistema. Ogni sistema infatti
16 è contraddistinto da un gran numero di limiti e costanti che lo caratterizzano
17 (i valori massimi e minimi delle variabili, o la lunghezza dei nomi dei file,
18 per esempio), e che possono dipendere da fattori molteplici, come
19 l'architettura hardware, l'implementazione del kernel e delle librerie, le
20 opzioni di configurazione.
22 La definizione di queste caratteristiche ed il tentativo di provvedere dei
23 meccanismi generali che i programmi potessero usare per ricavarle è uno degli
24 aspetti più complessi e controversi coi cui i vari standard si sono dovuti
25 confrontare, spesso con risultati spesso tutt'altro che chiari. Proveremo
26 comunque a dare una descrizione dei principali metodi previsti dai vari
27 standard per ricavare sia le caratteristiche specifiche del sistema, che
31 \subsection{Limiti e parametri di sistema}
32 \label{sec:sys_limits}
34 Quando si devono determinare le le caratteristiche generali del sistema ci si
35 trova di fronte a diverse possibilità; alcune di queste infatti possono
36 dipendere dall'architettura dell'hardware, o dal sistema operativo, altre
37 invece possono dipendere dalle opzioni con cui si è costruito il sistema (ad
38 esempio da come si è compilato il kernel), o dalla configurazione del
39 medesimo; per questo motivo in generale sono necessari due tipi diversi di
42 \item la possibilità di determinare limiti ed opzioni al momento della
44 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
47 La prima funzionalità si può ottenere includendo gli opportuni header file,
48 mentre per la seconda sono ovviamante necessarie delle funzioni; la situazione
49 è complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
50 sono fissi in una implementazione mentre possono variare in un altra. Tutto
51 questo crea una ambiguità che non è sempre possibile risolvere in maniera
52 chiara; in generale quello che succede è che quando i limiti del sistema sono
53 fissi essi vengono definiti come macro nel file \file{limits.h}, se invece
54 possono variare, il loro valore sarà ottenibile tramite la funzione
57 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
58 saranno sempre disponibili al momento della compilazione; un elenco, ripreso
59 da \file{limits.h}, è riportato in \tabref{tab:sys_ansic_macro}; come si vede
60 per la maggior parte di questi limiti attengono alle dimensioni dei dati
61 interi che sono in genere fissati dall'architettura hardware (le analoghe
62 informazioni per i dati in virgola mobile sono definite a parte, ed
63 accessibili includendo \file{float.h}). Lo standard prevede anche un'altra
64 costante, \macro{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
65 definita in \file{limits.h}, essa deve essere definita in \file{stdio.h} ed
66 avere un valore minimo di 8.
71 \begin{tabular}[c]{|l|r|l|}
73 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
76 \macro{MB\_LEN\_MAX}& 16 & massima dimensione di un
78 \macro{CHAR\_BIT} & 8 & bit di \type{char}\\
79 \macro{UCHAR\_MAX}& 255 & massimo di \type{unsigned char}\\
80 \macro{SCHAR\_MIN}& -128 & minimo di \type{signed char}\\
81 \macro{SCHAR\_MAX}& 127 & massimo di \type{signed char}\\
82 \macro{CHAR\_MIN} &\footnotemark& minimo di \type{char}\\
83 \macro{CHAR\_MAX} &\footnotemark& massimo di \type{char}\\
84 \macro{SHRT\_MIN} & -32768 & minimo di \type{short}\\
85 \macro{SHRT\_MAX} & 32767 & massimo di \type{short}\\
86 \macro{USHRT\_MAX}& 65535 & massimo di \type{unsigned short}\\
87 \macro{INT\_MAX} & 2147483647 & minimo di \type{int}\\
88 \macro{INT\_MIN} &-2147483648 & minimo di \type{int}\\
89 \macro{UINT\_MAX} & 4294967295 & massimo di \type{unsigned int}\\
90 \macro{LONG\_MAX} & 2147483647 & massimo di \type{long}\\
91 \macro{LONG\_MIN} &-2147483648 & minimo di \type{long}\\
92 \macro{ULONG\_MAX}& 4294967295 & massimo di \type{unsigned long}\\
95 \caption{Macro definite in \file{limits.h} in conformità allo standard
97 \label{tab:sys_ansic_macro}
100 \footnotetext[1]{il valore può essere 0 o \macro{SCHAR\_MIN} a seconda che il
101 sistema usi caratteri con segno o meno.}
103 \footnotetext[2]{il valore può essere \macro{UCHAR\_MAX} o \macro{SCHAR\_MAX}
104 a seconda che il sistema usi caratteri con segno o meno.}
106 A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
107 \type{long long} introdotto con il nuovo standard, i relativi valori sono in
108 \tabref{tab:sys_isoc90_macro}.
113 \begin{tabular}[c]{|l|r|l|}
115 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
118 \macro{LLONG\_MAX}& 9223372036854775807&massimo di \type{long long}\\
119 \macro{LLONG\_MIN}&-9223372036854775808&minimo di \type{long long}\\
120 \macro{ULLONG\_MAX}&18446744073709551615&
121 massimo di \type{unsigned long long}\\
124 \caption{Macro definite in \file{limits.h} in conformità allo standard
126 \label{tab:sys_isoc90_macro}
129 Ovviamente le dimensioni dei dati sono solo una piccola parte delle
130 caratteristiche del sistema; mancano completamente tutte quelle che dipendono
131 dalla implementazione dello stesso; questo per i sistemi unix-like è stato
132 definito in gran parte dallo standard POSIX.1 (che tratta anche i limiti delle
133 caratteristiche dei file che vedremo in \secref{sec:sys_file_limits}).
138 Lo standard POSIX.1 definisce 33 diversi limiti o costanti, 13 delle quali
139 devono essere sempre dichiarate, in quanto definiscono dei valori minimi che
140 qualunque implementazione che sia conforme allo standard deve avere. I loro
141 valori sono stati riportati in \secref{tab:sys_posix1_base}.
146 \begin{tabular}[c]{|l|r|p{8cm}|}
148 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
151 \macro{\_POSIX\_ARG\_MAX} &4096 & dimensione massima degli argomenti
152 passati ad una funzione della famiglia
154 \macro{\_POSIX\_CHILD\_MAX} &6 & numero massimo di processi contemporanei
155 che un utente può eseguire.\\
156 \macro{\_POSIX\_OPEN\_MAX} &16 & numero massimo di file che un processo
157 può mantenere aperti in contemporanea.\\
158 \macro{\_POSIX\_STREAM\_MAX}&8 & massimo numero di stream aperti per
159 processo in contemporanea.\\
160 \macro{\_POSIX\_TZNAME\_MAX}& & dimensione massima del nome di una
161 \texttt{timezone} (vedi ).\\
162 \macro{\_POSIX\_NGROUPS\_MAX}&0 & numero di gruppi supplementari per
164 \secref{sec:proc_access_id}).\\
165 \macro{\_POSIX\_SSIZE\_MAX}&32767& valore massimo del tipo
167 \macro{\_POSIX\_NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
168 \macro{\_POSIX\_PATH\_MAX}& 256 & lunghezza in byte di pathname.\\
169 \macro{\_POSIX\_PIPE\_BUF}& 512 & byte scrivibili atomicamente in una
171 \macro{\_POSIX\_LINK\_MAX} &8 & numero massimo di link a un file\\
172 \macro{\_POSIX\_MAX\_CANON}&255 & spazio disponibile nella coda di input
173 canonica del terminale\\
174 \macro{\_POSIX\_MAX\_INPUT}&255 & spazio disponibile nella coda di input
179 \caption{Costanti fisse, definite in \file{limits.h}, richieste
180 obbligatoriamente allo standard POSIX.1.}
181 \label{tab:sys_posix1_base}
184 In genere questi valori sono di scarsa utilità, la loro unica utilità è quella
185 di indicare un limite superiore che assicura la portabilità senza necessità di
186 ulteriori controlli. Tuttavia molti di essi sono troppo ristretti, ed
187 ampiamente superati in tutti i sistemi POSIX in uso oggigiorno.
190 Per questo lo standard prevede anche che ogni implementazione definisca delle
191 macro coi valori effettivi dei limiti generali del sistema, riportate in
200 \begin{tabular}[c]{|l|r|p{8cm}|}
202 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
203 \macro{\_POSIX\_AIO\_LISTIO\_MAX}& 2& \\
204 \macro{\_POSIX\_AIO\_MAX}& 1& \\
205 \macro{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
206 \macro{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
207 \macro{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
208 \macro{\_POSIX\_FD\_SETSIZE}& 16 & \\
212 \caption{Macro definite in \file{limits.h} in conformità allo standard
214 \label{tab:sys_posix1_macro}
217 Lo standard ANSI C definisce dei limiti solo sulle dimensioni dei tipi dei
218 dati, che sono ovviamente fissi, gli standard POSIX.1 e POSIX.2 definiscono
219 molti altri limiti attinenti a varie caratteristiche del sistema (come il
220 numero massimo di figli, la lunghezza di un pathname, ecc.) che possono essere
221 fissi o meno: quando sono fissi vengono definiti come macro nel file
222 \file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
223 tramite la funzione \func{sysconf}.
226 \subsection{La funzione \func{sysconf}}
227 \label{sec:sys_sysconf}
229 Come accennato in \secref{sec:sys_limits} quando uno dei limiti o delle
230 carateristiche del sistema può variare, per evitare di dover ricompilare un
231 programma tutte le volte che si cambiano le opzioni con cui è compilato il
232 kernel, o alcuni dei parametri modificabili a run time, è necessario ottenerne
233 il valore attraverso la funzione \func{sysconf}, il cui prototipo è:
234 \begin{prototype}{unistd.h}{long sysconf(int name)}
235 Restituisce il valore del parametro di sistema \param{name}.
237 \bodydesc{La funzione restituisce indietro il valore del parametro
238 richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
239 è disponibile e -1 in caso di errore (ma \var{errno} non viene settata).}
242 La funzione prende come argomento un intero che specifica quale dei limiti si
243 vuole conoscere; uno specchietto contentente i principali valori disponibili
244 in Linux (l'elenco completo è contenuto in \file{bits/confname}, una lista più
245 esaustiva si può trovare nel manuale delle \acr{glibc}), e la corrispondente
246 macro di sistema, è riportato in \ntab.
251 \begin{tabular}[c]{|l|l|p{9cm}|}
253 \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
256 \texttt{\_SC\_ARG\_MAX} &\macro{ARG\_MAX}&
257 La dimensione massima degli argomenti passati ad una funzione
258 della famiglia \func{exec}.\\
259 \texttt{\_SC\_CHILD\_MAX}&\macro{\_CHILD\_MAX}&
260 Il numero massimo di processi contemporanei che un utente può
262 \texttt{\_SC\_OPEN\_MAX}&\macro{\_OPEN\_MAX}&
263 Il numero massimo di file che un processo può mantenere aperti in
265 \texttt{\_SC\_STREAM\_MAX}& \macro{STREAM\_MAX}&
266 Il massimo numero di stream che un processo può mantenere aperti in
267 contemporanea. Questo liminte previsto anche dallo standard ANSI C, che
268 specifica la macro {FOPEN\_MAX}.\\
269 \texttt{\_SC\_TZNAME\_MAX}&\macro{TZNAME\_MAX}&
270 La dimensione massima di un nome di una \texttt{timezone} (vedi ).\\
271 \texttt{\_SC\_NGROUPS\_MAX}&\macro{NGROUP\_MAX}&
272 Massimo numero di gruppi supplementari che può avere un processo (vedi
273 \secref{sec:proc_access_id}).\\
274 \texttt{\_SC\_SSIZE\_MAX}&\macro{SSIZE\_MAX}&
275 valore massimo del tipo di dato \type{ssize\_t}.\\
276 \texttt{\_SC\_CLK\_TCK}& \macro{CLK\_TCK} &
277 Il numero di \textit{clock tick} al secondo, cioè la frequenza delle
278 interruzioni del timer di sistema (vedi \secref{sec:proc_priority}).\\
279 \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
280 Indica se è supportato il \textit{job conotrol} (vedi
281 \secref{sec:sess_xxx}) in stile POSIX.\\
282 \texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
283 Indica se il sistema supporta i \textit{saved id} (vedi
284 \secref{sec:proc_access_id}).\\
285 \texttt{\_SC\_VERSION}& \macro{\_POSIX\_VERSION} &
286 Indica il mese e l'anno di approvazione della revisione dello standard
287 POSIX.1 a cui il sistema fa riferimento, nel formato YYYYMML, la
288 revisione più recente è 199009L, che indica il Settembre 1990.\\
291 \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
292 \label{tab:sys_sysconf_par}
297 \subsection{I limiti dei file}
298 \label{sec:sys_file_limits}
300 La funzione \func{statfs} ...
301 La funzione \func{pathconf} ...
306 \section{Opzioni e configurazione del sistema}
307 \label{sec:sys_config}
309 \subsection{La funzione \func{sysctl}}
310 \label{sec:sys_sysctl}
316 \subsection{La configurazione dei filesystem}
317 \label{sec:sys_file_config}
319 La funzione \func{statfs} ...
323 \section{Limitazione ed uso delle risorse}
324 \label{sec:sys_res_limits}
326 In questa sezione esamimeremo le funzioni che permettono di esaminare e
327 controllare come le varie risorse del sistema (CPU, memoria, ecc.) vengono
328 utilizzate dai processi, e le modalità con cui è possibile imporre dei limiti
333 \subsection{L'uso delle risorse}
334 \label{sec:sys_resource_use}
337 \subsection{Limiti sulle risorse}
338 \label{sec:sys_resource_limit}
341 \subsection{Le risorse di memoria}
342 \label{sec:sys_memory_res}
345 \subsection{Le risorse di processore}
346 \label{sec:sys_cpu_load}
353 \begin{minipage}[c]{15cm}
354 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
356 struct timeval ru_utime; /* user time used */
357 struct timeval ru_stime; /* system time used */
358 long ru_maxrss; /* maximum resident set size */
359 long ru_ixrss; /* integral shared memory size */
360 long ru_idrss; /* integral unshared data size */
361 long ru_isrss; /* integral unshared stack size */
362 long ru_minflt; /* page reclaims */
363 long ru_majflt; /* page faults */
364 long ru_nswap; /* swaps */
365 long ru_inblock; /* block input operations */
366 long ru_oublock; /* block output operations */
367 long ru_msgsnd; /* messages sent */
368 long ru_msgrcv; /* messages received */
369 long ru_nsignals; ; /* signals received */
370 long ru_nvcsw; /* voluntary context switches */
371 long ru_nivcsw; /* involuntary context switches */
376 \caption{La struttura \var{rusage} per la lettura delle informazioni dei
377 delle risorse usate da un processo.}
378 \label{fig:sys_rusage_struct}
384 \var{tms\_utime}, \var{tms\_stime}, \var{tms\_cutime}, \var{tms\_uetime}
388 \section{La gestione dei tempi del sistema}
391 In questa sezione tratteremo le varie funzioni per la gestione delle
392 date e del tempo in un sistema unix-like, e quelle per convertire i vari
393 tempi nelle differenti rappresentazioni che vengono utilizzate.
396 \subsection{La misura del tempo in unix}
397 \label{sec:sys_unix_time}
399 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti
400 valori per i tempi all'interno del sistema, essi sono rispettivamente
401 chiamati \textit{calendar time} e \textit{process time}, secondo le
404 \item \textit{calendar time}: è il numero di secondi dalla mezzanotte del
405 primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
406 usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
407 Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
408 dato che l'UTC corrisponde all'ora locale di Greenwich. È il tempo su cui
409 viene mantenuto l'orologio del calcolatore, e viene usato ad esempio per
410 indicare le date di modifica dei file o quelle di avvio dei processi. Per
411 memorizzare questo tempo è stato riservato il tipo primitivo \type{time\_t}.
412 \item \textit{process time}: talvolta anche detto tempo di CPU. Viene misurato
413 in \textit{clock tick}, corrispondenti al numero di interruzioni effettuate
414 dal timer di sistema, e che per Linux avvengono ogni centesimo di
415 secondo\footnote{eccetto per la piattaforma alpha dove avvengono ogni
416 millesimo di secondo}. Il dato primitivo usato per questo tempo è
417 \type{clock\_t}, inoltre la costante \macro{HZ} restituisce la frequenza di
418 operazione del timer, e corrisponde dunque al numero di tick al secondo. Lo
419 standard POSIX definisce allo stesso modo la costante \macro{CLK\_TCK});
420 questo valore può comunque essere ottenuto con \func{sysconf} (vedi
421 \secref{sec:sys_limits}).
424 In genere si usa il \textit{calendar time} per tenere le date dei file e le
425 informazioni analoghe che riguardano i tempi di ``orologio'', usati ad esempio
426 per i demoni che compiono lavori amministrativi ad ore definite, come
427 \cmd{cron}. Di solito questo vene convertito automaticamente dal valore in UTC
428 al tempo locale, utilizzando le opportune informazioni di localizzazione
429 (specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
430 mantenuto dal sistema e non corrisponde all'orologio hardware del calcolatore.
432 Il \textit{process time} di solito si esprime in secondi e viene usato appunto
433 per tenere conto dei tempi di esecuzione dei processi. Per ciascun processo il
434 kernel tiene tre di questi tempi:
436 \item \textit{clock time}
437 \item \textit{user time}
438 \item \textit{system time}
440 il primo è il tempo ``reale'' (viene anche chiamato \textit{wall clock time})
441 dall'avvio del processo, e misura il tempo trascorso fino alla sua
442 conclusione; chiaramente un tale tempo dipende anche dal carico del sistema e
443 da quanti altri processi stavano girando nello stesso periodo. Il secondo
444 tempo è quello che la CPU ha speso nell'esecuzione delle istruzioni del
445 processo in user space. Il terzo è il tempo impiegato dal kernel per eseguire
446 delle system call per conto del processo medesimo (tipo quello usato per
447 eseguire una \func{write} su un file). In genere la somma di user e system
448 time viene chiamato \textit{CPU time}.
454 \section{La gestione degli errori}
455 \label{sec:sys_errors}
457 La gestione degli errori è in genere una materia complessa. Inoltre il modello
458 utilizzato dai sistema unix-like è basato sull'architettura a processi, e
459 presenta una serie di problemi nel caso lo si debba usare con i thread.
460 Esamineremo in questa sezione le sue caratteristiche principali.
463 \subsection{La variabile \var{errno}}
464 \label{sec:sys_errno}
466 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
467 riportare condizioni di errore, ed è una buona norma di programmazione
468 controllare sempre che le funzioni chiamate si siano concluse correttamente.
470 In genere le funzioni di libreria usano un valore speciale per indicare che
471 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
472 costante \macro{EOF} (a seconda della funzione); ma questo valore segnala solo
473 che c'è stato un errore, non il tipo di errore.
475 Per riportare il tipo di errore il sistema usa la variabile globale
476 \var{errno}\footnote{L'uso di una variabile globale può comportare alcuni
477 problemi (ad esempio nel caso dei thread) ma lo standard ISO C consente
478 anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
479 può anche usare una macro, e questo è infatti il modo usato da Linux per
480 renderla locale ai singoli thread.}, definita nell'header \file{errno.h}; la
481 variabile è in genere definita come \type{volatile} dato che può essere
482 cambiata in modo asincrono da un segnale (per una descrizione dei segnali si
483 veda \secref{cha:signals}), ma dato che un manipolatore di segnale scritto
484 bene salva e ripristina il valore della variabile, di questo non è necessario
485 preoccuparsi nella programmazione normale.
487 I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},
488 nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
489 costanti numeriche che identificano i vari errori; essi iniziano tutti per
490 \macro{E} e si possono considerare come nomi riservati. In seguito faremo
491 sempre rifermento a tali valori, quando descriveremo i possibili errori
492 restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
493 codice relativo ad un valore numerico con l'opzione \cmd{-l}.
495 Il valore di \var{errno} viene sempre settato a zero all'avvio di un
496 programma, gran parte delle funzioni di libreria settano \var{errno} ad un
497 valore diverso da zero in caso di errore. Il valore è invece indefinito in
498 caso di successo, perché anche se una funzione ha successo, può chiamarne
499 altre al suo interno che falliscono, modificando così \var{errno}.
501 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
502 essere il risultato di un errore precedente) e non lo si può usare per
503 determinare quando o se una chiamata a funzione è fallita. La procedura da
504 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
505 verificato il fallimento della funzione attraverso il suo codice di ritorno.
508 \subsection{Le funzioni \func{strerror} e \func{perror}}
509 \label{sec:sys_strerror}
511 Benché gli errori siano identificati univocamente dal valore numerico di
512 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
513 riportare in opportuni messaggi le condizioni di errore verificatesi. La
514 prima funzione che si può usare per ricavare i messaggi di errore è
515 \func{strerror}, il cui prototipo è:
516 \begin{prototype}{string.h}{char * strerror(int errnum)}
517 Ritorna una stringa (statica) che descrive l'errore il cui codice è passato
521 In generale \func{strerror} viene usata passando \var{errno} come parametro;
522 nel caso si specifichi un codice sbagliato verrà restituito un messaggio di
523 errore sconosciuto. La funzione utilizza una stringa statica che non deve
524 essere modificata dal programma e che è utilizzabile solo fino ad una chiamata
525 successiva a \func{strerror}; nel caso si usino i thread è
526 provvista\footnote{questa funzione è una estensione GNU, non fa parte dello
527 standard POSIX} una versione apposita:
528 \begin{prototype}{string.h}
529 {char * strerror\_r(int errnum, char * buff, size\_t size)}
530 Analoga a \func{strerror} ma ritorna il messaggio in un buffer
531 specificato da \param{buff} di lunghezza massima (compreso il terminatore)
535 che utilizza un buffer che il singolo thread deve allocare, per evitare i
536 problemi connessi alla condivisione del buffer statico. Infine, per completare
537 la caratterizzazione dell'errore, si può usare anche la variabile
538 globale\footnote{anche questa è una estensione GNU}
539 \var{program\_invocation\_short\_name} che riporta il nome del programma
540 attualmente in esecuzione.
542 Una seconda funzione usata per riportare i codici di errore in maniera
543 automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) è
544 \func{perror}, il cui prototipo è:
545 \begin{prototype}{stdio.h}{void perror (const char *message)}
546 Stampa il messaggio di errore relativo al valore corrente di \var{errno}
547 sullo standard error; preceduto dalla stringa \var{message}.
549 i messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
550 in \capref{cha:errors}), e, usando il valore corrente di \var{errno}, si
551 riferiscono all'ultimo errore avvenuto. La stringa specificata con
552 \var{message} viene stampato prime del messaggio d'errore, seguita dai due
553 punti e da uno spazio, il messaggio è terminato con un a capo.
555 Il messaggio può essere riportato anche usando altre variabili globali
556 dichiarate in \file{errno.h}:
558 const char *sys_errlist[];
561 la prima contiene i puntatori alle stringhe di errore indicizzati da
562 \var{errno}; la seconda esprime il valore più alto per un codice di errore,
563 l'utilizzo di questa stringa è sostanzialmente equivalente a quello di
566 In \nfig\ è riportata la sezione attinente del codice del programma
567 \cmd{errcode}, che può essere usato per stampare i messaggi di errore e le
568 costanti usate per identificare i singoli errori; il sorgente completo del
569 programma è allegato nel file \file{ErrCode.c} e contiene pure la gestione
570 delle opzioni e tutte le definizioni necessarie ad associare il valore
571 numerico alla costante simbolica. In particolare si è riportata la sezione che
572 converte la stringa passata come parametro in un intero (\texttt{\small
573 1--2}), controllando con i valori di ritorno di \func{strtol} che la
574 conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi stampa,
575 a seconda dell'opzione scelta il messaggio di errore (\texttt{\small 11--14})
576 o la macro (\texttt{\small 15--17}) associate a quel codice.
581 /* convert string to number */
582 err = strtol(argv[optind], NULL, 10);
583 /* testing error condition on conversion */
585 perror("Underflow on error code");
587 } else if (err==LONG_MIN) {
588 perror("Overflow on error code");
591 /* conversion is fine */
593 printf("Error message for %d is %s\n", err, strerror(err));
596 printf("Error label for %d is %s\n", err, err_code[err]);
599 \caption{Codice per la stampa del messaggio di errore standard.}
600 \label{fig:sys_err_mess}
604 \section{La gestione di utenti e gruppi}
605 \label{sec:sys_user_group}
610 %%% TeX-master: "gapil"