3 %% Copyright (C) 2000-2007 Simone Piccardi. Permission is granted to
4 %% copy, distribute and/or modify this document under the terms of the GNU Free
5 %% Documentation License, Version 1.1 or any later version published by the
6 %% Free Software Foundation; with the Invariant Sections being "Un preambolo",
7 %% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the
8 %% license is included in the section entitled "GNU Free Documentation
12 \chapter{La gestione del sistema, del tempo e degli errori}
15 In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
16 generali del sistema, come quelle per la gestione dei parametri e della
17 configurazione dello stesso, quelle per la lettura dei limiti e delle
18 caratteristiche, quelle per il controllo dell'uso delle risorse dei processi,
19 quelle per la gestione ed il controllo dei filesystem, degli utenti, dei tempi
24 \section{Capacità e caratteristiche del sistema}
25 \label{sec:sys_characteristics}
27 In questa sezione tratteremo le varie modalità con cui un programma può
28 ottenere informazioni riguardo alle capacità del sistema. Ogni sistema
29 unix-like infatti è contraddistinto da un gran numero di limiti e costanti che
30 lo caratterizzano, e che possono dipendere da fattori molteplici, come
31 l'architettura hardware, l'implementazione del kernel e delle librerie, le
32 opzioni di configurazione.
34 La definizione di queste caratteristiche ed il tentativo di provvedere dei
35 meccanismi generali che i programmi possono usare per ricavarle è uno degli
36 aspetti più complessi e controversi con cui le diverse standardizzazioni si
37 sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
38 Daremo comunque una descrizione dei principali metodi previsti dai vari
39 standard per ricavare sia le caratteristiche specifiche del sistema, che
40 quelle della gestione dei file.
43 \subsection{Limiti e parametri di sistema}
44 \label{sec:sys_limits}
46 Quando si devono determinare le caratteristiche generali del sistema ci si
47 trova di fronte a diverse possibilità; alcune di queste infatti possono
48 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
49 interi), o dal sistema operativo (come la presenza o meno del gruppo degli
50 identificatori \textit{saved}), altre invece possono dipendere dalle opzioni
51 con cui si è costruito il sistema (ad esempio da come si è compilato il
52 kernel), o dalla configurazione del medesimo; per questo motivo in generale
53 sono necessari due tipi diversi di funzionalità:
55 \item la possibilità di determinare limiti ed opzioni al momento della
57 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
60 La prima funzionalità si può ottenere includendo gli opportuni header file che
61 contengono le costanti necessarie definite come macro di preprocessore, per la
62 seconda invece sono ovviamente necessarie delle funzioni. La situazione è
63 complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
64 sono fissi in un'implementazione mentre possono variare in un altra. Tutto
65 questo crea una ambiguità che non è sempre possibile risolvere in maniera
66 chiara; in generale quello che succede è che quando i limiti del sistema sono
67 fissi essi vengono definiti come macro di preprocessore nel file
68 \file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
69 tramite la funzione \func{sysconf} (che esamineremo in
70 sez.~\ref{sec:sys_sysconf}).
72 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
73 saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
74 da \file{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si può
75 vedere per la maggior parte questi limiti attengono alle dimensioni dei dati
76 interi, che sono in genere fissati dall'architettura hardware (le analoghe
77 informazioni per i dati in virgola mobile sono definite a parte, ed
78 accessibili includendo \file{float.h}). Lo standard prevede anche un'altra
79 costante, \const{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
80 definita in \file{limits.h}; essa deve essere definita in \file{stdio.h} ed
81 avere un valore minimo di 8.
86 \begin{tabular}[c]{|l|r|l|}
88 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
91 \const{MB\_LEN\_MAX}& 16 & massima dimensione di un
93 \const{CHAR\_BIT} & 8 & bit di \ctyp{char}\\
94 \const{UCHAR\_MAX}& 255 & massimo di \ctyp{unsigned char}\\
95 \const{SCHAR\_MIN}& -128 & minimo di \ctyp{signed char}\\
96 \const{SCHAR\_MAX}& 127 & massimo di \ctyp{signed char}\\
97 \const{CHAR\_MIN} &\footnotemark& minimo di \ctyp{char}\\
98 \const{CHAR\_MAX} &\footnotemark& massimo di \ctyp{char}\\
99 \const{SHRT\_MIN} & -32768 & minimo di \ctyp{short}\\
100 \const{SHRT\_MAX} & 32767 & massimo di \ctyp{short}\\
101 \const{USHRT\_MAX}& 65535 & massimo di \ctyp{unsigned short}\\
102 \const{INT\_MAX} & 2147483647 & minimo di \ctyp{int}\\
103 \const{INT\_MIN} &-2147483648 & minimo di \ctyp{int}\\
104 \const{UINT\_MAX} & 4294967295 & massimo di \ctyp{unsigned int}\\
105 \const{LONG\_MAX} & 2147483647 & massimo di \ctyp{long}\\
106 \const{LONG\_MIN} &-2147483648 & minimo di \ctyp{long}\\
107 \const{ULONG\_MAX}& 4294967295 & massimo di \ctyp{unsigned long}\\
110 \caption{Costanti definite in \file{limits.h} in conformità allo standard
112 \label{tab:sys_ansic_macro}
115 \footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
116 sistema usi caratteri con segno o meno.}
118 \footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
119 a seconda che il sistema usi caratteri con segno o meno.}
121 A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
122 \ctyp{long long} introdotto con il nuovo standard, i relativi valori sono in
123 tab.~\ref{tab:sys_isoc90_macro}.
128 \begin{tabular}[c]{|l|r|l|}
130 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
133 \const{LLONG\_MAX}& 9223372036854775807& massimo di \ctyp{long long}\\
134 \const{LLONG\_MIN}&-9223372036854775808& minimo di \ctyp{long long}\\
135 \const{ULLONG\_MAX}&18446744073709551615&
136 massimo di \ctyp{unsigned long long}\\
139 \caption{Macro definite in \file{limits.h} in conformità allo standard
141 \label{tab:sys_isoc90_macro}
144 Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
145 delle caratteristiche del sistema; mancano completamente tutte quelle che
146 dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
147 sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
148 limiti relativi alle caratteristiche dei file che vedremo in
149 sez.~\ref{sec:sys_file_limits}.
151 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
152 meno chiare\footnote{tanto che Stevens, in \cite{APUE}, la porta come esempio
153 di ``\textsl{standardese}''.}. Lo standard prevede che ci siano 13 macro che
154 descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
155 riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
156 file, riportate in tab.~\ref{tab:sys_file_macro}).
161 \begin{tabular}[c]{|l|r|p{7cm}|}
163 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
166 \const{ARG\_MAX} &131072& Dimensione massima degli argomenti
167 passati ad una funzione della famiglia
169 \const{CHILD\_MAX} & 999& Numero massimo di processi contemporanei
170 che un utente può eseguire.\\
171 \const{OPEN\_MAX} & 256& Numero massimo di file che un processo
172 può mantenere aperti in contemporanea.\\
173 \const{STREAM\_MAX}& 8& Massimo numero di stream aperti per
174 processo in contemporanea.\\
175 \const{TZNAME\_MAX}& 6& Dimensione massima del nome di una
176 \texttt{timezone} (vedi
177 sez.~\ref{sec:sys_time_base})).\\
178 \const{NGROUPS\_MAX}& 32& Numero di gruppi supplementari per
179 processo (vedi sez.~\ref{sec:proc_access_id}).\\
180 \const{SSIZE\_MAX}&32767& Valore massimo del tipo \type{ssize\_t}.\\
183 \caption{Costanti per i limiti del sistema.}
184 \label{tab:sys_generic_macro}
187 Lo standard dice che queste macro devono essere definite in \file{limits.h}
188 quando i valori a cui fanno riferimento sono fissi, e altrimenti devono essere
189 lasciate indefinite, ed i loro valori dei limiti devono essere accessibili
190 solo attraverso \func{sysconf}. In realtà queste vengono sempre definite ad
191 un valore generico. Si tenga presente poi che alcuni di questi limiti possono
192 assumere valori molto elevati (come \const{CHILD\_MAX}), e non è pertanto il
193 caso di utilizzarli per allocare staticamente della memoria.
195 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
196 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
197 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
198 implementazione possa dichiararsi conforme allo standard; detti valori sono
199 riportati in tab.~\ref{tab:sys_posix1_general}.
204 \begin{tabular}[c]{|l|r|p{7cm}|}
206 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
209 \const{\_POSIX\_ARG\_MAX} & 4096& Dimensione massima degli argomenti
210 passati ad una funzione della famiglia
212 \const{\_POSIX\_CHILD\_MAX} & 6& Numero massimo di processi
213 contemporanei che un utente può
215 \const{\_POSIX\_OPEN\_MAX} & 16& Numero massimo di file che un processo
216 può mantenere aperti in
218 \const{\_POSIX\_STREAM\_MAX} & 8& Massimo numero di stream aperti per
219 processo in contemporanea.\\
220 \const{\_POSIX\_TZNAME\_MAX} & & Dimensione massima del nome di una
221 \textit{timezone} (vedi
222 sez.~\ref{sec:sys_date}). \\
223 \const{\_POSIX\_NGROUPS\_MAX}& 0& Numero di gruppi supplementari per
225 sez.~\ref{sec:proc_access_id}).\\
226 \const{\_POSIX\_SSIZE\_MAX} &32767& Valore massimo del tipo
228 \const{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
229 \const{\_POSIX\_AIO\_MAX} & 1& \\
232 \caption{Macro dei valori minimi delle caratteristiche generali del sistema
233 per la conformità allo standard POSIX.1.}
234 \label{tab:sys_posix1_general}
237 In genere questi valori non servono a molto, la loro unica utilità è quella di
238 indicare un limite superiore che assicura la portabilità senza necessità di
239 ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
240 i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
241 valori ottenuti da \func{sysconf}.
246 \begin{tabular}[c]{|l|p{8cm}|}
248 \textbf{Macro}&\textbf{Significato}\\
251 \macro{\_POSIX\_JOB\_CONTROL}& Il sistema supporta il
252 \textit{job control} (vedi
253 sez.~\ref{sec:sess_job_control}).\\
254 \macro{\_POSIX\_SAVED\_IDS} & Il sistema supporta gli identificatori del
255 gruppo \textit{saved} (vedi
256 sez.~\ref{sec:proc_access_id})
257 per il controllo di accesso dei processi\\
258 \const{\_POSIX\_VERSION} & Fornisce la versione dello standard POSIX.1
259 supportata nel formato YYYYMML (ad esempio
263 \caption{Alcune macro definite in \file{limits.h} in conformità allo standard
265 \label{tab:sys_posix1_other}
268 Oltre ai precedenti valori (e a quelli relativi ai file elencati in
269 tab.~\ref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
270 lo standard POSIX.1 ne prevede parecchi altri. La lista completa si trova
271 dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
272 incluso automaticamente all'interno di \file{limits.h}). Di questi vale la
273 pena menzionare alcune macro di uso comune, (riportate in
274 tab.~\ref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
275 denotano la presenza di alcune funzionalità nel sistema (come il supporto del
276 \textit{job control} o degli identificatori del gruppo \textit{saved}).
278 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
279 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
280 alle applicazioni di sistema presenti (come quelli su alcuni parametri delle
281 espressioni regolari o del comando \cmd{bc}), non li tratteremo
282 esplicitamente, se ne trova una menzione completa nell'header file
283 \file{bits/posix2\_lim.h}, e alcuni di loro sono descritti nella pagina di
284 manuale di \func{sysconf} e nel manuale delle \acr{glibc}.
287 \subsection{La funzione \func{sysconf}}
288 \label{sec:sys_sysconf}
290 Come accennato in sez.~\ref{sec:sys_limits} quando uno dei limiti o delle
291 caratteristiche del sistema può variare, per non dover essere costretti a
292 ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
293 compilato il kernel, o alcuni dei parametri modificabili a run time, è
294 necessario ottenerne il valore attraverso la funzione \funcd{sysconf}. Il
295 prototipo di questa funzione è:
296 \begin{prototype}{unistd.h}{long sysconf(int name)}
297 Restituisce il valore del parametro di sistema \param{name}.
299 \bodydesc{La funzione restituisce indietro il valore del parametro
300 richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
301 è disponibile e -1 in caso di errore (ma \var{errno} non viene impostata).}
304 La funzione prende come argomento un intero che specifica quale dei limiti si
305 vuole conoscere; uno specchietto contenente i principali valori disponibili in
306 Linux è riportato in tab.~\ref{tab:sys_sysconf_par}; l'elenco completo è
307 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
308 relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
313 \begin{tabular}[c]{|l|l|p{9cm}|}
315 \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
318 \texttt{\_SC\_ARG\_MAX} & \const{ARG\_MAX}&
319 La dimensione massima degli argomenti passati
320 ad una funzione della famiglia \func{exec}.\\
321 \texttt{\_SC\_CHILD\_MAX} & \const{\_CHILD\_MAX}&
322 Il numero massimo di processi contemporanei
323 che un utente può eseguire.\\
324 \texttt{\_SC\_OPEN\_MAX} & \const{\_OPEN\_MAX}&
325 Il numero massimo di file che un processo può
326 mantenere aperti in contemporanea.\\
327 \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
328 Il massimo numero di stream che un processo
329 può mantenere aperti in contemporanea. Questo
330 limite previsto anche dallo standard ANSI C,
331 che specifica la macro {FOPEN\_MAX}.\\
332 \texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
333 La dimensione massima di un nome di una
334 \texttt{timezone} (vedi
335 sez.~\ref{sec:sys_date}).\\
336 \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
337 Massimo numero di gruppi supplementari che
338 può avere un processo (vedi
339 sez.~\ref{sec:proc_access_id}).\\
340 \texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}&
341 Valore massimo del tipo di dato
343 \texttt{\_SC\_CLK\_TCK} & \const{CLK\_TCK} &
344 Il numero di \textit{clock tick} al secondo,
345 cioè l'unità di misura del
346 \itindex{process~time} \textit{process
348 sez.~\ref{sec:sys_unix_time}).\\
349 \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
350 Indica se è supportato il \textit{job
352 sez.~\ref{sec:sess_job_control}) in stile
354 \texttt{\_SC\_SAVED\_IDS} & \macro{\_POSIX\_SAVED\_IDS}&
355 Indica se il sistema supporta i
356 \textit{saved id} (vedi
357 sez.~\ref{sec:proc_access_id}).\\
358 \texttt{\_SC\_VERSION} & \const{\_POSIX\_VERSION} &
359 Indica il mese e l'anno di approvazione
360 della revisione dello standard POSIX.1 a cui
361 il sistema fa riferimento, nel formato
362 YYYYMML, la revisione più recente è 199009L,
363 che indica il Settembre 1990.\\
366 \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
367 \label{tab:sys_sysconf_par}
370 In generale ogni limite o caratteristica del sistema per cui è definita una
371 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
372 essere ottenuto attraverso una chiamata a \func{sysconf}. Il valore si otterrà
373 specificando come valore dell'argomento \param{name} il nome ottenuto
374 aggiungendo \code{\_SC\_} ai nomi delle macro definite dai primi due, o
375 sostituendolo a \code{\_POSIX\_} per le macro definite dagli gli altri due.
377 In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
378 macro non è definita, quindi con un codice analogo al seguente:
379 \includecodesnip{listati/get_child_max.c}
380 ma in realtà in Linux queste macro sono comunque definite, indicando però un
381 limite generico. Per questo motivo è sempre meglio usare i valori restituiti
385 \subsection{I limiti dei file}
386 \label{sec:sys_file_limits}
388 Come per le caratteristiche generali del sistema anche per i file esistono una
389 serie di limiti (come la lunghezza del nome del file o il numero massimo di
390 link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
391 in questo caso lo standard prevede alcune macro che ne specificano il valore,
392 riportate in tab.~\ref{tab:sys_file_macro}.
397 \begin{tabular}[c]{|l|r|l|}
399 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
402 \const{LINK\_MAX} &8 & Numero massimo di link a un file.\\
403 \const{NAME\_MAX}& 14 & Lunghezza in byte di un nome di file. \\
404 \const{PATH\_MAX}& 256 & Lunghezza in byte di un
405 \itindex{pathname} \textit{pathname}.\\
406 \const{PIPE\_BUF}&4096 & Byte scrivibili atomicamente in una pipe
407 (vedi sez.~\ref{sec:ipc_pipes}).\\
408 \const{MAX\_CANON}&255 & Dimensione di una riga di terminale in modo
409 canonico (vedi sez.~\ref{sec:term_design}).\\
410 \const{MAX\_INPUT}&255 & Spazio disponibile nella coda di input
412 sez.~\ref{sec:term_design}).\\
415 \caption{Costanti per i limiti sulle caratteristiche dei file.}
416 \label{tab:sys_file_macro}
419 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
420 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
421 conforme deve rispettare; le relative macro sono riportate in
422 tab.~\ref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per
423 le analoghe di tab.~\ref{tab:sys_posix1_general}.
428 \begin{tabular}[c]{|l|r|l|}
430 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
433 \const{\_POSIX\_LINK\_MAX} &8 & Numero massimo di link a un file.\\
434 \const{\_POSIX\_NAME\_MAX}& 14 & Lunghezza in byte di un nome di file.\\
435 \const{\_POSIX\_PATH\_MAX}& 256 & Lunghezza in byte di un
436 \itindex{pathname} \textit{pathname}.\\
437 \const{\_POSIX\_PIPE\_BUF}& 512 & Byte scrivibili atomicamente in una
439 \const{\_POSIX\_MAX\_CANON}&255 & Dimensione di una riga di
440 terminale in modo canonico.\\
441 \const{\_POSIX\_MAX\_INPUT}&255 & Spazio disponibile nella coda di input
443 % \const{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
444 % \const{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
445 % \const{\_POSIX\_FD\_SETSIZE}& 16 & \\
446 % \const{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
449 \caption{Costanti dei valori minimi delle caratteristiche dei file per la
450 conformità allo standard POSIX.1.}
451 \label{tab:sys_posix1_file}
454 Tutti questi limiti sono definiti in \file{limits.h}; come nel caso precedente
455 il loro uso è di scarsa utilità in quanto ampiamente superati in tutte le
456 implementazioni moderne.
459 \subsection{La funzione \func{pathconf}}
460 \label{sec:sys_pathconf}
462 In generale i limiti per i file sono molto più soggetti ad essere variabili
463 rispetto ai limiti generali del sistema; ad esempio parametri come la
464 lunghezza del nome del file o il numero di link possono variare da filesystem
465 a filesystem; per questo motivo questi limiti devono essere sempre controllati
466 con la funzione \funcd{pathconf}, il cui prototipo è:
467 \begin{prototype}{unistd.h}{long pathconf(char *path, int name)}
468 Restituisce il valore del parametro \param{name} per il file \param{path}.
470 \bodydesc{La funzione restituisce indietro il valore del parametro
471 richiesto, o -1 in caso di errore (ed \var{errno} viene impostata ad uno
472 degli errori possibili relativi all'accesso a \param{path}).}
475 E si noti come la funzione in questo caso richieda un argomento che specifichi
476 a quale file si fa riferimento, dato che il valore del limite cercato può
477 variare a seconda del filesystem. Una seconda versione della funzione,
478 \funcd{fpathconf}, opera su un file descriptor invece che su un
479 \itindex{pathname} \textit{pathname}. Il suo prototipo è:
480 \begin{prototype}{unistd.h}{long fpathconf(int fd, int name)}
481 Restituisce il valore del parametro \param{name} per il file \param{fd}.
483 \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
484 invece di un \itindex{pathname} \textit{pathname}; pertanto gli errori
485 restituiti cambiano di conseguenza.}
487 \noindent ed il suo comportamento è identico a quello di \func{pathconf}.
490 \subsection{La funzione \func{uname}}
491 \label{sec:sys_uname}
493 Un'altra funzione che si può utilizzare per raccogliere informazioni sia
494 riguardo al sistema che al computer su cui esso sta girando è \funcd{uname};
496 \begin{prototype}{sys/utsname.h}{int uname(struct utsname *info)}
497 Restituisce informazioni sul sistema nella struttura \param{info}.
499 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
500 fallimento, nel qual caso \var{errno} assumerà il valore \errval{EFAULT}.}
503 La funzione, che viene usata dal comando \cmd{uname}, restituisce le
504 informazioni richieste nella struttura \param{info}; anche questa struttura è
505 definita in \file{sys/utsname.h}, secondo quanto mostrato in
506 fig.~\ref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
507 indicano rispettivamente:
509 \item il nome del sistema operativo;
510 \item il nome della release del kernel;
511 \item il nome della versione del kernel;
512 \item il tipo di macchina in uso;
513 \item il nome della stazione;
514 \item il nome del domino.
516 l'ultima informazione è stata aggiunta di recente e non è prevista dallo
517 standard POSIX, essa è accessibile, come mostrato in
518 fig.~\ref{fig:sys_utsname}, solo definendo \macro{\_GNU\_SOURCE}.
521 \footnotesize \centering
522 \begin{minipage}[c]{15cm}
523 \includestruct{listati/ustname.h}
526 \caption{La struttura \structd{utsname}.}
527 \label{fig:sys_utsname}
530 In generale si tenga presente che le dimensioni delle stringe di una
531 \struct{utsname} non è specificata, e che esse sono sempre terminate con NUL;
532 il manuale delle \acr{glibc} indica due diverse dimensioni,
533 \const{\_UTSNAME\_LENGTH} per i campi standard e
534 \const{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
535 altri sistemi usano nomi diversi come \const{SYS\_NMLN} o \const{\_SYS\_NMLN}
536 o \const{UTSLEN} che possono avere valori diversi.\footnote{Nel caso di Linux
537 \func{uname} corrisponde in realtà a 3 system call diverse, le prime due
538 usano rispettivamente delle lunghezze delle stringhe di 9 e 65 byte; la
539 terza usa anch'essa 65 byte, ma restituisce anche l'ultimo campo,
540 \var{domainname}, con una lunghezza di 257 byte.}
543 \section{Opzioni e configurazione del sistema}
544 \label{sec:sys_config}
546 Come abbiamo accennato nella sezione precedente, non tutti i limiti che
547 caratterizzano il sistema sono fissi, o perlomeno non lo sono in tutte le
548 implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
549 di esaminare il meccanismo che permette, quando questi possono variare durante
550 l'esecuzione del sistema, di modificarli.
552 Inoltre, al di la di quelli che possono essere limiti caratteristici previsti
553 da uno standard, ogni sistema può avere una sua serie di altri parametri di
554 configurazione, che, non essendo mai fissi e variando da sistema a sistema,
555 non sono stati inclusi nella standardizzazione della sezione precedente. Per
556 questi occorre, oltre al meccanismo di impostazione, pure un meccanismo di
557 lettura. Affronteremo questi argomenti in questa sezione, insieme alle
558 funzioni che si usano per il controllo di altre caratteristiche generali del
559 sistema, come quelle per la gestione dei filesystem e di utenti e gruppi.
562 \subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
563 \label{sec:sys_sysctl}
565 La funzione che permette la lettura ed l'impostazione dei parametri del
566 sistema è \funcd{sysctl}; è una funzione derivata da BSD4.4, ma
567 l'implementazione è specifica di Linux; il suo prototipo è:
570 \funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
571 *newval, size\_t newlen)}
573 Legge o scrive uno dei parametri di sistema.
575 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
576 errore, nel qual caso \var{errno} assumerà uno dei valori:
578 \item[\errcode{EPERM}] non si ha il permesso di accedere ad uno dei
579 componenti nel cammino specificato per il parametro, o di accedere al
580 parametro nella modalità scelta.
581 \item[\errcode{ENOTDIR}] non esiste un parametro corrispondente al nome
583 % \item[\errcode{EFAULT}] si è specificato \param{oldlenp} zero quando
584 % \param{oldval} è non nullo.
585 \item[\errcode{EINVAL}] o si è specificato un valore non valido per il
586 parametro che si vuole impostare o lo spazio provvisto per il ritorno di un
587 valore non è delle giuste dimensioni.
588 \item[\errcode{ENOMEM}] talvolta viene usato più correttamente questo errore
589 quando non si è specificato sufficiente spazio per ricevere il valore di un
592 ed inoltre \errval{EFAULT}.
596 I parametri a cui la funzione permettere di accedere sono organizzati in
597 maniera gerarchica all'interno di un albero;\footnote{si tenga presente che
598 includendo solo \file{unistd.h}, saranno definiti solo i parametri generici;
599 dato che ce ne sono molti specifici dell'implementazione, nel caso di Linux
600 occorrerà includere anche i file \file{linux/unistd.h} e
601 \file{linux/sysctl.h}.} per accedere ad uno di essi occorre specificare un
602 cammino attraverso i vari nodi dell'albero, in maniera analoga a come avviene
603 per la risoluzione di un \itindex{pathname} \textit{pathname} (da cui l'uso
604 alternativo del filesystem \file{/proc}, che vedremo dopo).
606 Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
607 arriva ad identificare un parametro specifico è passato alla funzione
608 attraverso l'array \param{name}, di lunghezza \param{nlen}, che contiene la
609 sequenza dei vari nodi da attraversare. Ogni parametro ha un valore in un
610 formato specifico che può essere un intero, una stringa o anche una struttura
611 complessa, per questo motivo i valori vengono passati come puntatori
614 L'indirizzo a cui il valore corrente del parametro deve essere letto è
615 specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
616 \param{oldlenp} (passato come puntatore per avere indietro la dimensione
617 effettiva di quanto letto); il valore che si vuole impostare nel sistema è
618 passato in \param{newval} e la sua dimensione in \param{newlen}.
620 Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
621 valore letto restituito dalla funzione è quello precedente alla scrittura.
623 I parametri accessibili attraverso questa funzione sono moltissimi, e possono
624 essere trovati in \file{sysctl.h}, essi inoltre dipendono anche dallo stato
625 corrente del kernel (ad esempio dai moduli che sono stati caricati nel
626 sistema) e in genere i loro nomi possono variare da una versione di kernel
627 all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
628 quando esistono modalità alternative per ottenere le stesse informazioni.
629 Alcuni esempi di parametri ottenibili sono:
631 \item il nome di dominio
632 \item i parametri del meccanismo di \textit{paging}.
633 \item il filesystem montato come radice
634 \item la data di compilazione del kernel
635 \item i parametri dello stack TCP
636 \item il numero massimo di file aperti
639 Come accennato in Linux si ha una modalità alternativa per accedere alle
640 stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
641 \file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
642 kernel, che non fa riferimento a nessun dispositivo fisico, ma presenta in
643 forma di file alcune delle strutture interne del kernel stesso.
645 In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
646 di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
647 specificando un \itindex{pathname} \textit{pathname} e leggendo e scrivendo sul
648 file corrispondente al parametro scelto. Il kernel si occupa di generare al
649 volo il contenuto ed i nomi dei file corrispondenti, e questo ha il grande
650 vantaggio di rendere accessibili i vari parametri a qualunque comando di shell
651 e di permettere la navigazione dell'albero dei valori.
653 Alcune delle corrispondenze dei file presenti in \file{/proc/sys} con i valori
654 di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
655 in \file{linux/sysctl.h},\footnote{indicando un file di definizioni si fa
656 riferimento alla directory standard dei file di include, che in ogni
657 distribuzione che si rispetti è \file{/usr/include}.} la informazione
658 disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
659 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
661 Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc}
662 sono disponibili moltissime altre informazioni, fra cui ad esempio anche
663 quelle fornite da \func{uname} (vedi sez.~\ref{sec:sys_config}) che sono
664 mantenute nei file \file{ostype}, \file{hostname}, \file{osrelease},
665 \file{version} e \file{domainname} di \file{/proc/kernel/}.
669 \subsection{La gestione delle proprietà dei filesystem}
670 \label{sec:sys_file_config}
672 Come accennato in sez.~\ref{sec:file_organization} per poter accedere ai file
673 occorre prima rendere disponibile al sistema il filesystem su cui essi sono
674 memorizzati; l'operazione di attivazione del filesystem è chiamata
675 \textsl{montaggio}, per far questo in Linux\footnote{la funzione è specifica
676 di Linux e non è portabile.} si usa la funzione \funcd{mount} il cui
678 \begin{prototype}{sys/mount.h}
679 {mount(const char *source, const char *target, const char *filesystemtype,
680 unsigned long mountflags, const void *data)}
682 Monta il filesystem di tipo \param{filesystemtype} contenuto in \param{source}
683 sulla directory \param{target}.
685 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
686 fallimento, nel qual caso gli errori comuni a tutti i filesystem che possono
687 essere restituiti in \var{errno} sono:
689 \item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
690 \item[\errcode{ENODEV}] \param{filesystemtype} non esiste o non è configurato
692 \item[\errcode{ENOTBLK}] non si è usato un \textit{block device} per
693 \param{source} quando era richiesto.
694 \item[\errcode{EBUSY}] \param{source} è già montato, o non può essere
695 rimontato in read-only perché ci sono ancora file aperti in scrittura, o
696 \param{target} è ancora in uso.
697 \item[\errcode{EINVAL}] il device \param{source} presenta un
698 \textit{superblock} non valido, o si è cercato di rimontare un filesystem
699 non ancora montato, o di montarlo senza che \param{target} sia un
700 \textit{mount point} o di spostarlo quando \param{target} non è un
701 \textit{mount point} o è \file{/}.
702 \item[\errcode{EACCES}] non si ha il permesso di accesso su uno dei
703 componenti del \itindex{pathname} \textit{pathname}, o si è cercato
704 di montare un filesystem disponibile in sola lettura senza averlo
705 specificato o il device \param{source} è su un filesystem montato con
706 l'opzione \const{MS\_NODEV}.
707 \item[\errcode{ENXIO}] il \textit{major number} del device \param{source} è
709 \item[\errcode{EMFILE}] la tabella dei device \textit{dummy} è piena.
711 ed inoltre \errval{ENOTDIR}, \errval{EFAULT}, \errval{ENOMEM},
712 \errval{ENAMETOOLONG}, \errval{ENOENT} o \errval{ELOOP}.}
715 La funzione monta sulla directory \param{target}, detta \textit{mount point},
716 il filesystem contenuto in \param{source}. In generale un filesystem è
717 contenuto su un disco, e l'operazione di montaggio corrisponde a rendere
718 visibile al sistema il contenuto del suddetto disco, identificato attraverso
719 il file di dispositivo ad esso associato.
721 Ma la struttura del virtual filesystem vista in sez.~\ref{sec:file_vfs} è molto
722 più flessibile e può essere usata anche per oggetti diversi da un disco. Ad
723 esempio usando il \textit{loop device} si può montare un file qualunque (come
724 l'immagine di un CD-ROM o di un floppy) che contiene un filesystem, inoltre
725 alcuni filesystem, come \file{proc} o \file{devfs} sono del tutto virtuali, i
726 loro dati sono generati al volo ad ogni lettura, e passati al kernel ad ogni
729 Il tipo di filesystem è specificato da \param{filesystemtype}, che deve essere
730 una delle stringhe riportate nel file \file{/proc/filesystems}, che contiene
731 l'elenco dei filesystem supportati dal kernel; nel caso si sia indicato uno
732 dei filesystem virtuali, il contenuto di \param{source} viene ignorato.
734 Dopo l'esecuzione della funzione il contenuto del filesystem viene resto
735 disponibile nella directory specificata come \textit{mount point}, il
736 precedente contenuto di detta directory viene mascherato dal contenuto della
737 directory radice del filesystem montato.
739 Dal kernel 2.4.x inoltre è divenuto possibile sia spostare atomicamente un
740 \textit{mount point} da una directory ad un'altra, sia montare in diversi
741 \textit{mount point} lo stesso filesystem, sia montare più filesystem sullo
742 stesso \textit{mount point} (nel qual caso vale quanto appena detto, e solo il
743 contenuto dell'ultimo filesystem montato sarà visibile).
745 Ciascun filesystem è dotato di caratteristiche specifiche che possono essere
746 attivate o meno, alcune di queste sono generali (anche se non è detto siano
747 disponibili in ogni filesystem), e vengono specificate come opzioni di
748 montaggio con l'argomento \param{mountflags}.
750 In Linux \param{mountflags} deve essere un intero a 32 bit i cui 16 più
751 significativi sono un \textit{magic number}\footnote{cioè un numero speciale
752 usato come identificativo, che nel caso è \code{0xC0ED}; si può usare la
753 costante \const{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
754 riservata al \textit{magic number}.} mentre i 16 meno significativi sono
755 usati per specificare le opzioni; essi sono usati come maschera binaria e
756 vanno impostati con un OR aritmetico della costante \const{MS\_MGC\_VAL} con i
757 valori riportati in tab.~\ref{tab:sys_mount_flags}.
762 \begin{tabular}[c]{|l|r|l|}
764 \textbf{Parametro} & \textbf{Valore}&\textbf{Significato}\\
767 \const{MS\_RDONLY} & 1 & Monta in sola lettura.\\
768 \const{MS\_NOSUID} & 2 & Ignora i bit \itindex{suid~bit} \acr{suid} e
769 \itindex{sgid~bit} \acr{sgid}.\\
770 \const{MS\_NODEV} & 4 & Impedisce l'accesso ai file di dispositivo.\\
771 \const{MS\_NOEXEC} & 8 & Impedisce di eseguire programmi.\\
772 \const{MS\_SYNCHRONOUS}& 16 & Abilita la scrittura sincrona.\\
773 \const{MS\_REMOUNT} & 32 & Rimonta il filesystem cambiando le opzioni.\\
774 \const{MS\_MANDLOCK} & 64 & Consente il \textit{mandatory locking}
775 \itindex{mandatory~locking} (vedi
776 sez.~\ref{sec:file_mand_locking}).\\
777 \const{S\_WRITE} & 128 & Scrive normalmente.\\
778 \const{S\_APPEND} & 256 & Consente la scrittura solo in
779 \itindex{append~mode} \textit{append mode}
780 (vedi sez.~\ref{sec:file_sharing}).\\
781 \const{S\_IMMUTABLE} & 512 & Impedisce che si possano modificare i file.\\
782 \const{MS\_NOATIME} &1024 & Non aggiorna gli \textit{access time} (vedi
783 sez.~\ref{sec:file_file_times}).\\
784 \const{MS\_NODIRATIME}&2048 & Non aggiorna gli \textit{access time} delle
786 \const{MS\_BIND} &4096 & Monta il filesystem altrove.\\
787 \const{MS\_MOVE} &8192 & Sposta atomicamente il punto di montaggio.\\
790 \caption{Tabella dei codici dei flag di montaggio di un filesystem.}
791 \label{tab:sys_mount_flags}
794 % TODO aggiornare con i nuovi flag di man mount
796 Per l'impostazione delle caratteristiche particolari di ciascun filesystem si
797 usa invece l'argomento \param{data} che serve per passare le ulteriori
798 informazioni necessarie, che ovviamente variano da filesystem a filesystem.
800 La funzione \func{mount} può essere utilizzata anche per effettuare il
801 \textsl{rimontaggio} di un filesystem, cosa che permette di cambiarne al volo
802 alcune delle caratteristiche di funzionamento (ad esempio passare da sola
803 lettura a lettura/scrittura). Questa operazione è attivata attraverso uno dei
804 bit di \param{mountflags}, \const{MS\_REMOUNT}, che se impostato specifica che
805 deve essere effettuato il rimontaggio del filesystem (con le opzioni
806 specificate dagli altri bit), anche in questo caso il valore di \param{source}
809 Una volta che non si voglia più utilizzare un certo filesystem è possibile
810 \textsl{smontarlo} usando la funzione \funcd{umount}, il cui prototipo è:
811 \begin{prototype}{sys/mount.h}{umount(const char *target)}
813 Smonta il filesystem montato sulla directory \param{target}.
815 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
816 fallimento, nel qual caso \var{errno} assumerà uno dei valori:
818 \item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
819 \item[\errcode{EBUSY}] \param{target} è la directory di lavoro di qualche
820 processo, o contiene dei file aperti, o un altro mount point.
822 ed inoltre \errval{ENOTDIR}, \errval{EFAULT}, \errval{ENOMEM},
823 \errval{ENAMETOOLONG}, \errval{ENOENT} o \errval{ELOOP}.}
825 \noindent la funzione prende il nome della directory su cui il filesystem è
826 montato e non il file o il dispositivo che è stato montato,\footnote{questo è
827 vero a partire dal kernel 2.3.99-pre7, prima esistevano due chiamate
828 separate e la funzione poteva essere usata anche specificando il file di
829 dispositivo.} in quanto con il kernel 2.4.x è possibile montare lo stesso
830 dispositivo in più punti. Nel caso più di un filesystem sia stato montato
831 sullo stesso \textit{mount point} viene smontato quello che è stato montato
834 Si tenga presente che la funzione fallisce quando il filesystem è
835 \textsl{occupato}, questo avviene quando ci sono ancora file aperti sul
836 filesystem, se questo contiene la directory di lavoro corrente di un qualunque
837 processo o il mount point di un altro filesystem; in questo caso l'errore
838 restituito è \errcode{EBUSY}.
840 Linux provvede inoltre una seconda funzione, \funcd{umount2}, che in alcuni
841 casi permette di forzare lo smontaggio di un filesystem, anche quando questo
842 risulti occupato; il suo prototipo è:
843 \begin{prototype}{sys/mount.h}{umount2(const char *target, int flags)}
845 La funzione è identica a \func{umount} per comportamento e codici di errore,
846 ma con \param{flags} si può specificare se forzare lo smontaggio.
849 Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
850 definito è il bit \const{MNT\_FORCE}; gli altri bit devono essere nulli.
851 Specificando \const{MNT\_FORCE} la funzione cercherà di liberare il filesystem
852 anche se è occupato per via di una delle condizioni descritte in precedenza. A
853 seconda del tipo di filesystem alcune (o tutte) possono essere superate,
854 evitando l'errore di \errcode{EBUSY}. In tutti i casi prima dello smontaggio
855 viene eseguita una sincronizzazione dei dati.
857 % TODO documentare MNT_DETACH e MNT_EXPIRE ...
859 Altre due funzioni specifiche di Linux,\footnote{esse si trovano anche su BSD,
860 ma con una struttura diversa.} utili per ottenere in maniera diretta
861 informazioni riguardo al filesystem su cui si trova un certo file, sono
862 \funcd{statfs} e \funcd{fstatfs}, i cui prototipi sono:
865 \funcdecl{int statfs(const char *path, struct statfs *buf)}
867 \funcdecl{int fstatfs(int fd, struct statfs *buf)}
869 Restituisce in \param{buf} le informazioni relative al filesystem su cui è
870 posto il file specificato.
872 \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
873 errore, nel qual caso \var{errno} assumerà uno dei valori:
875 \item[\errcode{ENOSYS}] il filesystem su cui si trova il file specificato non
876 supporta la funzione.
878 e \errval{EFAULT} ed \errval{EIO} per entrambe, \errval{EBADF} per
879 \func{fstatfs}, \errval{ENOTDIR}, \errval{ENAMETOOLONG}, \errval{ENOENT},
880 \errval{EACCES}, \errval{ELOOP} per \func{statfs}.}
883 Queste funzioni permettono di ottenere una serie di informazioni generali
884 riguardo al filesystem su cui si trova il file specificato; queste vengono
885 restituite all'indirizzo \param{buf} di una struttura \struct{statfs} definita
886 come in fig.~\ref{fig:sys_statfs}, ed i campi che sono indefiniti per il
887 filesystem in esame sono impostati a zero. I valori del campo \var{f\_type}
888 sono definiti per i vari filesystem nei relativi file di header dei sorgenti
889 del kernel da costanti del tipo \var{XXX\_SUPER\_MAGIC}, dove \var{XXX} in
890 genere è il nome del filesystem stesso.
893 \footnotesize \centering
894 \begin{minipage}[c]{15cm}
895 \includestruct{listati/statfs.h}
898 \caption{La struttura \structd{statfs}.}
899 \label{fig:sys_statfs}
903 Le \acr{glibc} provvedono infine una serie di funzioni per la gestione dei due
904 file \file{/etc/fstab} ed \file{/etc/mtab}, che convenzionalmente sono usati
905 in quasi tutti i sistemi unix-like per mantenere rispettivamente le
906 informazioni riguardo ai filesystem da montare e a quelli correntemente
907 montati. Le funzioni servono a leggere il contenuto di questi file in
908 opportune strutture \struct{fstab} e \struct{mntent}, e, per \file{/etc/mtab}
909 per inserire e rimuovere le voci presenti nel file.
911 In generale si dovrebbero usare queste funzioni (in particolare quelle
912 relative a \file{/etc/mtab}), quando si debba scrivere un programma che
913 effettua il montaggio di un filesystem; in realtà in questi casi è molto più
914 semplice invocare direttamente il programma \cmd{mount}, per cui ne
915 tralasceremo la trattazione, rimandando al manuale delle \acr{glibc}
916 \cite{glibc} per la documentazione completa.
920 % TODO scrivere relativamente alle varie funzioni (getfsent e getmntent &C)
922 \subsection{La gestione delle informazioni su utenti e gruppi}
923 \label{sec:sys_user_group}
925 Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
926 (password, corrispondenze fra nomi simbolici e user-id, home directory, ecc.)
927 venivano registrate all'interno dei due file di testo \file{/etc/passwd} ed
928 \file{/etc/group},\footnote{in realtà oltre a questi nelle distribuzioni più
929 recenti è stato introdotto il sistema delle \textit{shadow password} che
930 prevede anche i due file \file{/etc/shadow} e \file{/etc/gshadow}, in cui
931 sono state spostate le informazioni di autenticazione (ed inserite alcune
932 estensioni) per toglierle dagli altri file che devono poter essere letti per
933 poter effettuare l'associazione fra username e \acr{uid}.} il cui formato è
934 descritto dalle relative pagine del manuale\footnote{nella quinta sezione,
935 quella dei file di configurazione, occorre cioè usare \cmd{man 5 passwd}
936 dato che altrimenti si avrebbe la pagina di manuale del comando
937 \cmd{passwd}.} e tutte le funzioni che richiedevano l'accesso a queste
938 informazione andavano a leggere direttamente il contenuto di questi file.
940 Col tempo però questa impostazione ha incominciato a mostrare dei limiti: da
941 una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
942 la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
943 che sta per \textit{Pluggable Authentication Method}) che fornisce una
944 interfaccia comune per i processi di autenticazione,\footnote{il
945 \textit{Pluggable Authentication Method} è un sistema modulare, in cui è
946 possibile utilizzare anche più meccanismi insieme, diventa così possibile
947 avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
948 diversi formati per le password e diversi supporti per le informazioni, il
949 tutto in maniera trasparente per le applicazioni purché per ciascun
950 meccanismo si disponga della opportuna libreria che implementa l'interfaccia
951 di PAM.} svincolando completamente le singole applicazione dai dettagli del
952 come questa viene eseguita e di dove vengono mantenuti i dati relativi;
953 dall'altra con il diffondersi delle reti la necessità di centralizzare le
954 informazioni degli utenti e dei gruppi per insiemi di macchine, in modo da
955 mantenere coerenti i dati, ha portato anche alla necessità di poter recuperare
956 e memorizzare dette informazioni su supporti diversi, introducendo il sistema
957 del \itindex{Name~Service~Switch} \textit{Name Service Switch} che tratteremo
958 brevemente più avanti (in sez.~\ref{sec:sock_resolver}) dato che la maggior
959 parte delle sua applicazioni sono relative alla risoluzioni di nomi di rete.
961 In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
962 per la lettura delle informazioni relative a utenti e gruppi tralasciando
963 completamente quelle relative all'autenticazione.
964 % Per questo non tratteremo
965 % affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
966 % \textit{Name Service Switch}, un meccanismo messo a disposizione dalle
967 % \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
968 % necessario trovare una corrispondenza fra un nome ed un numero (od altra
969 % informazione) ad esso associato, come appunto, quella fra uno username ed un
970 % \acr{uid} o fra un \acr{gid} ed il nome del gruppo corrispondente.
971 Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
972 queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
973 Service Switch}, per cui sono in grado di ricevere informazioni qualunque
974 sia il supporto su cui esse vengono mantenute. Per leggere le informazioni
975 relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
976 \funcd{getpwnam}, i cui prototipi sono:
979 \headdecl{sys/types.h}
980 \funcdecl{struct passwd *getpwuid(uid\_t uid)}
982 \funcdecl{struct passwd *getpwnam(const char *name)}
984 Restituiscono le informazioni relative all'utente specificato.
986 \bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
987 informazioni in caso di successo e \val{NULL} nel caso non sia stato
988 trovato nessun utente corrispondente a quanto specificato.}
991 Le due funzioni forniscono le informazioni memorizzate nel registro degli
992 utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
993 relative all'utente specificato attraverso il suo \acr{uid} o il nome di
994 login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
995 tipo \struct{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
996 riportata in fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente
997 illustrato il significato dei vari campi.
1002 \begin{minipage}[c]{15cm}
1003 \includestruct{listati/passwd.h}
1006 \caption{La struttura \structd{passwd} contenente le informazioni relative ad
1007 un utente del sistema.}
1008 \label{fig:sys_passwd_struct}
1011 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
1012 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
1013 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
1014 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
1015 essere rientranti; per questo motivo ne esistono anche due versioni
1016 alternative (denotate dalla solita estensione \code{\_r}), i cui prototipi
1021 \headdecl{sys/types.h}
1023 \funcdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
1024 char *buffer, size\_t buflen, struct passwd **result)}
1026 \funcdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
1027 *password, char *buffer, size\_t buflen, struct passwd **result)}
1029 Restituiscono le informazioni relative all'utente specificato.
1031 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1032 altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
1035 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
1036 la memoria necessaria a contenere le informazioni. In particolare i valori
1037 della struttura \struct{passwd} saranno restituiti all'indirizzo
1038 \param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
1039 un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
1040 puntate dai campi di \param{password}. Infine all'indirizzo puntato da
1041 \param{result} viene restituito il puntatore ai dati ottenuti, cioè
1042 \param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti. Qualora i
1043 dati non possano essere contenuti nei byte specificati da \param{buflen}, la
1044 funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
1045 impostato a \val{NULL}).
1047 Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
1048 \funcd{getgrgid} (e le relative analoghe rientranti con la stessa estensione
1049 \code{\_r}) che permettono di leggere le informazioni relative ai gruppi, i
1050 loro prototipi sono:
1053 \headdecl{sys/types.h}
1055 \funcdecl{struct group *getgrgid(gid\_t gid)}
1057 \funcdecl{struct group *getgrnam(const char *name)}
1059 \funcdecl{struct group *getpwuid\_r(gid\_t gid, struct group *password,
1060 char *buffer, size\_t buflen, struct group **result)}
1062 \funcdecl{struct group *getpwnam\_r(const char *name, struct group
1063 *password, char *buffer, size\_t buflen, struct group **result)}
1065 Restituiscono le informazioni relative al gruppo specificato.
1067 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1068 altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
1071 Il comportamento di tutte queste funzioni è assolutamente identico alle
1072 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
1073 in questo caso le informazioni vengono restituite in una struttura di tipo
1074 \struct{group}, la cui definizione è riportata in
1075 fig.~\ref{fig:sys_group_struct}.
1077 \begin{figure}[!htb]
1080 \begin{minipage}[c]{15cm}
1081 \includestruct{listati/group.h}
1084 \caption{La struttura \structd{group} contenente le informazioni relative ad
1085 un gruppo del sistema.}
1086 \label{fig:sys_group_struct}
1089 Le funzioni viste finora sono in grado di leggere le informazioni sia
1090 direttamente dal file delle password in \file{/etc/passwd} che tramite il
1091 sistema del \itindex{Name~Service~Switch} \textit{Name Service Switch} e
1092 sono completamente generiche. Si noti però che non c'è una funzione che
1093 permetta di impostare direttamente una password.\footnote{in realtà questo può
1094 essere fatto ricorrendo a PAM, ma questo è un altro discorso.} Dato che
1095 POSIX non prevede questa possibilità esiste un'altra interfaccia che lo fa,
1096 derivata da SVID le cui funzioni sono riportate in
1097 tab.~\ref{tab:sys_passwd_func}. Questa però funziona soltanto quando le
1098 informazioni sono mantenute su un apposito file di \textsl{registro} di utenti
1099 e gruppi, con il formato classico di \file{/etc/passwd} e \file{/etc/group}.
1104 \begin{tabular}[c]{|l|p{8cm}|}
1106 \textbf{Funzione} & \textbf{Significato}\\
1109 \func{fgetpwent} & Legge una voce dal file di registro degli utenti
1111 \func{fgetpwent\_r}& Come la precedente, ma rientrante.\\
1112 \func{putpwent} & Immette una voce in un file di registro degli
1114 \func{getpwent} & Legge una voce da \file{/etc/passwd}.\\
1115 \func{getpwent\_r} & Come la precedente, ma rientrante.\\
1116 \func{setpwent} & Ritorna all'inizio di \file{/etc/passwd}.\\
1117 \func{endpwent} & Chiude \file{/etc/passwd}.\\
1118 \func{fgetgrent} & Legge una voce dal file di registro dei gruppi
1120 \func{fgetgrent\_r}& Come la precedente, ma rientrante.\\
1121 \func{putgrent} & Immette una voce in un file di registro dei gruppi.\\
1122 \func{getgrent} & Legge una voce da \file{/etc/group}.\\
1123 \func{getgrent\_r} & Come la precedente, ma rientrante.\\
1124 \func{setgrent} & Ritorna all'inizio di \file{/etc/group}.\\
1125 \func{endgrent} & Chiude \file{/etc/group}.\\
1128 \caption{Funzioni per la manipolazione dei campi di un file usato come
1129 registro per utenti o gruppi nel formato di \file{/etc/passwd} e
1130 \file{/etc/groups}.}
1131 \label{tab:sys_passwd_func}
1134 Dato che oramai la gran parte delle distribuzioni di GNU/Linux utilizzano
1135 almeno le \textit{shadow password} (quindi con delle modifiche rispetto al
1136 formato classico del file \file{/etc/passwd}), si tenga presente che le
1137 funzioni di questa interfaccia che permettono di scrivere delle voci in un
1138 \textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
1139 hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
1140 questa estensione. Per questo motivo l'uso di queste funzioni è deprecato, in
1141 quanto comunque non funzionale, pertanto ci limiteremo a fornire soltanto
1142 l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
1143 ulteriore. Chi volesse insistere ad usare questa interfaccia può fare
1144 riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
1145 delle \acr{glibc} per i dettagli del funzionamento.
1149 \subsection{Il registro della \textsl{contabilità} degli utenti}
1150 \label{sec:sys_accounting}
1152 L'ultimo insieme di funzioni relative alla gestione del sistema che
1153 esamineremo è quello che permette di accedere ai dati del registro della
1154 cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti. In esso
1155 vengono mantenute una serie di informazioni storiche relative sia agli utenti
1156 che si sono collegati al sistema, (tanto per quelli correntemente collegati,
1157 che per la registrazione degli accessi precedenti), sia relative all'intero
1158 sistema, come il momento di lancio di processi da parte di \cmd{init}, il
1159 cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
1162 I dati vengono usualmente\footnote{questa è la locazione specificata dal
1163 \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
1164 delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
1165 \file{/var/log/wtmp}.\footnote{non si confonda quest'ultimo con il simile
1166 \file{/var/log/btmp} dove invece vengono memorizzati dal programma di login
1167 tutti tentativi di accesso fallito.} Quando un utente si collega viene
1168 aggiunta una voce a \file{/var/run/utmp} in cui viene memorizzato il nome di
1169 login, il terminale da cui ci si collega, l'\acr{uid} della shell di login,
1170 l'orario della connessione ed altre informazioni. La voce resta nel file fino
1171 al logout, quando viene cancellata e spostata in \file{/var/log/wtmp}.
1173 In questo modo il primo file viene utilizzato per registrare chi sta
1174 utilizzando il sistema al momento corrente, mentre il secondo mantiene la
1175 registrazione delle attività degli utenti. A quest'ultimo vengono anche
1176 aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
1177 come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
1178 informazioni sono descritte in dettaglio nel manuale delle \acr{glibc}.
1180 Questi file non devono mai essere letti direttamente, ma le informazioni che
1181 contengono possono essere ricavate attraverso le opportune funzioni di
1182 libreria. Queste sono analoghe alle precedenti funzioni (vedi
1183 tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
1184 solo che in questo caso la struttura del registro della \textsl{contabilità} è
1185 molto più complessa, dato che contiene diversi tipi di informazione.
1187 Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
1188 servono rispettivamente a aprire e a chiudere il file che contiene il
1189 registro, e a specificare su quale file esso viene mantenuto. I loro prototipi
1194 \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
1197 \funcdecl{void setutent(void)} Apre il file del registro, posizionandosi al
1200 \funcdecl{void endutent(void)} Chiude il file del registro.
1202 \bodydesc{Le funzioni non ritornano codici di errore.}
1204 e si tenga presente che le funzioni non restituiscono nessun valore, pertanto
1205 non è possibile accorgersi di eventuali errori (ad esempio se si è impostato
1206 un nome di file sbagliato con \func{utmpname}).
1208 Nel caso non si sia utilizzata \func{utmpname} per specificare un file di
1209 registro alternativo, sia \func{setutent} che \func{endutent} operano usando
1210 il default che è \file{/var/run/utmp}. Il nome di questo file, così come una
1211 serie di altri valori di default per i \textit{pathname} di uso più comune,
1212 viene mantenuto nei valori di una serie di costanti definite includendo
1213 \file{paths.h}, in particolare quelle che ci interessano sono:
1214 \begin{basedescript}{\desclabelwidth{2.0cm}}
1215 \item[\const{\_PATH\_UTMP}] specifica il file che contiene il registro per gli
1216 utenti correntemente collegati; questo è il valore che viene usato se non si
1217 è utilizzato \func{utmpname} per modificarlo.
1218 \item[\const{\_PATH\_WTMP}] specifica il file che contiene il registro per
1219 l'archivio storico degli utenti collegati.
1221 che nel caso di Linux hanno un valore corrispondente ai file
1222 \file{/var/run/utmp} e \file{/var/log/wtmp} citati in precedenza.
1224 Una volta aperto il file del registro degli utenti si può eseguire una
1225 scansione leggendo o scrivendo una voce con le funzioni \funcd{getutent},
1226 \funcd{getutid}, \funcd{getutline} e \funcd{pututline}, i cui prototipi sono:
1230 \funcdecl{struct utmp *getutent(void)}
1231 Legge una voce dalla posizione corrente nel registro.
1233 \funcdecl{struct utmp *getutid(struct utmp *ut)} Ricerca una voce sul
1234 registro in base al contenuto di \param{ut}.
1236 \funcdecl{struct utmp *getutline(struct utmp *ut)}
1237 Ricerca nel registro la prima voce corrispondente ad un processo sulla linea
1238 di terminale specificata tramite \param{ut}.
1240 \funcdecl{struct utmp *pututline(struct utmp *ut)}
1241 Scrive una voce nel registro.
1243 \bodydesc{Le funzioni ritornano il puntatore ad una struttura \struct{utmp}
1244 in caso di successo e \val{NULL} in caso di errore.}
1247 Tutte queste funzioni fanno riferimento ad una struttura di tipo
1248 \struct{utmp}, la cui definizione in Linux è riportata in
1249 fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
1250 voce dal registro; \func{getutent} legge semplicemente la prima voce
1251 disponibile; le altre due permettono di eseguire una ricerca.
1254 \begin{figure}[!htb]
1257 \begin{minipage}[c]{15cm}
1258 \includestruct{listati/utmp.h}
1261 \caption{La struttura \structd{utmp} contenente le informazioni di una voce
1262 del registro di \textsl{contabilità}.}
1263 \label{fig:sys_utmp_struct}
1266 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1267 campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
1268 riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
1269 \const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
1270 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1271 invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
1272 \const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
1273 corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1278 \begin{tabular}[c]{|l|p{8cm}|}
1280 \textbf{Valore} & \textbf{Significato}\\
1283 \const{EMPTY} & Non contiene informazioni valide.\\
1284 \const{RUN\_LVL} & Identica il runlevel del sistema.\\
1285 \const{BOOT\_TIME} & Identifica il tempo di avvio del sistema.\\
1286 \const{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
1288 \const{NEW\_TIME} & Identifica da quanto è stato modificato il
1290 \const{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
1291 \const{LOGIN\_PROCESS}& Identifica un processo di login.\\
1292 \const{USER\_PROCESS} & Identifica un processo utente.\\
1293 \const{DEAD\_PROCESS} & Identifica un processo terminato.\\
1294 % \const{ACCOUNTING} & ??? \\
1297 \caption{Classificazione delle voci del registro a seconda dei
1298 possibili valori del campo \var{ut\_type}.}
1299 \label{tab:sys_ut_type}
1302 La funzione \func{getutline} esegue la ricerca sulle voci che hanno
1303 \var{ut\_type} uguale a \const{LOGIN\_PROCESS} o \const{USER\_PROCESS},
1304 restituendo la prima che corrisponde al valore di \var{ut\_line}, che
1305 specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
1306 terminale che interessa. Lo stesso criterio di ricerca è usato da
1307 \func{pututline} per trovare uno spazio dove inserire la voce specificata,
1308 qualora non sia trovata la voce viene aggiunta in coda al registro.
1310 In generale occorre però tenere conto che queste funzioni non sono
1311 completamente standardizzate, e che in sistemi diversi possono esserci
1312 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1313 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1314 fornita dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1315 introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
1316 sono un sovrainsieme di \code{utmp}.
1318 Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
1319 inutili queste nuove strutture; pertanto esse e le relative funzioni di
1320 gestione (\func{getutxent}, \func{getutxid}, \func{getutxline},
1321 \func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
1322 sinonimi delle funzioni appena viste.
1324 Come visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
1325 staticamente rende le funzioni di lettura non rientranti; per questo motivo le
1326 \acr{glibc} forniscono anche delle versioni rientranti: \func{getutent\_r},
1327 \func{getutid\_r}, \func{getutline\_r}, che invece di restituire un puntatore
1328 restituiscono un intero e prendono due argomenti aggiuntivi. Le funzioni si
1329 comportano esattamente come le analoghe non rientranti, solo che restituiscono
1330 il risultato all'indirizzo specificato dal primo argomento aggiuntivo (di tipo
1331 \code{struct utmp *buffer}) mentre il secondo (di tipo \code{struct utmp
1332 **result)} viene usato per restituire il puntatore allo stesso buffer.
1334 Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
1335 in \file{wmtp} altre due funzioni, \funcd{updwtmp} e \funcd{logwtmp}, i cui
1340 \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1341 Aggiunge la voce \param{ut} nel registro \file{wmtp}.
1343 \funcdecl{void logwtmp(const char *line, const char *name, const char
1344 *host)} Aggiunge nel registro una voce con i valori specificati.
1347 La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
1348 direttamente una struttura \struct{utmp}, mentre la seconda utilizza gli
1349 argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
1350 poi aggiunge chiamando \func{updwtmp}.
1353 \section{Il controllo dell'uso delle risorse}
1354 \label{sec:sys_res_limits}
1357 Dopo aver esaminato le funzioni che permettono di controllare le varie
1358 caratteristiche, capacità e limiti del sistema a livello globale, in questa
1359 sezione tratteremo le varie funzioni che vengono usate per quantificare le
1360 risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
1361 permettono di imporre a ciascuno di essi vincoli e limiti di
1365 \subsection{L'uso delle risorse}
1366 \label{sec:sys_resource_use}
1368 Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
1369 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1370 di tipo \struct{rusage}, la cui definizione (che si trova in
1371 \file{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
1373 \begin{figure}[!htb]
1376 \begin{minipage}[c]{15cm}
1377 \includestruct{listati/rusage.h}
1380 \caption{La struttura \structd{rusage} per la lettura delle informazioni dei
1381 delle risorse usate da un processo.}
1382 \label{fig:sys_rusage_struct}
1385 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
1386 da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
1387 \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si trova
1388 nelle opzioni di compilazione del kernel (e di norma è disabilitato) che
1389 serve per mantenere una contabilità delle risorse usate da ciascun processo
1390 in maniera molto più dettagliata.} ma attualmente (con i kernel della serie
1391 2.4.x e 2.6.x) i soli campi che sono mantenuti sono: \var{ru\_utime},
1392 \var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I
1393 primi due indicano rispettivamente il tempo impiegato dal processo
1394 nell'eseguire le istruzioni in user space, e quello impiegato dal kernel nelle
1395 system call eseguite per conto del processo.
1397 Gli altri tre campi servono a quantificare l'uso della memoria
1398 virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
1399 \itindex{page~fault} \textit{page fault} (vedi sez.~\ref{sec:proc_mem_gen})
1400 avvenuti senza richiedere I/O su disco (i cosiddetti \textit{minor page
1401 fault}), a quelli che invece han richiesto I/O su disco (detti invece
1402 \textit{major page fault}) ed al numero di volte che il processo è stato
1403 completamente tolto dalla memoria per essere inserito nello swap.
1405 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
1406 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
1407 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
1408 ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
1411 Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
1412 visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di risorse
1413 impiegate dal processo di cui si è letto lo stato di terminazione, ma essa può
1414 anche essere letta direttamente utilizzando la funzione \funcd{getrusage}, il
1417 \headdecl{sys/time.h}
1418 \headdecl{sys/resource.h}
1421 \funcdecl{int getrusage(int who, struct rusage *usage)}
1422 Legge la quantità di risorse usate da un processo.
1425 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1426 nel qual caso \var{errno} può essere \errval{EINVAL} o \errval{EFAULT}.}
1429 L'argomento \param{who} permette di specificare il processo di cui si vuole
1430 leggere l'uso delle risorse; esso può assumere solo i due valori
1431 \const{RUSAGE\_SELF} per indicare il processo corrente e
1432 \const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
1433 ricevuto lo stato di terminazione.
1436 \subsection{Limiti sulle risorse}
1437 \label{sec:sys_resource_limit}
1439 Come accennato nell'introduzione il kernel mette a disposizione delle
1440 funzionalità che permettono non solo di mantenere dati statistici relativi
1441 all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
1442 utilizzo da parte dei vari processi o degli utenti.
1444 Per far questo esistono una serie di risorse e ad ogni processo vengono
1445 associati due diversi limiti per ciascuna di esse; questi sono il
1446 \textsl{limite corrente} (o \textit{current limit}) che esprime un valore
1447 massimo che il processo non può superare ad un certo momento, ed il
1448 \textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
1449 valore massimo che può assumere il \textsl{limite corrente}. In generale il
1450 primo viene chiamato anche \textit{soft limit} dato che il suo valore può
1451 essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
1452 fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
1458 \begin{tabular}[c]{|l|p{12cm}|}
1460 \textbf{Valore} & \textbf{Significato}\\
1463 \const{RLIMIT\_AS} & La dimensione massima della memoria virtuale di
1464 un processo, il cosiddetto \textit{Address
1465 Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se
1466 il limite viene superato dall'uso di funzioni
1467 come \func{brk}, \func{mremap} o \func{mmap}
1468 esse falliranno con un errore di
1469 \errcode{ENOMEM}, mentre se il superamento viene
1470 causato dalla crescita dello \itindex{stack}
1471 stack il processo riceverà un segnale di
1473 \const{RLIMIT\_CORE} & La massima dimensione per di un file di
1474 \itindex{core~dump} \textit{core dump} (vedi
1475 sez.~\ref{sec:sig_prog_error}) creato nella
1476 terminazione di un processo; file di dimensioni
1477 maggiori verranno troncati a questo valore,
1478 mentre con un valore si bloccherà la creazione
1479 dei \itindex{core~dump} \textit{core dump}.\\
1480 \const{RLIMIT\_CPU} & Il massimo tempo di CPU (vedi
1481 sez.~\ref{sec:sys_cpu_times}) che il processo può
1482 usare. Il superamento del limite corrente
1483 comporta l'emissione di un segnale di
1484 \const{SIGXCPU} la cui azione predefinita (vedi
1485 sez.~\ref{sec:sig_classification}) è terminare
1486 il processo. Il superamento del limite massimo
1487 comporta l'emissione di un segnale di
1488 \const{SIGKILL}.\footnotemark\\
1489 \const{RLIMIT\_DATA} & La massima dimensione del \index{segmento!dati}
1491 processo (vedi sez.~\ref{sec:proc_mem_layout}).
1492 Il tentativo di allocare più memoria di quanto
1493 indicato dal limite corrente causa il fallimento
1494 della funzione di allocazione (\func{brk} o
1495 \func{sbrk}) con un errore di \errcode{ENOMEM}.\\
1496 \const{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
1497 può creare. Se il processo cerca di scrivere
1498 oltre questa dimensione riceverà un segnale di
1499 \const{SIGXFSZ}, che di norma termina il
1500 processo; se questo viene intercettato la
1501 system call che ha causato l'errore fallirà con
1502 un errore di \errcode{EFBIG}.\\
1503 \const{RLIMIT\_LOCKS}& È un limite presente solo nelle prime versioni
1504 del kernel 2.4 sul numero massimo di
1505 \index{file!locking} \textit{file lock} (vedi
1506 sez.~\ref{sec:file_locking}) che un
1507 processo poteva effettuare.\\
1508 \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
1509 bloccata in RAM da un processo (vedi
1510 sez.~\ref{sec:proc_mem_lock}). Dal kernel 2.6.9
1511 questo limite comprende anche la memoria che può
1512 essere bloccata da ciascun utente nell'uso della
1513 memoria condivisa (vedi
1514 sez.~\ref{sec:ipc_sysv_shm}) che viene
1515 contabilizzata separatamente ma sulla quale
1516 viene applicato questo stesso limite.\\
1517 \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
1518 aprire. L'apertura di un ulteriore file farà
1519 fallire la funzione (\func{open}, \func{dup} o
1520 \func{pipe}) con un errore \errcode{EMFILE}.\\
1521 \const{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
1522 creati sullo stesso user id real. Se il limite
1523 viene raggiunto \func{fork} fallirà con un
1525 \const{RLIMIT\_SIGPENDING}& Il numero massimo di segnali che possono
1526 essere mantenuti in coda per ciascun utente,
1527 considerando sia i segnali normali che real-time
1528 (vedi sez.~\ref{sec:sig_real_time}). Il limite è
1529 attivo solo per \func{sigqueue}, con \func{kill}
1530 si potrà sempre inviare un segnale che non sia
1531 già presente su una coda.\footnotemark\\
1532 \const{RLIMIT\_STACK} & La massima dimensione dello \itindex{stack}
1534 processo. Se il processo esegue operazioni che
1535 estendano lo stack oltre questa dimensione
1536 riceverà un segnale di \const{SIGSEGV}.\\
1537 \const{RLIMIT\_RSS} & L'ammontare massimo di pagine di memoria dato al
1538 \index{segmento!testo} testo del processo. Il
1539 limite è solo una indicazione per il kernel,
1540 qualora ci fosse un surplus di memoria questa
1541 verrebbe assegnata.\\
1542 % TODO integrare con la roba di madvise
1545 \caption{Valori possibili dell'argomento \param{resource} delle funzioni
1546 \func{getrlimit} e \func{setrlimit}.}
1547 \label{tab:sys_rlimit_values}
1550 \footnotetext[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
1551 oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
1552 avviene quando viene superato il \textit{soft limit}; perciò per avere
1553 operazioni portabili è sempre opportuno intercettare \const{SIGXCPU} e
1554 terminare in maniera ordinata il processo.}
1556 \footnotetext{il limite su questa risorsa è stato introdotto con il kernel
1559 In generale il superamento di un limite corrente\footnote{di norma quanto
1560 riportato in tab.~\ref{tab:sys_rlimit_values} fa riferimento a quanto
1561 avviene al superamento del limite corrente, con l'eccezione
1562 \const{RLIMIT\_CPU} in cui si ha in comportamento diverso per il superamento
1563 dei due limiti.} comporta o l'emissione di un segnale o il fallimento della
1564 system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
1565 \const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
1566 creazione) dei file di \itindex{core~dump} \textit{core dump}.} per
1567 permettere di leggere e di impostare i limiti di utilizzo delle risorse da
1568 parte di un processo sono previste due funzioni, \funcd{getrlimit} e
1569 \funcd{setrlimit}, i cui prototipi sono:
1571 \headdecl{sys/time.h}
1572 \headdecl{sys/resource.h}
1575 \funcdecl{int getrlimit(int resource, struct rlimit *rlim)}
1577 Legge il limite corrente per la risorsa \param{resource}.
1579 \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)}
1581 Imposta il limite per la risorsa \param{resource}.
1583 \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
1584 errore, nel qual caso \var{errno} assumerà uno dei valori:
1586 \item[\errcode{EINVAL}] I valori per \param{resource} non sono validi.
1587 \item[\errcode{EPERM}] Un processo senza i privilegi di amministratore ha
1588 cercato di innalzare i propri limiti.
1590 ed \errval{EFAULT}.}
1594 Entrambe le funzioni permettono di specificare, attraverso l'argomento
1595 \param{resource}, su quale risorsa si vuole operare: i possibili valori di
1596 questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
1597 (rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
1598 poi effettuato attraverso la struttura \struct{rlimit} puntata da
1599 \param{rlim}, la cui definizione è riportata in
1600 fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
1601 limite corrente e limite massimo.
1604 \begin{figure}[!htb]
1607 \begin{minipage}[c]{15cm}
1608 \includestruct{listati/rlimit.h}
1611 \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
1612 delle risorse usate da un processo.}
1613 \label{fig:sys_rlimit_struct}
1617 Nello specificare un limite, oltre a fornire dei valori specifici, si può
1618 anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
1619 di una risorsa; ma si ricordi che solo un processo con i privilegi di
1620 amministratore\footnote{per essere precisi in questo caso quello che serve è
1621 la \itindex{capabilities} \textit{capability} \const{CAP\_SYS\_RESOURCE}.}
1622 può innalzare un limite al di sopra del valore corrente del limite massimo ed
1623 usare un valore qualsiasi per entrambi i limiti. Si tenga conto infine che
1624 tutti i limiti vengono ereditati dal processo padre attraverso una \func{fork}
1625 (vedi sez.~\ref{sec:proc_fork}) e mantenuti per gli altri programmi eseguiti
1626 attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
1629 \subsection{Le risorse di memoria e processore}
1630 \label{sec:sys_memory_res}
1632 La gestione della memoria è già stata affrontata in dettaglio in
1633 sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1634 meccanismo della \index{memoria~virtuale} memoria virtuale attraverso la
1635 divisione della memoria fisica in pagine.
1637 In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
1638 casi, come per l'I/O mappato in memoria (vedi sez.~\ref{sec:file_memory_map})
1639 che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
1640 dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
1641 gestire in maniera ottimale l'interazione della memoria che si sta allocando
1642 con il meccanismo della \index{paginazione} paginazione.
1644 Di solito la dimensione delle pagine di memoria è fissata dall'architettura
1645 hardware, per cui il suo valore di norma veniva mantenuto in una costante che
1646 bastava utilizzare in fase di compilazione, ma oggi, con la presenza di alcune
1647 architetture (ad esempio Sun Sparc) che permettono di variare questa
1648 dimensione, per non dover ricompilare i programmi per ogni possibile modello e
1649 scelta di dimensioni, è necessario poter utilizzare una funzione.
1651 Dato che si tratta di una caratteristica generale del sistema, questa
1652 dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
1653 \func{sysconf}, \footnote{nel caso specifico si dovrebbe utilizzare il
1654 parametro \const{\_SC\_PAGESIZE}.} ma in BSD 4.2 è stata introdotta una
1655 apposita funzione, \funcd{getpagesize}, che restituisce la dimensione delle
1656 pagine di memoria; il suo prototipo è:
1657 \begin{prototype}{unistd.h}{int getpagesize(void)}
1658 Legge le dimensioni delle pagine di memoria.
1660 \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
1661 sono previsti errori.}
1664 La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
1665 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1666 ha eliminata. In Linux è implementata come una system call nelle architetture
1667 in cui essa è necessaria, ed in genere restituisce il valore del simbolo
1668 \const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
1669 se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
1670 implementavano questa funzione restituendo sempre un valore statico.
1672 % TODO verificare meglio la faccenda di const{PAGE\_SIZE}
1674 Le \textsl{glibc} forniscono, come specifica estensione GNU, altre due
1675 funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
1676 di ottenere informazioni riguardo la memoria; i loro prototipi sono:
1678 \headdecl{sys/sysinfo.h}
1680 \funcdecl{long int get\_phys\_pages(void)}
1682 Legge il numero totale di pagine di memoria disponibili per il sistema.
1684 \funcdecl{long int get\_avphys\_pages(void)}
1686 Legge il numero di pagine di memoria disponibili nel sistema.
1688 \bodydesc{Le funzioni restituiscono un numero di pagine.}
1691 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1692 rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
1693 \const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1694 corrispondenti alla RAM della macchina; la seconda invece la memoria
1695 effettivamente disponibile per i processi.
1697 Le \acr{glibc} supportano inoltre, come estensioni GNU, due funzioni che
1698 restituiscono il numero di processori della macchina (e quello dei processori
1699 attivi); anche queste sono informazioni comunque ottenibili attraverso
1700 \func{sysconf} utilizzando rispettivamente i parametri
1701 \const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
1703 Infine le \acr{glibc} riprendono da BSD la funzione \funcd{getloadavg} che
1704 permette di ottenere il carico di processore della macchina, in questo modo è
1705 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1707 \begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
1708 Legge il carico medio della macchina.
1710 \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
1714 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1715 di processi attivi sulla coda dello \itindex{scheduler} scheduler, calcolato
1716 su diversi intervalli di tempo. Il numero di intervalli che si vogliono
1717 leggere è specificato da \param{nelem}, dato che nel caso di Linux il carico
1718 viene valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti),
1719 questo è anche il massimo valore che può essere assegnato a questo argomento.
1722 \subsection{La \textsl{contabilità} in stile BSD}
1723 \label{sec:sys_bsd_accounting}
1725 Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
1726 kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
1727 compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
1728 cosiddetto \textit{BSD accounting}, che consente di registrare su file una
1729 serie di informazioni\footnote{contenute nella struttura \texttt{acct}
1730 definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
1731 riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
1732 che viene terminato.
1734 Linux consente di salvare la contabilità delle informazioni relative alle
1735 risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
1737 \begin{prototype}{unistd.h}{int acct(const char *filename)}
1738 Abilita il \textit{BSD accounting}.
1740 \bodydesc{La funzione ritorna 0 in caso di successo o $-1$ in caso di
1741 errore, nel qual caso \var{errno} assumerà uno dei valori:
1743 \item[\errcode{EACCESS}] non si hanno i permessi per accedere a
1745 \item[\errcode{EPERM}] Il processo non ha privilegi sufficienti ad
1746 abilitare il \textit{BSD accounting}.
1747 \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
1748 \item[\errcode{EUSER}] non sono disponibili nel kernel strutture per il
1749 file o si è finita la memoria.
1751 ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
1752 \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
1753 \errval{ENOTDIR}, \errval{EROFS}.}
1756 La funzione attiva il salvataggio dei dati sul file indicato dal pathname
1757 contenuti nella stringa puntata da \param{filename}; la funzione richiede che
1758 il processo abbia i privilegi di amministratore (è necessaria la
1759 \itindex{capabilities} capability \const{CAP\_SYS\_PACCT}, vedi
1760 sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \const{NULL} per
1761 \param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
1762 semplice esempio per l'uso di questa funzione è riportato nel programma
1763 \texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
1765 Quando si attiva la contabilità, il file che si indica deve esistere; esso
1766 verrà aperto in sola scrittura;\footnote{si applicano al pathname indicato da
1767 \param{filename} tutte le restrizioni viste in cap.~\ref{cha:file_intro}.}
1768 le informazioni verranno registrate in \itindex{append~mode} \textit{append}
1769 in coda al file tutte le volte che un processo termina. Le informazioni
1770 vengono salvate in formato binario, e corrispondono al contenuto della
1771 apposita struttura dati definita all'interno del kernel.
1773 Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
1774 parametro di sistema, modificabile attraverso \file{/proc/sys/kernel/acct} (o
1775 tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi, il
1776 primo indica la percentuale di spazio disco libero sopra il quale viene
1777 ripresa una registrazione che era stata sospesa per essere scesi sotto il
1778 minimo indicato dal secondo valore (sempre in percentuale di spazio disco
1779 libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
1780 essere controllata detta percentuale.
1785 \section{La gestione dei tempi del sistema}
1786 \label{sec:sys_time}
1788 In questa sezione, una volta introdotti i concetti base della gestione dei
1789 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
1790 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
1791 veri tempi di sistema associati ai processi, a quelle per convertire i vari
1792 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
1793 gestione di data e ora.
1796 \subsection{La misura del tempo in Unix}
1797 \label{sec:sys_unix_time}
1799 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
1800 dati per la misure dei tempi all'interno del sistema: essi sono
1801 rispettivamente chiamati \itindend{calendar~time} \textit{calendar time} e
1802 \itindex{process~time} \textit{process time}, secondo le definizioni:
1803 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1804 \item[\textit{calendar time}] \itindend{calendar~time} detto anche
1805 \textsl{tempo di calendario}. È il numero di secondi dalla mezzanotte del
1806 primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
1807 usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
1808 Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
1809 dato che l'UTC corrisponde all'ora locale di Greenwich. È il tempo su cui
1810 viene mantenuto l'orologio del kernel, e viene usato ad esempio per indicare
1811 le date di modifica dei file o quelle di avvio dei processi. Per memorizzare
1812 questo tempo è stato riservato il tipo primitivo \type{time\_t}.
1813 \item[\textit{process time}] \itindex{process~time} detto talvolta
1814 \textsl{tempo di processore}. Viene misurato in \textit{clock tick}. Un
1815 tempo questo corrispondeva al numero di interruzioni effettuate dal timer di
1816 sistema, adesso lo standard POSIX richiede che esso sia pari al valore della
1817 costante \const{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000,
1818 qualunque sia la risoluzione reale dell'orologio di sistema e la frequenza
1819 delle interruzioni del timer.\footnote{quest'ultima, come accennato in
1820 sez.~\ref{sec:proc_hierarchy}, è invece data dalla costante \const{HZ}.}
1821 Il dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi
1822 una risoluzione del microsecondo. Il numero di tick al secondo può essere
1823 ricavato anche attraverso \func{sysconf} (vedi sez.~\ref{sec:sys_sysconf}).
1824 Il vecchio simbolo \const{CLK\_TCK} definito in \file{time.h} è ormai
1825 considerato obsoleto.
1828 In genere si usa il \itindend{calendar~time} \textit{calendar time} per
1829 esprimere le date dei file e le informazioni analoghe che riguardano i
1830 cosiddetti \textsl{tempi di orologio}, che vengono usati ad esempio per i
1831 demoni che compiono lavori amministrativi ad ore definite, come \cmd{cron}.
1833 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
1834 tempo locale, utilizzando le opportune informazioni di localizzazione
1835 (specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
1836 mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
1837 dall'orologio hardware del calcolatore.
1839 Anche il \itindex{process~time} \textit{process time} di solito si esprime in
1840 secondi, ma fornisce una precisione ovviamente superiore al \textit{calendar
1841 time} (che è mantenuto dal sistema con una granularità di un secondo) e
1842 viene usato per tenere conto dei tempi di esecuzione dei processi. Per ciascun
1843 processo il kernel calcola tre tempi diversi:
1844 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1845 \item[\textit{clock time}] il tempo \textsl{reale} (viene chiamato anche
1846 \textit{wall clock time} o \textit{elapsed time}) passato dall'avvio del
1847 processo. Chiaramente tale tempo dipende anche dal carico del sistema e da
1848 quanti altri processi stavano girando nello stesso periodo.
1850 \item[\textit{user time}] il tempo effettivo che il processore ha impiegato
1851 nell'esecuzione delle istruzioni del processo in user space. È quello
1852 riportato nella risorsa \var{ru\_utime} di \struct{rusage} vista in
1853 sez.~\ref{sec:sys_resource_use}.
1855 \item[\textit{system time}] il tempo effettivo che il processore ha impiegato
1856 per eseguire codice delle system call nel kernel per conto del processo. È
1857 quello riportato nella risorsa \var{ru\_stime} di \struct{rusage} vista in
1858 sez.~\ref{sec:sys_resource_use}.
1861 In genere la somma di \textit{user time} e \textit{system time} indica il
1862 tempo di processore totale che il sistema ha effettivamente utilizzato per
1863 eseguire un certo processo, questo viene chiamato anche \textit{CPU time} o
1864 \textsl{tempo di CPU}. Si può ottenere un riassunto dei valori di questi tempi
1865 quando si esegue un qualsiasi programma lanciando quest'ultimo come argomento
1866 del comando \cmd{time}.
1870 \subsection{La gestione del \textit{process time}}
1871 \label{sec:sys_cpu_times}
1873 \itindbeg{process~time}
1875 Di norma tutte le operazioni del sistema fanno sempre riferimento al
1876 \itindend{calendar~time} \textit{calendar time}, l'uso del \textit{process
1877 time} è riservato a quei casi in cui serve conoscere i tempi di esecuzione
1878 di un processo (ad esempio per valutarne l'efficienza). In tal caso infatti
1879 fare ricorso al \textit{calendar time} è inutile in quanto il tempo può essere
1880 trascorso mentre un altro processo era in esecuzione o in attesa del risultato
1881 di una operazione di I/O.
1883 La funzione più semplice per leggere il \textit{process time} di un processo è
1884 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
1885 utilizzato dallo stesso; il suo prototipo è:
1886 \begin{prototype}{time.h}{clock\_t clock(void)}
1887 Legge il valore corrente del tempo di CPU.
1889 \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
1893 La funzione restituisce il tempo in tick, quindi se si vuole il tempo in
1894 secondi occorre dividere il risultato per la costante
1895 \const{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
1896 POSIX richiede che \const{CLOCKS\_PER\_SEC} sia definito pari a 1000000
1897 indipendentemente dalla risoluzione del timer di sistema.} In genere
1898 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
1899 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
1900 riprenderà lo stesso valore iniziale.
1902 Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di CPU è la somma di
1903 altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
1904 quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
1905 possono essere letti attraverso la funzione \funcd{times}, il cui prototipo è:
1906 \begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
1907 Legge in \param{buf} il valore corrente dei tempi di processore.
1909 \bodydesc{La funzione ritorna il numero di clock tick dall'avvio del sistema
1910 in caso di successo e -1 in caso di errore.}
1913 La funzione restituisce i valori di \textit{process time} del processo
1914 corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
1915 in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
1916 due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
1917 \textit{system time} del processo, così come definiti in
1918 sez.~\ref{sec:sys_unix_time}.
1920 \begin{figure}[!htb]
1923 \begin{minipage}[c]{15cm}
1924 \includestruct{listati/tms.h}
1927 \caption{La struttura \structd{tms} dei tempi di processore associati a un
1929 \label{fig:sys_tms_struct}
1932 Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
1933 time} ed del \textit{system time} di tutti i processi figli che sono
1934 terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
1935 \var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
1936 ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.
1938 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
1939 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
1940 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
1941 lo stato di terminazione di tutti i suoi figli, questi processi
1942 ``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi.
1944 \itindend{process~time}
1947 \subsection{Le funzioni per il \textit{calendar time}}
1948 \label{sec:sys_time_base}
1950 \itindbeg{calendar~time}
1952 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
1953 mantenuto dal kernel in una variabile di tipo \type{time\_t}, che usualmente
1954 corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
1955 che di norma corrisponde a 32 bit). Il valore corrente del \textit{calendar
1956 time}, che indicheremo come \textsl{tempo di sistema}, può essere ottenuto
1957 con la funzione \funcd{time} che lo restituisce nel suddetto formato; il suo
1959 \begin{prototype}{time.h}{time\_t time(time\_t *t)}
1960 Legge il valore corrente del \textit{calendar time}.
1962 \bodydesc{La funzione ritorna il valore del \textit{calendar time} in caso
1963 di successo e -1 in caso di errore, che può essere solo \errval{EFAULT}.}
1965 \noindent dove \param{t}, se non nullo, deve essere l'indirizzo di una
1966 variabile su cui duplicare il valore di ritorno.
1968 Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
1969 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
1970 sia necessario; il suo prototipo è:
1971 \begin{prototype}{time.h}{int stime(time\_t *t)}
1972 Imposta a \param{t} il valore corrente del \textit{calendar time}.
1974 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1975 che può essere \errval{EFAULT} o \errval{EPERM}.}
1977 \noindent dato che modificare l'ora ha un impatto su tutto il sistema
1978 il cambiamento dell'orologio è una operazione privilegiata e questa funzione
1979 può essere usata solo da un processo con i privilegi di amministratore,
1980 altrimenti la chiamata fallirà con un errore di \errcode{EPERM}.
1982 Data la scarsa precisione nell'uso di \type{time\_t} (che ha una risoluzione
1983 massima di un secondo) quando si devono effettuare operazioni sui tempi di
1984 norma l'uso delle funzioni precedenti è sconsigliato, ed esse sono di solito
1985 sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le due
1986 funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
1987 \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
1988 in BSD4.3 sono indicate come sostitute delle precedenti.} i cui prototipi
1991 \headdecl{sys/time.h}
1994 \funcdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
1996 Legge il tempo corrente del sistema.
1998 \funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
2001 Imposta il tempo di sistema.
2003 \bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
2004 caso di errore, nel qual caso \var{errno} può assumere i valori
2005 \errval{EINVAL} \errval{EFAULT} e per \func{settimeofday} anche
2009 Queste funzioni utilizzano una struttura di tipo \struct{timeval}, la cui
2010 definizione, insieme a quella della analoga \struct{timespec}, è riportata in
2011 fig.~\ref{fig:sys_timeval_struct}. Le \acr{glibc} infatti forniscono queste due
2012 rappresentazioni alternative del \textit{calendar time} che rispetto a
2013 \type{time\_t} consentono rispettivamente precisioni del microsecondo e del
2014 nanosecondo.\footnote{la precisione è solo teorica, la precisione reale della
2015 misura del tempo dell'orologio di sistema non dipende dall'uso di queste
2018 \begin{figure}[!htb]
2019 \footnotesize \centering
2020 \begin{minipage}[c]{15cm}
2021 \includestruct{listati/timeval.h}
2024 \caption{Le strutture \structd{timeval} e \structd{timespec} usate per una
2025 rappresentazione ad alta risoluzione del \textit{calendar time}.}
2026 \label{fig:sys_timeval_struct}
2029 Come nel caso di \func{stime} anche \func{settimeofday} (la cosa continua a
2030 valere per qualunque funzione che vada a modificare l'orologio di sistema,
2031 quindi anche per quelle che tratteremo in seguito) può essere utilizzata solo
2032 da un processo coi privilegi di amministratore.
2034 Il secondo argomento di entrambe le funzioni è una struttura
2035 \struct{timezone}, che storicamente veniva utilizzata per specificare appunto
2036 la \textit{time zone}, cioè l'insieme del fuso orario e delle convenzioni per
2037 l'ora legale che permettevano il passaggio dal tempo universale all'ora
2038 locale. Questo argomento oggi è obsoleto ed in Linux non è mai stato
2039 utilizzato; esso non è supportato né dalle vecchie \textsl{libc5}, né dalle
2040 \textsl{glibc}: pertanto quando si chiama questa funzione deve essere sempre
2041 impostato a \val{NULL}.
2043 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
2044 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
2045 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
2046 conseguenze indesiderate. Ad esempio se si porta avanti l'orologio si possono
2047 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
2048 saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
2049 delle operazioni previste nell'intervallo di tempo che viene ripetuto.
2051 Per questo motivo la modalità più corretta per impostare l'ora è quella di
2052 usare la funzione \funcd{adjtime}, il cui prototipo è:
2053 \begin{prototype}{sys/time.h}
2054 {int adjtime(const struct timeval *delta, struct timeval *olddelta)}
2056 Aggiusta del valore \param{delta} l'orologio di sistema.
2058 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
2059 errore, nel qual caso \var{errno} assumerà il valore \errcode{EPERM}.}
2062 Questa funzione permette di avere un aggiustamento graduale del tempo di
2063 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
2064 di \param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
2065 positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
2066 il tempo richiesto, altrimenti sarà rallentato. Il secondo argomento viene
2067 usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
2071 \begin{figure}[!htb]
2072 \footnotesize \centering
2073 \begin{minipage}[c]{15cm}
2074 \includestruct{listati/timex.h}
2077 \caption{La struttura \structd{timex} per il controllo dell'orologio di
2079 \label{fig:sys_timex_struct}
2082 Linux poi prevede un'altra funzione, che consente un aggiustamento molto più
2083 dettagliato del tempo, permettendo ad esempio anche di modificare anche la
2084 velocità dell'orologio di sistema. La funzione è \funcd{adjtimex} ed il suo
2086 \begin{prototype}{sys/timex.h}
2087 {int adjtimex(struct timex *buf)}
2089 Aggiusta del valore \param{delta} l'orologio di sistema.
2091 \bodydesc{La funzione restituisce lo stato dell'orologio (un valore $>0$) in
2092 caso di successo e -1 in caso di errore, nel qual caso \var{errno}
2093 assumerà i valori \errval{EFAULT}, \errval{EINVAL} ed \errval{EPERM}.}
2096 La funzione richiede una struttura di tipo \struct{timex}, la cui definizione,
2097 così come effettuata in \file{sys/timex.h}, è riportata in
2098 fig.~\ref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore del
2099 campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
2100 specificato in un opportuno campo di \struct{timex}, deve essere impostato. Un
2101 valore nullo serve per leggere i parametri correnti; i valori diversi da zero
2102 devono essere specificati come OR binario delle costanti riportate in
2103 tab.~\ref{tab:sys_timex_mode}.
2105 La funzione utilizza il meccanismo di David L. Mills, descritto
2106 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
2107 protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
2108 portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
2109 \func{ntp\_adjtime}. La trattazione completa di questa funzione necessita di
2110 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
2111 a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
2112 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
2113 campi della struttura \struct{timex} può essere ritrovato in \cite{glibc}.
2118 \begin{tabular}[c]{|l|c|p{8.5cm}|}
2120 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2123 \const{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
2124 reale e l'orologio di sistema:
2125 deve essere indicata in microsecondi
2126 nel campo \var{offset} di
2128 \const{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenze in frequenza
2129 fra il tempo reale e l'orologio di
2130 sistema: deve essere indicata
2131 in parti per milione nel campo
2132 \var{frequency} di \struct{timex}.\\
2133 \const{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo
2135 sul tempo, espresso in microsecondi
2136 nel campo \var{maxerror} di
2138 \const{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
2139 sul tempo, espresso in microsecondi
2140 nel campo \var{esterror} di
2142 \const{ADJ\_STATUS} & 0x0010 & Imposta alcuni
2143 valori di stato interni usati dal
2144 sistema nella gestione
2145 dell'orologio specificati nel campo
2146 \var{status} di \struct{timex}.\\
2147 \const{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del
2148 PLL implementato dal kernel,
2149 specificato nel campo
2150 \var{constant} di \struct{timex}.\\
2151 \const{ADJ\_TICK} & 0x4000 & Imposta il valore dei tick del timer
2152 in microsecondi, espresso nel campo
2153 \var{tick} di \struct{timex}.\\
2154 \const{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Imposta uno spostamento una tantum
2155 dell'orologio secondo il valore del
2156 campo \var{offset} simulando il
2157 comportamento di \func{adjtime}.\\
2160 \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
2161 struttura \struct{timex}.}
2162 \label{tab:sys_timex_mode}
2165 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
2166 sintassi specificata per la forma equivalente di questa funzione definita come
2167 \func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
2173 \begin{tabular}[c]{|l|c|l|}
2175 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2178 \const{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
2179 \const{TIME\_INS} & 1 & Insert leap second.\\
2180 \const{TIME\_DEL} & 2 & Delete leap second.\\
2181 \const{TIME\_OOP} & 3 & Leap second in progress.\\
2182 \const{TIME\_WAIT} & 4 & Leap second has occurred.\\
2183 \const{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
2186 \caption{Possibili valori di ritorno di \func{adjtimex}.}
2187 \label{tab:sys_adjtimex_return}
2190 La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
2191 sistema; questo può assumere i valori riportati in
2192 tab.~\ref{tab:sys_adjtimex_return}. Un valore di -1 viene usato per riportare
2193 un errore; al solito se si cercherà di modificare l'orologio di sistema
2194 (specificando un \var{mode} diverso da zero) senza avere i privilegi di
2195 amministratore si otterrà un errore di \errcode{EPERM}.
2199 \subsection{La gestione delle date.}
2200 \label{sec:sys_date}
2202 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
2203 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
2204 illustrate, se han senso per specificare un intervallo, non sono molto
2205 intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
2206 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2207 time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2208 time} usuale in ore, minuti, secondi, ecc.
2210 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
2211 definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
2212 struttura che si utilizza quando si deve specificare un tempo a partire dai
2213 dati naturali (ora e data), dato che essa consente anche di trattare la
2214 gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
2215 \var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste da BSD e dalle
2216 \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
2217 fig.~\ref{fig:sys_tm_struct}.}
2219 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2220 da quelle usate per convertire gli altri formati in questo, usando o meno
2221 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2222 tempo in una stringa contenente data ed ora, i loro prototipi sono:
2225 \funcdecl{char *\funcd{asctime}(const struct tm *tm)}
2226 Produce una stringa con data e ora partendo da un valore espresso in
2227 \textit{broken-down time}.
2229 \funcdecl{char *\funcd{ctime}(const time\_t *timep)}
2230 Produce una stringa con data e ora partendo da un valore espresso in
2231 in formato \type{time\_t}.
2233 \funcdecl{struct tm *\funcd{gmtime}(const time\_t *timep)}
2234 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2235 \textit{broken-down time} espresso in UTC.
2237 \funcdecl{struct tm *\funcd{localtime}(const time\_t *timep)}
2238 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2239 \textit{broken-down time} espresso nell'ora locale.
2241 \funcdecl{time\_t \funcd{mktime}(struct tm *tm)}
2242 Converte il \textit{broken-down time} in formato \type{time\_t}.
2244 \bodydesc{Tutte le funzioni restituiscono un puntatore al risultato in caso
2245 di successo e \val{NULL} in caso di errore, tranne che \func{mktime} che
2246 restituisce direttamente il valore o -1 in caso di errore.}
2249 \begin{figure}[!htb]
2250 \footnotesize \centering
2251 \begin{minipage}[c]{15cm}
2252 \includestruct{listati/tm.h}
2255 \caption{La struttura \structd{tm} per una rappresentazione del tempo in
2256 termini di ora, minuti, secondi, ecc.}
2257 \label{fig:sys_tm_struct}
2262 Le prime due funzioni, \func{asctime} e \func{ctime} servono per poter
2263 stampare in forma leggibile un tempo; esse restituiscono il puntatore ad una
2264 stringa, allocata staticamente, nella forma:
2266 "Wed Jun 30 21:49:08 1993\n"
2268 e impostano anche la variabile \var{tzname} con l'informazione della
2269 \textit{time zone} corrente; \func{ctime} è banalmente definita in termini di
2270 \func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
2271 statica rende le funzioni non rientranti POSIX.1c e SUSv2 prevedono due
2272 sostitute rientranti, il cui nome è al solito ottenuto aggiungendo un
2273 \code{\_r}, che prendono un secondo argomento \code{char *buf}, in cui
2274 l'utente deve specificare il buffer su cui la stringa deve essere copiata
2275 (deve essere di almeno 26 caratteri).
2277 Le altre tre funzioni, \func{gmtime}, \func{localtime} e \func{mktime} servono
2278 per convertire il tempo dal formato \type{time\_t} a quello di \struct{tm} e
2279 viceversa; \func{gmtime} effettua la conversione usando il tempo coordinato
2280 universale (UTC), cioè l'ora di Greenwich; mentre \func{localtime} usa l'ora
2281 locale; \func{mktime} esegue la conversione inversa.
2283 Anche in questo caso le prime due funzioni restituiscono l'indirizzo di una
2284 struttura allocata staticamente, per questo sono state definite anche altre
2285 due versioni rientranti (con la solita estensione \code{\_r}), che prevedono
2286 un secondo argomento \code{struct tm *result}, fornito dal chiamante, che deve
2287 preallocare la struttura su cui sarà restituita la conversione.
2289 Come mostrato in fig.~\ref{fig:sys_tm_struct} il \textit{broken-down time}
2290 permette di tenere conto anche della differenza fra tempo universale e ora
2291 locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
2292 variabili globali mostrate in fig.~\ref{fig:sys_tzname}, cui si accede quando
2293 si include \file{time.h}. Queste variabili vengono impostate quando si chiama
2294 una delle precedenti funzioni di conversione, oppure invocando direttamente la
2295 funzione \funcd{tzset}, il cui prototipo è:
2296 \begin{prototype}{sys/timex.h}
2299 Imposta le variabili globali della \textit{time zone}.
2301 \bodydesc{La funzione non ritorna niente e non dà errori.}
2304 La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire dal
2305 valore della variabile di ambiente \const{TZ}, se quest'ultima non è definita
2306 verrà usato il file \file{/etc/localtime}.
2308 \begin{figure}[!htb]
2311 \begin{minipage}[c]{15cm}
2312 \includestruct{listati/time_zone_var.c}
2315 \caption{Le variabili globali usate per la gestione delle \textit{time
2317 \label{fig:sys_tzname}
2320 La variabile \var{tzname} contiene due stringhe, che indicano i due nomi
2321 standard della \textit{time zone} corrente. La prima è il nome per l'ora
2322 solare, la seconda per l'ora legale.\footnote{anche se sono indicati come
2323 \code{char *} non è il caso di modificare queste stringhe.} La variabile
2324 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2325 \var{daylight} indica se è attiva o meno l'ora legale.
2327 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2328 stampare un tempo o una data, la flessibilità non fa parte delle sue
2329 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2330 giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
2332 \begin{prototype}{time.h}
2333 {size\_t strftime(char *s, size\_t max, const char *format,
2334 const struct tm *tm)}
2336 Stampa il tempo \param{tm} nella stringa \param{s} secondo il formato
2339 \bodydesc{La funzione ritorna il numero di caratteri stampati in \param{s},
2340 altrimenti restituisce 0.}
2343 La funzione converte opportunamente il tempo \param{tm} in una stringa di
2344 testo da salvare in \param{s}, purché essa sia di dimensione, indicata da
2345 \param{size}, sufficiente. I caratteri generati dalla funzione vengono
2346 restituiti come valore di ritorno, ma non tengono conto del terminatore
2347 finale, che invece viene considerato nel computo della dimensione; se
2348 quest'ultima è eccessiva viene restituito 0 e lo stato di \param{s} è
2354 \begin{tabular}[c]{|c|l|p{6cm}|}
2356 \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2359 \var{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
2360 \var{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
2361 \var{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
2362 \var{\%B}&\texttt{April} & Nome del mese, completo.\\
2363 \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
2364 \var{\%d}&\texttt{24} & Giorno del mese.\\
2365 \var{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
2366 \var{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
2367 \var{\%j}&\texttt{114} & Giorno dell'anno.\\
2368 \var{\%m}&\texttt{04} & Mese dell'anno.\\
2369 \var{\%M}&\texttt{40} & Minuto.\\
2370 \var{\%p}&\texttt{PM} & AM/PM.\\
2371 \var{\%S}&\texttt{50} & Secondo.\\
2372 \var{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
2374 \var{\%w}&\texttt{3} & Giorno della settimana. \\
2375 \var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
2377 \var{\%x}&\texttt{04/24/02} & La data.\\
2378 \var{\%X}&\texttt{18:40:50} & L'ora.\\
2379 \var{\%y}&\texttt{02} & Anno nel secolo.\\
2380 \var{\%Y}&\texttt{2002} & Anno.\\
2381 \var{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
2382 \var{\%\%}&\texttt{\%} & Il carattere \%.\\
2385 \caption{Valori previsti dallo standard ANSI C per modificatore della
2386 stringa di formato di \func{strftime}.}
2387 \label{tab:sys_strftime_format}
2390 Il risultato della funzione è controllato dalla stringa di formato
2391 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2392 viene utilizzato come modificatore; alcuni\footnote{per la precisione quelli
2393 definiti dallo standard ANSI C, che sono anche quelli riportati da POSIX.1;
2394 le \acr{glibc} provvedono tutte le estensioni introdotte da POSIX.2 per il
2395 comando \cmd{date}, i valori introdotti da SVID3 e ulteriori estensioni GNU;
2396 l'elenco completo dei possibili valori è riportato nella pagina di manuale
2397 della funzione.} dei possibili valori che esso può assumere sono riportati
2398 in tab.~\ref{tab:sys_strftime_format}. La funzione tiene conto anche della
2399 presenza di una localizzazione per stampare in maniera adeguata i vari nomi.
2401 \itindend{calendar~time}
2404 \section{La gestione degli errori}
2405 \label{sec:sys_errors}
2407 In questa sezione esamineremo le caratteristiche principali della gestione
2408 degli errori in un sistema unix-like. Infatti a parte il caso particolare di
2409 alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
2410 unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
2411 un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
2412 semplicemente usando un opportuno valore di ritorno della funzione invocata.
2413 Inoltre il sistema di classificazione degli errori è basato sull'architettura
2414 a processi, e presenta una serie di problemi nel caso lo si debba usare con i
2418 \subsection{La variabile \var{errno}}
2419 \label{sec:sys_errno}
2421 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2422 riportare condizioni di errore, ed è una norma fondamentale di buona
2423 programmazione controllare \textbf{sempre} che le funzioni chiamate si siano
2424 concluse correttamente.
2426 In genere le funzioni di libreria usano un valore speciale per indicare che
2427 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
2428 costante \val{EOF} (a seconda della funzione); ma questo valore segnala solo
2429 che c'è stato un errore, non il tipo di errore.
2431 Per riportare il tipo di errore il sistema usa la variabile globale
2432 \var{errno},\footnote{L'uso di una variabile globale può comportare alcuni
2433 problemi (ad esempio nel caso dei thread) ma lo standard ISO C consente
2434 anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
2435 può anche usare una macro, e questo è infatti il modo usato da Linux per
2436 renderla locale ai singoli thread.} definita nell'header \file{errno.h}; la
2437 variabile è in genere definita come \direct{volatile} dato che può essere
2438 cambiata in modo asincrono da un segnale (si veda sez.~\ref{sec:sig_sigchld}
2439 per un esempio, ricordando quanto trattato in sez.~\ref{sec:proc_race_cond}),
2440 ma dato che un gestore di segnale scritto bene salva e ripristina il valore
2441 della variabile, di questo non è necessario preoccuparsi nella programmazione
2444 I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
2445 nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
2446 costanti numeriche che identificano i vari errori; essi iniziano tutti per
2447 \val{E} e si possono considerare come nomi riservati. In seguito faremo
2448 sempre riferimento a tali valori, quando descriveremo i possibili errori
2449 restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
2450 codice relativo ad un valore numerico con l'opzione \cmd{-l}.
2452 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
2453 programma, gran parte delle funzioni di libreria impostano \var{errno} ad un
2454 valore diverso da zero in caso di errore. Il valore è invece indefinito in
2455 caso di successo, perché anche se una funzione ha successo, può chiamarne
2456 altre al suo interno che falliscono, modificando così \var{errno}.
2458 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
2459 essere il risultato di un errore precedente) e non lo si può usare per
2460 determinare quando o se una chiamata a funzione è fallita. La procedura da
2461 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
2462 verificato il fallimento della funzione attraverso il suo codice di ritorno.
2465 \subsection{Le funzioni \func{strerror} e \func{perror}}
2466 \label{sec:sys_strerror}
2468 Benché gli errori siano identificati univocamente dal valore numerico di
2469 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
2470 riportare in opportuni messaggi le condizioni di errore verificatesi. La
2471 prima funzione che si può usare per ricavare i messaggi di errore è
2472 \funcd{strerror}, il cui prototipo è:
2473 \begin{prototype}{string.h}{char *strerror(int errnum)}
2474 Restituisce una stringa con il messaggio di errore relativo ad
2477 \bodydesc{La funzione ritorna il puntatore ad una stringa di errore.}
2481 La funzione ritorna il puntatore alla stringa contenente il messaggio di
2482 errore corrispondente al valore di \param{errnum}, se questo non è un valore
2483 valido verrà comunque restituita una stringa valida contenente un messaggio
2484 che dice che l'errore è sconosciuto, e \var{errno} verrà modificata assumendo
2485 il valore \errval{EINVAL}.
2487 In generale \func{strerror} viene usata passando \var{errno} come argomento,
2488 ed il valore di quest'ultima non verrà modificato. La funzione inoltre tiene
2489 conto del valore della variabile di ambiente \val{LC\_MESSAGES} per usare le
2490 appropriate traduzioni dei messaggi d'errore nella localizzazione presente.
2492 La funzione utilizza una stringa statica che non deve essere modificata dal
2493 programma; essa è utilizzabile solo fino ad una chiamata successiva a
2494 \func{strerror} o \func{perror}, nessun'altra funzione di libreria tocca
2495 questa stringa. In ogni caso l'uso di una stringa statica rende la funzione
2496 non rientrante, per cui nel caso si usino i thread le librerie
2497 forniscono\footnote{questa funzione è la versione prevista dalle \acr{glibc},
2498 ed effettivamente definita in \file{string.h}, ne esiste una analoga nello
2499 standard SUSv3 (quella riportata dalla pagina di manuale), che restituisce
2500 \code{int} al posto di \code{char *}, e che tronca la stringa restituita a
2501 \param{size}.} una apposita versione rientrante \func{strerror\_r}, il cui
2503 \begin{prototype}{string.h}
2504 {char * strerror\_r(int errnum, char *buf, size\_t size)}
2506 Restituisce una stringa con il messaggio di errore relativo ad
2509 \bodydesc{La funzione restituisce l'indirizzo del messaggio in caso di
2510 successo e \val{NULL} in caso di errore; nel qual caso \var{errno}
2513 \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
2515 \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
2516 contenere la stringa di errore.
2521 La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
2522 nel buffer \param{buf} che il singolo thread deve allocare autonomamente per
2523 evitare i problemi connessi alla condivisione del buffer statico. Il messaggio
2524 è copiato fino alla dimensione massima del buffer, specificata dall'argomento
2525 \param{size}, che deve comprendere pure il carattere di terminazione;
2526 altrimenti la stringa viene troncata.
2528 Una seconda funzione usata per riportare i codici di errore in maniera
2529 automatizzata sullo standard error (vedi sez.~\ref{sec:file_std_descr}) è
2530 \funcd{perror}, il cui prototipo è:
2531 \begin{prototype}{stdio.h}{void perror(const char *message)}
2532 Stampa il messaggio di errore relativo al valore corrente di \var{errno}
2533 sullo standard error; preceduto dalla stringa \param{message}.
2536 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
2537 in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
2538 riferiscono all'ultimo errore avvenuto. La stringa specificata con
2539 \param{message} viene stampato prima del messaggio d'errore, seguita dai due
2540 punti e da uno spazio, il messaggio è terminato con un a capo.
2542 Il messaggio può essere riportato anche usando le due variabili globali:
2543 \includecodesnip{listati/errlist.c}
2544 dichiarate in \file{errno.h}. La prima contiene i puntatori alle stringhe di
2545 errore indicizzati da \var{errno}; la seconda esprime il valore più alto per
2546 un codice di errore, l'utilizzo di questa stringa è sostanzialmente
2547 equivalente a quello di \func{strerror}.
2549 \begin{figure}[!htb]
2550 \footnotesize \centering
2551 \begin{minipage}[c]{15cm}
2552 \includecodesample{listati/errcode_mess.c}
2555 \caption{Codice per la stampa del messaggio di errore standard.}
2556 \label{fig:sys_err_mess}
2559 In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
2560 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
2561 errore e le costanti usate per identificare i singoli errori; il sorgente
2562 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
2563 gestione delle opzioni e tutte le definizioni necessarie ad associare il
2564 valore numerico alla costante simbolica. In particolare si è riportata la
2565 sezione che converte la stringa passata come argomento in un intero
2566 (\texttt{\small 1--2}), controllando con i valori di ritorno di \func{strtol}
2567 che la conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi
2568 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
2569 11--14}) o la macro (\texttt{\small 15--17}) associate a quel codice.
2573 \subsection{Alcune estensioni GNU}
2574 \label{sec:sys_err_GNU}
2576 Le precedenti funzioni sono quelle definite ed usate nei vari standard; le
2577 \acr{glibc} hanno però introdotto una serie di estensioni ``GNU'' che
2578 forniscono alcune funzionalità aggiuntive per una gestione degli errori
2579 semplificata e più efficiente.
2581 La prima estensione consiste in due variabili, \code{char *
2582 program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
2583 servono per ricavare il nome del programma; queste sono utili quando si deve
2584 aggiungere il nome del programma (cosa comune quando si ha un programma che
2585 non viene lanciato da linea di comando e salva gli errori in un file di log)
2586 al messaggio d'errore. La prima contiene il nome usato per lanciare il
2587 programma (ed è equivalente ad \code{argv[0]}); la seconda mantiene solo il
2588 nome del programma (senza eventuali directory in testa).
2590 Uno dei problemi che si hanno con l'uso di \func{perror} è che non c'è
2591 flessibilità su quello che si può aggiungere al messaggio di errore, che può
2592 essere solo una stringa. In molte occasioni invece serve poter scrivere dei
2593 messaggi con maggiore informazione; ad esempio negli standard di
2594 programmazione GNU si richiede che ogni messaggio di errore sia preceduto dal
2595 nome del programma, ed in generale si può voler stampare il contenuto di
2596 qualche variabile; per questo le \acr{glibc} definiscono la funzione
2597 \funcd{error}, il cui prototipo è:
2598 \begin{prototype}{stdio.h}
2599 {void error(int status, int errnum, const char *format, ...)}
2601 Stampa un messaggio di errore formattato.
2603 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2606 La funzione fa parte delle estensioni GNU per la gestione degli errori,
2607 l'argomento \param{format} prende la stessa sintassi di \func{printf}, ed i
2608 relativi argomenti devono essere forniti allo stesso modo, mentre
2609 \param{errnum} indica l'errore che si vuole segnalare (non viene quindi usato
2610 il valore corrente di \var{errno}); la funzione stampa sullo standard error il
2611 nome del programma, come indicato dalla variabile globale \var{program\_name},
2612 seguito da due punti ed uno spazio, poi dalla stringa generata da
2613 \param{format} e dagli argomenti seguenti, seguita da due punti ed uno spazio
2614 infine il messaggio di errore relativo ad \param{errnum}, il tutto è terminato
2617 Il comportamento della funzione può essere ulteriormente controllato se si
2618 definisce una variabile \var{error\_print\_progname} come puntatore ad una
2619 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
2620 il nome del programma.
2622 L'argomento \param{status} può essere usato per terminare direttamente il
2623 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
2624 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
2625 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
2626 un'altra variabile globale, \var{error\_message\_count}, che tiene conto di
2627 quanti errori ci sono stati.
2629 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
2630 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
2631 l'errore è \funcd{error\_at\_line}; il suo prototipo è:
2632 \begin{prototype}{stdio.h}
2633 {void error\_at\_line(int status, int errnum, const char *fname,
2634 unsigned int lineno, const char *format, ...)}
2636 Stampa un messaggio di errore formattato.
2638 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2640 \noindent ed il suo comportamento è identico a quello di \func{error} se non
2641 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
2642 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
2643 stampa del nome del programma. Inoltre essa usa un'altra variabile globale,
2644 \var{error\_one\_per\_line}, che impostata ad un valore diverso da zero fa si
2645 che errori relativi alla stessa linea non vengano ripetuti.
2648 % LocalWords: filesystem like kernel saved header limits sysconf sez tab float
2649 % LocalWords: FOPEN stdio MB LEN CHAR char UCHAR unsigned SCHAR MIN signed INT
2650 % LocalWords: SHRT short USHRT int UINT LONG long ULONG LLONG ULLONG POSIX ARG
2651 % LocalWords: Stevens exec CHILD STREAM stream TZNAME timezone NGROUPS SSIZE
2652 % LocalWords: ssize LISTIO JOB CONTROL job control IDS VERSION YYYYMML bits bc
2653 % LocalWords: dall'header posix lim nell'header glibc run unistd name errno SC
2654 % LocalWords: NGROUP CLK TCK clock tick process PATH pathname BUF CANON path
2655 % LocalWords: pathconf fpathconf descriptor fd uname sys struct utsname info
2656 % LocalWords: EFAULT fig SOURCE NUL LENGTH DOMAIN NMLN UTSLEN system call proc
2657 % LocalWords: domainname sysctl BSD nlen void oldval size oldlenp newval EPERM
2658 % LocalWords: newlen ENOTDIR EINVAL ENOMEM linux l'array oldvalue paging stack
2659 % LocalWords: TCP shell Documentation ostype hostname osrelease version mount
2660 % LocalWords: const source filesystemtype mountflags ENODEV ENOTBLK block read
2661 % LocalWords: device EBUSY only superblock point EACCES NODEV ENXIO major xC
2662 % LocalWords: number EMFILE dummy ENAMETOOLONG ENOENT ELOOP virtual devfs MGC
2663 % LocalWords: magic MSK RDONLY NOSUID suid sgid NOEXEC SYNCHRONOUS REMOUNT MNT
2664 % LocalWords: MANDLOCK mandatory locking WRITE APPEND append IMMUTABLE NOATIME
2665 % LocalWords: access NODIRATIME BIND MOVE umount flags FORCE statfs fstatfs ut
2666 % LocalWords: buf ENOSYS EIO EBADF type fstab mntent home shadow username uid
2667 % LocalWords: passwd PAM Pluggable Authentication Method Service Switch pwd ru
2668 % LocalWords: getpwuid getpwnam NULL buflen result ERANGE getgrnam getgrgid AS
2669 % LocalWords: grp group gid SVID fgetpwent putpwent getpwent setpwent endpwent
2670 % LocalWords: fgetgrent putgrent getgrent setgrent endgrent accounting init HZ
2671 % LocalWords: runlevel Hierarchy logout setutent endutent utmpname utmp paths
2672 % LocalWords: WTMP getutent getutid getutline pututline LVL OLD DEAD EMPTY dev
2673 % LocalWords: line libc XPG utmpx getutxent getutxid getutxline pututxline who
2674 % LocalWords: setutxent endutxent wmtp updwtmp logwtmp wtmp host rusage utime
2675 % LocalWords: minflt majflt nswap fault swap timeval wait getrusage usage SELF
2676 % LocalWords: CHILDREN current limit soft RLIMIT Address brk mremap mmap dump
2677 % LocalWords: SIGSEGV SIGXCPU SIGKILL sbrk FSIZE SIGXFSZ EFBIG LOCKS lock dup
2678 % LocalWords: MEMLOCK NOFILE NPROC fork EAGAIN SIGPENDING sigqueue kill RSS tv
2679 % LocalWords: resource getrlimit setrlimit rlimit rlim INFINITY capabilities
2680 % LocalWords: capability CAP l'I Sun Sparc PAGESIZE getpagesize SVr SUSv get
2681 % LocalWords: phys pages avphys NPROCESSORS CONF ONLN getloadavg stdlib double
2682 % LocalWords: loadavg nelem scheduler CONFIG ACCT acct filename EACCESS EUSER
2683 % LocalWords: ENFILE EROFS PACCT AcctCtrl cap calendar UTC Jan the Epoch GMT
2684 % LocalWords: Greenwich Mean l'UTC timer CLOCKS SEC cron wall elapsed times tz
2685 % LocalWords: tms dell' cutime cstime waitpid gettimeofday settimeofday timex
2686 % LocalWords: timespec adjtime olddelta adjtimex David Mills nell' RFC NTP ntp
2687 % LocalWords: nell'RFC ADJ FREQUENCY frequency MAXERROR maxerror ESTERROR PLL
2688 % LocalWords: esterror TIMECONST constant SINGLESHOT MOD INS insert leap OOP
2689 % LocalWords: second delete progress has occurred BAD broken tm gmtoff asctime
2690 % LocalWords: ctime timep gmtime localtime mktime tzname tzset daylight format
2691 % LocalWords: strftime thread EOF modifiable lvalue app errcode strerror LC at
2692 % LocalWords: perror string errnum MESSAGES error message ErrCode strtol log
2693 % LocalWords: program invocation argv printf print progname exit count fname
2694 % LocalWords: lineno one standardese Di
2698 %%% Local Variables:
2700 %%% TeX-master: "gapil"