3 %% Copyright (C) 2000-2012 Simone Piccardi. Permission is granted to
4 %% copy, distribute and/or modify this document under the terms of the GNU Free
5 %% Documentation License, Version 1.1 or any later version published by the
6 %% Free Software Foundation; with the Invariant Sections being "Un preambolo",
7 %% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the
8 %% license is included in the section entitled "GNU Free Documentation
12 \chapter{La gestione del sistema, del tempo e degli errori}
15 In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
16 generali del sistema, come quelle per la gestione dei parametri e della
17 configurazione dello stesso, quelle per la lettura dei limiti e delle
18 caratteristiche, quelle per il controllo dell'uso delle risorse dei processi,
19 quelle per la gestione ed il controllo dei filesystem, degli utenti, dei tempi
23 \section{La gestione di catteristiche e parametri del sistema}
24 \label{sec:sys_characteristics}
26 In questa sezione tratteremo le varie modalità con cui un programma può
27 ottenere informazioni riguardo alle capacità del sistema, e, per quelle per
28 cui è possibile, sul come modificarle. Ogni sistema unix-like infatti è
29 contraddistinto da un gran numero di limiti e costanti che lo caratterizzano,
30 e che possono dipendere da fattori molteplici, come l'architettura hardware,
31 l'implementazione del kernel e delle librerie, le opzioni di
32 configurazione. Il kernel inoltre mette a disposizione l'accesso ad alcuni
33 parametri che possono modificarne il comportamento.
35 La definizione di queste caratteristiche ed il tentativo di provvedere dei
36 meccanismi generali che i programmi possono usare per ricavarle è uno degli
37 aspetti più complessi e controversi con cui le diverse standardizzazioni si
38 sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
39 Daremo comunque una descrizione dei principali metodi previsti dai vari
40 standard per ricavare sia le caratteristiche specifiche del sistema, che
41 quelle della gestione dei file e prenderemo in esame le modalità con cui è
42 possibile intervenire sui parametri del kernel.
44 \subsection{Limiti e caratteristiche del sistema}
45 \label{sec:sys_limits}
47 Quando si devono determinare le caratteristiche generali del sistema ci si
48 trova di fronte a diverse possibilità; alcune di queste infatti possono
49 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
50 interi), o dal sistema operativo (come la presenza o meno del gruppo degli
51 identificatori \textit{saved}), altre invece possono dipendere dalle opzioni
52 con cui si è costruito il sistema (ad esempio da come si è compilato il
53 kernel), o dalla configurazione del medesimo; per questo motivo in generale
54 sono necessari due tipi diversi di funzionalità:
56 \item la possibilità di determinare limiti ed opzioni al momento della
58 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
61 La prima funzionalità si può ottenere includendo gli opportuni header file che
62 contengono le costanti necessarie definite come macro di preprocessore, per la
63 seconda invece sono ovviamente necessarie delle funzioni. La situazione è
64 complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
65 sono fissi in un'implementazione mentre possono variare in un altra: tutto
66 questo crea una ambiguità che non è sempre possibile risolvere in maniera
67 chiara. In generale quello che succede è che quando i limiti del sistema sono
68 fissi essi vengono definiti come macro di preprocessore nel file
69 \headfile{limits.h}, se invece possono variare, il loro valore sarà ottenibile
70 tramite la funzione \func{sysconf} (che esamineremo a breve).
75 \begin{tabular}[c]{|l|r|l|}
77 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
80 \const{MB\_LEN\_MAX}& 16 & Massima dimensione di un
82 \const{CHAR\_BIT} & 8 & Numero di bit di \ctyp{char}.\\
83 \const{UCHAR\_MAX}& 255 & Massimo di \ctyp{unsigned char}.\\
84 \const{SCHAR\_MIN}& -128 & Minimo di \ctyp{signed char}.\\
85 \const{SCHAR\_MAX}& 127 & Massimo di \ctyp{signed char}.\\
86 \const{CHAR\_MIN} & 0 o -128 & Minimo di \ctyp{char}.\footnotemark\\
87 \const{CHAR\_MAX} & 127 o 255 & Massimo di \ctyp{char}.\footnotemark\\
88 \const{SHRT\_MIN} & -32768 & Minimo di \ctyp{short}.\\
89 \const{SHRT\_MAX} & 32767 & Massimo di \ctyp{short}.\\
90 \const{USHRT\_MAX}& 65535 & Massimo di \ctyp{unsigned short}.\\
91 \const{INT\_MAX} & 2147483647 & Minimo di \ctyp{int}.\\
92 \const{INT\_MIN} &-2147483648 & Minimo di \ctyp{int}.\\
93 \const{UINT\_MAX} & 4294967295 & Massimo di \ctyp{unsigned int}.\\
94 \const{LONG\_MAX} & 2147483647 & Massimo di \ctyp{long}.\\
95 \const{LONG\_MIN} &-2147483648 & Minimo di \ctyp{long}.\\
96 \const{ULONG\_MAX}& 4294967295 & Massimo di \ctyp{unsigned long}.\\
99 \caption{Costanti definite in \headfile{limits.h} in conformità allo standard
101 \label{tab:sys_ansic_macro}
104 \footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
105 sistema usi caratteri con segno o meno.}
107 \footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
108 a seconda che il sistema usi caratteri con segno o meno.}
110 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
111 saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
112 da \headfile{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si
113 può vedere per la maggior parte questi limiti attengono alle dimensioni dei
114 dati interi, che sono in genere fissati dall'architettura hardware, le
115 analoghe informazioni per i dati in virgola mobile sono definite a parte, ed
116 accessibili includendo \headfile{float.h}.
121 \begin{tabular}[c]{|l|r|l|}
123 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
126 \const{LLONG\_MAX}& 9223372036854775807& Massimo di \ctyp{long long}.\\
127 \const{LLONG\_MIN}&-9223372036854775808& Minimo di \ctyp{long long}.\\
128 \const{ULLONG\_MAX}&18446744073709551615&
129 Massimo di \ctyp{unsigned long long}.\\
132 \caption{Macro definite in \headfile{limits.h} in conformità allo standard
134 \label{tab:sys_isoc90_macro}
137 Lo standard prevede anche un'altra costante, \const{FOPEN\_MAX}, che può non
138 essere fissa e che pertanto non è definita in \headfile{limits.h}, essa deve
139 essere definita in \headfile{stdio.h} ed avere un valore minimo di 8. A questi
140 valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo \ctyp{long
141 long} introdotto con il nuovo standard, i relativi valori sono in
142 tab.~\ref{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}.
154 \begin{tabular}[c]{|l|r|p{8cm}|}
156 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
159 \const{ARG\_MAX} &131072& Dimensione massima degli argomenti
160 passati ad una funzione della famiglia
162 \const{CHILD\_MAX} & 999& Numero massimo di processi contemporanei
163 che un utente può eseguire.\\
164 \const{OPEN\_MAX} & 256& Numero massimo di file che un processo
165 può mantenere aperti in contemporanea.\\
166 \const{STREAM\_MAX}& 8& Massimo numero di stream aperti per
167 processo in contemporanea.\\
168 \const{TZNAME\_MAX}& 6& Dimensione massima del nome di una
169 \texttt{timezone} (vedi
170 sez.~\ref{sec:sys_time_base})).\\
171 \const{NGROUPS\_MAX}& 32& Numero di gruppi supplementari per
172 processo (vedi sez.~\ref{sec:proc_access_id}).\\
173 \const{SSIZE\_MAX}&32767& Valore massimo del tipo \type{ssize\_t}.\\
176 \caption{Costanti per i limiti del sistema.}
177 \label{tab:sys_generic_macro}
180 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
181 meno chiare, tanto che Stevens, in \cite{APUE}, la porta come esempio di
182 ``\textsl{standardese}''. Lo standard prevede che ci siano 13 macro che
183 descrivono le caratteristiche del sistema: 7 per le caratteristiche generiche,
184 riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
185 file, riportate in tab.~\ref{tab:sys_file_macro}.
190 \begin{tabular}[c]{|l|r|p{8cm}|}
192 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
195 \const{\_POSIX\_ARG\_MAX} & 4096& Dimensione massima degli argomenti
196 passati ad una funzione della famiglia
198 \const{\_POSIX\_CHILD\_MAX} & 6& Numero massimo di processi
199 contemporanei che un utente può
201 \const{\_POSIX\_OPEN\_MAX} & 16& Numero massimo di file che un processo
202 può mantenere aperti in
204 \const{\_POSIX\_STREAM\_MAX} & 8& Massimo numero di stream aperti per
205 processo in contemporanea.\\
206 \const{\_POSIX\_TZNAME\_MAX} & 6& Dimensione massima del nome di una
207 \textit{timezone} (vedi
208 sez.~\ref{sec:sys_date}). \\
209 \const{\_POSIX\_RTSIG\_MAX} & 8& Numero massimo di segnali
210 \textit{real-time} (vedi
211 sez.~\ref{sec:sig_real_time}).\\
212 \const{\_POSIX\_NGROUPS\_MAX}& 0& Numero di gruppi supplementari per
214 sez.~\ref{sec:proc_access_id}).\\
215 \const{\_POSIX\_SSIZE\_MAX} &32767& Valore massimo del tipo
217 % \const{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
218 % \const{\_POSIX\_AIO\_MAX} & 1& \\
221 \caption{Macro dei valori minimi di alcune caratteristiche generali del
222 sistema per la conformità allo standard POSIX.1.}
223 \label{tab:sys_posix1_general}
226 Lo standard dice che queste macro devono essere definite in
227 \headfile{limits.h} quando i valori a cui fanno riferimento sono fissi, e
228 altrimenti devono essere lasciate indefinite, ed i loro valori dei limiti
229 devono essere accessibili solo attraverso \func{sysconf}. In realtà queste
230 vengono sempre definite ad un valore generico. Si tenga presente poi che
231 alcuni di questi limiti possono assumere valori molto elevati (come
232 \const{CHILD\_MAX}), e non è pertanto il caso di utilizzarli per allocare
233 staticamente della memoria.
235 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
236 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
237 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
238 implementazione possa dichiararsi conforme allo standard, alcuni dei questi
239 valori sono riportati in tab.~\ref{tab:sys_posix1_general}.
241 In genere questi valori non servono a molto, la loro unica utilità è quella di
242 indicare un limite superiore che assicura la portabilità senza necessità di
243 ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
244 i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
245 valori ottenuti da \func{sysconf}.
250 \begin{tabular}[c]{|l|p{8cm}|}
252 \textbf{Macro}&\textbf{Significato}\\
255 \macro{\_POSIX\_JOB\_CONTROL}& Il sistema supporta il
256 \textit{job control} (vedi
257 sez.~\ref{sec:sess_job_control}).\\
258 \macro{\_POSIX\_SAVED\_IDS} & Il sistema supporta gli identificatori del
259 gruppo \textit{saved} (vedi
260 sez.~\ref{sec:proc_access_id})
261 per il controllo di accesso dei processi\\
262 \const{\_POSIX\_VERSION} & Fornisce la versione dello standard POSIX.1
263 supportata nel formato YYYYMML (ad esempio
267 \caption{Alcune macro definite in \headfile{limits.h} in conformità allo
269 \label{tab:sys_posix1_other}
272 Oltre ai precedenti valori e a quelli relativi ai file elencati in
273 tab.~\ref{tab:sys_posix1_file},, che devono essere obbligatoriamente definiti,
274 lo standard POSIX.1 ne prevede molti altri. La lista completa si trova
275 dall'header file \file{bits/posix1\_lim.h}, da non usare mai direttamente (è
276 incluso automaticamente all'interno di \headfile{limits.h}). Di questi vale la
277 pena menzionarne alcune macro di uso comune, riportate in
278 tab.~\ref{tab:sys_posix1_other}, che non indicano un valore specifico, ma
279 denotano la presenza di alcune funzionalità nel sistema, come il supporto del
280 \textit{job control} o degli identificatori del gruppo \textit{saved}.
282 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
283 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
284 alle applicazioni di sistema presenti, come quelli su alcuni parametri delle
285 espressioni regolari o del comando \cmd{bc}, non li tratteremo esplicitamente,
286 se ne trova una menzione completa nell'header file \file{bits/posix2\_lim.h},
287 e alcuni di loro sono descritti nella pagina di manuale di \func{sysconf} e
288 nel manuale delle \acr{glibc}.
290 Quando uno dei limiti o delle caratteristiche del sistema può variare, per non
291 dover essere costretti a ricompilare un programma tutte le volte che si
292 cambiano le opzioni con cui è compilato il kernel, o alcuni dei parametri
293 modificabili al momento dell'esecuzione, è necessario ottenerne il valore
294 attraverso la funzione \funcd{sysconf}, cui prototipo è:
298 \fdecl{long sysconf(int name)}
299 \fdesc{Restituisce il valore di un parametro di sistema.}
302 {La funzione ritorna in caso di successo il valore del parametro richiesto, o
303 1 se si tratta di un'opzione disponibile, 0 se l'opzione non è disponibile e
304 $-1$ per un errore, nel qual caso però \var{errno} non viene impostata.}
307 La funzione prende come argomento un intero che specifica quale dei limiti si
308 vuole conoscere. Uno specchietto contenente i principali valori disponibili in
309 Linux è riportato in tab.~\ref{tab:sys_sysconf_par}, l'elenco completo è
310 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
311 relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
316 \begin{tabular}[c]{|l|l|p{8cm}|}
318 \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
321 \texttt{\_SC\_ARG\_MAX} & \const{ARG\_MAX}&
322 La dimensione massima degli argomenti passati
323 ad una funzione della famiglia \func{exec}.\\
324 \texttt{\_SC\_CHILD\_MAX} & \const{CHILD\_MAX}&
325 Il numero massimo di processi contemporanei
326 che un utente può eseguire.\\
327 \texttt{\_SC\_OPEN\_MAX} & \const{OPEN\_MAX}&
328 Il numero massimo di file che un processo può
329 mantenere aperti in contemporanea.\\
330 \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
331 Il massimo numero di stream che un processo
332 può mantenere aperti in contemporanea. Questo
333 limite previsto anche dallo standard ANSI C,
334 che specifica la macro {FOPEN\_MAX}.\\
335 \texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
336 La dimensione massima di un nome di una
337 \texttt{timezone} (vedi
338 sez.~\ref{sec:sys_date}).\\
339 \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
340 Massimo numero di gruppi supplementari che
341 può avere un processo (vedi
342 sez.~\ref{sec:proc_access_id}).\\
343 \texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}&
344 Valore massimo del tipo di dato
346 \texttt{\_SC\_CLK\_TCK} & \const{CLK\_TCK} &
347 Il numero di \itindex{clock~tick}
348 \textit{clock tick} al secondo,
349 cioè l'unità di misura del
350 \itindex{process~time} \textit{process
352 sez.~\ref{sec:sys_unix_time}).\\
353 \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
354 Indica se è supportato il \textit{job
356 sez.~\ref{sec:sess_job_control}) in stile
358 \texttt{\_SC\_SAVED\_IDS} & \macro{\_POSIX\_SAVED\_IDS}&
359 Indica se il sistema supporta i
360 \textit{saved id} (vedi
361 sez.~\ref{sec:proc_access_id}).\\
362 \texttt{\_SC\_VERSION} & \const{\_POSIX\_VERSION} &
363 Indica il mese e l'anno di approvazione
364 della revisione dello standard POSIX.1 a cui
365 il sistema fa riferimento, nel formato
366 YYYYMML, la revisione più recente è 199009L,
367 che indica il Settembre 1990.\\
370 \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
371 \label{tab:sys_sysconf_par}
374 In generale ogni limite o caratteristica del sistema per cui è definita una
375 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
376 essere ottenuto attraverso una chiamata a \func{sysconf}. Il nome della
377 costante da utilizzare come valore dell'argomento \param{name} si otterrà
378 aggiungendo \code{\_SC\_} ai nomi delle costanti definite dai primi due
379 standard (quelle di tab.~\ref{tab:sys_generic_macro}), o sostituendolo a
380 \code{\_POSIX\_} per le costanti definite dagli altri due standard (quelle di
381 tab.~\ref{tab:sys_posix1_general}).
383 In linea teorica si dovrebbe fare uso di \func{sysconf} solo quando la
384 relativa costante di sistema non è definita, quindi con un codice analogo al
386 \includecodesnip{listati/get_child_max.c}
387 ma in realtà con Linux queste costanti sono comunque definite, indicando però
388 un limite generico che non è detto sia corretto; per questo motivo è sempre
389 meglio usare i valori restituiti da \func{sysconf}.
392 \subsection{Limiti e caratteristiche dei file}
393 \label{sec:sys_file_limits}
395 Come per le caratteristiche generali del sistema anche per i file esistono una
396 serie di limiti (come la lunghezza del nome del file o il numero massimo di
397 link) che dipendono sia dall'implementazione che dal filesystem in uso. Anche
398 in questo caso lo standard prevede alcune macro che ne specificano il valore,
399 riportate in tab.~\ref{tab:sys_file_macro}.
404 \begin{tabular}[c]{|l|r|l|}
406 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
409 \const{LINK\_MAX} &8 & Numero massimo di link a un file.\\
410 \const{NAME\_MAX}& 14 & Lunghezza in byte di un nome di file. \\
411 \const{PATH\_MAX}& 256 & Lunghezza in byte di un \textit{pathname}.\\
412 \const{PIPE\_BUF}&4096 & Byte scrivibili atomicamente in una pipe
413 (vedi sez.~\ref{sec:ipc_pipes}).\\
414 \const{MAX\_CANON}&255 & Dimensione di una riga di terminale in modo
415 canonico (vedi sez.~\ref{sec:term_io_design}).\\
416 \const{MAX\_INPUT}&255 & Spazio disponibile nella coda di input
418 sez.~\ref{sec:term_io_design}).\\
421 \caption{Costanti per i limiti sulle caratteristiche dei file.}
422 \label{tab:sys_file_macro}
425 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
426 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
427 conforme deve rispettare. Le relative macro sono riportate in
428 tab.~\ref{tab:sys_posix1_file} e per esse vale lo stesso discorso fatto per le
429 analoghe di tab.~\ref{tab:sys_posix1_general}.
434 \begin{tabular}[c]{|l|r|l|}
436 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
439 \const{\_POSIX\_LINK\_MAX} &8 & Numero massimo di link a un file.\\
440 \const{\_POSIX\_NAME\_MAX}& 14 & Lunghezza in byte di un nome di file.\\
441 \const{\_POSIX\_PATH\_MAX}& 256 & Lunghezza in byte di un
443 \const{\_POSIX\_PIPE\_BUF}& 512 & Byte scrivibili atomicamente in una
445 \const{\_POSIX\_MAX\_CANON}&255 & Dimensione di una riga di
446 terminale in modo canonico.\\
447 \const{\_POSIX\_MAX\_INPUT}&255 & Spazio disponibile nella coda di input
449 % \const{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
450 % \const{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
451 % \const{\_POSIX\_FD\_SETSIZE}& 16 & \\
452 % \const{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
455 \caption{Costanti dei valori minimi delle caratteristiche dei file per la
456 conformità allo standard POSIX.1.}
457 \label{tab:sys_posix1_file}
460 Tutti questi limiti sono definiti in \headfile{limits.h}; come nel caso
461 precedente il loro uso è di scarsa utilità in quanto ampiamente superati in
462 tutte le implementazioni moderne. In generale i limiti per i file sono molto
463 più soggetti ad essere variabili rispetto ai limiti generali del sistema; ad
464 esempio parametri come la lunghezza del nome del file o il numero di link
465 possono variare da filesystem a filesystem.
467 Per questo motivo quando si ha a che fare con limiti relativi ai file questi
468 devono essere sempre controllati con la funzione \funcd{pathconf}, il cui
473 \fdecl{long pathconf(char *path, int name)}
474 \fdesc{Restituisce il valore di un parametro dei file.}
477 {La funzione ritorna il valore del parametro richiesto in caso di successo e
478 $-1$ per un errore, nel qual caso \var{errno} viene impostata ad uno degli
479 errori possibili relativi all'accesso a \param{path}.}
482 La funzione richiede che si specifichi il limite che si vuole controllare con
483 l'argomento \param{name}, per il quale si deve usare la relativa costante
484 identificativa, il cui nome si ottiene da quelle descritte in
485 tab.~\ref{tab:sys_file_macro} e tab.~\ref{tab:sys_posix1_file} con la stessa
486 convenzione già vista con \func{sysconf}, ma un questo caso con l'uso del
487 suffisso ``\texttt{\_PC\_}''.
489 In questo caso la funzione richiede anche un secondo argomento \param{path}
490 che specifichi a quale file si fa riferimento, dato che il valore del limite
491 cercato può variare a seconda del filesystem su cui si trova il file. Una
492 seconda versione della funzione, \funcd{fpathconf}, opera su un file
493 descriptor invece che su un \textit{pathname}, il suo prototipo è:
497 \fdecl{long fpathconf(int fd, int name)}
498 \fdesc{Restituisce il valore di un parametro dei file.}
501 {È identica a \func{pathconf} solo che utilizza un file descriptor invece di
502 un \textit{pathname}; pertanto gli errori restituiti in \var{errno} cambiano
505 \noindent ed il suo comportamento è identico a quello di \func{pathconf} a
506 parte quello di richiedere l'indicazione di un file descriptor
507 nell'argomento \param{fd}.
511 \subsection{I parametri del kernel ed il filesystem \texttt{/proc}}
512 \label{sec:sys_sysctl}
514 Tradizionalmente la funzione che permette la lettura ed l'impostazione dei
515 parametri del sistema è \funcm{sysctl}. Si tratta di una funzione derivata da
516 BSD4.4 ed introdotta su Linux a partire dal kernel 1.3.57, ma oggi il suo uso
517 è totalmente deprecato. Una \textit{system call} \funcm{\_sysctl} continua ad
518 esistere, ma non dispone più di una interfaccia nella \acr{glibc} ed il suo
519 utilizzo può essere effettuato solo tramite \func{syscall}, ma di nuovo questo
520 viene sconsigliato in quanto la funzionalità non è più mantenuta e molto
521 probabilmente sarà rimossa nel prossimo futuro. Per questo motivo eviteremo di
522 trattarne i particolari.
524 Lo scopo di \funcm{sysctl} era quello di fornire ai programmi una modalità per
525 modificare i parametri di sistema. Questi erano organizzati in maniera
526 gerarchica all'interno di un albero e per accedere a ciascuno di essi
527 occorreva specificare un percorso attraverso i vari nodi dell'albero, in
528 maniera analoga a come avviene per la risoluzione di un \textit{pathname}.
530 I parametri accessibili e modificabili attraverso questa funzione sono
531 moltissimi, dipendendo anche dallo stato corrente del kernel, ad esempio dai
532 moduli che sono stati caricati nel sistema. Inoltre non essendo standardizzati
533 i loro nomi possono variare da una versione di kernel all'altra, alcuni esempi
534 di questi parametri sono:
536 \item il nome di dominio
537 \item i parametri del meccanismo di \textit{paging}.
538 \item il filesystem montato come radice
539 \item la data di compilazione del kernel
540 \item i parametri dello stack TCP
541 \item il numero massimo di file aperti
544 Dato che fin dall'inizio i parametri erano organizzati in una struttura
545 albero, è parso naturale rimappare questa organizzazione utilizzando il
546 filesystem \file{/proc}. Questo è un filesystem virtuale, generato
547 direttamente dal kernel, che non fa riferimento a nessun dispositivo fisico,
548 ma presenta in forma di file i dati di alcune delle strutture interne del
549 kernel stesso. Il suo utilizzo principale, come denuncia il nome stesso, è
550 quello di fornire una interfaccia per ricavare i dati dei processi (venne
551 introdotto a questo scopo su BSD), ma nel corso del tempo il suo uso è stato
554 In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
555 di una gerarchia di file e directory a partire dalla directory
556 \file{/proc/sys}, cosicché è possibile accedere al valore di un parametro del
557 kernel tramite il \textit{pathname} ad un file sotto \file{/proc/sys}
558 semplicemente leggendone il contenuto, così come si può modificare un
559 parametro scrivendo sul file ad esso corrispondente.
561 Il kernel si occupa di generare al volo il contenuto ed i nomi dei file
562 corrispondenti ai vari parametri che sono presenti, e questo ha il grande
563 vantaggio di rendere accessibili gli stessi ad un qualunque comando di shell e
564 di permettere la navigazione dell'albero in modo da riconoscere quali
565 parametri sono presenti senza dover cercare un valore all'interno di una
568 Inizialmente l'uso del filesystem \file{/proc} serviva soltanto a replicare,
569 con altrettante corrispondenze ai file presenti in \file{/proc/sys}, i valori
570 dei parametri usati da \func{sysctl}, ma vista la assoluta naturalità
571 dell'interfaccia, e la sua maggiore efficienza, nelle versioni più recenti del
572 kernel questa è diventata la modalità canonica per modificare i parametri del
573 kernel, evitando di dover ricorrere all'uso di una \textit{system call}
574 specifica che prima o poi verrà eliminata.
576 Nonostante la semplificazione nella gestione ottenuta con l'uso di
577 \file{/proc/sys} resta il problema generale di conoscere il significato di
578 ciascuno degli innumerevoli parametri che vi si trovano. Purtroppo la
579 documentazione degli stessi spesso risulta incompleta e non aggiornata, ma
580 buona parte di quelli può importanti sono descritti dalla documentazione
581 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
583 Ma oltre alle informazioni che sostituiscono quelle ottenibili dalla ormai
584 deprecata \func{sysctl} dentro \file{proc} sono disponibili moltissime altre
585 informazioni, fra cui ad esempio anche quelle fornite dalla funzione
586 \funcd{uname},\footnote{con Linux ci sono in realtà 3 \textit{system call}
587 diverse per le dimensioni delle stringe restituite, le prime due usano
588 rispettivamente delle lunghezze di 9 e 65 byte, la terza usa anch'essa 65
589 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con una
590 lunghezza di 257 byte, la \acr{glibc} provvede a mascherare questi dettagli
591 usando la versione più recente disponibile.} il cui prototipo è:
594 \fhead{sys/utsname.h}
595 \fdecl{int uname(struct utsname *info)}
596 \fdesc{Restituisce informazioni generali sul sistema.}
599 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
600 caso \var{errno} può assumere solo il valore \errval{EFAULT}.}
603 La funzione, che viene usata dal comando \cmd{uname}, restituisce una serie di
604 informazioni relative al sistema nelle stringhe che costituiscono i campi
605 della struttura \struct{utsname} (la cui definizione è riportata in
606 fig.~\ref{fig:sys_utsname}) che viene scritta nel buffer puntato
607 dall'argomento \param{info}.
609 \begin{figure}[!ht!b]
610 \footnotesize \centering
611 \begin{minipage}[c]{0.8\textwidth}
612 \includestruct{listati/ustname.h}
615 \caption{La struttura \structd{utsname}.}
616 \label{fig:sys_utsname}
619 Si noti come in fig.~\ref{fig:sys_utsname} le dimensioni delle stringhe di
620 \struct{utsname} non sono specificate. Il manuale delle \acr{glibc} indica
621 due costanti per queste dimensioni, \const{\_UTSNAME\_LENGTH} per i campi
622 standard e \const{\_UTSNAME\_DOMAIN\_LENGTH} per quello relativo al nome di
623 dominio, altri sistemi usano nomi diversi come \const{SYS\_NMLN} o
624 \const{\_SYS\_NMLN} o \const{UTSLEN} che possono avere valori diversi. Dato
625 che il buffer deve essere preallocata l'unico modo per farlo in maniera sicura
626 è allora usare come dimensione il valore ottenuto con \code{sizeof(utsname)}.
628 Le informazioni vengono restituite in ciascuno dei singoli campi di
629 \struct{utsname} in forma di stringhe terminate dal carattere NUL. In
630 particolare dette informazioni sono:
632 \item il nome del sistema operativo;
633 \item il nome della macchine (l'\textit{hostname});
634 \item il nome della release del kernel;
635 \item il nome della versione del kernel;
636 \item il tipo di hardware della macchina;
637 \item il nome del domino (il \textit{doaminname}).
640 Ma l'ultima di queste informazioni è stata aggiunta di recente e non è
641 prevista dallo standard POSIX, per questo essa è accessibile, come mostrato in
642 fig.~\ref{fig:sys_utsname}, solo se si è definita la macro
643 \macro{\_GNU\_SOURCE}.
645 Come accennato queste stesse informazioni, anche se a differenza di
646 \func{sysctl} la funzione continua ad essere mantenuta, si possono ottenere
647 direttamente tramite il filesystem \file{/proc}, esse infatti sono mantenute
648 rispettivamente nei file \sysctlrelfile{kernel}{ostype},
649 \sysctlrelfile{kernel}{hostname}, \sysctlrelfile{kernel}{osrelease},
650 \sysctlrelfile{kernel}{version} e \sysctlrelfile{kernel}{domainname} di
651 \file{/proc/sys/kernel/}.
657 \section{La gestione del sistema}
658 \label{sec:sys_management}
660 In questa sezione prenderemo in esame le interfacce di programmazione messe a
661 disposizione per affrontare una serie di tematiche di gestione generale del
662 sistema come quelle relative alla gestione di utenti e gruppi, delle
663 informazioni relative ai collegamenti al sistema, dello spegnimento e del
664 riavvio di una macchina.
667 \subsection{La gestione delle informazioni su utenti e gruppi}
668 \label{sec:sys_user_group}
670 Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
671 (password, corrispondenze fra nomi simbolici e \ids{UID} numerici, home
672 directory, ecc.) venivano registrate all'interno dei due file di testo
673 \conffile{/etc/passwd} ed \conffile{/etc/group},\footnote{in realtà oltre a
674 questi nelle distribuzioni più recenti è stato introdotto il sistema delle
675 \textit{shadow password} che prevede anche i due file \conffile{/etc/shadow}
676 e \conffile{/etc/gshadow}, in cui sono state spostate le informazioni di
677 autenticazione (ed inserite alcune estensioni) per toglierle dagli altri
678 file che devono poter essere letti per poter effettuare l'associazione fra
679 username e \ids{UID}.} il cui formato è descritto dalle relative pagine del
680 manuale\footnote{nella quinta sezione, quella dei file di configurazione,
681 occorre cioè usare \cmd{man 5 passwd} dato che altrimenti si avrebbe la
682 pagina di manuale del comando \cmd{passwd}.} e tutte le funzioni che
683 richiedevano l'accesso a queste informazione andavano a leggere direttamente
684 il contenuto di questi file.
686 Col tempo però questa impostazione ha incominciato a mostrare dei limiti: da
687 una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
688 la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
689 che sta per \textit{Pluggable Authentication Method}) che fornisce una
690 interfaccia comune per i processi di autenticazione,\footnote{il
691 \textit{Pluggable Authentication Method} è un sistema modulare, in cui è
692 possibile utilizzare anche più meccanismi insieme, diventa così possibile
693 avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
694 diversi formati per le password e diversi supporti per le informazioni, il
695 tutto in maniera trasparente per le applicazioni purché per ciascun
696 meccanismo si disponga della opportuna libreria che implementa l'interfaccia
697 di PAM.} svincolando completamente le singole applicazione dai dettagli del
698 come questa viene eseguita e di dove vengono mantenuti i dati relativi;
699 dall'altra con il diffondersi delle reti la necessità di centralizzare le
700 informazioni degli utenti e dei gruppi per insiemi di macchine, in modo da
701 mantenere coerenti i dati, ha portato anche alla necessità di poter recuperare
702 e memorizzare dette informazioni su supporti diversi, introducendo il sistema
703 del \itindex{Name~Service~Switch~(NSS)} \textit{Name Service Switch} che
704 tratteremo brevemente più avanti (in sez.~\ref{sec:sock_resolver}) dato che la
705 maggior parte delle sua applicazioni sono relative alla risoluzioni di nomi di
708 In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
709 per la lettura delle informazioni relative a utenti e gruppi tralasciando
710 completamente quelle relative all'autenticazione.
711 % Per questo non tratteremo
712 % affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
713 % \textit{Name Service Switch}, un meccanismo messo a disposizione dalle
714 % \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
715 % necessario trovare una corrispondenza fra un nome ed un numero (od altra
716 % informazione) ad esso associato, come appunto, quella fra uno username ed un
717 % \ids{UID} o fra un \ids{GID} ed il nome del gruppo corrispondente.
718 Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
719 queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
720 Service Switch}, per cui sono in grado di ricevere informazioni qualunque
721 sia il supporto su cui esse vengono mantenute. Per leggere le informazioni
722 relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
723 \funcd{getpwnam}, i cui prototipi sono:
726 \headdecl{sys/types.h}
727 \funcdecl{struct passwd *getpwuid(uid\_t uid)}
729 \funcdecl{struct passwd *getpwnam(const char *name)}
731 Restituiscono le informazioni relative all'utente specificato.
733 \bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
734 informazioni in caso di successo e \val{NULL} nel caso non sia stato
735 trovato nessun utente corrispondente a quanto specificato.}
738 Le due funzioni forniscono le informazioni memorizzate nel registro degli
739 utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
740 relative all'utente specificato attraverso il suo \ids{UID} o il nome di
741 login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
742 tipo \struct{passwd} la cui definizione (anch'essa eseguita in
743 \headfile{pwd.h}) è riportata in fig.~\ref{fig:sys_passwd_struct}, dove è pure
744 brevemente illustrato il significato dei vari campi.
749 \begin{minipage}[c]{\textwidth}
750 \includestruct{listati/passwd.h}
753 \caption{La struttura \structd{passwd} contenente le informazioni relative ad
754 un utente del sistema.}
755 \label{fig:sys_passwd_struct}
758 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
759 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
760 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
761 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
762 essere \index{funzioni!rientranti} rientranti; per questo motivo ne esistono
763 anche due versioni alternative (denotate dalla solita estensione \code{\_r}),
764 i cui prototipi sono:
768 \headdecl{sys/types.h}
770 \funcdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
771 char *buffer, size\_t buflen, struct passwd **result)}
773 \funcdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
774 *password, char *buffer, size\_t buflen, struct passwd **result)}
776 Restituiscono le informazioni relative all'utente specificato.
778 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
779 altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
782 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
783 la memoria necessaria a contenere le informazioni. In particolare i valori
784 della struttura \struct{passwd} saranno restituiti all'indirizzo
785 \param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
786 un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
787 puntate dai campi di \param{password}. Infine all'indirizzo puntato da
788 \param{result} viene restituito il puntatore ai dati ottenuti, cioè
789 \param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti. Qualora i
790 dati non possano essere contenuti nei byte specificati da \param{buflen}, la
791 funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
792 impostato a \val{NULL}).
794 Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
795 \funcd{getgrgid} (e le relative analoghe \index{funzioni!rientranti}
796 rientranti con la stessa estensione \code{\_r}) che permettono di leggere le
797 informazioni relative ai gruppi, i loro prototipi sono:
800 \headdecl{sys/types.h}
802 \funcdecl{struct group *getgrgid(gid\_t gid)}
804 \funcdecl{struct group *getgrnam(const char *name)}
806 \funcdecl{struct group *getpwuid\_r(gid\_t gid, struct group *password,
807 char *buffer, size\_t buflen, struct group **result)}
809 \funcdecl{struct group *getpwnam\_r(const char *name, struct group
810 *password, char *buffer, size\_t buflen, struct group **result)}
812 Restituiscono le informazioni relative al gruppo specificato.
814 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
815 altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
818 Il comportamento di tutte queste funzioni è assolutamente identico alle
819 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
820 in questo caso le informazioni vengono restituite in una struttura di tipo
821 \struct{group}, la cui definizione è riportata in
822 fig.~\ref{fig:sys_group_struct}.
827 \begin{minipage}[c]{\textwidth}
828 \includestruct{listati/group.h}
831 \caption{La struttura \structd{group} contenente le informazioni relative ad
832 un gruppo del sistema.}
833 \label{fig:sys_group_struct}
836 Le funzioni viste finora sono in grado di leggere le informazioni sia
837 direttamente dal file delle password in \conffile{/etc/passwd} che tramite il
838 sistema del \itindex{Name~Service~Switch~(NSS)} \textit{Name Service Switch} e
839 sono completamente generiche. Si noti però che non c'è una funzione che
840 permetta di impostare direttamente una password.\footnote{in realtà questo può
841 essere fatto ricorrendo a PAM, ma questo è un altro discorso.} Dato che
842 POSIX non prevede questa possibilità esiste un'altra interfaccia che lo fa,
843 derivata da SVID le cui funzioni sono riportate in
844 tab.~\ref{tab:sys_passwd_func}. Questa però funziona soltanto quando le
845 informazioni sono mantenute su un apposito file di \textsl{registro} di utenti
846 e gruppi, con il formato classico di \conffile{/etc/passwd} e
847 \conffile{/etc/group}.
852 \begin{tabular}[c]{|l|p{8cm}|}
854 \textbf{Funzione} & \textbf{Significato}\\
857 \funcm{fgetpwent} & Legge una voce dal file di registro degli utenti
859 \funcm{fgetpwent\_r}& Come la precedente, ma \index{funzioni!rientranti}
861 \funcm{putpwent} & Immette una voce in un file di registro degli
863 \funcm{getpwent} & Legge una voce da \conffile{/etc/passwd}.\\
864 \funcm{getpwent\_r} & Come la precedente, ma \index{funzioni!rientranti}
866 \funcm{setpwent} & Ritorna all'inizio di \conffile{/etc/passwd}.\\
867 \funcm{endpwent} & Chiude \conffile{/etc/passwd}.\\
868 \funcm{fgetgrent} & Legge una voce dal file di registro dei gruppi
870 \funcm{fgetgrent\_r}& Come la precedente, ma \index{funzioni!rientranti}
872 \funcm{putgrent} & Immette una voce in un file di registro dei gruppi.\\
873 \funcm{getgrent} & Legge una voce da \conffile{/etc/group}.\\
874 \funcm{getgrent\_r} & Come la precedente, ma \index{funzioni!rientranti}
876 \funcm{setgrent} & Ritorna all'inizio di \conffile{/etc/group}.\\
877 \funcm{endgrent} & Chiude \conffile{/etc/group}.\\
880 \caption{Funzioni per la manipolazione dei campi di un file usato come
881 registro per utenti o gruppi nel formato di \conffile{/etc/passwd} e
882 \conffile{/etc/group}.}
883 \label{tab:sys_passwd_func}
886 % TODO mancano i prototipi di alcune delle funzioni
888 Dato che oramai la gran parte delle distribuzioni di GNU/Linux utilizzano
889 almeno le \textit{shadow password} (quindi con delle modifiche rispetto al
890 formato classico del file \conffile{/etc/passwd}), si tenga presente che le
891 funzioni di questa interfaccia che permettono di scrivere delle voci in un
892 \textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
893 hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
894 questa estensione. Per questo motivo l'uso di queste funzioni è deprecato, in
895 quanto comunque non funzionale, pertanto ci limiteremo a fornire soltanto
896 l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
897 ulteriore. Chi volesse insistere ad usare questa interfaccia può fare
898 riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
899 delle \acr{glibc} per i dettagli del funzionamento.
903 \subsection{Il registro della \textsl{contabilità} degli utenti}
904 \label{sec:sys_accounting}
906 L'ultimo insieme di funzioni relative alla gestione del sistema che
907 esamineremo è quello che permette di accedere ai dati del registro della
908 cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti. In esso
909 vengono mantenute una serie di informazioni storiche relative sia agli utenti
910 che si sono collegati al sistema, (tanto per quelli correntemente collegati,
911 che per la registrazione degli accessi precedenti), sia relative all'intero
912 sistema, come il momento di lancio di processi da parte di \cmd{init}, il
913 cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
916 I dati vengono usualmente\footnote{questa è la locazione specificata dal
917 \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
918 delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
919 \file{/var/log/wtmp}.\footnote{non si confonda quest'ultimo con il simile
920 \file{/var/log/btmp} dove invece vengono memorizzati dal programma di login
921 tutti tentativi di accesso fallito.} Quando un utente si collega viene
922 aggiunta una voce a \file{/var/run/utmp} in cui viene memorizzato il nome di
923 login, il terminale da cui ci si collega, l'\ids{UID} della shell di login,
924 l'orario della connessione ed altre informazioni. La voce resta nel file fino
925 al logout, quando viene cancellata e spostata in \file{/var/log/wtmp}.
927 In questo modo il primo file viene utilizzato per registrare chi sta
928 utilizzando il sistema al momento corrente, mentre il secondo mantiene la
929 registrazione delle attività degli utenti. A quest'ultimo vengono anche
930 aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
931 come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
932 informazioni sono descritte in dettaglio nel manuale delle \acr{glibc}.
934 Questi file non devono mai essere letti direttamente, ma le informazioni che
935 contengono possono essere ricavate attraverso le opportune funzioni di
936 libreria. Queste sono analoghe alle precedenti funzioni (vedi
937 tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
938 solo che in questo caso la struttura del registro della \textsl{contabilità} è
939 molto più complessa, dato che contiene diversi tipi di informazione.
941 Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
942 servono rispettivamente a aprire e a chiudere il file che contiene il
943 registro, e a specificare su quale file esso viene mantenuto. I loro prototipi
948 \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
951 \funcdecl{void setutent(void)} Apre il file del registro, posizionandosi al
954 \funcdecl{void endutent(void)} Chiude il file del registro.
956 \bodydesc{Le funzioni non ritornano codici di errore.}
958 e si tenga presente che le funzioni non restituiscono nessun valore, pertanto
959 non è possibile accorgersi di eventuali errori (ad esempio se si è impostato
960 un nome di file sbagliato con \func{utmpname}).
962 Nel caso non si sia utilizzata \func{utmpname} per specificare un file di
963 registro alternativo, sia \func{setutent} che \func{endutent} operano usando
964 il default che è \sysfile{/var/run/utmp}. Il nome di questo file, così come
965 una serie di altri valori di default per i \textit{pathname} di uso più
966 comune, viene mantenuto nei valori di una serie di costanti definite
967 includendo \headfile{paths.h}, in particolare quelle che ci interessano sono:
968 \begin{basedescript}{\desclabelwidth{2.0cm}}
969 \item[\const{\_PATH\_UTMP}] specifica il file che contiene il registro per gli
970 utenti correntemente collegati; questo è il valore che viene usato se non si
971 è utilizzato \func{utmpname} per modificarlo.
972 \item[\const{\_PATH\_WTMP}] specifica il file che contiene il registro per
973 l'archivio storico degli utenti collegati.
975 che nel caso di Linux hanno un valore corrispondente ai file
976 \sysfile{/var/run/utmp} e \sysfile{/var/log/wtmp} citati in precedenza.
978 Una volta aperto il file del registro degli utenti si può eseguire una
979 scansione leggendo o scrivendo una voce con le funzioni \funcd{getutent},
980 \funcd{getutid}, \funcd{getutline} e \funcd{pututline}, i cui prototipi sono:
984 \funcdecl{struct utmp *getutent(void)}
985 Legge una voce dalla posizione corrente nel registro.
987 \funcdecl{struct utmp *getutid(struct utmp *ut)} Ricerca una voce sul
988 registro in base al contenuto di \param{ut}.
990 \funcdecl{struct utmp *getutline(struct utmp *ut)}
991 Ricerca nel registro la prima voce corrispondente ad un processo sulla linea
992 di terminale specificata tramite \param{ut}.
994 \funcdecl{struct utmp *pututline(struct utmp *ut)}
995 Scrive una voce nel registro.
997 \bodydesc{Le funzioni ritornano il puntatore ad una struttura \struct{utmp}
998 in caso di successo e \val{NULL} in caso di errore.}
1001 Tutte queste funzioni fanno riferimento ad una struttura di tipo
1002 \struct{utmp}, la cui definizione in Linux è riportata in
1003 fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
1004 voce dal registro; \func{getutent} legge semplicemente la prima voce
1005 disponibile; le altre due permettono di eseguire una ricerca.
1008 \begin{figure}[!htb]
1011 \begin{minipage}[c]{\textwidth}
1012 \includestruct{listati/utmp.h}
1015 \caption{La struttura \structd{utmp} contenente le informazioni di una voce
1016 del registro di \textsl{contabilità}.}
1017 \label{fig:sys_utmp_struct}
1020 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1021 campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
1022 riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
1023 \const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
1024 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1025 invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
1026 \const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
1027 corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1032 \begin{tabular}[c]{|l|p{8cm}|}
1034 \textbf{Valore} & \textbf{Significato}\\
1037 \const{EMPTY} & Non contiene informazioni valide.\\
1038 \const{RUN\_LVL} & Identica il runlevel del sistema.\\
1039 \const{BOOT\_TIME} & Identifica il tempo di avvio del sistema.\\
1040 \const{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
1042 \const{NEW\_TIME} & Identifica da quanto è stato modificato il
1044 \const{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
1045 \const{LOGIN\_PROCESS}& Identifica un processo di login.\\
1046 \const{USER\_PROCESS} & Identifica un processo utente.\\
1047 \const{DEAD\_PROCESS} & Identifica un processo terminato.\\
1048 % \const{ACCOUNTING} & ??? \\
1051 \caption{Classificazione delle voci del registro a seconda dei
1052 possibili valori del campo \var{ut\_type}.}
1053 \label{tab:sys_ut_type}
1056 La funzione \func{getutline} esegue la ricerca sulle voci che hanno
1057 \var{ut\_type} uguale a \const{LOGIN\_PROCESS} o \const{USER\_PROCESS},
1058 restituendo la prima che corrisponde al valore di \var{ut\_line}, che
1059 specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
1060 terminale che interessa. Lo stesso criterio di ricerca è usato da
1061 \func{pututline} per trovare uno spazio dove inserire la voce specificata,
1062 qualora non sia trovata la voce viene aggiunta in coda al registro.
1064 In generale occorre però tenere conto che queste funzioni non sono
1065 completamente standardizzate, e che in sistemi diversi possono esserci
1066 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1067 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1068 fornita dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1069 introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
1070 sono un sovrainsieme di \code{utmp}.
1072 Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
1073 inutili queste nuove strutture; pertanto esse e le relative funzioni di
1074 gestione (\funcm{getutxent}, \funcm{getutxid}, \funcm{getutxline},
1075 \funcm{pututxline}, \funcm{setutxent} e \funcm{endutxent}) sono ridefinite come
1076 sinonimi delle funzioni appena viste.
1078 % TODO (verificare le funzioni di cui sopra )
1080 Come visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
1081 staticamente rende le funzioni di lettura non \index{funzioni!rientranti}
1082 rientranti; per questo motivo le \acr{glibc} forniscono anche delle versioni
1083 \index{funzioni!rientranti} rientranti: \funcm{getutent\_r}, \funcm{getutid\_r},
1084 \funcm{getutline\_r}, che invece di restituire un puntatore restituiscono un
1085 intero e prendono due argomenti aggiuntivi. Le funzioni si comportano
1086 esattamente come le analoghe non \index{funzioni!rientranti} rientranti, solo
1087 che restituiscono il risultato all'indirizzo specificato dal primo argomento
1088 aggiuntivo (di tipo \code{struct utmp *buffer}) mentre il secondo (di tipo
1089 \code{struct utmp **result)} viene usato per restituire il puntatore allo
1092 Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
1093 in \file{wmtp} altre due funzioni, \funcd{updwtmp} e \funcd{logwtmp}, i cui
1098 \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1099 Aggiunge la voce \param{ut} nel registro \file{wmtp}.
1101 \funcdecl{void logwtmp(const char *line, const char *name, const char
1102 *host)} Aggiunge nel registro una voce con i valori specificati.
1105 La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
1106 direttamente una struttura \struct{utmp}, mentre la seconda utilizza gli
1107 argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
1108 poi aggiunge chiamando \func{updwtmp}.
1112 % TODO documentare keyctl ????
1113 % (fare sezione dedicata ????)
1114 %\subsection{La gestione delle chiavi crittografiche}
1115 %\label{sec:keyctl_management}
1118 \subsection{La gestione dello spegnimento e del riavvio}
1119 \label{sec:sys_reboot}
1123 % TODO trattare reboot, kexec_load, ...
1127 \section{Il controllo dell'uso delle risorse}
1128 \label{sec:sys_res_limits}
1131 Dopo aver esaminato le funzioni che permettono di controllare le varie
1132 caratteristiche, capacità e limiti del sistema a livello globale, in questa
1133 sezione tratteremo le varie funzioni che vengono usate per quantificare le
1134 risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
1135 permettono di imporre a ciascuno di essi vincoli e limiti di
1139 \subsection{L'uso delle risorse}
1140 \label{sec:sys_resource_use}
1142 Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
1143 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1144 di tipo \struct{rusage}, la cui definizione (che si trova in
1145 \headfile{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
1147 \begin{figure}[!htb]
1150 \begin{minipage}[c]{\textwidth}
1151 \includestruct{listati/rusage.h}
1154 \caption{La struttura \structd{rusage} per la lettura delle informazioni dei
1155 delle risorse usate da un processo.}
1156 \label{fig:sys_rusage_struct}
1159 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
1160 da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
1161 \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si trova
1162 nelle opzioni di compilazione del kernel (e di norma è disabilitato) che
1163 serve per mantenere una contabilità delle risorse usate da ciascun processo
1164 in maniera molto più dettagliata.} ma attualmente (con i kernel della serie
1165 2.4.x e 2.6.x) i soli campi che sono mantenuti sono: \var{ru\_utime},
1166 \var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I
1167 primi due indicano rispettivamente il tempo impiegato dal processo
1168 nell'eseguire le istruzioni in user space, e quello impiegato dal kernel nelle
1169 system call eseguite per conto del processo.
1171 Gli altri tre campi servono a quantificare l'uso della memoria
1172 virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
1173 \itindex{page~fault} \textit{page fault} (vedi sez.~\ref{sec:proc_mem_gen})
1174 avvenuti senza richiedere I/O su disco (i cosiddetti \textit{minor page
1175 fault}), a quelli che invece han richiesto I/O su disco (detti invece
1176 \textit{major page fault}) ed al numero di volte che il processo è stato
1177 completamente tolto dalla memoria per essere inserito nello swap.
1179 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
1180 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
1181 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
1182 ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
1183 \struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
1185 Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
1186 visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di risorse
1187 impiegate dal processo di cui si è letto lo stato di terminazione, ma essa può
1188 anche essere letta direttamente utilizzando la funzione \funcd{getrusage}, il
1191 \headdecl{sys/time.h}
1192 \headdecl{sys/resource.h}
1195 \funcdecl{int getrusage(int who, struct rusage *usage)}
1196 Legge la quantità di risorse usate da un processo.
1199 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1200 nel qual caso \var{errno} può essere \errval{EINVAL} o \errval{EFAULT}.}
1203 L'argomento \param{who} permette di specificare il processo di cui si vuole
1204 leggere l'uso delle risorse; esso può assumere solo i due valori
1205 \const{RUSAGE\_SELF} per indicare il processo corrente e
1206 \const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
1207 ricevuto lo stato di terminazione.
1209 % TODO previsto in futuro \const{RUSAGE\_THREAD}, verificare.
1211 \subsection{Limiti sulle risorse}
1212 \label{sec:sys_resource_limit}
1214 Come accennato nell'introduzione il kernel mette a disposizione delle
1215 funzionalità che permettono non solo di mantenere dati statistici relativi
1216 all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
1217 utilizzo da parte dei vari processi o degli utenti.
1219 Per far questo esistono una serie di risorse e ad ogni processo vengono
1220 associati due diversi limiti per ciascuna di esse; questi sono il
1221 \textsl{limite corrente} (o \textit{current limit}) che esprime un valore
1222 massimo che il processo non può superare ad un certo momento, ed il
1223 \textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
1224 valore massimo che può assumere il \textsl{limite corrente}. In generale il
1225 primo viene chiamato anche \textit{soft limit} dato che il suo valore può
1226 essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
1227 fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
1230 %TODO: tabella troppo grossa, trasformare in lista
1235 \begin{tabular}[c]{|l|p{12cm}|}
1237 \textbf{Valore} & \textbf{Significato}\\
1240 \const{RLIMIT\_AS} & La dimensione massima della memoria virtuale di
1241 un processo, il cosiddetto \textit{Address
1242 Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se
1243 il limite viene superato dall'uso di funzioni
1244 come \func{brk}, \func{mremap} o \func{mmap}
1245 esse falliranno con un errore di
1246 \errcode{ENOMEM}, mentre se il superamento viene
1247 causato dalla crescita dello \itindex{stack}
1248 \textit{stack} il processo riceverà un segnale di
1250 \const{RLIMIT\_CORE} & La massima dimensione per di un file di
1251 \itindex{core~dump} \textit{core dump} (vedi
1252 sez.~\ref{sec:sig_prog_error}) creato nella
1253 terminazione di un processo; file di dimensioni
1254 maggiori verranno troncati a questo valore,
1255 mentre con un valore si bloccherà la creazione
1256 dei \itindex{core~dump} \textit{core dump}.\\
1257 \const{RLIMIT\_CPU} & Il massimo tempo di CPU (vedi
1258 sez.~\ref{sec:sys_cpu_times}) che il processo può
1259 usare. Il superamento del limite corrente
1260 comporta l'emissione di un segnale di
1261 \signal{SIGXCPU}, la cui azione predefinita (vedi
1262 sez.~\ref{sec:sig_classification}) è terminare
1263 il processo, una volta al secondo fino al
1264 raggiungimento del limite massimo. Il
1265 superamento del limite massimo
1266 comporta l'emissione di un segnale di
1267 \signal{SIGKILL}.\footnotemark\\
1268 \const{RLIMIT\_DATA} & La massima dimensione del \index{segmento!dati}
1270 processo (vedi sez.~\ref{sec:proc_mem_layout}).
1271 Il tentativo di allocare più memoria di quanto
1272 indicato dal limite corrente causa il fallimento
1273 della funzione di allocazione (\func{brk} o
1274 \func{sbrk}) con un errore di \errcode{ENOMEM}.\\
1275 \const{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
1276 può creare. Se il processo cerca di scrivere
1277 oltre questa dimensione riceverà un segnale di
1278 \signal{SIGXFSZ}, che di norma termina il
1279 processo; se questo viene intercettato la
1280 system call che ha causato l'errore fallirà con
1281 un errore di \errcode{EFBIG}.\\
1282 \const{RLIMIT\_LOCKS}& È un limite presente solo nelle prime versioni
1283 del kernel 2.4 sul numero massimo di
1284 \itindex{file~locking} \textit{file lock} (vedi
1285 sez.~\ref{sec:file_locking}) che un
1286 processo poteva effettuare.\\
1287 \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
1288 bloccata in RAM da un processo (vedi
1289 sez.~\ref{sec:proc_mem_lock}). Dal kernel 2.6.9
1290 questo limite comprende anche la memoria che può
1291 essere bloccata da ciascun utente nell'uso della
1292 memoria condivisa (vedi
1293 sez.~\ref{sec:ipc_sysv_shm}) che viene
1294 contabilizzata separatamente ma sulla quale
1295 viene applicato questo stesso limite.\\
1296 % TODO trattare i seguenti...
1297 % \const{RLIMIT\_MSGQUEUE}& Il numero massimo di \\
1298 % \const{RLIMIT\_NICE}& Il numero massimo di \\
1299 % \const{RLIMIT\_RTPRIO}& Il numero massimo di \\
1300 % aggiungere i limiti che mancano come RLIMIT_RTTIME introdotto con il 2.6.25
1301 % vedi file include/asm-generic/resource.h
1302 \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
1303 aprire. L'apertura di un ulteriore file farà
1304 fallire la funzione (\func{open}, \func{dup} o
1305 \func{pipe}) con un errore \errcode{EMFILE}.\\
1306 \const{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
1307 creati sullo stesso user id real. Se il limite
1308 viene raggiunto \func{fork} fallirà con un
1310 \const{RLIMIT\_SIGPENDING}& Il numero massimo di segnali che possono
1311 essere mantenuti in coda per ciascun utente,
1312 considerando sia i segnali normali che real-time
1313 (vedi sez.~\ref{sec:sig_real_time}). Il limite è
1314 attivo solo per \func{sigqueue}, con \func{kill}
1315 si potrà sempre inviare un segnale che non sia
1316 già presente su una coda.\footnotemark\\
1317 \const{RLIMIT\_STACK} & La massima dimensione dello \itindex{stack}
1318 \textit{stack} del processo. Se il processo
1319 esegue operazioni che estendano lo
1320 \textit{stack} oltre questa dimensione
1321 riceverà un segnale di \signal{SIGSEGV}.\\
1322 % TODO dal 2.6.23 il significato è cambiato, vedi anche man execve
1323 \const{RLIMIT\_RSS} & L'ammontare massimo di pagine di memoria dato al
1324 \index{segmento!testo} testo del processo. Il
1325 limite è solo una indicazione per il kernel,
1326 qualora ci fosse un surplus di memoria questa
1327 verrebbe assegnata.\\
1328 % TODO: aggiungere a \const{RLIMIT\_STACK} i dati di execve:
1329 % Questi fino al kernel 2.6.23 erano fissi e costituiti da
1330 % 32 pagine di memoria (corrispondenti per la gran parte delle architetture a
1331 % 128kb di dati). Dal 2.6.23 su molte architettire il limite viene stabilito in
1332 % base al valore della risorsa \const{RLIMIT\_STACK} (vedi
1333 % sez.~\ref{sec:sys_resource_limit}), ad un quarto dello spazio da essa
1334 % indicato). Dal 2.6.25 viene comunque garantito uno spazio base di 32 pagine.
1336 % TODO integrare con la roba di madvise
1337 % TODO integrare con le ultime aggiunte, vedi pagina di manuale
1340 \caption{Valori possibili dell'argomento \param{resource} delle funzioni
1341 \func{getrlimit} e \func{setrlimit}.}
1342 \label{tab:sys_rlimit_values}
1345 \footnotetext[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
1346 oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
1347 avviene quando viene superato il \textit{soft limit}; perciò per avere
1348 operazioni portabili è sempre opportuno intercettare il primo
1349 \signal{SIGXCPU} e terminare in maniera ordinata il processo.}
1351 \footnotetext{il limite su questa risorsa è stato introdotto con il kernel
1354 % TODO trattare prlimit64 introdotta con il 2.6.36 che dovrebbe sostituire
1358 In generale il superamento di un limite corrente\footnote{di norma quanto
1359 riportato in tab.~\ref{tab:sys_rlimit_values} fa riferimento a quanto
1360 avviene al superamento del limite corrente, con l'eccezione
1361 \const{RLIMIT\_CPU} in cui si ha in comportamento diverso per il superamento
1362 dei due limiti.} comporta o l'emissione di un segnale o il fallimento della
1363 system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
1364 \const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
1365 creazione) dei file di \itindex{core~dump} \textit{core dump}.} per
1366 permettere di leggere e di impostare i limiti di utilizzo delle risorse da
1367 parte di un processo sono previste due funzioni, \funcd{getrlimit} e
1368 \funcd{setrlimit}, i cui prototipi sono:
1370 \headdecl{sys/time.h}
1371 \headdecl{sys/resource.h}
1374 \funcdecl{int getrlimit(int resource, struct rlimit *rlim)}
1376 Legge il limite corrente per la risorsa \param{resource}.
1378 \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)}
1380 Imposta il limite per la risorsa \param{resource}.
1382 \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
1383 errore, nel qual caso \var{errno} assumerà uno dei valori:
1385 \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi.
1386 \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1387 cercato di innalzare i propri limiti.
1389 ed \errval{EFAULT}.}
1393 Entrambe le funzioni permettono di specificare, attraverso l'argomento
1394 \param{resource}, su quale risorsa si vuole operare: i possibili valori di
1395 questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
1396 (rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
1397 poi effettuato attraverso la struttura \struct{rlimit} puntata da
1398 \param{rlim}, la cui definizione è riportata in
1399 fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
1400 limite corrente e limite massimo.
1403 \begin{figure}[!htb]
1406 \begin{minipage}[c]{\textwidth}
1407 \includestruct{listati/rlimit.h}
1410 \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
1411 delle risorse usate da un processo.}
1412 \label{fig:sys_rlimit_struct}
1416 Nello specificare un limite, oltre a fornire dei valori specifici, si può
1417 anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
1418 di una risorsa; ma si ricordi che solo un processo con i privilegi di
1419 amministratore\footnote{per essere precisi in questo caso quello che serve è
1420 la \itindex{capabilities} \textit{capability} \const{CAP\_SYS\_RESOURCE}
1421 (vedi sez.~\ref{sec:proc_capabilities}).} può innalzare un limite al di
1422 sopra del valore corrente del limite massimo ed usare un valore qualsiasi per
1423 entrambi i limiti. Si tenga conto infine che tutti i limiti vengono ereditati
1424 dal processo padre attraverso una \func{fork} (vedi sez.~\ref{sec:proc_fork})
1425 e mantenuti per gli altri programmi eseguiti attraverso una \func{exec} (vedi
1426 sez.~\ref{sec:proc_exec}).
1429 \subsection{Le risorse di memoria e processore}
1430 \label{sec:sys_memory_res}
1432 La gestione della memoria è già stata affrontata in dettaglio in
1433 sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1434 meccanismo della \index{memoria~virtuale} memoria virtuale attraverso la
1435 divisione della memoria fisica in pagine.
1437 In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
1438 casi, come per l'I/O mappato in memoria (vedi sez.~\ref{sec:file_memory_map})
1439 che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
1440 dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
1441 gestire in maniera ottimale l'interazione della memoria che si sta allocando
1442 con il meccanismo della \index{paginazione} paginazione.
1444 Di solito la dimensione delle pagine di memoria è fissata dall'architettura
1445 hardware, per cui il suo valore di norma veniva mantenuto in una costante che
1446 bastava utilizzare in fase di compilazione, ma oggi, con la presenza di alcune
1447 architetture (ad esempio Sun Sparc) che permettono di variare questa
1448 dimensione, per non dover ricompilare i programmi per ogni possibile modello e
1449 scelta di dimensioni, è necessario poter utilizzare una funzione.
1451 Dato che si tratta di una caratteristica generale del sistema, questa
1452 dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
1453 \func{sysconf}, \footnote{nel caso specifico si dovrebbe utilizzare il
1454 parametro \const{\_SC\_PAGESIZE}.} ma in BSD 4.2 è stata introdotta una
1455 apposita funzione, \funcd{getpagesize}, che restituisce la dimensione delle
1456 pagine di memoria; il suo prototipo è:
1457 \begin{prototype}{unistd.h}{int getpagesize(void)}
1458 Legge le dimensioni delle pagine di memoria.
1460 \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
1461 sono previsti errori.}
1464 La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
1465 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1466 ha eliminata. In Linux è implementata come una system call nelle architetture
1467 in cui essa è necessaria, ed in genere restituisce il valore del simbolo
1468 \const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
1469 se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
1470 implementavano questa funzione restituendo sempre un valore statico.
1472 % TODO verificare meglio la faccenda di const{PAGE\_SIZE}
1474 Le \textsl{glibc} forniscono, come specifica estensione GNU, altre due
1475 funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
1476 di ottenere informazioni riguardo la memoria; i loro prototipi sono:
1478 \headdecl{sys/sysinfo.h}
1480 \funcdecl{long int get\_phys\_pages(void)}
1482 Legge il numero totale di pagine di memoria disponibili per il sistema.
1484 \funcdecl{long int get\_avphys\_pages(void)}
1486 Legge il numero di pagine di memoria disponibili nel sistema.
1488 \bodydesc{Le funzioni restituiscono un numero di pagine.}
1491 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1492 rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
1493 \const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1494 corrispondenti alla RAM della macchina; la seconda invece la memoria
1495 effettivamente disponibile per i processi.
1497 Le \acr{glibc} supportano inoltre, come estensioni GNU, due funzioni che
1498 restituiscono il numero di processori della macchina (e quello dei processori
1499 attivi); anche queste sono informazioni comunque ottenibili attraverso
1500 \func{sysconf} utilizzando rispettivamente i parametri
1501 \const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
1503 Infine le \acr{glibc} riprendono da BSD la funzione \funcd{getloadavg} che
1504 permette di ottenere il carico di processore della macchina, in questo modo è
1505 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1507 \begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
1508 Legge il carico medio della macchina.
1510 \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
1514 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1515 di processi attivi sulla coda dello \itindex{scheduler} scheduler, calcolato
1516 su diversi intervalli di tempo. Il numero di intervalli che si vogliono
1517 leggere è specificato da \param{nelem}, dato che nel caso di Linux il carico
1518 viene valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti),
1519 questo è anche il massimo valore che può essere assegnato a questo argomento.
1522 \subsection{La \textsl{contabilità} in stile BSD}
1523 \label{sec:sys_bsd_accounting}
1525 Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
1526 kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
1527 compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
1528 cosiddetto \textit{BSD accounting}, che consente di registrare su file una
1529 serie di informazioni\footnote{contenute nella struttura \texttt{acct}
1530 definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
1531 riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
1532 che viene terminato.
1534 Linux consente di salvare la contabilità delle informazioni relative alle
1535 risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
1537 \begin{prototype}{unistd.h}{int acct(const char *filename)}
1538 Abilita il \textit{BSD accounting}.
1540 \bodydesc{La funzione ritorna 0 in caso di successo o $-1$ in caso di
1541 errore, nel qual caso \var{errno} assumerà uno dei valori:
1543 \item[\errcode{EACCES}] non si hanno i permessi per accedere a
1545 \item[\errcode{EPERM}] il processo non ha privilegi sufficienti ad
1546 abilitare il \textit{BSD accounting}.
1547 \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
1548 \item[\errcode{EUSERS}] non sono disponibili nel kernel strutture per il
1549 file o si è finita la memoria.
1551 ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
1552 \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
1553 \errval{ENOTDIR}, \errval{EROFS}.}
1556 La funzione attiva il salvataggio dei dati sul file indicato dal
1557 \textit{pathname} contenuti nella stringa puntata da \param{filename}; la
1558 funzione richiede che il processo abbia i privilegi di amministratore (è
1559 necessaria la \itindex{capabilities} capability \const{CAP\_SYS\_PACCT}, vedi
1560 sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \val{NULL} per
1561 \param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
1562 semplice esempio per l'uso di questa funzione è riportato nel programma
1563 \texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
1565 Quando si attiva la contabilità, il file che si indica deve esistere; esso
1566 verrà aperto in sola scrittura; le informazioni verranno registrate in
1567 \itindex{append~mode} \textit{append} in coda al file tutte le volte che un
1568 processo termina. Le informazioni vengono salvate in formato binario, e
1569 corrispondono al contenuto della apposita struttura dati definita all'interno
1572 Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
1573 parametro di sistema, modificabile attraverso \sysctlfile{kernel/acct}
1574 (o tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi,
1575 il primo indica la percentuale di spazio disco libero sopra il quale viene
1576 ripresa una registrazione che era stata sospesa per essere scesi sotto il
1577 minimo indicato dal secondo valore (sempre in percentuale di spazio disco
1578 libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
1579 essere controllata detta percentuale.
1582 \section{La gestione dei tempi del sistema}
1583 \label{sec:sys_time}
1585 In questa sezione, una volta introdotti i concetti base della gestione dei
1586 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
1587 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
1588 veri tempi di sistema associati ai processi, a quelle per convertire i vari
1589 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
1590 gestione di data e ora.
1593 \subsection{La misura del tempo in Unix}
1594 \label{sec:sys_unix_time}
1596 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
1597 dati per la misure dei tempi all'interno del sistema: essi sono
1598 rispettivamente chiamati \itindex{calendar~time} \textit{calendar time} e
1599 \itindex{process~time} \textit{process time}, secondo le definizioni:
1600 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1601 \item[\textit{calendar time}] \itindex{calendar~time} detto anche
1602 \textsl{tempo di calendario}. È il numero di secondi dalla mezzanotte del
1603 primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
1604 usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
1605 Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
1606 dato che l'UTC corrisponde all'ora locale di Greenwich. È il tempo su cui
1607 viene mantenuto l'orologio del kernel, e viene usato ad esempio per indicare
1608 le date di modifica dei file o quelle di avvio dei processi. Per memorizzare
1609 questo tempo è stato riservato il tipo primitivo \type{time\_t}.
1610 \item[\textit{process time}] \itindex{process~time} detto talvolta
1611 \textsl{tempo di processore}. Viene misurato in \itindex{clock~tick}
1612 \textit{clock tick}. Un tempo questo corrispondeva al numero di interruzioni
1613 effettuate dal timer di sistema, adesso lo standard POSIX richiede che esso
1614 sia pari al valore della costante \const{CLOCKS\_PER\_SEC}, che deve essere
1615 definita come 1000000, qualunque sia la risoluzione reale dell'orologio di
1616 sistema e la frequenza delle interruzioni del timer.\footnote{quest'ultima,
1617 come accennato in sez.~\ref{sec:proc_hierarchy}, è invece data dalla
1618 costante \const{HZ}.} Il dato primitivo usato per questo tempo è
1619 \type{clock\_t}, che ha quindi una risoluzione del microsecondo. Il numero
1620 di \itindex{clock~tick} \textit{tick} al secondo può essere ricavato anche
1621 attraverso \func{sysconf} (vedi sez.~\ref{sec:sys_limits}). Il vecchio
1622 simbolo \const{CLK\_TCK} definito in \headfile{time.h} è ormai considerato
1626 In genere si usa il \itindex{calendar~time} \textit{calendar time} per
1627 esprimere le date dei file e le informazioni analoghe che riguardano i
1628 cosiddetti \textsl{tempi di orologio}, che vengono usati ad esempio per i
1629 demoni che compiono lavori amministrativi ad ore definite, come \cmd{cron}.
1631 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
1632 tempo locale, utilizzando le opportune informazioni di localizzazione
1633 (specificate in \conffile{/etc/timezone}). E da tenere presente che questo
1634 tempo è mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
1635 dall'orologio hardware del calcolatore.
1637 Anche il \itindex{process~time} \textit{process time} di solito si esprime in
1638 secondi, ma fornisce una precisione ovviamente superiore al \textit{calendar
1639 time} (che è mantenuto dal sistema con una granularità di un secondo) e
1640 viene usato per tenere conto dei tempi di esecuzione dei processi. Per ciascun
1641 processo il kernel calcola tre tempi diversi:
1642 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1643 \item[\textit{clock time}] il tempo \textsl{reale} (viene chiamato anche
1644 \textit{wall clock time} o \textit{elapsed time}) passato dall'avvio del
1645 processo. Chiaramente tale tempo dipende anche dal carico del sistema e da
1646 quanti altri processi stavano girando nello stesso periodo.
1648 \item[\textit{user time}] il tempo effettivo che il processore ha impiegato
1649 nell'esecuzione delle istruzioni del processo in user space. È quello
1650 riportato nella risorsa \var{ru\_utime} di \struct{rusage} vista in
1651 sez.~\ref{sec:sys_resource_use}.
1653 \item[\textit{system time}] il tempo effettivo che il processore ha impiegato
1654 per eseguire codice delle system call nel kernel per conto del processo. È
1655 quello riportato nella risorsa \var{ru\_stime} di \struct{rusage} vista in
1656 sez.~\ref{sec:sys_resource_use}.
1659 In genere la somma di \textit{user time} e \textit{system time} indica il
1660 tempo di processore totale che il sistema ha effettivamente utilizzato per
1661 eseguire un certo processo, questo viene chiamato anche \textit{CPU time} o
1662 \textsl{tempo di CPU}. Si può ottenere un riassunto dei valori di questi tempi
1663 quando si esegue un qualsiasi programma lanciando quest'ultimo come argomento
1664 del comando \cmd{time}.
1668 \subsection{La gestione del \textit{process time}}
1669 \label{sec:sys_cpu_times}
1671 \itindbeg{process~time}
1673 Di norma tutte le operazioni del sistema fanno sempre riferimento al
1674 \itindex{calendar~time} \textit{calendar time}, l'uso del \textit{process
1675 time} è riservato a quei casi in cui serve conoscere i tempi di esecuzione
1676 di un processo (ad esempio per valutarne l'efficienza). In tal caso infatti
1677 fare ricorso al \textit{calendar time} è inutile in quanto il tempo può essere
1678 trascorso mentre un altro processo era in esecuzione o in attesa del risultato
1679 di una operazione di I/O.
1681 La funzione più semplice per leggere il \textit{process time} di un processo è
1682 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
1683 utilizzato dallo stesso; il suo prototipo è:
1684 \begin{prototype}{time.h}{clock\_t clock(void)}
1685 Legge il valore corrente del tempo di CPU.
1687 \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
1691 La funzione restituisce il tempo in \itindex{clock~tick} \texttt{clock tick},
1692 quindi se si vuole il tempo in secondi occorre dividere il risultato per la
1693 costante \const{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard
1694 ANSI C, POSIX richiede che \const{CLOCKS\_PER\_SEC} sia definito pari a
1695 1000000 indipendentemente dalla risoluzione del timer di sistema.} In genere
1696 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
1697 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
1698 riprenderà lo stesso valore iniziale.
1700 % TODO questi valori sono obsoleti, verificare il tutto.
1702 Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di CPU è la somma di
1703 altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
1704 quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
1705 possono essere letti attraverso la funzione \funcd{times}, il cui prototipo è:
1706 \begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
1707 Legge in \param{buf} il valore corrente dei tempi di processore.
1709 \bodydesc{La funzione ritorna il numero di \itindex{clock~tick}
1710 \textit{clock tick} dall'avvio del sistema in caso di successo e -1 in
1714 La funzione restituisce i valori di \textit{process time} del processo
1715 corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
1716 in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
1717 due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
1718 \textit{system time} del processo, così come definiti in
1719 sez.~\ref{sec:sys_unix_time}.
1721 \begin{figure}[!htb]
1724 \begin{minipage}[c]{\textwidth}
1725 \includestruct{listati/tms.h}
1728 \caption{La struttura \structd{tms} dei tempi di processore associati a un
1730 \label{fig:sys_tms_struct}
1733 Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
1734 time} ed del \textit{system time} di tutti i processi figli che sono
1735 terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
1736 \var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
1737 ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.
1739 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
1740 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
1741 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
1742 lo stato di terminazione di tutti i suoi figli, questi processi
1743 ``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi.
1745 \itindend{process~time}
1748 \subsection{Le funzioni per il \textit{calendar time}}
1749 \label{sec:sys_time_base}
1751 \itindbeg{calendar~time}
1753 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
1754 mantenuto dal kernel in una variabile di tipo \type{time\_t},\footnote{in
1755 realtà il kernel usa una rappresentazione interna di che fornisce una
1756 precisione molto maggiore, e consente per questo anche di usare
1757 rappresentazioni diverse del \textit{calendar time}.} che usualmente
1758 corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
1759 che di norma corrisponde a 32 bit). Il valore corrente del \textit{calendar
1760 time}, che indicheremo come \textsl{tempo di sistema}, può essere ottenuto
1761 con la funzione \funcd{time} che lo restituisce nel suddetto formato; il suo
1763 \begin{prototype}{time.h}{time\_t time(time\_t *t)}
1764 Legge il valore corrente del \textit{calendar time}.
1766 \bodydesc{La funzione ritorna il valore del \textit{calendar time} in caso
1767 di successo e -1 in caso di errore, che può essere solo \errval{EFAULT}.}
1769 \noindent dove \param{t}, se non nullo, deve essere l'indirizzo di una
1770 variabile su cui duplicare il valore di ritorno.
1772 Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
1773 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
1774 sia necessario; il suo prototipo è:
1775 \begin{prototype}{time.h}{int stime(time\_t *t)}
1776 Imposta a \param{t} il valore corrente del \textit{calendar time}.
1778 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1779 che può essere \errval{EFAULT} o \errval{EPERM}.}
1781 \noindent dato che modificare l'ora ha un impatto su tutto il sistema
1782 il cambiamento dell'orologio è una operazione privilegiata e questa funzione
1783 può essere usata solo da un processo con i privilegi di amministratore,
1784 altrimenti la chiamata fallirà con un errore di \errcode{EPERM}.
1786 Data la scarsa precisione nell'uso di \type{time\_t} (che ha una risoluzione
1787 massima di un secondo) quando si devono effettuare operazioni sui tempi di
1788 norma l'uso delle funzioni precedenti è sconsigliato, ed esse sono di solito
1789 sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le due
1790 funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
1791 \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
1792 in BSD4.3 sono indicate come sostitute delle precedenti.} i cui prototipi
1795 \headdecl{sys/time.h}
1798 \funcdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
1800 Legge il tempo corrente del sistema.
1802 \funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
1805 Imposta il tempo di sistema.
1807 \bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
1808 caso di errore, nel qual caso \var{errno} può assumere i valori
1809 \errval{EINVAL} \errval{EFAULT} e per \func{settimeofday} anche
1813 Si noti come queste funzioni utilizzino per indicare il tempo una struttura di
1814 tipo \struct{timeval}, la cui definizione si è già vista in
1815 fig.~\ref{fig:sys_timeval_struct}, questa infatti permette una espressione
1816 alternativa dei valori del \textit{calendar time}, con una precisione,
1817 rispetto a \type{time\_t}, fino al microsecondo.\footnote{la precisione è solo
1818 teorica, la precisione reale della misura del tempo dell'orologio di sistema
1819 non dipende dall'uso di queste strutture.}
1821 Come nel caso di \func{stime} anche \func{settimeofday} (la cosa continua a
1822 valere per qualunque funzione che vada a modificare l'orologio di sistema,
1823 quindi anche per quelle che tratteremo in seguito) può essere utilizzata solo
1824 da un processo coi privilegi di amministratore.\footnote{più precisamente la
1825 capabitity \const{CAP\_SYS\_TIME}.}
1827 Il secondo argomento di entrambe le funzioni è una struttura
1828 \struct{timezone}, che storicamente veniva utilizzata per specificare appunto
1829 la \textit{time zone}, cioè l'insieme del fuso orario e delle convenzioni per
1830 l'ora legale che permettevano il passaggio dal tempo universale all'ora
1831 locale. Questo argomento oggi è obsoleto ed in Linux non è mai stato
1832 utilizzato; esso non è supportato né dalle vecchie \textsl{libc5}, né dalle
1833 \textsl{glibc}: pertanto quando si chiama questa funzione deve essere sempre
1834 impostato a \val{NULL}.
1836 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
1837 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
1838 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
1839 conseguenze indesiderate. Ad esempio se si porta avanti l'orologio si possono
1840 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
1841 saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
1842 delle operazioni previste nell'intervallo di tempo che viene ripetuto.
1844 Per questo motivo la modalità più corretta per impostare l'ora è quella di
1845 usare la funzione \funcd{adjtime}, il cui prototipo è:
1846 \begin{prototype}{sys/time.h}
1847 {int adjtime(const struct timeval *delta, struct timeval *olddelta)}
1849 Aggiusta del valore \param{delta} l'orologio di sistema.
1851 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
1852 errore, nel qual caso \var{errno} assumerà il valore \errcode{EPERM}.}
1855 Questa funzione permette di avere un aggiustamento graduale del tempo di
1856 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
1857 di \param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
1858 positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
1859 il tempo richiesto, altrimenti sarà rallentato. Il secondo argomento viene
1860 usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
1864 \begin{figure}[!htb]
1865 \footnotesize \centering
1866 \begin{minipage}[c]{\textwidth}
1867 \includestruct{listati/timex.h}
1870 \caption{La struttura \structd{timex} per il controllo dell'orologio di
1872 \label{fig:sys_timex_struct}
1875 Linux poi prevede un'altra funzione, che consente un aggiustamento molto più
1876 dettagliato del tempo, permettendo ad esempio anche di modificare anche la
1877 velocità dell'orologio di sistema. La funzione è \funcd{adjtimex} ed il suo
1879 \begin{prototype}{sys/timex.h}
1880 {int adjtimex(struct timex *buf)}
1882 Aggiusta del valore \param{delta} l'orologio di sistema.
1884 \bodydesc{La funzione restituisce lo stato dell'orologio (un valore $>0$) in
1885 caso di successo e -1 in caso di errore, nel qual caso \var{errno}
1886 assumerà i valori \errval{EFAULT}, \errval{EINVAL} ed \errval{EPERM}.}
1889 La funzione richiede una struttura di tipo \struct{timex}, la cui definizione,
1890 così come effettuata in \headfile{sys/timex.h}, è riportata in
1891 fig.~\ref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore
1892 del campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
1893 specificato in un opportuno campo di \struct{timex}, deve essere impostato. Un
1894 valore nullo serve per leggere i parametri correnti; i valori diversi da zero
1895 devono essere specificati come OR binario delle costanti riportate in
1896 tab.~\ref{tab:sys_timex_mode}.
1898 La funzione utilizza il meccanismo di David L. Mills, descritto
1899 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
1900 protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
1901 portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
1902 \func{ntp\_adjtime}. La trattazione completa di questa funzione necessita di
1903 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
1904 a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
1905 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
1906 campi della struttura \struct{timex} può essere ritrovato in \cite{GlibcMan}.
1911 \begin{tabular}[c]{|l|c|p{8.5cm}|}
1913 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
1916 \const{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
1917 reale e l'orologio di sistema:
1918 deve essere indicata in microsecondi
1919 nel campo \var{offset} di
1921 \const{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenze in frequenza
1922 fra il tempo reale e l'orologio di
1923 sistema: deve essere indicata
1924 in parti per milione nel campo
1925 \var{frequency} di \struct{timex}.\\
1926 \const{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo
1928 sul tempo, espresso in microsecondi
1929 nel campo \var{maxerror} di
1931 \const{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
1932 sul tempo, espresso in microsecondi
1933 nel campo \var{esterror} di
1935 \const{ADJ\_STATUS} & 0x0010 & Imposta alcuni
1936 valori di stato interni usati dal
1937 sistema nella gestione
1938 dell'orologio specificati nel campo
1939 \var{status} di \struct{timex}.\\
1940 \const{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del
1941 PLL implementato dal kernel,
1942 specificato nel campo
1943 \var{constant} di \struct{timex}.\\
1944 \const{ADJ\_TICK} & 0x4000 & Imposta il valore dei \textit{tick}
1945 \itindex{clock~tick} del timer in
1946 microsecondi, espresso nel campo
1947 \var{tick} di \struct{timex}.\\
1948 \const{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Imposta uno spostamento una tantum
1949 dell'orologio secondo il valore del
1950 campo \var{offset} simulando il
1951 comportamento di \func{adjtime}.\\
1954 \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
1955 struttura \struct{timex}.}
1956 \label{tab:sys_timex_mode}
1959 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
1960 sintassi specificata per la forma equivalente di questa funzione definita come
1961 \func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
1967 \begin{tabular}[c]{|l|c|l|}
1969 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
1972 \const{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
1973 \const{TIME\_INS} & 1 & Insert leap second.\\
1974 \const{TIME\_DEL} & 2 & Delete leap second.\\
1975 \const{TIME\_OOP} & 3 & Leap second in progress.\\
1976 \const{TIME\_WAIT} & 4 & Leap second has occurred.\\
1977 \const{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
1980 \caption{Possibili valori di ritorno di \func{adjtimex}.}
1981 \label{tab:sys_adjtimex_return}
1984 La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
1985 sistema; questo può assumere i valori riportati in
1986 tab.~\ref{tab:sys_adjtimex_return}. Un valore di -1 viene usato per riportare
1987 un errore; al solito se si cercherà di modificare l'orologio di sistema
1988 (specificando un \var{mode} diverso da zero) senza avere i privilegi di
1989 amministratore si otterrà un errore di \errcode{EPERM}.
1993 \subsection{La gestione delle date.}
1994 \label{sec:sys_date}
1996 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
1997 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
1998 illustrate, se han senso per specificare un intervallo, non sono molto
1999 intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
2000 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2001 time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2002 time} usuale in ore, minuti, secondi, ecc.
2004 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
2005 definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
2006 struttura che si utilizza quando si deve specificare un tempo a partire dai
2007 dati naturali (ora e data), dato che essa consente anche di trattare la
2008 gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
2009 \var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste da BSD e dalle
2010 \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
2011 fig.~\ref{fig:sys_tm_struct}.}
2013 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2014 da quelle usate per convertire gli altri formati in questo, usando o meno
2015 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2016 tempo in una stringa contenente data ed ora, i loro prototipi sono:
2019 \funcdecl{char *\funcd{asctime}(const struct tm *tm)}
2020 Produce una stringa con data e ora partendo da un valore espresso in
2021 \textit{broken-down time}.
2023 \funcdecl{char *\funcd{ctime}(const time\_t *timep)}
2024 Produce una stringa con data e ora partendo da un valore espresso in
2025 in formato \type{time\_t}.
2027 \funcdecl{struct tm *\funcd{gmtime}(const time\_t *timep)}
2028 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2029 \textit{broken-down time} espresso in UTC.
2031 \funcdecl{struct tm *\funcd{localtime}(const time\_t *timep)}
2032 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2033 \textit{broken-down time} espresso nell'ora locale.
2035 \funcdecl{time\_t \funcd{mktime}(struct tm *tm)}
2036 Converte il \textit{broken-down time} in formato \type{time\_t}.
2038 \bodydesc{Tutte le funzioni restituiscono un puntatore al risultato in caso
2039 di successo e \val{NULL} in caso di errore, tranne che \func{mktime} che
2040 restituisce direttamente il valore o -1 in caso di errore.}
2043 \begin{figure}[!htb]
2044 \footnotesize \centering
2045 \begin{minipage}[c]{\textwidth}
2046 \includestruct{listati/tm.h}
2049 \caption{La struttura \structd{tm} per una rappresentazione del tempo in
2050 termini di ora, minuti, secondi, ecc.}
2051 \label{fig:sys_tm_struct}
2056 Le prime due funzioni, \func{asctime} e \func{ctime} servono per poter
2057 stampare in forma leggibile un tempo; esse restituiscono il puntatore ad una
2058 stringa, allocata staticamente, nella forma:
2060 "Wed Jun 30 21:49:08 1993\n"
2062 e impostano anche la variabile \var{tzname} con l'informazione della
2063 \textit{time zone} corrente; \func{ctime} è banalmente definita in termini di
2064 \func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
2065 statica rende le funzioni non \index{funzioni!rientranti} rientranti POSIX.1c
2066 e SUSv2 prevedono due sostitute \index{funzioni!rientranti} rientranti, il cui
2067 nome è al solito ottenuto aggiungendo un \code{\_r}, che prendono un secondo
2068 argomento \code{char *buf}, in cui l'utente deve specificare il buffer su cui
2069 la stringa deve essere copiata (deve essere di almeno 26 caratteri).
2071 Le altre tre funzioni, \func{gmtime}, \func{localtime} e \func{mktime} servono
2072 per convertire il tempo dal formato \type{time\_t} a quello di \struct{tm} e
2073 viceversa; \func{gmtime} effettua la conversione usando il tempo coordinato
2074 universale (UTC), cioè l'ora di Greenwich; mentre \func{localtime} usa l'ora
2075 locale; \func{mktime} esegue la conversione inversa.
2077 Anche in questo caso le prime due funzioni restituiscono l'indirizzo di una
2078 struttura allocata staticamente, per questo sono state definite anche altre
2079 due versioni \index{funzioni!rientranti} rientranti (con la solita estensione
2080 \code{\_r}), che prevedono un secondo argomento \code{struct tm *result},
2081 fornito dal chiamante, che deve preallocare la struttura su cui sarà
2082 restituita la conversione.
2084 Come mostrato in fig.~\ref{fig:sys_tm_struct} il \textit{broken-down time}
2085 permette di tenere conto anche della differenza fra tempo universale e ora
2086 locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
2087 \index{variabili!globali} variabili globali mostrate in
2088 fig.~\ref{fig:sys_tzname}, cui si accede quando si include
2089 \headfile{time.h}. Queste variabili vengono impostate quando si chiama una
2090 delle precedenti funzioni di conversione, oppure invocando direttamente la
2091 funzione \funcd{tzset}, il cui prototipo è:
2092 \begin{prototype}{sys/timex.h}
2095 Imposta le variabili globali della \textit{time zone}.
2097 \bodydesc{La funzione non ritorna niente e non dà errori.}
2100 La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire
2101 dal valore della variabile di ambiente \envvar{TZ}, se quest'ultima non è
2102 definita verrà usato il file \conffile{/etc/localtime}.
2104 \begin{figure}[!htb]
2107 \begin{minipage}[c]{\textwidth}
2108 \includestruct{listati/time_zone_var.c}
2111 \caption{Le \index{variabili!globali} variabili globali usate per la
2112 gestione delle \textit{time zone}.}
2113 \label{fig:sys_tzname}
2116 La variabile \var{tzname} contiene due stringhe, che indicano i due nomi
2117 standard della \textit{time zone} corrente. La prima è il nome per l'ora
2118 solare, la seconda per l'ora legale.\footnote{anche se sono indicati come
2119 \code{char *} non è il caso di modificare queste stringhe.} La variabile
2120 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2121 \var{daylight} indica se è attiva o meno l'ora legale.
2123 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2124 stampare un tempo o una data, la flessibilità non fa parte delle sue
2125 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2126 giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
2128 \begin{prototype}{time.h}
2129 {size\_t strftime(char *s, size\_t max, const char *format,
2130 const struct tm *tm)}
2132 Stampa il tempo \param{tm} nella stringa \param{s} secondo il formato
2135 \bodydesc{La funzione ritorna il numero di caratteri stampati in \param{s},
2136 altrimenti restituisce 0.}
2139 La funzione converte opportunamente il tempo \param{tm} in una stringa di
2140 testo da salvare in \param{s}, purché essa sia di dimensione, indicata da
2141 \param{size}, sufficiente. I caratteri generati dalla funzione vengono
2142 restituiti come valore di ritorno, ma non tengono conto del terminatore
2143 finale, che invece viene considerato nel computo della dimensione; se
2144 quest'ultima è eccessiva viene restituito 0 e lo stato di \param{s} è
2150 \begin{tabular}[c]{|c|l|p{6cm}|}
2152 \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2155 \var{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
2156 \var{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
2157 \var{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
2158 \var{\%B}&\texttt{April} & Nome del mese, completo.\\
2159 \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
2160 \var{\%d}&\texttt{24} & Giorno del mese.\\
2161 \var{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
2162 \var{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
2163 \var{\%j}&\texttt{114} & Giorno dell'anno.\\
2164 \var{\%m}&\texttt{04} & Mese dell'anno.\\
2165 \var{\%M}&\texttt{40} & Minuto.\\
2166 \var{\%p}&\texttt{PM} & AM/PM.\\
2167 \var{\%S}&\texttt{50} & Secondo.\\
2168 \var{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
2170 \var{\%w}&\texttt{3} & Giorno della settimana. \\
2171 \var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
2173 \var{\%x}&\texttt{04/24/02} & La data.\\
2174 \var{\%X}&\texttt{18:40:50} & L'ora.\\
2175 \var{\%y}&\texttt{02} & Anno nel secolo.\\
2176 \var{\%Y}&\texttt{2002} & Anno.\\
2177 \var{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
2178 \var{\%\%}&\texttt{\%} & Il carattere \%.\\
2181 \caption{Valori previsti dallo standard ANSI C per modificatore della
2182 stringa di formato di \func{strftime}.}
2183 \label{tab:sys_strftime_format}
2186 Il risultato della funzione è controllato dalla stringa di formato
2187 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2188 viene utilizzato come modificatore; alcuni\footnote{per la precisione quelli
2189 definiti dallo standard ANSI C, che sono anche quelli riportati da POSIX.1;
2190 le \acr{glibc} provvedono tutte le estensioni introdotte da POSIX.2 per il
2191 comando \cmd{date}, i valori introdotti da SVID3 e ulteriori estensioni GNU;
2192 l'elenco completo dei possibili valori è riportato nella pagina di manuale
2193 della funzione.} dei possibili valori che esso può assumere sono riportati
2194 in tab.~\ref{tab:sys_strftime_format}. La funzione tiene conto anche della
2195 presenza di una localizzazione per stampare in maniera adeguata i vari nomi.
2197 \itindend{calendar~time}
2200 \section{La gestione degli errori}
2201 \label{sec:sys_errors}
2203 In questa sezione esamineremo le caratteristiche principali della gestione
2204 degli errori in un sistema unix-like. Infatti a parte il caso particolare di
2205 alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
2206 unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
2207 un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
2208 semplicemente usando un opportuno valore di ritorno della funzione invocata.
2209 Inoltre il sistema di classificazione degli errori è basato sull'architettura
2210 a processi, e presenta una serie di problemi nel caso lo si debba usare con i
2211 \itindex{thread} \textit{thread}.
2214 \subsection{La variabile \var{errno}}
2215 \label{sec:sys_errno}
2217 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2218 riportare condizioni di errore, ed è una norma fondamentale di buona
2219 programmazione controllare \textbf{sempre} che le funzioni chiamate si siano
2220 concluse correttamente.
2222 In genere le funzioni di libreria usano un valore speciale per indicare che
2223 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
2224 costante \val{EOF} (a seconda della funzione); ma questo valore segnala solo
2225 che c'è stato un errore, non il tipo di errore.
2227 Per riportare il tipo di errore il sistema usa \index{variabili!globali} la
2228 variabile globale \var{errno},\footnote{l'uso di una variabile globale può
2229 comportare alcuni problemi (ad esempio nel caso dei \itindex{thread}
2230 \textit{thread}) ma lo standard ISO C consente anche di definire \var{errno}
2231 come un \textit{modifiable lvalue}, quindi si può anche usare una macro, e
2232 questo è infatti il modo usato da Linux per renderla locale ai singoli
2233 \itindex{thread} \textit{thread}.} definita nell'header \headfile{errno.h};
2234 la variabile è in genere definita come \direct{volatile} dato che può essere
2235 cambiata in modo asincrono da un segnale (si veda sez.~\ref{sec:sig_sigchld}
2236 per un esempio, ricordando quanto trattato in sez.~\ref{sec:proc_race_cond}),
2237 ma dato che un gestore di segnale scritto bene salva e ripristina il valore
2238 della variabile, di questo non è necessario preoccuparsi nella programmazione
2241 I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
2242 nell'header \headfile{errno.h} sono anche definiti i nomi simbolici per le
2243 costanti numeriche che identificano i vari errori; essi iniziano tutti per
2244 \val{E} e si possono considerare come nomi riservati. In seguito faremo sempre
2245 riferimento a tali valori, quando descriveremo i possibili errori restituiti
2246 dalle funzioni. Il programma di esempio \cmd{errcode} stampa il codice
2247 relativo ad un valore numerico con l'opzione \cmd{-l}.
2249 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
2250 programma, gran parte delle funzioni di libreria impostano \var{errno} ad un
2251 valore diverso da zero in caso di errore. Il valore è invece indefinito in
2252 caso di successo, perché anche se una funzione ha successo, può chiamarne
2253 altre al suo interno che falliscono, modificando così \var{errno}.
2255 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
2256 essere il risultato di un errore precedente) e non lo si può usare per
2257 determinare quando o se una chiamata a funzione è fallita. La procedura da
2258 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
2259 verificato il fallimento della funzione attraverso il suo codice di ritorno.
2262 \subsection{Le funzioni \func{strerror} e \func{perror}}
2263 \label{sec:sys_strerror}
2265 Benché gli errori siano identificati univocamente dal valore numerico di
2266 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
2267 riportare in opportuni messaggi le condizioni di errore verificatesi. La
2268 prima funzione che si può usare per ricavare i messaggi di errore è
2269 \funcd{strerror}, il cui prototipo è:
2270 \begin{prototype}{string.h}{char *strerror(int errnum)}
2271 Restituisce una stringa con il messaggio di errore relativo ad
2274 \bodydesc{La funzione ritorna il puntatore ad una stringa di errore.}
2278 La funzione ritorna il puntatore alla stringa contenente il messaggio di
2279 errore corrispondente al valore di \param{errnum}, se questo non è un valore
2280 valido verrà comunque restituita una stringa valida contenente un messaggio
2281 che dice che l'errore è sconosciuto, e \var{errno} verrà modificata assumendo
2282 il valore \errval{EINVAL}.
2284 In generale \func{strerror} viene usata passando \var{errno} come argomento,
2285 ed il valore di quest'ultima non verrà modificato. La funzione inoltre tiene
2286 conto del valore della variabile di ambiente \envvar{LC\_MESSAGES} per usare
2287 le appropriate traduzioni dei messaggi d'errore nella localizzazione presente.
2289 La funzione utilizza una stringa statica che non deve essere modificata dal
2290 programma; essa è utilizzabile solo fino ad una chiamata successiva a
2291 \func{strerror} o \func{perror}, nessun'altra funzione di libreria tocca
2292 questa stringa. In ogni caso l'uso di una stringa statica rende la funzione
2293 non \index{funzioni!rientranti} rientrante, per cui nel caso si usino i
2294 \itindex{thread} \textit{thread} le librerie forniscono\footnote{questa
2295 funzione è la versione prevista dalle \acr{glibc}, ed effettivamente
2296 definita in \headfile{string.h}, ne esiste una analoga nello standard SUSv3
2297 (quella riportata dalla pagina di manuale), che restituisce \code{int} al
2298 posto di \code{char *}, e che tronca la stringa restituita a
2299 \param{size}.} una apposita versione \index{funzioni!rientranti} rientrante
2300 \funcd{strerror\_r}, il cui prototipo è:
2301 \begin{prototype}{string.h}
2302 {char * strerror\_r(int errnum, char *buf, size\_t size)}
2304 Restituisce una stringa con il messaggio di errore relativo ad
2307 \bodydesc{La funzione restituisce l'indirizzo del messaggio in caso di
2308 successo e \val{NULL} in caso di errore; nel qual caso \var{errno}
2311 \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
2313 \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
2314 contenere la stringa di errore.
2319 La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
2320 nel buffer \param{buf} che il singolo \itindex{thread} \textit{thread} deve
2321 allocare autonomamente per evitare i problemi connessi alla condivisione del
2322 buffer statico. Il messaggio è copiato fino alla dimensione massima del
2323 buffer, specificata dall'argomento
2324 \param{size}, che deve comprendere pure il carattere di terminazione;
2325 altrimenti la stringa viene troncata.
2327 Una seconda funzione usata per riportare i codici di errore in maniera
2328 automatizzata sullo standard error è \funcd{perror}, il cui prototipo è:
2329 \begin{prototype}{stdio.h}{void perror(const char *message)}
2330 Stampa il messaggio di errore relativo al valore corrente di \var{errno}
2331 sullo standard error; preceduto dalla stringa \param{message}.
2334 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
2335 in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
2336 riferiscono all'ultimo errore avvenuto. La stringa specificata con
2337 \param{message} viene stampato prima del messaggio d'errore, seguita dai due
2338 punti e da uno spazio, il messaggio è terminato con un a capo.
2340 Il messaggio può essere riportato anche usando le due
2341 \index{variabili!globali} variabili globali:
2342 \includecodesnip{listati/errlist.c}
2343 dichiarate in \headfile{errno.h}. La prima contiene i puntatori alle stringhe
2344 di errore indicizzati da \var{errno}; la seconda esprime il valore più alto
2345 per un codice di errore, l'utilizzo di questa stringa è sostanzialmente
2346 equivalente a quello di \func{strerror}.
2348 \begin{figure}[!htbp]
2349 \footnotesize \centering
2350 \begin{minipage}[c]{\codesamplewidth}
2351 \includecodesample{listati/errcode_mess.c}
2354 \caption{Codice per la stampa del messaggio di errore standard.}
2355 \label{fig:sys_err_mess}
2358 In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
2359 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
2360 errore e le costanti usate per identificare i singoli errori; il sorgente
2361 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
2362 gestione delle opzioni e tutte le definizioni necessarie ad associare il
2363 valore numerico alla costante simbolica. In particolare si è riportata la
2364 sezione che converte la stringa passata come argomento in un intero
2365 (\texttt{\small 1--2}), controllando con i valori di ritorno di \funcm{strtol}
2366 che la conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi
2367 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
2368 11--14}) o la macro (\texttt{\small 15--17}) associate a quel codice.
2372 \subsection{Alcune estensioni GNU}
2373 \label{sec:sys_err_GNU}
2375 Le precedenti funzioni sono quelle definite ed usate nei vari standard; le
2376 \acr{glibc} hanno però introdotto una serie di estensioni ``GNU'' che
2377 forniscono alcune funzionalità aggiuntive per una gestione degli errori
2378 semplificata e più efficiente.
2380 La prima estensione consiste in due variabili, \code{char *
2381 program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
2382 servono per ricavare il nome del programma; queste sono utili quando si deve
2383 aggiungere il nome del programma (cosa comune quando si ha un programma che
2384 non viene lanciato da linea di comando e salva gli errori in un file di log)
2385 al messaggio d'errore. La prima contiene il nome usato per lanciare il
2386 programma (ed è equivalente ad \code{argv[0]}); la seconda mantiene solo il
2387 nome del programma (senza eventuali directory in testa).
2389 Uno dei problemi che si hanno con l'uso di \func{perror} è che non c'è
2390 flessibilità su quello che si può aggiungere al messaggio di errore, che può
2391 essere solo una stringa. In molte occasioni invece serve poter scrivere dei
2392 messaggi con maggiore informazione; ad esempio negli standard di
2393 programmazione GNU si richiede che ogni messaggio di errore sia preceduto dal
2394 nome del programma, ed in generale si può voler stampare il contenuto di
2395 qualche variabile; per questo le \acr{glibc} definiscono la funzione
2396 \funcd{error}, il cui prototipo è:
2397 \begin{prototype}{stdio.h}
2398 {void error(int status, int errnum, const char *format, ...)}
2400 Stampa un messaggio di errore formattato.
2402 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2405 La funzione fa parte delle estensioni GNU per la gestione degli errori,
2406 l'argomento \param{format} prende la stessa sintassi di \func{printf}, ed i
2407 relativi argomenti devono essere forniti allo stesso modo, mentre
2408 \param{errnum} indica l'errore che si vuole segnalare (non viene quindi usato
2409 il valore corrente di \var{errno}); la funzione stampa sullo standard error il
2410 nome del programma, come indicato dalla \index{variabili!globali} variabile
2411 globale \var{program\_name}, seguito da due punti ed uno spazio, poi dalla
2413 \param{format} e dagli argomenti seguenti, seguita da due punti ed uno spazio
2414 infine il messaggio di errore relativo ad \param{errnum}, il tutto è terminato
2417 Il comportamento della funzione può essere ulteriormente controllato se si
2418 definisce una variabile \var{error\_print\_progname} come puntatore ad una
2419 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
2420 il nome del programma.
2422 L'argomento \param{status} può essere usato per terminare direttamente il
2423 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
2424 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
2425 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
2426 un'altra \index{variabili!globali} variabile globale,
2427 \var{error\_message\_count}, che tiene conto di quanti errori ci sono stati.
2429 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
2430 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
2431 l'errore è \funcd{error\_at\_line}; il suo prototipo è:
2432 \begin{prototype}{stdio.h}
2433 {void error\_at\_line(int status, int errnum, const char *fname,
2434 unsigned int lineno, const char *format, ...)}
2436 Stampa un messaggio di errore formattato.
2438 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2440 \noindent ed il suo comportamento è identico a quello di \func{error} se non
2441 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
2442 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
2443 stampa del nome del programma. Inoltre essa usa un'altra
2444 \index{variabili!globali} variabile globale, \var{error\_one\_per\_line}, che
2445 impostata ad un valore diverso da zero fa si che errori relativi alla stessa
2446 linea non vengano ripetuti.
2449 % LocalWords: filesystem like kernel saved header limits sysconf sez tab float
2450 % LocalWords: FOPEN stdio MB LEN CHAR char UCHAR unsigned SCHAR MIN signed INT
2451 % LocalWords: SHRT short USHRT int UINT LONG long ULONG LLONG ULLONG POSIX ARG
2452 % LocalWords: Stevens exec CHILD STREAM stream TZNAME timezone NGROUPS SSIZE
2453 % LocalWords: ssize LISTIO JOB CONTROL job control IDS VERSION YYYYMML bits bc
2454 % LocalWords: dall'header posix lim nell'header glibc run unistd name errno
2455 % LocalWords: NGROUP CLK TCK clock tick process PATH pathname BUF CANON path
2456 % LocalWords: pathconf fpathconf descriptor fd uname sys struct utsname info
2457 % LocalWords: EFAULT fig SOURCE NUL LENGTH DOMAIN NMLN UTSLEN system call proc
2458 % LocalWords: domainname sysctl BSD nlen void oldval size oldlenp newval EPERM
2459 % LocalWords: newlen ENOTDIR EINVAL ENOMEM linux array oldvalue paging stack
2460 % LocalWords: TCP shell Documentation ostype hostname osrelease version mount
2461 % LocalWords: const source filesystemtype mountflags ENODEV ENOTBLK block read
2462 % LocalWords: device EBUSY only EACCES NODEV ENXIO major
2463 % LocalWords: number EMFILE dummy ENAMETOOLONG ENOENT ELOOP virtual devfs MGC
2464 % LocalWords: magic MSK RDONLY NOSUID suid sgid NOEXEC SYNCHRONOUS REMOUNT MNT
2465 % LocalWords: MANDLOCK mandatory locking WRITE APPEND append IMMUTABLE NOATIME
2466 % LocalWords: access NODIRATIME BIND MOVE umount flags FORCE statfs fstatfs ut
2467 % LocalWords: buf ENOSYS EIO EBADF type fstab mntent home shadow username uid
2468 % LocalWords: passwd PAM Pluggable Authentication Method Service Switch pwd ru
2469 % LocalWords: getpwuid getpwnam NULL buflen result ERANGE getgrnam getgrgid AS
2470 % LocalWords: grp group gid SVID fgetpwent putpwent getpwent setpwent endpwent
2471 % LocalWords: fgetgrent putgrent getgrent setgrent endgrent accounting init HZ
2472 % LocalWords: runlevel Hierarchy logout setutent endutent utmpname utmp paths
2473 % LocalWords: WTMP getutent getutid getutline pututline LVL OLD DEAD EMPTY dev
2474 % LocalWords: line libc XPG utmpx getutxent getutxid getutxline pututxline who
2475 % LocalWords: setutxent endutxent wmtp updwtmp logwtmp wtmp host rusage utime
2476 % LocalWords: minflt majflt nswap fault swap timeval wait getrusage usage SELF
2477 % LocalWords: CHILDREN current limit soft RLIMIT address brk mremap mmap dump
2478 % LocalWords: SIGSEGV SIGXCPU SIGKILL sbrk FSIZE SIGXFSZ EFBIG LOCKS lock dup
2479 % LocalWords: MEMLOCK NOFILE NPROC fork EAGAIN SIGPENDING sigqueue kill RSS tv
2480 % LocalWords: resource getrlimit setrlimit rlimit rlim INFINITY capabilities
2481 % LocalWords: capability CAP l'I Sun Sparc PAGESIZE getpagesize SVr SUSv get
2482 % LocalWords: phys pages avphys NPROCESSORS CONF ONLN getloadavg stdlib double
2483 % LocalWords: loadavg nelem scheduler CONFIG ACCT acct filename EUSER
2484 % LocalWords: ENFILE EROFS PACCT AcctCtrl cap calendar UTC Jan the Epoch GMT
2485 % LocalWords: Greenwich Mean l'UTC timer CLOCKS SEC cron wall elapsed times tz
2486 % LocalWords: tms cutime cstime waitpid gettimeofday settimeofday timex
2487 % LocalWords: timespec adjtime olddelta adjtimex David Mills RFC NTP ntp
2488 % LocalWords: nell'RFC ADJ FREQUENCY frequency MAXERROR maxerror ESTERROR PLL
2489 % LocalWords: esterror TIMECONST constant SINGLESHOT MOD INS insert leap OOP
2490 % LocalWords: second delete progress has occurred BAD broken tm gmtoff asctime
2491 % LocalWords: ctime timep gmtime localtime mktime tzname tzset daylight format
2492 % LocalWords: strftime thread EOF modifiable lvalue app errcode strerror LC at
2493 % LocalWords: perror string errnum MESSAGES error message ErrCode strtol log
2494 % LocalWords: program invocation argv printf print progname exit count fname
2495 % LocalWords: lineno one standardese Di page Wed Wednesday Apr April PM AM
2499 %%% Local Variables:
2501 %%% TeX-master: "gapil"