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 dei parametri e della
6 configurazione dello stesso, quelle per la lettura dei limiti e delle
7 caratteristiche, quelle per il controllo dell'uso delle risorse dei processi,
8 quelle per la gestione ed il controllo dei filesystem, degli utenti, dei tempi
13 \section{Capacità e caratteristiche del sistema}
14 \label{sec:sys_characteristics}
16 In questa sezione tratteremo le varie modalità con cui un programma può
17 ottenere informazioni riguardo alle capacità del sistema. Ogni sistema
18 unix-like infatti è contraddistinto da un gran numero di limiti e costanti che
19 lo caratterizzano, e che possono dipendere da fattori molteplici, come
20 l'architettura hardware, l'implementazione del kernel e delle librerie, le
21 opzioni di configurazione.
23 La definizione di queste caratteristiche ed il tentativo di provvedere dei
24 meccanismi generali che i programmi possono usare per ricavarle è uno degli
25 aspetti più complessi e controversi con cui le diverse standardizzazioni si
26 sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
27 Daremo comunque una descrizione dei principali metodi previsti dai vari
28 standard per ricavare sia le caratteristiche specifiche del sistema, che
29 quelle della gestione dei file.
32 \subsection{Limiti e parametri di sistema}
33 \label{sec:sys_limits}
35 Quando si devono determinare le le caratteristiche generali del sistema ci si
36 trova di fronte a diverse possibilità; alcune di queste infatti possono
37 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
38 interi), o dal sistema operativo (come la presenza o meno del gruppo degli
39 identificatori \textit{saved}), altre invece possono dipendere dalle opzioni
40 con cui si è costruito il sistema (ad esempio da come si è compilato il
41 kernel), o dalla configurazione del medesimo; per questo motivo in generale
42 sono necessari due tipi diversi di funzionalità:
44 \item la possibilità di determinare limiti ed opzioni al momento della
46 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
49 La prima funzionalità si può ottenere includendo gli opportuni header file che
50 contengono le costanti necessarie definite come macro di preprocessore, per la
51 seconda invece sono ovviamente necessarie delle funzioni. La situazione è
52 complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
53 sono fissi in un'implementazione mentre possono variare in un altra. Tutto
54 questo crea una ambiguità che non è sempre possibile risolvere in maniera
55 chiara; in generale quello che succede è che quando i limiti del sistema sono
56 fissi essi vengono definiti come macro di preprocessore nel file
57 \file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
58 tramite la funzione \func{sysconf} (che esamineremo in
59 \secref{sec:sys_sysconf}).
61 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
62 saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
63 da \file{limits.h}, è riportato in \tabref{tab:sys_ansic_macro}. Come si può
64 vedere per la maggior parte questi limiti attengono alle dimensioni dei dati
65 interi, che sono in genere fissati dall'architettura hardware (le analoghe
66 informazioni per i dati in virgola mobile sono definite a parte, ed
67 accessibili includendo \file{float.h}). Lo standard prevede anche un'altra
68 costante, \macro{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
69 definita in \file{limits.h}; essa deve essere definita in \file{stdio.h} ed
70 avere un valore minimo di 8.
75 \begin{tabular}[c]{|l|r|l|}
77 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
80 \macro{MB\_LEN\_MAX}& 16 & massima dimensione di un
82 \macro{CHAR\_BIT} & 8 & bit di \ctyp{char}\\
83 \macro{UCHAR\_MAX}& 255 & massimo di \ctyp{unsigned char}\\
84 \macro{SCHAR\_MIN}& -128 & minimo di \ctyp{signed char}\\
85 \macro{SCHAR\_MAX}& 127 & massimo di \ctyp{signed char}\\
86 \macro{CHAR\_MIN} &\footnotemark& minimo di \ctyp{char}\\
87 \macro{CHAR\_MAX} &\footnotemark& massimo di \ctyp{char}\\
88 \macro{SHRT\_MIN} & -32768 & minimo di \ctyp{short}\\
89 \macro{SHRT\_MAX} & 32767 & massimo di \ctyp{short}\\
90 \macro{USHRT\_MAX}& 65535 & massimo di \ctyp{unsigned short}\\
91 \macro{INT\_MAX} & 2147483647 & minimo di \ctyp{int}\\
92 \macro{INT\_MIN} &-2147483648 & minimo di \ctyp{int}\\
93 \macro{UINT\_MAX} & 4294967295 & massimo di \ctyp{unsigned int}\\
94 \macro{LONG\_MAX} & 2147483647 & massimo di \ctyp{long}\\
95 \macro{LONG\_MIN} &-2147483648 & minimo di \ctyp{long}\\
96 \macro{ULONG\_MAX}& 4294967295 & massimo di \ctyp{unsigned long}\\
99 \caption{Costanti definite in \file{limits.h} in conformità allo standard
101 \label{tab:sys_ansic_macro}
104 \footnotetext[1]{il valore può essere 0 o \macro{SCHAR\_MIN} a seconda che il
105 sistema usi caratteri con segno o meno.}
107 \footnotetext[2]{il valore può essere \macro{UCHAR\_MAX} o \macro{SCHAR\_MAX}
108 a seconda che il sistema usi caratteri con segno o meno.}
110 A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
111 \ctyp{long long} introdotto con il nuovo standard, i relativi valori sono in
112 \tabref{tab:sys_isoc90_macro}.
117 \begin{tabular}[c]{|l|r|l|}
119 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
122 \macro{LLONG\_MAX}& 9223372036854775807& massimo di \ctyp{long long}\\
123 \macro{LLONG\_MIN}&-9223372036854775808& minimo di \ctyp{long long}\\
124 \macro{ULLONG\_MAX}&18446744073709551615&
125 massimo di \ctyp{unsigned long long}\\
128 \caption{Macro definite in \file{limits.h} in conformità allo standard
130 \label{tab:sys_isoc90_macro}
133 Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
134 delle caratteristiche del sistema; mancano completamente tutte quelle che
135 dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
136 sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
137 limiti relativi alle caratteristiche dei file che vedremo in
138 \secref{sec:sys_file_limits}.
140 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
141 meno chiare\footnote{tanto che Stevens, in \cite{APUE}, la porta come esempio
142 di ``standardese''.}. Lo standard prevede che ci siano 13 macro che
143 descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
144 riportate in \tabref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
145 file, riportate in \tabref{tab:sys_file_macro}).
150 \begin{tabular}[c]{|l|r|p{8cm}|}
152 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
155 \macro{ARG\_MAX} &131072& dimensione massima degli argomenti
156 passati ad una funzione della famiglia
158 \macro{CHILD\_MAX} & 999& numero massimo di processi contemporanei
159 che un utente può eseguire.\\
160 \macro{OPEN\_MAX} & 256& numero massimo di file che un processo
161 può mantenere aperti in contemporanea.\\
162 \macro{STREAM\_MAX}& 8& massimo numero di stream aperti per
163 processo in contemporanea.\\
164 \macro{TZNAME\_MAX}& 6& dimensione massima del nome di una
165 \texttt{timezone} (vedi
166 \secref{sec:sys_time_base})).\\
167 \macro{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
168 processo (vedi \secref{sec:proc_access_id}).\\
169 \macro{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
173 \caption{Costanti per i limiti del sistema.}
174 \label{tab:sys_generic_macro}
177 Lo standard dice che queste macro devono essere definite in \file{limits.h}
178 quando i valori a cui fanno riferimento sono fissi, e altrimenti devono essere
179 lasciate indefinite, ed i loro valori dei limiti devono essere accessibili
180 solo attraverso \func{sysconf}. In realtà queste vengono sempre definite ad
181 un valore generico. Si tenga presente poi che alcuni di questi limiti possono
182 assumere valori molto elevati (come \macro{CHILD\_MAX}), e non è pertanto il
183 caso di utilizzarli per allocare staticamente della memoria.
185 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
186 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
187 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
188 implementazione possa dichiararsi conforme allo standard; detti valori sono
189 riportati in \tabref{tab:sys_posix1_general}.
194 \begin{tabular}[c]{|l|r|p{8cm}|}
196 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
199 \macro{\_POSIX\_ARG\_MAX} & 4096& dimensione massima degli argomenti
200 passati ad una funzione della famiglia
202 \macro{\_POSIX\_CHILD\_MAX} & 6& numero massimo di processi
203 contemporanei che un utente può
205 \macro{\_POSIX\_OPEN\_MAX} & 16& numero massimo di file che un processo
206 può mantenere aperti in
208 \macro{\_POSIX\_STREAM\_MAX} & 8& massimo numero di stream aperti per
209 processo in contemporanea.\\
210 \macro{\_POSIX\_TZNAME\_MAX} & & dimensione massima del nome di una
211 \texttt{timezone} (vedi
212 \secref{sec:sys_date}). \\
213 \macro{\_POSIX\_NGROUPS\_MAX}& 0& numero di gruppi supplementari per
215 \secref{sec:proc_access_id}).\\
216 \macro{\_POSIX\_SSIZE\_MAX} &32767& valore massimo del tipo
218 \macro{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
219 \macro{\_POSIX\_AIO\_MAX} & 1& \\
223 \caption{Macro dei valori minimi delle caratteristiche generali del sistema
224 per la conformità allo standard POSIX.1.}
225 \label{tab:sys_posix1_general}
228 In genere questi valori non servono a molto, la loro unica utilità è quella di
229 indicare un limite superiore che assicura la portabilità senza necessità di
230 ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
231 i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
232 valori ottenuti da \func{sysconf}.
237 \begin{tabular}[c]{|l|p{8cm}|}
239 \textbf{Macro}&\textbf{Significato}\\
242 \macro{\_POSIX\_JOB\_CONTROL}& il sistema supporta il
243 \textit{job control} (vedi
244 \secref{sec:sess_job_control}).\\
245 \macro{\_POSIX\_SAVED\_IDS} & il sistema supporta gli identificatori del
246 gruppo \textit{saved} (vedi
247 \secref{sec:proc_access_id})
248 per il controllo di accesso dei processi\\
249 \macro{\_POSIX\_VERSION} & fornisce la versione dello standard POSIX.1
250 supportata nel formato YYYYMML (ad esempio
254 \caption{Alcune macro definite in \file{limits.h} in conformità allo standard
256 \label{tab:sys_posix1_other}
259 Oltre ai precedenti valori (e a quelli relativi ai file elencati in
260 \tabref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
261 lo standard POSIX.1 ne prevede parecchi altri. La lista completa si trova
262 dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
263 incluso automaticamente all'interno di \file{limits.h}). Di questi vale la
264 pena menzionare alcune macro di uso comune, (riportate in
265 \tabref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
266 denotano la presenza di alcune funzionalità nel sistema (come il supporto del
267 \textit{job control} o degli identificatori del gruppo \textit{saved}).
269 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
270 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
271 alle applicazioni di sistema presenti (come quelli su alcuni parametri delle
272 espressioni regolari o del comando \cmd{bc}), non li tratteremo
273 esplicitamente, se ne trova una menzione completa nell'header file
274 \file{bits/posix2\_lim.h}, e alcuni di loro sono descritti nella pagina di
275 manuale di \func{sysconf} e nel manuale delle \acr{glibc}.
278 \subsection{La funzione \func{sysconf}}
279 \label{sec:sys_sysconf}
281 Come accennato in \secref{sec:sys_limits} quando uno dei limiti o delle
282 caratteristiche del sistema può variare, per non dover essere costretti a
283 ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
284 compilato il kernel, o alcuni dei parametri modificabili a run time, è
285 necessario ottenerne il valore attraverso la funzione \func{sysconf}. Il
286 prototipo di questa funzione è:
287 \begin{prototype}{unistd.h}{long sysconf(int name)}
288 Restituisce il valore del parametro di sistema \param{name}.
290 \bodydesc{La funzione restituisce indietro il valore del parametro
291 richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
292 è disponibile e -1 in caso di errore (ma \var{errno} non viene impostata).}
295 La funzione prende come argomento un intero che specifica quale dei limiti si
296 vuole conoscere; uno specchietto contenente i principali valori disponibili in
297 Linux è riportato in \tabref{tab:sys_sysconf_par}; l'elenco completo è
298 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
299 relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
304 \begin{tabular}[c]{|l|l|p{9cm}|}
306 \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
309 \texttt{\_SC\_ARG\_MAX} &\macro{ARG\_MAX}&
310 La dimensione massima degli argomenti passati ad una funzione
311 della famiglia \func{exec}.\\
312 \texttt{\_SC\_CHILD\_MAX}&\macro{\_CHILD\_MAX}&
313 Il numero massimo di processi contemporanei che un utente può
315 \texttt{\_SC\_OPEN\_MAX}&\macro{\_OPEN\_MAX}&
316 Il numero massimo di file che un processo può mantenere aperti in
318 \texttt{\_SC\_STREAM\_MAX}& \macro{STREAM\_MAX}&
319 Il massimo numero di stream che un processo può mantenere aperti in
320 contemporanea. Questo limite previsto anche dallo standard ANSI C, che
321 specifica la macro {FOPEN\_MAX}.\\
322 \texttt{\_SC\_TZNAME\_MAX}&\macro{TZNAME\_MAX}&
323 La dimensione massima di un nome di una \texttt{timezone} (vedi
324 \secref{sec:sys_date}).\\
325 \texttt{\_SC\_NGROUPS\_MAX}&\macro{NGROUP\_MAX}&
326 Massimo numero di gruppi supplementari che può avere un processo (vedi
327 \secref{sec:proc_access_id}).\\
328 \texttt{\_SC\_SSIZE\_MAX}&\macro{SSIZE\_MAX}&
329 valore massimo del tipo di dato \type{ssize\_t}.\\
330 \texttt{\_SC\_CLK\_TCK}& \macro{CLK\_TCK} &
331 Il numero di \textit{clock tick} al secondo, cioè l'unità di misura del
332 \textit{process time} (vedi \secref{sec:sys_unix_time}).\\
333 \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
334 Indica se è supportato il \textit{job control} (vedi
335 \secref{sec:sess_job_control}) in stile POSIX.\\
336 \texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
337 Indica se il sistema supporta i \textit{saved id} (vedi
338 \secref{sec:proc_access_id}).\\
339 \texttt{\_SC\_VERSION}& \macro{\_POSIX\_VERSION} &
340 Indica il mese e l'anno di approvazione della revisione dello standard
341 POSIX.1 a cui il sistema fa riferimento, nel formato YYYYMML, la
342 revisione più recente è 199009L, che indica il Settembre 1990.\\
345 \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
346 \label{tab:sys_sysconf_par}
349 In generale ogni limite o caratteristica del sistema per cui è definita una
350 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
351 essere ottenuto attraverso una chiamata a \func{sysconf}. Il valore si otterrà
352 specificando come valore del parametro \param{name} il nome ottenuto
353 aggiungendo \code{\_SC\_} ai nomi delle macro definite dai primi due, o
354 sostituendolo a \code{\_POSIX\_} per le macro definite dagli gli altri due.
356 In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
357 macro non è definita, quindi con un codice analogo al seguente:
359 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
365 int val = sysconf(_SC_CHILD_MAX);
367 perror("fatal error");
374 ma in realtà in Linux queste macro sono comunque definite, indicando però un
375 limite generico. Per questo motivo è sempre meglio usare i valori restituiti
379 \subsection{I limiti dei file}
380 \label{sec:sys_file_limits}
382 Come per le caratteristiche generali del sistema anche per i file esistono una
383 serie di limiti (come la lunghezza del nome del file o il numero massimo di
384 link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
385 in questo caso lo standard prevede alcune macro che ne specificano il valore,
386 riportate in \tabref{tab:sys_file_macro}.
391 \begin{tabular}[c]{|l|r|l|}
393 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
396 \macro{LINK\_MAX} &8 & numero massimo di link a un file\\
397 \macro{NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
398 \macro{PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
399 \macro{PIPE\_BUF}&4096 & byte scrivibili atomicamente in una pipe
400 (vedi \secref{sec:ipc_pipes}).\\
401 \macro{MAX\_CANON}&255 & dimensione di una riga di terminale in modo
402 canonico (vedi \secref{sec:term_design}).\\
403 \macro{MAX\_INPUT}&255 & spazio disponibile nella coda di input
404 del terminale (vedi \secref{sec:term_design}).\\
407 \caption{Macro per i limiti sulle caratteristiche dei file.}
408 \label{tab:sys_file_macro}
411 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
412 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
413 conforme deve rispettare; le relative macro sono riportate in
414 \tabref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per le
415 analoghe di \tabref{tab:sys_posix1_general}.
420 \begin{tabular}[c]{|l|r|l|}
422 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
425 \macro{\_POSIX\_LINK\_MAX} &8 & numero massimo di link a un file.\\
426 \macro{\_POSIX\_NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
427 \macro{\_POSIX\_PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
428 \macro{\_POSIX\_PIPE\_BUF}& 512 & byte scrivibili atomicamente in una
430 \macro{\_POSIX\_MAX\_CANON}&255 & dimensione di una riga di
431 terminale in modo canonico.\\
432 \macro{\_POSIX\_MAX\_INPUT}&255 & spazio disponibile nella coda di input
434 % \macro{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
435 % \macro{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
436 % \macro{\_POSIX\_FD\_SETSIZE}& 16 & \\
437 % \macro{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
440 \caption{Macro dei valori minimi delle caratteristiche dei file per la
441 conformità allo standard POSIX.1.}
442 \label{tab:sys_posix1_file}
445 Tutti questi limiti sono definiti in \file{limits.h}; come nel caso precedente
446 il loro uso è di scarsa utilità in quanto ampiamente superati in tutte le
447 implementazioni moderne.
450 \subsection{La funzione \func{pathconf}}
451 \label{sec:sys_pathconf}
453 In generale i limiti per i file sono molto più soggetti ad essere variabili
454 rispetto ai limiti generali del sistema; ad esempio parametri come la
455 lunghezza del nome del file o il numero di link possono variare da filesystem
456 a filesystem; per questo motivo questi limiti devono essere sempre controllati
457 con la funzione \func{pathconf}, il cui prototipo è:
458 \begin{prototype}{unistd.h}{long pathconf(char *path, int name)}
459 Restituisce il valore del parametro \param{name} per il file \param{path}.
461 \bodydesc{La funzione restituisce indietro il valore del parametro
462 richiesto, o -1 in caso di errore (ed \var{errno} viene impostata ad uno
463 degli errori possibili relativi all'accesso a \param{path}).}
466 E si noti come la funzione in questo caso richieda un parametro che specifichi
467 a quale file si fa riferimento, dato che il valore del limite cercato può
468 variare a seconda del filesystem. Una seconda versione della funzione,
469 \func{fpathconf}, opera su un file descriptor invece che su un pathname. Il
471 \begin{prototype}{unistd.h}{long fpathconf(int fd, int name)}
472 Restituisce il valore del parametro \param{name} per il file \param{fd}.
474 \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
475 invece di un pathname; pertanto gli errori restituiti cambiano di
478 \noindent ed il suo comportamento è identico a quello di \func{pathconf}.
481 \subsection{La funzione \func{uname}}
482 \label{sec:sys_uname}
484 Un'altra funzione che si può utilizzare per raccogliere informazioni sia
485 riguardo al sistema che al computer su cui esso sta girando è \func{uname}; il
487 \begin{prototype}{sys/utsname.h}{int uname(struct utsname *info)}
488 Restituisce informazioni sul sistema nella struttura \param{info}.
490 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
491 fallimento, nel qual caso \var{errno} assumerà il valore \macro{EFAULT}.}
494 La funzione, che viene usata dal comando \cmd{uname}, restituisce le
495 informazioni richieste nella struttura \param{info}; anche questa struttura è
496 definita in \file{sys/utsname.h}, secondo quanto mostrato in
497 \secref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
498 indicano rispettivamente:
500 \item il nome del sistema operativo;
501 \item il nome della release del kernel;
502 \item il nome della versione del kernel;
503 \item il tipo di macchina in uso;
504 \item il nome della stazione;
505 \item il nome del domino.
507 l'ultima informazione è stata aggiunta di recente e non è prevista dallo
508 standard POSIX, essa è accessibile, come mostrato in \figref{fig:sys_utsname},
509 solo definendo \macro{\_GNU\_SOURCE}.
512 \footnotesize \centering
513 \begin{minipage}[c]{15cm}
514 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
528 \caption{La struttura \var{utsname}.}
529 \label{fig:sys_utsname}
532 In generale si tenga presente che le dimensioni delle stringe di una
533 \var{utsname} non è specificata, e che esse sono sempre terminate con
534 \macro{NULL}; il manuale delle \acr{glibc} indica due diverse dimensioni,
535 \macro{\_UTSNAME\_LENGTH} per i campi standard e
536 \macro{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
537 altri sistemi usano nomi diversi come \macro{SYS\_NMLN} o \macro{\_SYS\_NMLN}
538 o \macro{UTSLEN} che possono avere valori diversi.\footnote{Nel caso di Linux
539 \func{uname} corrisponde in realtà a 3 system call diverse, le prime due usano
540 rispettivamente delle lunghezze delle stringhe di 9 e 65 byte; la terza usa
541 anch'essa 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con
542 una lunghezza di 257 byte.}
545 \section{Opzioni e configurazione del sistema}
546 \label{sec:sys_config}
548 Come abbiamo accennato nella sezione precedente, non tutti i limiti che
549 caratterizzano il sistema sono fissi, o perlomeno non lo sono in tutte le
550 implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
551 di esaminare il meccanismo che permette, quando questi possono variare durante
552 l'esecuzione del sistema, di modificarli.
554 Inoltre, al di la di quelli che possono essere limiti caratteristici previsti
555 da uno standard, ogni sistema può avere una sua serie di altri parametri di
556 configurazione, che, non essendo mai fissi e variando da sistema a sistema,
557 non sono stati inclusi nella standardizzazione della sezione precedente. Per
558 questi occorre, oltre al meccanismo di impostazione, pure un meccanismo di
559 lettura. Affronteremo questi argomenti in questa sezione, insieme alle
560 funzioni che si usano per il controllo di altre caratteristiche generali del
561 sistema, come quelle per la gestione dei filesystem e di utenti e gruppi.
564 \subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
565 \label{sec:sys_sysctl}
567 La funzione che permette la lettura ed l'impostazione dei parametri del
568 sistema è \func{sysctl}; è una funzione derivata da BSD4.4, ma
569 l'implementazione è specifica di Linux; il suo prototipo è:
572 \funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
573 *newval, size\_t newlen)}
575 Legge o scrive uno dei parametri di sistema.
577 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
578 errore, nel qual caso \var{errno} assumerà uno dei valori:
580 \item[\macro{EPERM}] non si ha il permesso di accedere ad uno dei componenti
581 nel cammino specificato per il parametro, o di accedere al parametro nella
583 \item[\macro{ENOTDIR}] non esiste un parametro corrispondente al nome
585 % \item[\macro{EFAULT}] si è specificato \param{oldlenp} zero quando
586 % \param{oldval} è non nullo.
587 \item[\macro{EINVAL}] o si è specificato un valore non valido per il
588 parametro che si vuole impostare o lo spazio provvisto per il ritorno di un
589 valore non è delle giuste dimensioni.
590 \item[\macro{ENOMEM}] talvolta viene usato più correttamente questo errore
591 quando non si è specificato sufficiente spazio per ricevere il valore di un
594 ed inoltre \macro{EFAULT}.
598 I parametri a cui la funzione permettere di accedere sono organizzati in
599 maniera gerarchica all'interno un albero;\footnote{si tenga presente che
600 includendo solo \file{unistd.h}, saranno definiti solo i parametri generici;
601 dato che ce ne sono molti specifici dell'implementazione, nel caso di Linux
602 occorrerà includere anche i file \file{linux/unistd.h} e
603 \file{linux/sysctl.h}.} per accedere ad uno di essi occorre specificare un
604 cammino attraverso i vari nodi dell'albero, in maniera analoga a come avviene
605 per la risoluzione di un pathname (da cui l'uso alternativo del filesystem
606 \file{/proc}, che vedremo dopo).
608 Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
609 arriva ad identificare un parametro specifico è passato alla funzione
610 attraverso l'array \param{name}, di lunghezza \param{nlen}, che contiene la
611 sequenza dei vari nodi da attraversare. Ogni parametro ha un valore in un
612 formato specifico che può essere un intero, una stringa o anche una struttura
613 complessa, per questo motivo il valori vengono passati come puntatori
616 L'indirizzo a cui il valore corrente del parametro deve essere letto è
617 specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
618 \param{oldlenp} (passato come puntatore per avere indietro la dimensione
619 effettiva di quanto letto); il valore che si vuole impostare nel sistema è
620 passato in \param{newval} e la sua dimensione in \param{newlen}.
622 Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
623 valore letto restituito dalla funzione è quello precedente alla scrittura.
625 I parametri accessibili attraverso questa funzione sono moltissimi, e possono
626 essere trovati in \file{sysctl.h}, essi inoltre dipendono anche dallo stato
627 corrente del kernel (ad esempio dai moduli che sono stati caricati nel
628 sistema) e in genere i loro nomi possono variare da una versione di kernel
629 all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
630 quando esistono modalità alternative per ottenere le stesse informazioni.
631 Alcuni esempi di parametri ottenibili sono:
633 \item il nome di dominio
634 \item i parametri del meccanismo di \textit{paging}.
635 \item il filesystem montato come radice
636 \item la data di compilazione del kernel
637 \item i parametri dello stack TCP
638 \item il numero massimo di file aperti
641 Come accennato in Linux si ha una modalità alternativa per accedere alle
642 stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
643 \file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
644 kernel, che non fa riferimento a nessun dispositivo fisico, ma presenta in
645 forma di file alcune delle strutture interne del kernel stesso.
647 In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
648 di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
649 specificando un pathname e leggendo e scrivendo sul file corrispondente al
650 parametro scelto. Il kernel si occupa di generare al volo il contenuto ed i
651 nomi dei file corrispondenti, e questo ha il grande vantaggio di rendere
652 accessibili i vari parametri a qualunque comando di shell e di permettere la
653 navigazione dell'albero dei valori.
655 Alcune delle corrispondenze dei file presenti in \file{/proc/sys} con i valori
656 di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
657 in \file{linux/sysctl.h},\footnote{indicando un file di definizioni si fa
658 riferimento alla directory standard dei file di include, che in ogni
659 distribuzione che si rispetti è \file{/usr/include}.} la informazione
660 disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
661 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
663 Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc}
664 sono disponibili moltissime altre informazioni, fra cui ad esempio anche
665 quelle fornite da \func{uname} (vedi \secref{sec:sys_config}) che sono
666 mantenute nei file \file{ostype}, \file{hostname}, \file{osrelease},
667 \file{version} e \file{domainname} di \file{/proc/kernel/}.
671 \subsection{La gestione delle proprietà dei filesystem}
672 \label{sec:sys_file_config}
674 Come accennato in \secref{sec:file_organization} per poter accedere ai file
675 occorre prima rendere disponibile al sistema il filesystem su cui essi sono
676 memorizzati; l'operazione di attivazione del filesystem è chiamata
677 \textsl{montaggio}, per far questo in Linux\footnote{la funzione è specifica
678 di Linux e non è portabile.} si usa la funzione \func{mount} il cui prototipo
680 \begin{prototype}{sys/mount.h}
681 {mount(const char *source, const char *target, const char *filesystemtype,
682 unsigned long mountflags, const void *data)}
684 Monta il filesystem di tipo \param{filesystemtype} contenuto in \param{source}
685 sulla directory \param{target}.
687 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
688 fallimento, nel qual caso gli errori comuni a tutti i filesystem che possono
689 essere restituiti in \var{errno} sono:
691 \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
692 \item[\macro{ENODEV}] \param{filesystemtype} non esiste o non è configurato
694 \item[\macro{ENOTBLK}] non si è usato un \textit{block device} per
695 \param{source} quando era richiesto.
696 \item[\macro{EBUSY}] \param{source} è già montato, o non può essere
697 rimontato in read-only perché ci sono ancora file aperti in scrittura, o
698 \param{target} è ancora in uso.
699 \item[\macro{EINVAL}] il device \param{source} presenta un
700 \textit{superblock} non valido, o si è cercato di rimontare un filesystem
701 non ancora montato, o di montarlo senza che \param{target} sia un
702 \textit{mount point} o di spostarlo quando \param{target} non è un
703 \textit{mount point} o è \file{/}.
704 \item[\macro{EACCES}] non si ha il permesso di accesso su uno dei componenti
705 del pathname, o si è cercato di montare un filesystem disponibile in sola
706 lettura senza averlo specificato o il device \param{source} è su un
707 filesystem montato con l'opzione \macro{MS\_NODEV}.
708 \item[\macro{ENXIO}] il \textit{major number} del device \param{source} è
710 \item[\macro{EMFILE}] la tabella dei device \textit{dummy} è piena.
712 ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
713 \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
716 La funzione monta sulla directory \param{target}, detta \textit{mount point},
717 il filesystem contenuto in \param{source}. In generale un filesystem è
718 contenuto su un disco, e l'operazione di montaggio corrisponde a rendere
719 visibile al sistema il contenuto del suddetto disco, identificato attraverso
720 il file di dispositivo ad esso associato.
722 Ma la struttura del virtual filesystem vista in \secref{sec:file_vfs} è molto
723 più flessibile e può essere usata anche per oggetti diversi da un disco. Ad
724 esempio usando il \textit{loop device} si può montare un file qualunque (come
725 l'immagine di un CD-ROM o di un floppy) che contiene un filesystem, inoltre
726 alcuni filesystem, come \file{proc} o \file{devfs} sono del tutto virtuali, i
727 loro dati sono generati al volo ad ogni lettura, e passati al kernel ad ogni
730 Il tipo di filesystem è specificato da \param{filesystemtype}, che deve essere
731 una delle stringhe riportate nel file \file{/proc/filesystems}, che contiene
732 l'elenco dei filesystem supportati dal kernel; nel caso si sia indicato uno
733 dei filesystem virtuali, il contenuto di \param{source} viene ignorato.
735 Dopo l'esecuzione della funzione il contenuto del filesystem viene resto
736 disponibile nella directory specificata come \textit{mount point}, il
737 precedente contenuto di detta directory viene mascherato dal contenuto della
738 directory radice del filesystem montato.
740 Dal kernel 2.4.x inoltre è divenuto possibile sia spostare atomicamente un
741 \textit{mount point} da una directory ad un'altra, sia montare in diversi
742 \textit{mount point} lo stesso filesystem, sia montare più filesystem sullo
743 stesso \textit{mount point} (nel qual caso vale quanto appena detto, e solo il
744 contenuto dell'ultimo filesystem montato sarà visibile).
746 Ciascun filesystem è dotato di caratteristiche specifiche che possono essere
747 attivate o meno, alcune di queste sono generali (anche se non è detto siano
748 disponibili in ogni filesystem), e vengono specificate come opzioni di
749 montaggio con l'argomento \param{mountflags}.
751 In Linux \param{mountflags} deve essere un intero a 32 bit i cui 16 più
752 significativi sono un \textit{magic number}\footnote{cioè un numero speciale
753 usato come identificativo, che nel caso è \code{0xC0ED}; si può usare la
754 costante \macro{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
755 riservata al \textit{magic number}.} mentre i 16 meno significativi sono
756 usati per specificare le opzioni; essi sono usati come maschera binaria e
757 vanno impostati con un OR aritmetico della costante \macro{MS\_MGC\_VAL} con i
758 valori riportati in \tabref{tab:sys_mount_flags}.
763 \begin{tabular}[c]{|l|r|l|}
765 \textbf{Parametro} & \textbf{Valore}&\textbf{Significato}\\
768 \macro{MS\_RDONLY} & 1 & monta in sola lettura\\
769 \macro{MS\_NOSUID} & 2 & ignora i bit \acr{suid} e \acr{sgid}\\
770 \macro{MS\_NODEV} & 4 & impedisce l'accesso ai file di dispositivo\\
771 \macro{MS\_NOEXEC} & 8 & impedisce di eseguire programmi \\
772 \macro{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
773 \macro{MS\_REMOUNT} & 32 & rimonta il filesystem cambiando i flag\\
774 \macro{MS\_MANDLOCK} & 64 & consente il \textit{mandatory locking} (vedi
775 \secref{sec:file_mand_locking})\\
776 \macro{S\_WRITE} & 128 & scrive normalmente \\
777 \macro{S\_APPEND} & 256 & consente la scrittura solo in \textit{append
778 mode} (vedi \secref{sec:file_sharing})\\
779 \macro{S\_IMMUTABLE} & 512 & impedisce che si possano modificare i file \\
780 \macro{MS\_NOATIME} &1024 & non aggiorna gli \textit{access time} (vedi
781 \secref{sec:file_file_times})\\
782 \macro{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
784 \macro{MS\_BIND} &4096 & monta il filesystem altrove\\
785 \macro{MS\_MOVE} &8192 & sposta atomicamente il punto di montaggio \\
788 \caption{Tabella dei codici dei flag di montaggio di un filesystem.}
789 \label{tab:sys_mount_flags}
792 Per l'impostazione delle caratteristiche particolari di ciascun filesystem si
793 usa invece l'argomento \param{data} che serve per passare le ulteriori
794 informazioni necessarie, che ovviamente variano da filesystem a filesystem.
796 La funzione \func{mount} può essere utilizzata anche per effettuare il
797 \textsl{rimontaggio} di un filesystem, cosa che permette di cambiarne al volo
798 alcune delle caratteristiche di funzionamento (ad esempio passare da sola
799 lettura a lettura/scrittura). Questa operazione è attivata attraverso uno dei
800 bit di \param{mountflags}, \macro{MS\_REMOUNT}, che se impostato specifica che
801 deve essere effettuato il rimontaggio del filesystem (con le opzioni
802 specificate dagli altri bit), anche in questo caso il valore di \param{source}
805 Una volta che non si voglia più utilizzare un certo filesystem è possibile
806 \textsl{smontarlo} usando la funzione \func{umount}, il cui prototipo è:
807 \begin{prototype}{sys/mount.h}{umount(const char *target)}
809 Smonta il filesystem montato sulla directory \param{target}.
811 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
812 fallimento, nel qual caso \var{errno} assumerà uno dei valori:
814 \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
815 \item[\macro{EBUSY}] \param{target} è la directory di lavoro di qualche
816 processo, o contiene dei file aperti, o un altro mount point.
818 ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
819 \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
821 \noindent la funzione prende il nome della directory su cui il filesystem è
822 montato e non il file o il dispositivo che è stato montato,\footnote{questo è
823 vero a partire dal kernel 2.3.99-pre7, prima esistevano due chiamate
824 separate e la funzione poteva essere usata anche specificando il file di
825 dispositivo.} in quanto con il kernel 2.4.x è possibile montare lo stesso
826 dispositivo in più punti. Nel caso più di un filesystem sia stato montato
827 sullo stesso \textit{mount point} viene smontato quello che è stato montato
830 Si tenga presente che la funzione fallisce quando il filesystem è
831 \textsl{occupato}, questo avviene quando ci sono ancora file aperti sul
832 filesystem, se questo contiene la directory di lavoro corrente di un qualunque
833 processo o il mount point di un altro filesystem; in questo caso l'errore
834 restituito è \macro{EBUSY}.
836 Linux provvede inoltre una seconda funzione, \func{umount2}, che in alcuni
837 casi permette di forzare lo smontaggio di un filesystem, anche quando questo
838 risulti occupato; il suo prototipo è:
839 \begin{prototype}{sys/mount.h}{umount2(const char *target, int flags)}
841 La funzione è identica a \func{umount} per comportamento e codici di errore,
842 ma con \param{flags} si può specificare se forzare lo smontaggio.
845 Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
846 definito è il bit \macro{MNT\_FORCE}; gli altri bit devono essere nulli.
847 Specificando \macro{MNT\_FORCE} la funzione cercherà di liberare il filesystem
848 anche se è occupato per via di una delle condizioni descritte in precedenza. A
849 seconda del tipo di filesystem alcune (o tutte) possono essere superate,
850 evitando l'errore di \macro{EBUSY}. In tutti i casi prima dello smontaggio
851 viene eseguita una sincronizzazione dei dati.
853 Altre due funzioni specifiche di Linux,\footnote{esse si trovano anche su BSD,
854 ma con una struttura diversa.} utili per ottenere in maniera diretta
855 informazioni riguardo al filesystem su cui si trova un certo file, sono
856 \func{statfs} e \func{fstatfs}, i cui prototipi sono:
859 \funcdecl{int statfs(const char *path, struct statfs *buf)}
861 \funcdecl{int fstatfs(int fd, struct statfs *buf)}
863 Restituisce in \param{buf} le informazioni relative al filesystem su cui è
864 posto il file specificato.
866 \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
867 errore, nel qual caso \var{errno} assumerà uno dei valori:
869 \item[\macro{ENOSYS}] il filesystem su cui si trova il file specificato non
870 supporta la funzione.
872 e \macro{EFAULT} ed \macro{EIO} per entrambe, \macro{EBADF} per
873 \func{fstatfs}, \macro{ENOTDIR}, \macro{ENAMETOOLONG}, \macro{ENOENT},
874 \macro{EACCES}, \macro{ELOOP} per \func{statfs}.}
877 Queste funzioni permettono di ottenere una serie di informazioni generali
878 riguardo al filesystem su cui si trova il file specificato; queste vengono
879 restituite una struttura \param{buf} di tipo \type{statfs} definita come in
880 \ref{fig:sys_statfs}, ed i campi che sono indefiniti per il filesystem in
881 esame sono impostati a zero. I valori del campo \var{f\_type} sono definiti per
882 i vari filesystem nei relativi file di header dei sorgenti del kernel da
883 costanti del tipo \macro{XXX\_SUPER\_MAGIC}, dove \macro{XXX} in genere è il
884 nome del filesystem stesso.
887 \footnotesize \centering
888 \begin{minipage}[c]{15cm}
889 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
891 long f_type; /* tipo di filesystem */
892 long f_bsize; /* dimensione ottimale dei blocchi di I/O */
893 long f_blocks; /* blocchi totali nel filesystem */
894 long f_bfree; /* blocchi liberi nel filesystem */
895 long f_bavail; /* blocchi liberi agli utenti normali */
896 long f_files; /* inodes totali nel filesystem */
897 long f_ffree; /* inodes liberi nel filesystem */
898 fsid_t f_fsid; /* filesystem id */
899 long f_namelen; /* lunghezza massima dei nomi dei file */
900 long f_spare[6]; /* riservati per uso futuro */
905 \caption{La struttura \var{statfs}.}
906 \label{fig:sys_statfs}
910 Le \acr{glibc} provvedono infine una serie di funzioni per la gestione dei due
911 file \file{/etc/fstab} ed \file{/etc/mtab}, che convenzionalmente sono usati in
912 quasi tutti i sistemi unix-like per mantenere rispettivamente le informazioni
913 riguardo ai filesystem da montare e a quelli correntemente montati. Le
914 funzioni servono a leggere il contenuto di questi file in opportune strutture
915 \var{struct fstab} e \var{struct mntent}, e, per \file{/etc/mtab} per inserire
916 e rimuovere le voci presenti nel file.
918 In generale si dovrebbero usare queste funzioni (in particolare quelle
919 relative a \file{/etc/mtab}), quando si debba scrivere un programma che
920 effettua il montaggio di un filesystem; in realtà in questi casi è molto più
921 semplice invocare direttamente il programma \cmd{mount}, per cui ne
922 tralasceremo la trattazione, rimandando al manuale delle \acr{glibc}
923 \cite{glibc} per la documentazione completa.
926 \subsection{La gestione di utenti e gruppi}
927 \label{sec:sys_user_group}
929 Tradizionalmente l'informazione per la gestione di utenti e gruppi veniva
930 tenuta tutta nei due file di testo \file{/etc/passwd} ed \file{/etc/group}, e
931 tutte le funzioni facevano riferimento ad essi. Oggi la maggior parte delle
932 distribuzioni di Linux usa la libreria PAM (sigla che sta \textit{Pluggable
933 Authentication Method}) che permette di separare completamente i meccanismi
934 di gestione degli utenti (autenticazione, riconoscimento, ecc.) dalle modalità
935 in cui i relativi dati vengono mantenuti, per cui pur restando in gran parte
936 le stesse\footnote{in genere quello che viene cambiato è l'informazione usata
937 per l'autenticazione, che non è più necessariamente una password criptata da
938 verificare, ma può assumere le forme più diverse, come impronte digitali,
939 chiavi elettroniche, ecc.}, le informazioni non sono più necessariamente
940 mantenute in quei file.
942 In questo paragrafo ci limiteremo comunque alle funzioni classiche per la
943 lettura delle informazioni relative a utenti e gruppi previste dallo standard
944 POSIX.1, che fanno riferimento a quanto memorizzato nei due file appena
945 citati, il cui formato è descritto dalle relative pagine del manuale (cioè
946 \cmd{man 5 passwd} e \cmd{man 5 group}).
948 Per leggere le informazioni relative ad un utente si possono usare due
949 funzioni, \func{getpwuid} e \func{getpwnam}, i cui prototipi sono:
952 \headdecl{sys/types.h}
953 \funcdecl{struct passwd *getpwuid(uid\_t uid)}
955 \funcdecl{struct passwd *getpwnam(const char *name)}
957 Restituiscono le informazioni relative all'utente specificato.
959 \bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
960 informazioni in caso di successo e \macro{NULL} nel caso non sia stato
961 trovato nessun utente corrispondente a quanto specificato.}
964 Le due funzioni forniscono le informazioni memorizzate nel database degli
965 utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
966 relative all'utente specificato attraverso il suo \acr{uid} o il nome di
967 login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
968 tipo \type{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
969 riportata in \figref{fig:sys_passwd_struct}, dove è pure brevemente illustrato
970 il significato dei vari campi.
975 \begin{minipage}[c]{15cm}
976 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
978 char *pw_name; /* user name */
979 char *pw_passwd; /* user password */
980 uid_t pw_uid; /* user id */
981 gid_t pw_gid; /* group id */
982 char *pw_gecos; /* real name */
983 char *pw_dir; /* home directory */
984 char *pw_shell; /* shell program */
989 \caption{La struttura \var{passwd} contenente le informazioni relative ad un
991 \label{fig:sys_passwd_struct}
994 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
995 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
996 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
997 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
998 essere rientranti, per cui ne esistono anche due versioni alternative
999 (denotate dalla solita estensione \code{\_r}), i cui prototipi sono:
1003 \headdecl{sys/types.h}
1005 \funcdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
1006 char *buffer, size\_t buflen, struct passwd **result)}
1008 \funcdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
1009 *password, char *buffer, size\_t buflen, struct passwd **result)}
1011 Restituiscono le informazioni relative all'utente specificato.
1013 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1014 altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
1017 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
1018 la memoria necessaria a contenere le informazioni. In particolare i valori
1019 della struttura \var{passwd} saranno restituiti all'indirizzo \param{password}
1020 mentre la memoria allocata all'indirizzo \param{buffer}, per un massimo di
1021 \param{buflen} byte, sarà utilizzata per contenere le stringhe puntate dai
1022 campi di \param{password}. Infine all'indirizzo puntato da \param{result}
1023 viene restituito il puntatore ai dati ottenuti, cioè \param{buffer} nel caso
1024 l'utente esista, o \macro{NULL} altrimenti. Qualora i dati non possano essere
1025 contenuti nei byte specificati da \param{buflen}, la funzione fallirà
1026 restituendo \macro{ERANGE} (e \param{result} sarà comunque impostato a
1029 Del tutto analoghe alle precedenti sono le funzioni \func{getgrnam} e
1030 \func{getgrgid} (e le relative analoghe rientranti con la stessa estensione
1031 \code{\_r}) che permettono di leggere le informazioni relative ai gruppi, i
1032 loro prototipi sono:
1035 \headdecl{sys/types.h}
1037 \funcdecl{struct group *getgrgid(gid\_t gid)}
1039 \funcdecl{struct group *getgrnam(const char *name)}
1041 \funcdecl{struct group *getpwuid\_r(gid\_t gid, struct group *password,
1042 char *buffer, size\_t buflen, struct group **result)}
1044 \funcdecl{struct group *getpwnam\_r(const char *name, struct group
1045 *password, char *buffer, size\_t buflen, struct group **result)}
1047 Restituiscono le informazioni relative al gruppo specificato.
1049 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1050 altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
1053 Il comportamento di tutte queste funzioni è assolutamente identico alle
1054 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
1055 in questo caso le informazioni vengono restituite in una struttura di tipo
1056 \type{group}, la cui definizione è riportata in \figref{fig:sys_group_struct}.
1058 \begin{figure}[!htb]
1061 \begin{minipage}[c]{15cm}
1062 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1064 char *gr_name; /* group name */
1065 char *gr_passwd; /* group password */
1066 gid_t gr_gid; /* group id */
1067 char **gr_mem; /* group members */
1072 \caption{La struttura \var{group} contenente le informazioni relative ad un
1073 gruppo del sistema.}
1074 \label{fig:sys_group_struct}
1077 Le funzioni viste finora sono in grado di leggere le informazioni sia dal file
1078 delle password in \file{/etc/passwd} che con qualunque altro metodo sia stato
1079 utilizzato per mantenere il database degli utenti. Non permettono però di
1080 impostare direttamente le password; questo è possibile con un'altra interfaccia
1081 al database degli utenti, derivata da SVID, che però funziona soltanto con un
1082 database che sia tenuto su un file che abbia il formato classico di
1088 \begin{tabular}[c]{|l|p{8cm}|}
1090 \textbf{Funzione} & \textbf{Significato}\\
1093 \func{fgetpwent} & Legge una voce dal database utenti da un file
1094 specificato aprendolo la prima volta.\\
1095 \func{fgetpwent\_r}& Come la precedente, ma rientrante.\\
1096 \func{getpwent} & Legge una voce dal database utenti (da
1097 \file{/etc/passwd}) aprendolo la prima volta.\\
1098 \func{getpwent\_r} & Come la precedente, ma rientrante.\\
1099 \func{setpwent} & Ritorna all'inizio del database.\\
1100 \func{putpwent} & Immette una voce nel database utenti.\\
1101 \func{endpwent} & Chiude il database degli utenti.\\
1102 \func{fgetgrent} & Legge una voce dal database dei gruppi da un file
1103 specificato aprendolo la prima volta.\\
1104 \func{fgetgrent\_r}& Come la precedente, ma rientrante.\\
1105 \func{getgrent} & Legge una voce dal database dei gruppi (da
1106 \file{/etc/passwd}) aprendolo la prima volta.\\
1107 \func{getgrent\_r} & Come la precedente, ma rientrante.\\
1108 \func{setgrent} & Immette una voce nel database dei gruppi.\\
1109 \func{putgrent} & Immette una voce nel database dei gruppi.\\
1110 \func{endgrent} & Chiude il database dei gruppi.\\
1113 \caption{Funzioni per la manipolazione dei campi di un file usato come
1114 database di utenti e gruppi nel formato di \file{/etc/passwd} e
1115 \file{/etc/groups}.}
1116 \label{tab:sys_passwd_func}
1119 Dato che ormai la gran parte delle distribuzioni di Linux utilizzano PAM, che
1120 come minimo usa almeno le \textit{shadow password} (quindi con delle modifiche
1121 rispetto al formato classico di \file{/etc/passwd}), le funzioni che danno la
1122 capacità scrivere delle voci nel database (cioè \func{putpwent} e
1123 \func{putgrent}) non permettono di effettuarne una specificazione in maniera
1124 completa. Per questo motivo l'uso di queste funzioni è deprecato in favore
1125 dell'uso di PAM, ci limiteremo pertanto ad elencarle in
1126 \tabref{tab:sys_passwd_func}, rimandando chi fosse interessato alle rispettive
1127 pagine di manuale e al manuale delle \acr{glibc} per i dettagli del loro
1132 \subsection{Il database di accounting}
1133 \label{sec:sys_accounting}
1135 L'ultimo insieme di funzioni relative alla gestione del sistema che
1136 esamineremo è quello che permette di accedere ai dati del database di
1137 \textit{accounting}. In esso vengono mantenute una serie di informazioni
1138 storiche relative sia agli utenti che si sono collegati al sistema, (tanto per
1139 quelli correntemente collegati, che per la registrazione degli accessi
1140 precedenti), sia relative all'intero sistema, come il momento di lancio di
1141 processi da parte di \cmd{init}, il cambiamento dell'orologio di sistema, il
1142 cambiamento di runlevel o il riavvio della macchina.
1144 I dati vengono usualmente\footnote{questa è la locazione specificata dal
1145 \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
1146 delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
1147 \file{/var/log/wtmp}. Quando un utente si collega viene aggiunta una voce a
1148 \file{/var/run/utmp} in cui viene memorizzato il nome di login, il terminale
1149 da cui ci si collega, l'\acr{uid} della shell di login, l'orario della
1150 connessione ed altre informazioni. La voce resta nel file fino al logout,
1151 quando viene cancellata e spostata in \file{/var/log/wtmp}.
1153 In questo modo il primo file viene utilizzato per registrare sta utilizzando
1154 il sistema al momento corrente, mentre il secondo mantiene la registrazione
1155 delle attività degli utenti. A quest'ultimo vengono anche aggiunte delle voci
1156 speciali per tenere conto dei cambiamenti del sistema, come la modifica del
1157 runlevel, il riavvio della macchina, ecc. Tutte queste informazioni sono
1158 descritte in dettaglio nel manuale delle \acr{glibc}.
1160 Questi file non devono mai essere letti direttamente, ma le informazioni che
1161 contengono possono essere ricavate attraverso le opportune funzioni di
1162 libreria. Queste sono analoghe alle precedenti (vedi
1163 \tabref{tab:sys_passwd_func}) usate per accedere al database degli utenti,
1164 solo che in questo caso la struttura del database di accounting è molto più
1165 complessa, dato che contiene diversi tipi di informazione.
1167 Le prime tre funzioni, \func{setutent}, \func{endutent} e \func{utmpname}
1168 servono rispettivamente a aprire e a chiudere il file che contiene il
1169 database, e a specificare su quale file esso viene mantenuto. I loro prototipi
1174 \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
1175 database di \textit{accounting}.
1177 \funcdecl{void setutent(void)} Apre il file del database di
1178 \textit{accounting}, posizionandosi al suo inizio.
1180 \funcdecl{void endutent(void)} Chiude il file del database di
1181 \textit{accounting}.
1183 \bodydesc{Le funzioni non ritornano codici di errore.}
1186 In caso questo non venga specificato nessun file viene usato il valore
1187 standard \macro{\_PATH\_UTMP} (che è definito in \file{paths.h}); in genere
1188 \func{utmpname} prevede due possibili valori:
1189 \begin{basedescript}{\desclabelwidth{2.0cm}}
1190 \item[\macro{\_PATH\_UTMP}] Specifica il database di accounting per gli utenti
1191 correntemente collegati.
1192 \item[\macro{\_PATH\_WTMP}] Specifica il database di accounting per l'archivio
1193 storico degli utenti collegati.
1195 corrispondenti ai file \file{/var/run/utmp} e \file{/var/log/wtmp} visti in
1198 Una volta aperto il file si può eseguire una scansione leggendo o scrivendo
1199 una voce con le funzioni \func{getutent}, \func{getutid}, \func{getutline} e
1200 \func{pututline}, i cui prototipi sono:
1204 \funcdecl{struct utmp *getutent(void)}
1205 Legge una voce dal dalla posizione corrente nel database.
1207 \funcdecl{struct utmp *getutid(struct utmp *ut)}
1208 Ricerca una voce sul database in base al contenuto di \param{ut}.
1210 \funcdecl{struct utmp *getutline(struct utmp *ut)}
1211 Ricerca nel database la prima voce corrispondente ad un processo sulla linea
1212 di terminale specificata tramite \param{ut}.
1214 \funcdecl{struct utmp *pututline(struct utmp *ut)}
1215 Scrive una voce nel database.
1217 \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
1218 caso di successo e \macro{NULL} in caso di errore.}
1221 Tutte queste funzioni fanno riferimento ad una struttura di tipo \var{utmp},
1222 la cui definizione in Linux è riportata in \secref{fig:sys_utmp_struct}. Le
1223 prime tre funzioni servono per leggere una voce dal database; \func{getutent}
1224 legge semplicemente la prima voce disponibile; le altre due permettono di
1225 eseguire una ricerca.
1227 \begin{figure}[!htb]
1230 \begin{minipage}[c]{15cm}
1231 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1234 short int ut_type; /* Type of login. */
1235 pid_t ut_pid; /* Process ID of login process. */
1236 char ut_line[UT_LINESIZE]; /* Devicename. */
1237 char ut_id[4]; /* Inittab ID. */
1238 char ut_user[UT_NAMESIZE]; /* Username. */
1239 char ut_host[UT_HOSTSIZE]; /* Hostname for remote login. */
1240 struct exit_status ut_exit; /* Exit status of a process marked
1242 long int ut_session; /* Session ID, used for windowing. */
1243 struct timeval ut_tv; /* Time entry was made. */
1244 int32_t ut_addr_v6[4]; /* Internet address of remote host. */
1245 char __unused[20]; /* Reserved for future use. */
1250 \caption{La struttura \var{utmp} contenente le informazioni di una voce del
1251 database di \textit{accounting}.}
1252 \label{fig:sys_utmp_struct}
1255 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1256 campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
1257 riportati in \tabref{tab:sys_ut_type}, quando assume i valori
1258 \macro{RUN\_LVL}, \macro{BOOT\_TIME}, \macro{OLD\_TIME}, \macro{NEW\_TIME},
1259 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1260 invece assume i valori \macro{INIT\_PROCESS}, \macro{LOGIN\_PROCESS},
1261 \macro{USER\_PROCESS} o \macro{DEAD\_PROCESS} verrà restituita la prima voce
1262 corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1267 \begin{tabular}[c]{|l|p{8cm}|}
1269 \textbf{Funzione} & \textbf{Significato}\\
1272 \macro{EMPTY} & Non contiene informazioni valide. \\
1273 \macro{RUN\_LVL} & Identica il runlevel del sistema. \\
1274 \macro{BOOT\_TIME} & Identifica il tempo di avvio del sistema \\
1275 \macro{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
1277 \macro{NEW\_TIME} & Identifica da quanto è stato modificato il
1279 \macro{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}. \\
1280 \macro{LOGIN\_PROCESS}& Identifica un processo di login. \\
1281 \macro{USER\_PROCESS} & Identifica un processo utente. \\
1282 \macro{DEAD\_PROCESS} & Identifica un processo terminato. \\
1283 \macro{ACCOUNTING} & ??? \\
1286 \caption{Classificazione delle voci del database di accounting a seconda dei
1287 possibili valori del campo \var{ut\_type}.}
1288 \label{tab:sys_ut_type}
1291 La funzione \func{getutline} esegue la ricerca sulle voci che hanno
1292 \var{ut\_type} uguale a \macro{LOGIN\_PROCESS} o \macro{USER\_PROCESS},
1293 restituendo la prima che corrisponde al valore di \var{ut\_line}, che
1294 specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
1295 terminale che interessa. Lo stesso criterio di ricerca è usato da
1296 \func{pututline} per trovare uno spazio dove inserire la voce specificata,
1297 qualora non sia trovata la voce viene aggiunta in coda al database.
1299 In generale occorre però tenere conto che queste funzioni non sono
1300 completamente standardizzate, e che in sistemi diversi possono esserci
1301 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1302 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1303 fornita dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1304 introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
1305 sono un sovrainsieme di \code{utmp}.
1307 Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
1308 inutili queste nuove strutture; pertanto esse e le relative funzioni di
1309 gestione (\func{getutxent}, \func{getutxid}, \func{getutxline},
1310 \func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
1311 sinonimi delle funzioni appena viste.
1313 Come visto in \secref{sec:sys_user_group}, l'uso di strutture allocate
1314 staticamente rende le funzioni di lettura non rientranti; per questo motivo le
1315 \acr{glibc} forniscono anche delle versioni rientranti: \func{getutent\_r},
1316 \func{getutid\_r}, \func{getutline\_r}, che invece di restituire un puntatore
1317 restituiscono un intero e prendono due argomenti aggiuntivi. Le funzioni si
1318 comportano esattamente come le analoghe non rientranti, solo che restituiscono
1319 il risultato all'indirizzo specificato dal primo argomento aggiuntivo (di tipo
1320 \code{struct utmp *buffer}) mentre il secondo (di tipo \code{struct utmp
1321 **result)} viene usato per restituire il puntatore allo stesso buffer.
1323 Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
1324 in \file{wmtp} altre due funzioni, \func{updwtmp} e \func{logwtmp}, i cui
1329 \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1330 Aggiunge la voce \param{ut} nel database di accounting \file{wmtp}.
1332 \funcdecl{void logwtmp(const char *line, const char *name, const char
1333 *host)} Aggiunge nel database di accounting una voce con i valori
1336 \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
1337 caso di successo e \macro{NULL} in caso di errore.}
1340 La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
1341 direttamente una struttura \type{utmp}, mentre la seconda utilizza gli
1342 argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
1343 poi aggiunge chiamando \func{updwtmp}.
1346 \section{Limitazione ed uso delle risorse}
1347 \label{sec:sys_res_limits}
1350 Dopo aver esaminato le funzioni che permettono di controllare le varie
1351 caratteristiche, capacità e limiti del sistema a livello globale, in questa
1352 sezione tratteremo le varie funzioni che vengono usate per quantificare le
1353 risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
1354 permettono di imporre a ciascuno di essi vincoli e limiti di utilizzo.
1357 \subsection{L'uso delle risorse}
1358 \label{sec:sys_resource_use}
1360 Come abbiamo accennato in \secref{sec:proc_wait4} le informazioni riguardo
1361 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1362 di tipo \code{struct }\type{rusage}, la cui definizione (che si trova in
1363 \file{sys/resource.h}) è riportata in \figref{fig:sys_rusage_struct}.
1365 \begin{figure}[!htb]
1368 \begin{minipage}[c]{15cm}
1369 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1371 struct timeval ru_utime; /* user time used */
1372 struct timeval ru_stime; /* system time used */
1373 long ru_maxrss; /* maximum resident set size */
1374 long ru_ixrss; /* integral shared memory size */
1375 long ru_idrss; /* integral unshared data size */
1376 long ru_isrss; /* integral unshared stack size */
1377 long ru_minflt; /* page reclaims */
1378 long ru_majflt; /* page faults */
1379 long ru_nswap; /* swaps */
1380 long ru_inblock; /* block input operations */
1381 long ru_oublock; /* block output operations */
1382 long ru_msgsnd; /* messages sent */
1383 long ru_msgrcv; /* messages received */
1384 long ru_nsignals; ; /* signals received */
1385 long ru_nvcsw; /* voluntary context switches */
1386 long ru_nivcsw; /* involuntary context switches */
1391 \caption{La struttura \var{rusage} per la lettura delle informazioni dei
1392 delle risorse usate da un processo.}
1393 \label{fig:sys_rusage_struct}
1396 La struttura è ripresa da BSD 4.3, ma attualmente (con i kernel della serie
1397 2.4.x) i soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
1398 \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I primi due indicano
1399 rispettivamente il tempo impiegato dal processo nell'eseguire le istruzioni in
1400 user space, e quello impiegato dal kernel nelle system call eseguite per conto
1403 Gli altri tre campi servono a quantificare l'uso della memoria
1404 virtuale\index{memoria virtuale} e corrispondono rispettivamente al numero di
1405 \textit{page fault}\index{page fault} (vedi \secref{sec:proc_mem_gen})
1406 avvenuti senza richiedere I/O (i cosiddetti \textit{minor page fault}), a
1407 quelli che invece han richiesto I/O (detti invece \textit{major page fault})
1408 ed al numero di volte che il processo è stato completamente tolto dalla
1409 memoria per essere inserito nello swap.
1411 In genere includere esplicitamente \file{<sys/time.h>} non è più necessario,
1412 ma aumenta la portabilità, e serve comunque quando, come nella maggior parte
1413 dei casi, si debba accedere ai campi di \var{rusage} relativi ai tempi di
1414 utilizzo del processore, che sono definiti come \code{struct }\type{timeval}.
1417 Questa è la stessa struttura utilizzata da \func{wait4} per ricavare la
1418 quantità di risorse impiegato dal processo di cui si è letto lo stato di
1419 terminazione, ma essa può anche essere letta direttamente utilizzando la
1420 funzione \func{getrusage}, il cui prototipo è:
1422 \headdecl{sys/time.h}
1423 \headdecl{sys/resource.h}
1426 \funcdecl{int getrusage(int who, struct rusage *usage)}
1427 Legge la quantità di risorse usate da un processo.
1430 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1431 nel qual caso \var{errno} può essere \macro{EINVAL} o \macro{EFAULT}.}
1434 L'argomento \param{who} permette di specificare il processo di cui si vuole
1435 leggere l'uso delle risorse; esso può assumere solo i due valori
1436 \macro{RUSAGE\_SELF} per indicare il processo corrente e
1437 \macro{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
1438 ricevuto lo stato di terminazione.
1441 \subsection{Limiti sulle risorse}
1442 \label{sec:sys_resource_limit}
1444 Come accennato nell'introduzione oltre a leggere l'uso delle risorse da parte
1445 di un processo si possono anche imporre dei limiti sulle sue capacità. Ogni
1446 processo ha in generale due limiti associati ad ogni risorsa; questi sono
1447 detti il \textsl{limite corrente} (o \textit{current limit}) che esprime il
1448 valore che attualmente il processo non può superare, ed il \textsl{limite
1449 massimo} (o \textit{maximum limit}) che esprime il valore massimo che può
1450 assumere il \textsl{limite corrente}.
1452 In generale il primo viene chiamato un limite \textsl{soffice} (o \textit{soft
1453 limit}) dato che il suo valore può essere aumentato, mentre il secondo è
1454 detto \textsl{duro} (o \textit{hard limit}), in quanto un processo normale non
1455 può modificarne il valore. Il valore di questi limiti è mantenuto in una
1456 struttura \var{rlimit}, la cui definizione è riportata in
1457 \figref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a limite
1460 \begin{figure}[!htb]
1463 \begin{minipage}[c]{15cm}
1464 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1472 \caption{La struttura \var{rlimit} per impostare i limiti di utilizzo
1473 delle risorse usate da un processo.}
1474 \label{fig:sys_rlimit_struct}
1477 In genere il superamento di un limite comporta o l'emissione di un segnale o
1478 il fallimento della system call che lo ha provocato; per far leggere o impostare
1479 i limiti di utilizzo delle risorse da parte di un processo le \acr{glibc}
1480 prevedono due funzioni, \func{getrlimit} e \func{setrlimit}, i cui prototipi
1483 \headdecl{sys/time.h}
1484 \headdecl{sys/resource.h}
1487 \funcdecl{int getrlimit(int resource, struct rlimit *rlim)}
1489 Legge il limite corrente per la risorsa \param{resource}.
1491 \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)}
1493 Imposta il limite per la risorsa \param{resource}.
1495 \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
1496 errore, nel qual caso \var{errno} assumerà uno dei valori:
1498 \item[\macro{EINVAL}] I valori per \param{resource} non sono validi.
1499 \item[\macro{EPERM}] Un processo senza i privilegi di amministratore ha
1500 cercato di innalzare i propri limiti.
1505 Entrambe le funzioni permettono di specificare su quale risorsa si vuole
1506 operare attraverso \param{resource}, i cui possibili valori sono elencati in
1507 \secref{tab:sys_rlimit_values}, e utilizzano una struttura \var{rlimit} per
1508 specificarne i valori.
1513 \begin{tabular}[c]{|l|p{12cm}|}
1515 \textbf{Valore} & \textbf{Significato}\\
1518 \macro{RLIMIT\_CPU} & Il massimo tempo di CPU che il processo può
1519 usare. Il superamento del limite comporta
1520 l'emissione di un segnale di \macro{SIGXCPU}.\\
1521 \macro{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
1522 può usare. Se il processo cerca di scrivere
1523 oltre questa dimensione riceverà un segnale di
1525 \macro{RLIMIT\_DATA} & La massima dimensione della memoria dati di un
1526 processo. Il tentativo di allocare più memoria
1527 causa il fallimento della funzione di
1529 \macro{RLIMIT\_STACK} & La massima dimensione dello stack del
1530 processo. Se il processo esegue operazioni che
1531 estendano lo stack oltre questa dimensione
1532 riceverà un segnale di \macro{SIGSEGV}.\\
1533 \macro{RLIMIT\_CORE} & La massima dimensione di un file di \textit{core
1534 dump} creato da un processo. Nel caso le
1535 dimensioni dovessero essere maggiori il file non
1536 verrebbe generato.\footnotemark\\
1537 \macro{RLIMIT\_RSS} & L'ammontare massimo di memoria fisica dato al
1538 processo. Il limite è solo una indicazione per
1539 il kernel, qualora ci fosse un surplus di
1540 memoria questa verrebbe assegnata.\\
1541 \macro{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
1542 creati sullo stesso user id. Se il limite viene
1543 raggiunto \func{fork} fallirà con un
1545 \macro{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
1546 aprire. L'apertura di un ulteriore file fallirà
1547 con un errore \macro{EMFILE}.\\
1548 \macro{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
1549 bloccata (vedi \secref{sec:proc_mem_lock}).\\
1550 \macro{RLIMIT\_AS} & La dimensione massima di tutta la memoria che il
1551 processo può ottenere. Se il processo tenta di
1552 allocarne di più funzioni come \func{brk},
1553 \func{malloc} o \func{mmap} falliranno. \\
1556 \caption{Valori possibili dell'argomento \param{resource} delle funzioni
1557 \func{getrlimit} e \func{setrlimit}.}
1558 \label{tab:sys_rlimit_values}
1561 \footnotetext{Impostare questo limite a zero è la maniera più semplice per
1562 evitare la creazione di \file{core} file.}
1564 È inoltre definita la costante \macro{RLIM\_INFINITY} che permette di
1565 sbloccare l'uso di una risorsa, ma solo un processo con i privilegi di
1566 amministratore può innalzare un limite al di sopra del valore corrente del
1567 limite massimo. Si tenga conto infine che tutti i limiti vengono ereditati dal
1568 processo padre attraverso una \func{fork} (vedi \secref{sec:proc_fork}) e
1569 mantenuti attraverso una \func{exec} (vedi \secref{sec:proc_exec}).
1572 \subsection{Le risorse di memoria e processore}
1573 \label{sec:sys_memory_res}
1575 La gestione della memoria è già stata affrontata in dettaglio in
1576 \secref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1577 meccanismo della memoria virtuale\index{memoria virtuale} attraverso la
1578 divisione della memoria fisica in pagine.
1580 In genere questo è del tutto trasparente al singolo processo, ma in certi
1581 casi, come per l'I/O mappato in memoria (vedi \secref{sec:file_memory_map})
1582 che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
1583 dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
1584 gestire in maniera ottimale l'interazione della memoria allocata con il
1585 meccanismo della paginazione.
1587 Di solito la dimensione delle pagine di memoria è fissata dall'architettura
1588 hardware, per cui in genere la dimensione delle pagine di memoria era una
1589 costante definita in fase di compilazione, ma oggi alcune architetture (ad
1590 esempio su Sun Sparc) permettono di variare questa dimensione, e non volendo
1591 dover fornire binari diversi per ogni possibile modello, è necessario poter
1592 utilizzare una funzione.
1594 In genere questa dimensione può essere ottenuta attraverso una chiamata a
1595 \func{sysconf} come \code{sysconf(\_SC\_PAGESIZE)}, ma in BSD 4.2 è stata
1596 introdotta una apposita funzione, \func{getpagesize}, che restituisce la
1597 dimensione delle pagine di memoria; il suo prototipo è:
1598 \begin{prototype}{unistd.h}{int getpagesize(void)}
1599 Legge le dimensioni delle pagine di memoria.
1601 \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
1602 sono previsti errori.}
1605 La funzione è prevista in SVr4, 4.4BSD e SUSv2, anche se questo ultimo
1606 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1607 ha eliminata. In Linux è implementata come una system call nelle architetture
1608 in cui essa è necessaria, ed in genere restituisce il valore del simbolo
1609 \macro{PAGE\_SIZE} del kernel, anche se le versioni delle librerie del C
1610 precedenti le \acr{glibc} 2.1 implementavano questa funzione restituendo
1611 sempre un valore statico.
1613 Le \acr{glibc} forniscono, come specifica estensione GNU, altre due funzioni,
1614 \func{get\_phys\_pages} e \func{get\_avphys\_pages} che permettono di ottenere
1615 informazioni riguardo la memoria; i loro prototipi sono:
1617 \headdecl{sys/sysinfo.h}
1619 \funcdecl{long int get\_phys\_pages(void)}
1621 Legge il numero totale di pagine di memoria disponibili per il sistema.
1623 \funcdecl{long int get\_avphys\_pages(void)}
1625 Legge il numero di pagine di memoria disponibili nel sistema.
1627 \bodydesc{Le funzioni restituiscono un numero di pagine.}
1630 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1631 rispettivamente con i parametri \macro{\_SC\_PHYS\_PAGES} e
1632 \macro{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1633 corrispondenti alla RAM della macchina; la seconda invece la memoria
1634 effettivamente disponibile per i processi.
1636 Le \acr{glibc} supportano inoltre, come estensioni GNU, due funzioni che
1637 restituiscono il numero di processori della macchina (e quello dei processori
1638 attivi); anche queste sono informazioni comunque ottenibili attraverso
1639 \func{sysconf} utilizzando rispettivamente i parametri
1640 \macro{\_SC\_NPROCESSORS\_CONF} e \macro{\_SC\_NPROCESSORS\_ONLN}.
1642 Infine le \acr{glibc} riprendono da BSD la funzione \func{getloadavg} che
1643 permette di ottenere il carico di processore della macchina, in questo modo è
1644 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1646 \begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
1647 Legge il carico medio della macchina.
1649 \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
1653 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1654 di processi attivi sulla coda dello scheduler, calcolato su un diverso
1655 intervalli di tempo. Il numero di intervalli che si vogliono leggere è
1656 specificato da \param{nelem}, dato che nel caso di Linux il carico viene
1657 valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti), questo è
1658 anche il massimo valore che può essere assegnato a questo argomento.
1662 \section{La gestione dei tempi del sistema}
1663 \label{sec:sys_time}
1665 In questa sezione, una volta introdotti i concetti base della gestione dei
1666 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
1667 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
1668 veri tempi di sistema associati ai processi, a quelle per convertire i vari
1669 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
1670 gestione di data e ora.
1673 \subsection{La misura del tempo in Unix}
1674 \label{sec:sys_unix_time}
1676 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
1677 dati per la misure dei tempi all'interno del sistema: essi sono
1678 rispettivamente chiamati \textit{calendar time} e \textit{process time},
1679 secondo le definizioni:
1681 \item[\textit{calendar time}]: detto anche \textsl{tempo di calendario}. È il
1682 numero di secondi dalla mezzanotte del primo gennaio 1970, in tempo
1683 universale coordinato (o UTC), data che viene usualmente indicata con
1684 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the Epoch}. Questo tempo viene
1685 anche chiamato anche GMT (Greenwich Mean Time) dato che l'UTC corrisponde
1686 all'ora locale di Greenwich. È il tempo su cui viene mantenuto l'orologio
1687 del kernel, e viene usato ad esempio per indicare le date di modifica dei
1688 file o quelle di avvio dei processi. Per memorizzare questo tempo è stato
1689 riservato il tipo primitivo \type{time\_t}.
1690 \item[\textit{process time}]: detto talvolta \textsl{tempo di processore}.
1691 Viene misurato in \textit{clock tick}. Un tempo questo corrispondeva al
1692 numero di interruzioni effettuate dal timer di sistema, adesso lo standard
1693 POSIX richiede che esso sia pari al valore della costante
1694 \macro{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000, qualunque
1695 sia la risoluzione reale dell'orologio di sistema e la frequenza delle
1696 interruzioni del timer.\footnote{quest'ultima, come accennato in
1697 \secref{sec:proc_hierarchy}, è invece data dalla costante \macro{HZ}.} Il
1698 dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi una
1699 risoluzione del microsecondo. Il numero di tick al secondo può essere
1700 ricavato anche attraverso \func{sysconf} (vedi \secref{sec:sys_sysconf}). Il
1701 vecchio simbolo \macro{CLK\_TCK} definito in \file{time.h} è ormai
1702 considerato obsoleto.
1705 In genere si usa il \textit{calendar time} per esprimere le date dei file e le
1706 informazioni analoghe che riguardano i cosiddetti \textsl{tempi di orologio},
1707 che vengono usati ad esempio per i demoni che compiono lavori amministrativi
1708 ad ore definite, come \cmd{cron}.
1710 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
1711 tempo locale, utilizzando le opportune informazioni di localizzazione
1712 (specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
1713 mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
1714 dall'orologio hardware del calcolatore.
1716 Anche il \textit{process time} di solito si esprime in secondi, ma provvede
1717 una precisione ovviamente superiore al \textit{calendar time} (che è mantenuto
1718 dal sistema con una granularità di un secondo) e viene usato per tenere conto
1719 dei tempi di esecuzione dei processi. Per ciascun processo il kernel calcola
1721 \begin{description*}
1722 \item[\textit{clock time}]: il tempo \textsl{reale} (viene chiamato anche
1723 \textit{wall clock time}) passato dall'avvio del processo. Chiaramente tale
1724 tempo dipende anche dal carico del sistema e da quanti altri processi
1725 stavano girando nello stesso periodo.
1726 \item[\textit{user time}]: il tempo che la CPU ha impiegato nell'esecuzione
1727 delle istruzioni del processo in user space.
1728 \item[\textit{system time}]: il tempo che la CPU ha impiegato nel kernel per
1729 eseguire delle system call per conto del processo.
1732 In genere la somma di \textit{user time} e \textit{system time} indica il
1733 tempo di processore totale in cui il sistema è stato effettivamente impegnato
1734 nell'eseguire un certo processo e viene chiamato \textit{CPU time} o
1735 \textsl{tempo di CPU}.
1739 \subsection{La gestione del \textit{process time}}
1740 \label{sec:sys_cpu_times}
1742 Di norma tutte le operazioni del sistema fanno sempre riferimento al
1743 \textit{calendar time}, l'uso del \textit{process time} è riservato a quei
1744 casi in cui serve conoscere i tempi di esecuzione di un processo (ad esempio
1745 per valutarne l'efficienza). In tal caso infatti fare ricorso al
1746 \textit{calendar time} è inutile in quanto il tempo può essere trascorso mentre
1747 un altro processo era in esecuzione o in attesa del risultato di una
1750 La funzione più semplice per leggere il \textit{process time} di un processo è
1751 \func{clock}, che da una valutazione approssimativa del tempo di CPU
1752 utilizzato dallo stesso; il suo prototipo è:
1753 \begin{prototype}{time.h}{clock\_t clock(void)}
1754 Legge il valore corrente del tempo di CPU.
1756 \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
1760 La funzione restituisce il tempo in tick, quindi se si vuole il tempo in
1761 secondi occorre moltiplicare il risultato per la costante
1762 \macro{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
1763 POSIX richiede che \macro{CLOCKS\_PER\_SEC} sia definito pari a 1000000
1764 indipendentemente dalla risoluzione del timer di sistema.} In genere
1765 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
1766 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
1767 riprenderà lo stesso valore iniziale.
1769 Come accennato in \secref{sec:sys_unix_time} il tempo di CPU è la somma di
1770 altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
1771 quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
1772 possono essere letti attraverso la funzione \func{times}, il cui prototipo è:
1773 \begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
1774 Legge in \param{buf} il valore corrente dei tempi di processore.
1776 \bodydesc{La funzione ritorna il numero di clock tick dall'avvio del sistema
1777 in caso di successo e -1 in caso di errore.}
1780 La funzione restituisce i valori di process time del processo corrente in una
1781 struttura di tipo \var{tms}, la cui definizione è riportata in
1782 \secref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi due,
1783 \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
1784 \textit{system time} del processo, così come definiti in
1785 \secref{sec:sys_unix_time}.
1787 \begin{figure}[!htb]
1790 \begin{minipage}[c]{15cm}
1791 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1793 clock_t tms_utime; /* user time */
1794 clock_t tms_stime; /* system time */
1795 clock_t tms_cutime; /* user time of children */
1796 clock_t tms_cstime; /* system time of children */
1801 \caption{La struttura \var{tms} dei tempi di processore associati a un
1803 \label{fig:sys_tms_struct}
1806 Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
1807 time} ed del \textit{system time} di tutti i processi figli che sono
1808 terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
1809 \var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
1810 ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.
1812 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
1813 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
1814 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
1815 lo stato di terminazione di tutti i suoi figli, questi processi ``nipoti'' non
1816 verranno considerati nel calcolo di questi tempi.
1820 \subsection{Le funzioni per il \textit{calendar time}}
1821 \label{sec:sys_time_base}
1823 Come anticipato in \secref{sec:sys_unix_time} il \textit{calendar time} è
1824 mantenuto dal kernel in una variabile di tipo \type{time\_t}, che usualmente
1825 corrisponde ad un tipo nativo (in Linux è un intero a 32 bit). Il valore
1826 corrente del \textit{calendar time}, che indicheremo come \textsl{tempo di
1827 sistema}, può essere ottenuto con la funzione \func{time} che lo restituisce
1828 in nel suddetto formato; il suo prototipo è:
1829 \begin{prototype}{time.h}{time\_t time(time\_t *t)}
1830 Legge il valore corrente del \textit{calendar time}.
1832 \bodydesc{La funzione ritorna il valore del \textit{calendar time} in caso
1833 di successo e -1 in caso di errore, che può essere solo \macro{EFAULT}.}
1835 \noindent dove \param{t}, se non nullo, deve essere l'indirizzo di una
1836 variabile su cui duplicare il valore di ritorno.
1838 Analoga a \func{time} è la funzione \func{stime} che serve per effettuare
1839 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
1840 sia necessario; il suo prototipo è:
1841 \begin{prototype}{time.h}{int stime(time\_t *t)}
1842 Imposta a \param{t} il valore corrente del \textit{calendar time}.
1844 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1845 che può essere \macro{EFAULT} o \macro{EPERM}.}
1847 \noindent dato che modificare l'ora ha un impatto su tutto il sistema
1848 il cambiamento dell'orologio è una operazione privilegiata e questa funzione
1849 può essere usata solo da un processo con i privilegi di amministratore,
1850 altrimenti la chiamata fallirà con un errore di \macro{EPERM}.
1852 Data la scarsa precisione nell'uso di \type{time\_t} (che ha una risoluzione
1853 massima di un secondo) quando si devono effettuare operazioni sui tempi di
1854 norma l'uso delle funzioni precedenti è sconsigliato, ed esse sono di solito
1855 sostituite da \func{gettimeofday} e \func{settimeofday},\footnote{le due
1856 funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
1857 \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
1858 in BSD4.3 sono indicate come sostitute delle precedenti.} i cui prototipi
1861 \headdecl{sys/time.h}
1864 \funcdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
1866 Legge il tempo corrente del sistema.
1868 \funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
1871 Imposta il tempo di sistema.
1873 \bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
1874 caso di errore, nel qual caso \var{errno} può assumere i valori
1875 \macro{EINVAL} \macro{EFAULT} e per \func{settimeofday} anche
1879 Queste funzioni utilizzano una struttura di tipo \var{timeval}, la cui
1880 definizione, insieme a quella della analoga \var{timespec}, è riportata in
1881 \figref{fig:sys_timeval_struct}. Le \acr{glibc} infatti forniscono queste due
1882 rappresentazioni alternative del \textit{calendar time} che rispetto a
1883 \type{time\_t} consentono rispettivamente precisioni del microsecondo e del
1884 nanosecondo.\footnote{la precisione è solo teorica, la precisione reale della
1885 misura del tempo dell'orologio di sistema non dipende dall'uso di queste
1888 \begin{figure}[!htb]
1889 \footnotesize \centering
1890 \begin{minipage}[c]{15cm}
1891 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1894 long tv_sec; /* seconds */
1895 long tv_usec; /* microseconds */
1898 time_t tv_sec; /* seconds */
1899 long tv_nsec; /* nanoseconds */
1904 \caption{Le strutture \var{timeval} e \var{timespec} usate per una
1905 rappresentazione ad alta risoluzione del \textit{calendar time}.}
1906 \label{fig:sys_timeval_struct}
1909 Come nel caso di \func{stime} anche \func{settimeofday} (e qualunque funzione
1910 vada a modificare l'orologio di sistema, come quelle che tratteremo in
1911 seguito) può essere utilizzata solo da un processo coi privilegi di
1912 amministratore. Il secondo parametro di entrambe le funzioni è una struttura
1913 \var{timezone}, che storicamente veniva utilizzata per specificare appunto la
1914 \textit{time zone}, cioè l'insieme del fuso orario e delle convenzioni per
1915 l'ora legale che permettevano il passaggio dal tempo universale all'ora
1916 locale. Questo parametro è obsoleto e in Linux non è mai stato utilizzato e
1917 non è supportato né dalle vecchie \textsl{libc5}, né dalle \textsl{glibc}:
1918 pertanto deve essere sempre impostato a \macro{NULL}.
1920 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
1921 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
1922 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
1923 conseguenze indesiderate; ad esempio se si porta avanti l'orologio si possono
1924 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
1925 saltato. Per questo motivo la modalità più corretta per impostare l'ora è quella
1926 di usare la funzione \func{adjtime}, il cui prototipo è:
1927 \begin{prototype}{sys/time.h}
1928 {int adjtime(const struct timeval *delta, struct timeval *olddelta)}
1930 Aggiusta del valore \param{delta} l'orologio di sistema.
1932 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
1933 errore, nel qual caso \var{errno} assumerà il valore \macro{EPERM}.}
1936 Questa funzione permette di avere un aggiustamento graduale del tempo di
1937 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
1938 di \param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
1939 positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
1940 il tempo richiesto, altrimenti sarà rallentato. Il secondo parametro viene
1941 usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
1944 Linux poi prevede un'altra funzione, \func{adjtimex}, che consente un
1945 aggiustamento molto più dettagliato, permettendo ad esempio anche di
1946 modificare anche la velocità dell'orologio di sistema. Il suo prototipo è:
1947 \begin{prototype}{sys/timex.h}
1948 {int adjtimex(struct timex *buf)}
1950 Aggiusta del valore \param{delta} l'orologio di sistema.
1952 \bodydesc{La funzione restituisce lo stato dell'orologio (un valore $>0$) in
1953 caso di successo e -1 in caso di errore, nel qual caso \var{errno}
1954 assumerà i valori \macro{EFAULT}, \macro{EINVAL} ed \macro{EPERM}.}
1957 La funzione richiede una struttura di tipo \var{timex}, la cui definizione,
1958 così come effettuata in \file{sys/timex.h}, è riportata in
1959 \figref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore del
1960 campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
1961 specificato in un opportuno campo di \var{timex}, deve essere impostato. Un
1962 valore nullo serve per leggere i parametri correnti; i valori diversi da zero
1963 devono essere specificati come OR binario delle costanti riportate in
1964 \secref{tab:sys_timex_mode}.
1966 \begin{figure}[!htb]
1967 \footnotesize \centering
1968 \begin{minipage}[c]{15cm}
1969 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1971 unsigned int modes; /* mode selector */
1972 long int offset; /* time offset (usec) */
1973 long int freq; /* frequency offset (scaled ppm) */
1974 long int maxerror; /* maximum error (usec) */
1975 long int esterror; /* estimated error (usec) */
1976 int status; /* clock command/status */
1977 long int constant; /* pll time constant */
1978 long int precision; /* clock precision (usec) (read only) */
1979 long int tolerance; /* clock frequency tolerance (ppm) (read only) */
1980 struct timeval time; /* (read only) */
1981 long int tick; /* (modified) usecs between clock ticks */
1982 long int ppsfreq; /* pps frequency (scaled ppm) (ro) */
1983 long int jitter; /* pps jitter (us) (ro) */
1984 int shift; /* interval duration (s) (shift) (ro) */
1985 long int stabil; /* pps stability (scaled ppm) (ro) */
1986 long int jitcnt; /* jitter limit exceeded (ro) */
1987 long int calcnt; /* calibration intervals (ro) */
1988 long int errcnt; /* calibration errors (ro) */
1989 long int stbcnt; /* stability limit exceeded (ro) */
1994 \caption{La struttura \var{timex} per il controllo dell'orologio di sistema.}
1995 \label{fig:sys_timex_struct}
1998 La funzione utilizza il meccanismo di David L. Mills, descritto nell'RFC~1305,
1999 che è alla base del protocollo NTP; la funzione è specifica di Linux e non
2000 deve essere usata se la portabilità è un requisito, le \acr{glibc} provvedono
2001 anche un suo omonimo \func{ntp\_adjtime}. La trattazione completa di questa
2002 funzione necessita di una lettura approfondita del meccanismo descritto
2003 nell'RFC~1305, ci limitiamo a descrivere in \tabref{tab:sys_timex_mode} i
2004 principali valori utilizzabili per il campo \var{mode}, un elenco più
2005 dettagliato del significato dei vari campi della struttura \var{timex} può
2006 essere ritrovato in \cite{glibc}.
2011 \begin{tabular}[c]{|l|c| p{10cm}|}
2013 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2016 \macro{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
2017 reale e l'orologio di sistema, che
2018 deve essere indicata in microsecondi
2019 nel campo \var{offset} di
2021 \macro{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenze in frequenza
2022 fra il tempo reale e l'orologio di
2023 sistema, che deve essere indicata
2024 in parti per milione nel campo
2025 \var{frequency} di \var{timex}.\\
2026 \macro{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo dell'errore
2027 sul tempo, espresso in microsecondi
2028 nel campo \var{maxerror} di
2030 \macro{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
2031 sul tempo, espresso in microsecondi
2032 nel campo \var{esterror} di
2034 \macro{ADJ\_STATUS} & 0x0010 & Imposta alcuni
2035 valori di stato interni usati dal
2036 sistema nella gestione
2037 dell'orologio specificati nel campo
2038 \var{status} di \var{timex}.\\
2039 \macro{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del PLL
2040 implementato dal kernel,
2041 specificato nel campo
2042 \var{constant} di \var{timex}.\\
2043 \macro{ADJ\_TICK} & 0x4000 & Imposta il valore dei tick del timer
2044 in microsecondi, espresso nel campo
2045 \var{tick} di \var{timex}.\\
2046 \macro{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Imposta uno spostamento una tantum
2047 dell'orologio secondo il valore del
2048 campo \var{offset} simulando il
2049 comportamento di \func{adjtime}.\\
2052 \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
2053 struttura \var{timex}.}
2054 \label{tab:sys_timex_mode}
2057 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
2058 sintassi specificata per la forma equivalente di questa funzione definita come
2059 \func{ntp\_adjtime}, utilizzando il prefisso \macro{MOD} al posto di
2065 \begin{tabular}[c]{|l|c| p{10cm}|}
2067 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2070 \macro{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
2071 \macro{TIME\_INS} & 1 & insert leap second.\\
2072 \macro{TIME\_DEL} & 2 & delete leap second.\\
2073 \macro{TIME\_OOP} & 3 & leap second in progress.\\
2074 \macro{TIME\_WAIT} & 4 & leap second has occurred.\\
2075 \macro{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
2078 \caption{Possibili valori di ritorno di \func{adjtimex}.}
2079 \label{tab:sys_adjtimex_return}
2082 La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
2083 sistema; questo può assumere i valori riportati in
2084 \tabref{tab:sys_adjtimex_return}. Un valore di -1 viene usato per riportare
2085 un errore; al solito se si cercherà di modificare l'orologio di sistema
2086 (specificando un \var{mode} diverso da zero) senza avere i privilegi di
2087 amministratore si otterrà un errore di \macro{EPERM}.
2090 \subsection{La gestione delle date.}
2091 \label{sec:sys_date}
2093 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
2094 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
2095 illustrate, se han senso per specificare un intervallo, non sono molto
2096 intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
2097 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2098 time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2099 time} usuale in ore, minuti, secondi, ecc.
2101 \begin{figure}[!htb]
2102 \footnotesize \centering
2103 \begin{minipage}[c]{15cm}
2104 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
2106 int tm_sec; /* seconds */
2107 int tm_min; /* minutes */
2108 int tm_hour; /* hours */
2109 int tm_mday; /* day of the month */
2110 int tm_mon; /* month */
2111 int tm_year; /* year */
2112 int tm_wday; /* day of the week */
2113 int tm_yday; /* day in the year */
2114 int tm_isdst; /* daylight saving time */
2115 long int tm_gmtoff; /* Seconds east of UTC. */
2116 cost char *tm_zone; /* Timezone abbreviation. */
2121 \caption{La struttura \var{tm} per una rappresentazione del tempo in termini
2122 di ora, minuti, secondi, ecc.}
2123 \label{fig:sys_tm_struct}
2126 Questo viene effettuato attraverso una opportuna struttura \var{tm}, la cui
2127 definizione è riportata in \figref{fig:sys_tm_struct}, ed è in genere questa
2128 struttura che si utilizza quando si deve specificare un tempo a partire dai
2129 dati naturali (ora e data), dato che essa consente anche di trattare la
2130 gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
2131 \var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste da BSD e dalle
2132 \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
2133 \figref{fig:sys_tm_struct}.}
2135 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2136 da quelle usate per convertire gli altri formati in questo, usando o meno
2137 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2138 tempo in una stringa contenente data ed ora, i loro prototipi sono:
2141 \funcdecl{char *asctime(const struct tm *tm)}
2142 Produce una stringa con data e ora partendo da un valore espresso in
2143 \textit{broken-down time}.
2145 \funcdecl{char *ctime(const time\_t *timep)}
2146 Produce una stringa con data e ora partendo da un valore espresso in
2147 in formato \type{time\_t}.
2149 \funcdecl{struct tm *gmtime(const time\_t *timep)}
2150 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2151 \textit{broken-down time} espresso in UTC.
2153 \funcdecl{struct tm *localtime(const time\_t *timep)}
2154 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2155 \textit{broken-down time} espresso nell'ora locale.
2157 \funcdecl{time\_t mktime(struct tm *tm)}
2158 Converte il \textit{broken-down time} in formato \type{time\_t}.
2160 \bodydesc{Tutte le funzioni restituiscono un puntatore al risultato in caso
2161 di successo e \macro{NULL} in caso di errore, tranne che \func{mktime} che
2162 restituisce direttamente il valore o -1 in caso di errore.}
2165 Le prime due funzioni, \func{asctime} e \func{ctime} servono per poter
2166 stampare in forma leggibile un tempo; esse restituiscono il puntatore ad una
2167 stringa, allocata staticamente, nella forma:
2169 "Wed Jun 30 21:49:08 1993\n"
2171 e impostano anche la variabile \var{tzname} con l'informazione della \textit{time
2172 zone} corrente; \func{ctime} è banalmente definita in termini di
2173 \func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
2174 statica rende le funzioni non rientranti POSIX.1c e SUSv2 prevedono due
2175 sostitute rientranti, il cui nome è al solito ottenuto appendendo un
2176 \code{\_r}, che prendono un secondo parametro \code{char *buf}, in cui
2177 l'utente deve specificare il buffer su cui la stringa deve essere copiata
2178 (deve essere di almeno 26 caratteri).
2180 Le altre tre funzioni, \func{gmtime}, \func{localtime} e \func{mktime} servono
2181 per convertire il tempo dal formato \type{time\_t} a quello di \var{tm} e
2182 viceversa; \func{gmtime} effettua la conversione usando il tempo coordinato
2183 universale (UTC), cioè l'ora di Greenwich; mentre \func{localtime} usa l'ora
2184 locale; \func{mktime} esegue la conversione inversa.
2186 Anche in questo caso le prime due funzioni restituiscono l'indirizzo di una
2187 struttura allocata staticamente, per questo sono state definite anche altre
2188 due versioni rientranti (con la solita estensione \code{\_r}), che prevedono
2189 un secondo parametro \code{struct tm *result}, fornito dal chiamante, che deve
2190 preallocare la struttura su cui sarà restituita la conversione.
2192 Come mostrato in \figref{fig:sys_tm_struct} il \textit{broken-down time}
2193 permette di tenere conto anche della differenza fra tempo universale e ora
2194 locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
2195 variabili globali mostrate in \figref{fig:sys_tzname}, cui si accede quando si
2196 include \file{time.h}. Queste variabili vengono impostate quando si chiama una
2197 delle precedenti funzioni di conversione, oppure invocando direttamente la
2198 funzione \func{tzset}, il cui prototipo è:
2199 \begin{prototype}{sys/timex.h}
2202 Imposta le variabili globali della \textit{time zone}.
2204 \bodydesc{La funzione non ritorna niente e non dà errori.}
2207 La funzione inizializza le variabili di \figref{fig:sys_tzname} a partire dal
2208 valore della variabile di ambiente \macro{TZ}, se quest'ultima non è definita
2209 verrà usato il file \file{/etc/localtime}.
2211 \begin{figure}[!htb]
2214 \begin{minipage}[c]{15cm}
2215 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
2216 extern char *tzname[2];
2217 extern long timezone;
2218 extern int daylight;
2222 \caption{Le variabili globali usate per la gestione delle \textit{time
2224 \label{fig:sys_tzname}
2227 La variabile \var{tzname} contiene due stringhe, che indicano i due nomi
2228 standard della \textit{time zone} corrente. La prima è il nome per l'ora
2229 solare, la seconda per l'ora legale.\footnote{anche se sono indicati come
2230 \code{char *} non è il caso di modificare queste stringhe.} La variabile
2231 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2232 \var{daylight} indica se è attiva o meno l'ora legale.
2234 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2235 stampare un tempo o una data, la flessibilità non fa parte delle sue
2236 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2237 gionrno) di un tempo si può ricorrere alla più sofisticata \func{strftime}, il
2239 \begin{prototype}{time.h}
2240 {size\_t strftime(char *s, size\_t max, const char *format,
2241 const struct tm *tm)}
2243 Stampa il tempo \param{tm} nella stringa \param{s} secondo il formato
2246 \bodydesc{La funzione ritorna il numero di caratteri stampati in \param{s},
2247 altrimenti restuisce 0.}
2250 La funzione converte opportunamente il tempo \param{tm} in una stringa di
2251 testo da salvare in \param{s}, purché essa sia di dimensione, indicata da
2252 \param{size}, sufficiente. I caratteri generati dalla funzione vengono
2253 restituiti come valore di ritorno, ma non tengono conto del terminatore
2254 finale, che invece viene considerato nel computo della dimensione; se
2255 quest'ultima è eccessiva viene restituito 0 e lo stato di \param{s} è
2261 \begin{tabular}[c]{|c|l|p{6cm}|}
2263 \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2266 \macro{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
2267 \macro{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
2268 \macro{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
2269 \macro{\%B}&\texttt{April} & Nome del mese, completo.\\
2270 \macro{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
2271 \macro{\%d}&\texttt{24} & Giorno del mese.\\
2272 \macro{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
2273 \macro{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
2274 \macro{\%j}&\texttt{114} & Giorno dell'anno.\\
2275 \macro{\%m}&\texttt{04} & Mese dell'anno.\\
2276 \macro{\%M}&\texttt{40} & Minuto.\\
2277 \macro{\%p}&\texttt{PM} & AM/PM.\\
2278 \macro{\%S}&\texttt{50} & Secondo.\\
2279 \macro{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
2281 \macro{\%w}&\texttt{3} & Giorno della settimana. \\
2282 \macro{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
2284 \macro{\%x}&\texttt{04/24/02} & La data.\\
2285 \macro{\%X}&\texttt{18:40:50} & L'ora.\\
2286 \macro{\%y}&\texttt{02} & Anno nel secolo.\\
2287 \macro{\%Y}&\texttt{2002} & Anno.\\
2288 \macro{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
2289 \macro{\%\%}&\texttt{\%} & Il carattere \%.\\
2292 \caption{Valori previsti dallo standard ANSI C per modificatore della
2293 stringa di formato di \func{strftime}.}
2294 \label{tab:sys_strftime_format}
2297 Il risultato della funzione è controllato dalla stringa di formato
2298 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2299 viene utilizzato come modificatore; alcuni\footnote{per la precisione quelli
2300 definiti dallo standard ANSI C, che sono anche quelli riportati da POSIX.1;
2301 le \acr{glibc} provvedono tutte le estensioni introdotte da POSIX.2 per il
2302 comando \cmd{date}, i valori introdotti da SVID3 e ulteriori estensioni GNU;
2303 l'elenco completo dei possibili valori è riportato nella pagina di manuale
2304 della funzione.} dei possibili valori che esso può assumere sono ripotati in
2305 \tabref{tab:sys_strftime_format}. La funzione tiene conto anche della presenza
2306 di una localizzazione per stampare in maniera adeguata i vari nomi.
2309 \section{La gestione degli errori}
2310 \label{sec:sys_errors}
2312 La gestione degli errori è in genere una materia complessa. Inoltre il modello
2313 utilizzato dai sistema unix-like è basato sull'architettura a processi, e
2314 presenta una serie di problemi nel caso lo si debba usare con i thread.
2315 Esamineremo in questa sezione le sue caratteristiche principali.
2318 \subsection{La variabile \var{errno}}
2319 \label{sec:sys_errno}
2321 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2322 riportare condizioni di errore, ed è una buona norma di programmazione
2323 controllare sempre che le funzioni chiamate si siano concluse correttamente.
2325 In genere le funzioni di libreria usano un valore speciale per indicare che
2326 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
2327 costante \macro{EOF} (a seconda della funzione); ma questo valore segnala solo
2328 che c'è stato un errore, non il tipo di errore.
2330 Per riportare il tipo di errore il sistema usa la variabile globale
2331 \var{errno},\footnote{L'uso di una variabile globale può comportare alcuni
2332 problemi (ad esempio nel caso dei thread) ma lo standard ISO C consente
2333 anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
2334 può anche usare una macro, e questo è infatti il modo usato da Linux per
2335 renderla locale ai singoli thread.} definita nell'header \file{errno.h}; la
2336 variabile è in genere definita come \ctyp{volatile} dato che può essere
2337 cambiata in modo asincrono da un segnale (si veda \ref{sec:sig_sigchld} per un
2338 esempio, ricordando quanto trattato in \ref{sec:proc_race_cond}), ma dato che
2339 un manipolatore di segnale scritto bene salva e ripristina il valore della
2340 variabile, di questo non è necessario preoccuparsi nella programmazione
2343 I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},
2344 nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
2345 costanti numeriche che identificano i vari errori; essi iniziano tutti per
2346 \macro{E} e si possono considerare come nomi riservati. In seguito faremo
2347 sempre riferimento a tali valori, quando descriveremo i possibili errori
2348 restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
2349 codice relativo ad un valore numerico con l'opzione \cmd{-l}.
2351 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
2352 programma, gran parte delle funzioni di libreria impostano \var{errno} ad un
2353 valore diverso da zero in caso di errore. Il valore è invece indefinito in
2354 caso di successo, perché anche se una funzione ha successo, può chiamarne
2355 altre al suo interno che falliscono, modificando così \var{errno}.
2357 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
2358 essere il risultato di un errore precedente) e non lo si può usare per
2359 determinare quando o se una chiamata a funzione è fallita. La procedura da
2360 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
2361 verificato il fallimento della funzione attraverso il suo codice di ritorno.
2364 \subsection{Le funzioni \func{strerror} e \func{perror}}
2365 \label{sec:sys_strerror}
2367 Benché gli errori siano identificati univocamente dal valore numerico di
2368 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
2369 riportare in opportuni messaggi le condizioni di errore verificatesi. La
2370 prima funzione che si può usare per ricavare i messaggi di errore è
2371 \func{strerror}, il cui prototipo è:
2372 \begin{prototype}{string.h}{char *strerror(int errnum)}
2373 Restituisce una stringa con il messaggio di errore relativo ad
2376 \bodydesc{La funzione ritorna il puntatore alla stringa col messaggio di
2377 errore in caso di successo e \macro{NULL} in caso di errore, nel qual caso
2378 \var{errno} assumerà il valore \macro{EINVAL} se si è specificato un
2379 numero di errore non valido.}
2382 In generale \func{strerror} viene usata passando \var{errno} come parametro;
2383 nel caso si specifichi un codice sbagliato verrà restituito un messaggio di
2384 errore sconosciuto, e la funzione restituirà come errore \macro{EINVAL}. La
2385 funzione tiene conto del valore della variabile di ambiente
2386 \macro{LC\_MESSAGES} per usare eventuali traduzioni dei messaggi d'errore
2387 nella localizzazione presente.
2389 La funzione utilizza una stringa statica che non deve essere modificata dal
2390 programma e che è utilizzabile solo fino ad una chiamata successiva a
2391 \func{strerror}; per questo motivo non è rientrante e nel caso si usino i
2392 thread è provvista\footnote{questa funzione è la versione prevista dalle
2393 \acr{glibc}, ed effettivamente definita in \file{string.h}, ne esiste una
2394 analoga nello standard SUSv3 (quella riportata dalla pagina di manuale), che
2395 restituisce \code{int} al posto di \code{char *}, e che tronca la stringa
2396 restituita a \param{size}.} una versione apposita:
2397 \begin{prototype}{string.h}
2398 {char * strerror\_r(int errnum, char *buf, size\_t size)}
2400 Analoga a \func{strerror} ma usa il buffer \param{buf} di lunghezza massima
2401 (compreso il terminatore) \param{size}.
2403 \bodydesc{La funzione restituisce il puntatore alla stringa; in caso di
2404 errore \var{errno} oltre a \macro{EINVAL} può assumere anche il valore
2405 \macro{ERANGE} per indicare che non c'è sufficiente memoria per contenere
2406 la stringa di descrizione.}
2409 che utilizza un buffer che il singolo thread deve allocare, per evitare i
2410 problemi connessi alla condivisione del buffer statico. La funzione
2411 restituisce l'indirizzo della stringa usata, che può essere contenuta nel
2412 buffer specificato da \param{buf}, per una lunghezza non superiore a
2413 \param{size}, nel qual caso la stringa sarebbe troncata e terminata con
2417 Una seconda funzione usata per riportare i codici di errore in maniera
2418 automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) è
2419 \func{perror}, il cui prototipo è:
2420 \begin{prototype}{stdio.h}{void perror(const char *message)}
2421 Stampa il messaggio di errore relativo al valore corrente di \var{errno}
2422 sullo standard error; preceduto dalla stringa \var{message}.
2425 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
2426 in \capref{cha:errors}), e, usando il valore corrente di \var{errno}, si
2427 riferiscono all'ultimo errore avvenuto. La stringa specificata con
2428 \var{message} viene stampato prime del messaggio d'errore, seguita dai due
2429 punti e da uno spazio, il messaggio è terminato con un a capo.
2431 Il messaggio può essere riportato anche usando altre variabili globali
2432 dichiarate in \file{errno.h}:
2434 const char *sys_errlist[];
2437 la prima contiene i puntatori alle stringhe di errore indicizzati da
2438 \var{errno}; la seconda esprime il valore più alto per un codice di errore,
2439 l'utilizzo di questa stringa è sostanzialmente equivalente a quello di
2442 \begin{figure}[!htb]
2444 \begin{lstlisting}{}
2445 /* convert string to number */
2446 err = strtol(argv[optind], NULL, 10);
2447 /* testing error condition on conversion */
2448 if (err==LONG_MIN) {
2449 perror("Underflow on error code");
2451 } else if (err==LONG_MIN) {
2452 perror("Overflow on error code");
2455 /* conversion is fine */
2457 printf("Error message for %d is %s\n", err, strerror(err));
2460 printf("Error label for %d is %s\n", err, err_code[err]);
2463 \caption{Codice per la stampa del messaggio di errore standard.}
2464 \label{fig:sys_err_mess}
2467 In \figref{fig:sys_err_mess} è riportata la sezione attinente del codice del
2468 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
2469 errore e le costanti usate per identificare i singoli errori; il sorgente
2470 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
2471 gestione delle opzioni e tutte le definizioni necessarie ad associare il
2472 valore numerico alla costante simbolica. In particolare si è riportata la
2473 sezione che converte la stringa passata come parametro in un intero
2474 (\texttt{\small 1--2}), controllando con i valori di ritorno di \func{strtol}
2475 che la conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi
2476 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
2477 11--14}) o la macro (\texttt{\small 15--17}) associate a quel codice.
2481 \subsection{Alcune estensioni GNU}
2482 \label{sec:sys_err_GNU}
2484 Le precedenti funzioni sono quelle definite ed usate nei vari standard; le
2485 \acr{glibc} hanno però introdotto una serie di estensioni ``GNU'' che
2486 forniscono alcune funzionalità aggiuntive per una gestione degli errori
2487 semplificata e più efficiente.
2489 La prima estensione consiste in due variabili, \code{char *
2490 program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
2491 servono per ricavare il nome del programma; queste sono utili quando si deve
2492 aggiungere il nome del programma (cosa comune quando si ha un programma che
2493 non viene lanciato da linea di comando e salva gli errori in un file di log)
2494 al messaggio d'errore. La prima contiene il nome usato per lanciare il
2495 programma (ed è equivalente ad \code{argv[0]}); la seconda mantiene solo il
2496 nome del programma (senza eventuali directory in testa).
2498 Uno dei problemi che si hanno con l'uso di \func{perror} è che non c'è
2499 flessibilità su quello che si può aggiungere al messaggio di errore, che può
2500 essere solo una stringa. In molte occasioni invece serve poter scrivere dei
2501 messaggi con maggiore informazione; ad esempio negli standard di
2502 programmazione GNU si richiede che ogni messaggio di errore sia preceduto dal
2503 nome del programma, ed in generale si può voler stampare il contenuto di
2504 qualche variabile; per questo le \acr{glibc} definiscono la funzione
2505 \func{error}, il cui prototipo è:
2506 \begin{prototype}{stdio.h}
2507 {void error(int status, int errnum, const char *format, ...)}
2509 Stampa un messaggio di errore formattato.
2511 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2514 La funzione fa parte delle estensioni GNU per la gestione degli errori,
2515 l'argomento \param{format} prende la stessa sintassi di \func{printf}, ed i
2516 relativi parametri devono essere forniti allo stesso modo, mentre
2517 \param{errnum} indica l'errore che si vuole segnalare (non viene quindi usato
2518 il valore corrente di \var{errno}); la funzione stampa sullo standard error il
2519 nome del programma, come indicato dalla variabile globale \var{program\_name},
2520 seguito da due punti ed uno spazio, poi dalla stringa generata da
2521 \param{format} e dagli argomenti seguenti, seguita da due punti ed uno spazio
2522 infine il messaggio di errore relativo ad \param{errnum}, il tutto è terminato
2525 Il comportamento della funzione può essere ulteriormente controllato se si
2526 definisce una variabile \var{error\_print\_progname} come puntatore ad una
2527 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
2528 il nome del programma.
2530 L'argomento \param{status} può essere usato per terminare direttamente il
2531 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
2532 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
2533 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
2534 un'altra variabile globale, \var{error\_message\_count}, che tiene conto di
2535 quanti errori ci sono stati.
2537 Un'altra funzione per la stampa degli errori, ancora più sofisticata, è
2538 \func{error\_at\_line}, che prende due argomenti aggiuntivi per indicare linea
2539 e file su cui è avvenuto l'errore; il suo prototipo è:
2540 \begin{prototype}{stdio.h}
2541 {void error\_at\_line(int status, int errnum, const char *fname,
2542 unsigned int lineno, const char *format, ...)}
2544 Stampa un messaggio di errore formattato.
2546 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2548 \noindent ed il suo comportamento è identico a quello di \func{error} se non
2549 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
2550 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
2551 stampa del nome del programma. Inoltre essa usa un'altra variabile globale,
2552 \var{error\_one\_per\_line}, che impostata ad un valore diverso da zero fa si
2553 che errori relativi alla stessa linea non vengano ripetuti.
2558 %%% Local Variables:
2560 %%% TeX-master: "gapil"
projects / gapil.git / blob