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
546 \index{file!filesystem~\texttt {/proc}!definizione|(}
548 Dato che fin dall'inizio i parametri erano organizzati in una struttura
549 albero, è parso naturale rimappare questa organizzazione utilizzando il
550 filesystem \file{/proc}. Questo è un filesystem completamente virtuale, il cui
551 contenuto è generato direttamente dal kernel, che non fa riferimento a nessun
552 dispositivo fisico, ma presenta in forma di file e directory i dati di alcune
553 delle strutture interne del kernel stesso. Il suo utilizzo principale, come
554 denuncia il nome stesso, è quello di fornire una interfaccia per ottenere i
555 dati relativi ai processi (venne introdotto a questo scopo su BSD), ma nel
556 corso del tempo il suo uso è stato ampliato.
558 All'interno di questo filesystem sono pertanto presenti una serie di file che
559 riflettono il contenuto dei parametri del kernel (molti dei quali accessibili
560 in sola lettura) e in altrettante directory, nominate secondo il relativo
561 \ids{PID}, vengono mantenute le informazioni relative a ciascun processo
564 In particolare l'albero dei valori dei parametri di sistema impostabili con
565 \func{sysctl} viene presentato in forma di una gerarchia di file e directory a
566 partire dalla directory \file{/proc/sys}, cosicché è possibile accedere al
567 valore di un parametro del kernel tramite il \textit{pathname} ad un file
568 sotto \file{/proc/sys} semplicemente leggendone il contenuto, così come si può
569 modificare un parametro scrivendo sul file ad esso corrispondente.
571 Il kernel si occupa di generare al volo il contenuto ed i nomi dei file
572 corrispondenti ai vari parametri che sono presenti, e questo ha il grande
573 vantaggio di rendere accessibili gli stessi ad un qualunque comando di shell e
574 di permettere la navigazione dell'albero in modo da riconoscere quali
575 parametri sono presenti senza dover cercare un valore all'interno di una
578 Inizialmente l'uso del filesystem \file{/proc} serviva soltanto a replicare
579 l'accesso, con altrettante corrispondenze ai file presenti in
580 \file{/proc/sys}, ai parametri impostabili tradizionalmente con \func{sysctl},
581 ma vista la assoluta naturalità dell'interfaccia, e la sua maggiore
582 efficienza, nelle versioni più recenti del kernel questa è diventata la
583 modalità canonica per modificare i parametri del kernel, evitando di dover
584 ricorrere all'uso di una \textit{system call} specifica che pur essendo ancora
585 presente, prima o poi verrà eliminata.
587 Nonostante la semplificazione nella gestione ottenuta con l'uso di
588 \file{/proc/sys} resta il problema generale di conoscere il significato di
589 ciascuno degli innumerevoli parametri che vi si trovano. Purtroppo la
590 documentazione degli stessi spesso risulta incompleta e non aggiornata, ma
591 buona parte di quelli può importanti sono descritti dalla documentazione
592 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
594 Ma oltre alle informazioni che sostituiscono quelle ottenibili dalla ormai
595 deprecata \func{sysctl} dentro \file{/proc} sono disponibili moltissime altre
596 informazioni, fra cui ad esempio anche quelle fornite dalla funzione di
597 sistema \funcd{uname},\footnote{con Linux ci sono in realtà 3 \textit{system
598 call} diverse per le dimensioni delle stringhe restituite, le prime due
599 usano rispettivamente delle lunghezze di 9 e 65 byte, la terza usa anch'essa
600 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con una
601 lunghezza di 257 byte, la \acr{glibc} provvede a mascherare questi dettagli
602 usando la versione più recente disponibile.} il cui prototipo è:
605 \fhead{sys/utsname.h}
606 \fdecl{int uname(struct utsname *info)}
607 \fdesc{Restituisce informazioni generali sul sistema.}
610 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
611 caso \var{errno} può assumere solo il valore \errval{EFAULT}.}
614 La funzione, che viene usata dal comando \cmd{uname}, restituisce una serie di
615 informazioni relative al sistema nelle stringhe che costituiscono i campi
616 della struttura \struct{utsname} (la cui definizione è riportata in
617 fig.~\ref{fig:sys_utsname}) che viene scritta nel buffer puntato
618 dall'argomento \param{info}.
620 \begin{figure}[!ht!b]
621 \footnotesize \centering
622 \begin{minipage}[c]{0.8\textwidth}
623 \includestruct{listati/ustname.h}
626 \caption{La struttura \structd{utsname}.}
627 \label{fig:sys_utsname}
630 Si noti come in fig.~\ref{fig:sys_utsname} le dimensioni delle stringhe di
631 \struct{utsname} non sono specificate. Il manuale delle \acr{glibc} indica
632 due costanti per queste dimensioni, \const{\_UTSNAME\_LENGTH} per i campi
633 standard e \const{\_UTSNAME\_DOMAIN\_LENGTH} per quello relativo al nome di
634 dominio, altri sistemi usano nomi diversi come \const{SYS\_NMLN} o
635 \const{\_SYS\_NMLN} o \const{UTSLEN} che possono avere valori diversi. Dato
636 che il buffer per \struct{utsname} deve essere preallocato l'unico modo per
637 farlo in maniera sicura è allora usare come dimensione il valore ottenuto con
638 \code{sizeof(utsname)}.
640 Le informazioni vengono restituite in ciascuno dei singoli campi di
641 \struct{utsname} in forma di stringhe terminate dal carattere NUL. In
642 particolare dette informazioni sono:
644 \item il nome del sistema operativo;
645 \item il nome della macchine (l'\textit{hostname});
646 \item il nome della release del kernel;
647 \item il nome della versione del kernel;
648 \item il tipo di hardware della macchina;
649 \item il nome del domino (il \textit{domainname});
651 ma l'ultima di queste informazioni è stata aggiunta di recente e non è
652 prevista dallo standard POSIX, per questo essa è accessibile, come mostrato in
653 fig.~\ref{fig:sys_utsname}, solo se si è definita la macro
654 \macro{\_GNU\_SOURCE}.
656 Come accennato queste stesse informazioni, anche se a differenza di
657 \func{sysctl} la funzione continua ad essere mantenuta, si possono ottenere
658 direttamente tramite il filesystem \file{/proc}, esse infatti sono mantenute
659 rispettivamente nei file \sysctlrelfile{kernel}{ostype},
660 \sysctlrelfile{kernel}{hostname}, \sysctlrelfile{kernel}{osrelease},
661 \sysctlrelfile{kernel}{version} e \sysctlrelfile{kernel}{domainname} che si
662 trovano sotto la directory \file{/proc/sys/kernel/}.
664 \index{file!filesystem~\texttt {/proc}!definizione|)}
668 \section{La gestione del sistema}
669 \label{sec:sys_management}
671 In questa sezione prenderemo in esame le interfacce di programmazione messe a
672 disposizione per affrontare una serie di tematiche attinenti la gestione
673 generale del sistema come quelle relative alla gestione di utenti e gruppi, al
674 trattamento delle informazioni relative ai collegamenti al sistema, alle
675 modalità per effettuare lo spegnimento o il riavvio di una macchina.
678 \subsection{La gestione delle informazioni su utenti e gruppi}
679 \label{sec:sys_user_group}
681 Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
682 (password, corrispondenze fra nomi simbolici e \ids{UID} numerici, home
683 directory, ecc.) venivano registrate all'interno dei due file di testo
684 \conffile{/etc/passwd} ed \conffile{/etc/group}, il cui formato è descritto
685 dalle relative pagine del manuale\footnote{nella quinta sezione, quella dei
686 file di configurazione (esistono comandi corrispondenti), una trattazione
687 sistemistica dell'intero argomento coperto in questa sezione si consulti
688 sez.~4.3 di \cite{AGL}.} e tutte le funzioni che richiedevano l'accesso a
689 queste informazione andavano a leggere direttamente il contenuto di questi
692 In realtà oltre a questi due file da molto tempo gran parte dei sistemi
693 unix-like usano il cosiddetto sistema delle \textit{shadow password} che
694 prevede anche i due file \conffile{/etc/shadow} e \conffile{/etc/gshadow}, in
695 cui sono state spostate le informazioni di autenticazione (ed inserite alcune
696 estensioni di gestione avanzata) per toglierle dagli altri file che devono
697 poter essere letti da qualunque processo per poter effettuare l'associazione
698 fra username e \ids{UID}.
700 Col tempo però questa impostazione ha incominciato a mostrare dei limiti. Da
701 una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
702 la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
703 che sta per \textit{Pluggable Authentication Method}) che fornisce una
704 interfaccia comune per i processi di autenticazione, svincolando completamente
705 le singole applicazioni dai dettagli del come questa viene eseguita e di dove
706 vengono mantenuti i dati relativi. Si tratta di un sistema modulare, in cui è
707 possibile utilizzare anche più meccanismi insieme, diventa così possibile
708 avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
709 diversi formati per le password e diversi supporti per le informazioni. Il
710 tutto avviene in maniera trasparente per le applicazioni purché per ciascun
711 meccanismo si disponga della opportuna libreria che implementa l'interfaccia
714 Dall'altra parte, il diffondersi delle reti e la necessità di centralizzare le
715 informazioni degli utenti e dei gruppi per insiemi di macchine e servizi
716 all'interno di una stessa organizzazione, in modo da mantenere coerenti i
717 dati, ha portato anche alla necessità di poter recuperare e memorizzare dette
718 informazioni su supporti diversi dai file citati, introducendo il sistema del
719 \itindex{Name~Service~Switch~(NSS)} \textit{Name Service Switch} che
720 tratteremo brevemente più avanti (in sez.~\ref{sec:sock_resolver}) dato che la
721 sua applicazione è cruciale nella procedura di risoluzione di nomi di rete.
723 In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
724 per la lettura delle informazioni relative a utenti e gruppi tralasciando
725 completamente quelle relative all'autenticazione.
726 % Per questo non tratteremo
727 % affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
728 % \textit{Name Service Switch}, un meccanismo messo a disposizione dalle
729 % \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
730 % necessario trovare una corrispondenza fra un nome ed un numero (od altra
731 % informazione) ad esso associato, come appunto, quella fra uno username ed un
732 % \ids{UID} o fra un \ids{GID} ed il nome del gruppo corrispondente.
733 Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
734 queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
735 Service Switch}, per cui sono in grado di ricevere informazioni qualunque
736 sia il supporto su cui esse vengono mantenute. Per leggere le informazioni
737 relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
738 \funcd{getpwnam}, i cui prototipi sono:
743 \fdecl{struct passwd *getpwuid(uid\_t uid)}
744 \fdecl{struct passwd *getpwnam(const char *name)}
745 \fdesc{Restituiscono le informazioni relative all'utente specificato.}
748 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
749 in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
750 utente corrispondente a quanto specificato, nel qual caso \var{errno}
751 assumerà il valore riportato dalle funzioni sottostanti.}
754 Le due funzioni forniscono le informazioni memorizzate nel registro degli
755 utenti (che nelle versioni più recenti per la parte di credenziali di
756 autenticazione vengono ottenute attraverso PAM) relative all'utente
757 specificato attraverso il suo \ids{UID} o il nome di login. Entrambe le
758 funzioni restituiscono un puntatore ad una struttura di tipo \struct{passwd}
759 la cui definizione (anch'essa eseguita in \headfile{pwd.h}) è riportata in
760 fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente illustrato il
761 significato dei vari campi.
766 \begin{minipage}[c]{0.8\textwidth}
767 \includestruct{listati/passwd.h}
770 \caption{La struttura \structd{passwd} contenente le informazioni relative
771 ad un utente del sistema.}
772 \label{fig:sys_passwd_struct}
775 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
776 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
777 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
778 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
779 essere \index{funzioni!rientranti} rientranti; per questo motivo ne esistono
780 anche due versioni alternative (denotate dalla solita estensione \code{\_r}),
781 i cui prototipi sono:
786 \fdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
787 char *buffer, size\_t buflen, struct passwd **result)}
788 \fdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
789 *password, char *buffer, size\_t buflen, struct passwd **result)}
790 \fdesc{Restituiscono le informazioni relative all'utente specificato.}
793 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
794 caso \var{errno} assumerà il valore riportato dalle funzioni sottostanti.}
797 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
798 la memoria necessaria a contenere le informazioni. In particolare i valori
799 della struttura \struct{passwd} saranno restituiti all'indirizzo
800 \param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
801 un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
802 puntate dai campi di \param{password}. Infine all'indirizzo puntato da
803 \param{result} viene restituito il puntatore ai dati ottenuti, cioè
804 \param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti. Qualora i
805 dati non possano essere contenuti nei byte specificati da \param{buflen}, la
806 funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
807 impostato a \val{NULL}).
809 Sia queste versioni rientranti che precedenti gli errori eventualmente
810 riportati in \var{errno} in caso di fallimento dipendono dalla sottostanti
811 funzioni di sistema usate per ricavare le informazioni (si veda quanto
812 illustrato in sez.~\ref{sec:sys_errno}) per cui se lo si vuole utilizzare è
813 opportuno inizializzarlo a zero prima di invocare le funzioni per essere
814 sicuri di non avere un residuo di errore da una chiamata precedente. Il non
815 aver trovato l'utente richiesto infatti può essere dovuto a diversi motivi (a
816 partire dal fatto che non esista) per cui si possono ottenere i valori di
817 errore più vari a seconda dei casi.
819 Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
820 \funcd{getgrgid} che permettono di leggere le informazioni relative ai gruppi,
821 i loro prototipi sono:
826 \fdecl{struct group *getgrgid(gid\_t gid)}
827 \fdecl{struct group *getgrnam(const char *name)}
828 \fdesc{Restituiscono le informazioni relative al gruppo specificato.}
831 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
832 in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
833 utente corrispondente a quanto specificato, nel qual caso \var{errno}
834 assumerà il valore riportato dalle funzioni sottostanti.}
837 Come per le precedenti per gli utenti esistono anche le analoghe versioni
838 \index{funzioni!rientranti} rientranti che di nuovo utilizzano la stessa
839 estensione \code{\_r}; i loro prototipi sono:
844 \fdecl{int getgrgid\_r(gid\_t gid, struct group *grp, char *buf,
845 size\_t buflen, struct group **result)}
846 \fdecl{int getgrnam\_r(const char *name, struct group *grp, char *buf,
847 size\_t buflen, struct group **result)}
848 \fdesc{Restituiscono le informazioni relative al gruppo specificato.}
851 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
852 caso \var{errno} assumerà il valore riportato dalle funzioni sottostanti.}
856 Il comportamento di tutte queste funzioni è assolutamente identico alle
857 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
858 in questo caso le informazioni vengono restituite in una struttura di tipo
859 \struct{group}, la cui definizione è riportata in
860 fig.~\ref{fig:sys_group_struct}.
865 \begin{minipage}[c]{0.8\textwidth}
866 \includestruct{listati/group.h}
869 \caption{La struttura \structd{group} contenente le informazioni relative ad
870 un gruppo del sistema.}
871 \label{fig:sys_group_struct}
874 Le funzioni viste finora sono in grado di leggere le informazioni sia
875 direttamente dal file delle password in \conffile{/etc/passwd} che tramite il
876 sistema del \itindex{Name~Service~Switch~(NSS)} \textit{Name Service Switch} e
877 sono completamente generiche. Si noti però che non c'è una funzione che
878 permetta di impostare direttamente una password.\footnote{in realtà questo può
879 essere fatto ricorrendo alle funzioni della libreria PAM, ma questo non è un
880 argomento che trattremo qui.} Dato che POSIX non prevede questa possibilità
881 esiste un'altra interfaccia che lo fa, derivata da SVID le cui funzioni sono
882 riportate in tab.~\ref{tab:sys_passwd_func}. Questa interfaccia però funziona
883 soltanto quando le informazioni sono mantenute su un apposito file di
884 \textsl{registro} di utenti e gruppi, con il formato classico di
885 \conffile{/etc/passwd} e \conffile{/etc/group}.
890 \begin{tabular}[c]{|l|p{8cm}|}
892 \textbf{Funzione} & \textbf{Significato}\\
895 \funcm{fgetpwent} & Legge una voce dal file di registro degli utenti
897 \funcm{fgetpwent\_r}& Come la precedente, ma \index{funzioni!rientranti}
899 \funcm{putpwent} & Immette una voce in un file di registro degli
901 \funcm{getpwent} & Legge una voce da \conffile{/etc/passwd}.\\
902 \funcm{getpwent\_r} & Come la precedente, ma \index{funzioni!rientranti}
904 \funcm{setpwent} & Ritorna all'inizio di \conffile{/etc/passwd}.\\
905 \funcm{endpwent} & Chiude \conffile{/etc/passwd}.\\
906 \funcm{fgetgrent} & Legge una voce dal file di registro dei gruppi
908 \funcm{fgetgrent\_r}& Come la precedente, ma \index{funzioni!rientranti}
910 \funcm{putgrent} & Immette una voce in un file di registro dei gruppi.\\
911 \funcm{getgrent} & Legge una voce da \conffile{/etc/group}.\\
912 \funcm{getgrent\_r} & Come la precedente, ma \index{funzioni!rientranti}
914 \funcm{setgrent} & Ritorna all'inizio di \conffile{/etc/group}.\\
915 \funcm{endgrent} & Chiude \conffile{/etc/group}.\\
918 \caption{Funzioni per la manipolazione dei campi di un file usato come
919 registro per utenti o gruppi nel formato di \conffile{/etc/passwd} e
920 \conffile{/etc/group}.}
921 \label{tab:sys_passwd_func}
924 % TODO mancano i prototipi di alcune delle funzioni
926 Dato che oramai tutte le distribuzioni di GNU/Linux utilizzano le
927 \textit{shadow password} (quindi con delle modifiche rispetto al formato
928 classico del file \conffile{/etc/passwd}), si tenga presente che le funzioni
929 di questa interfaccia che permettono di scrivere delle voci in un
930 \textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
931 hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
934 Per questo motivo l'uso di queste funzioni è deprecato, in quanto comunque non
935 funzionale rispetto ad un sistema attuale, pertanto ci limiteremo a fornire
936 soltanto l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
937 ulteriore. Chi volesse insistere ad usare questa interfaccia può fare
938 riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
939 delle \acr{glibc} per i dettagli del funzionamento.
943 \subsection{Il registro della \textsl{contabilità} degli utenti}
944 \label{sec:sys_accounting}
946 Un altro insieme di funzioni relative alla gestione del sistema che
947 esamineremo è quello che permette di accedere ai dati del registro della
948 cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti. In esso
949 vengono mantenute una serie di informazioni storiche relative sia agli utenti
950 che si sono collegati al sistema, tanto per quelli correntemente collegati,
951 che per la registrazione degli accessi precedenti, sia relative all'intero
952 sistema, come il momento di lancio di processi da parte di \cmd{init}, il
953 cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
956 I dati vengono usualmente memorizzati nei due file \file{/var/run/utmp} e
957 \file{/var/log/wtmp}. che sono quelli previsti dal \textit{Linux Filesystem
958 Hierarchy Standard}, adottato dalla gran parte delle distribuzioni. Quando
959 un utente si collega viene aggiunta una voce a \file{/var/run/utmp} in cui
960 viene memorizzato il nome di login, il terminale da cui ci si collega,
961 l'\ids{UID} della shell di login, l'orario della connessione ed altre
962 informazioni. La voce resta nel file fino al logout, quando viene cancellata
963 e spostata in \file{/var/log/wtmp}.
965 In questo modo il primo file viene utilizzato per registrare chi sta
966 utilizzando il sistema al momento corrente, mentre il secondo mantiene la
967 registrazione delle attività degli utenti. A quest'ultimo vengono anche
968 aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
969 come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
970 informazioni sono descritte in dettaglio nel manuale delle \acr{glibc}.
972 Questi file non devono mai essere letti direttamente, ma le informazioni che
973 contengono possono essere ricavate attraverso le opportune funzioni di
974 libreria. Queste sono analoghe alle precedenti funzioni (vedi
975 tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
976 solo che in questo caso la struttura del registro della \textsl{contabilità} è
977 molto più complessa, dato che contiene diversi tipi di informazione.
979 Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
980 servono rispettivamente a aprire e a chiudere il file che contiene il registro
981 della \textsl{contabilità} degli, e a specificare su quale file esso viene
982 mantenuto. I loro prototipi sono:
986 \fdecl{void utmpname(const char *file)}
987 \fdesc{Specifica il file da usare come registro.}
988 \fdecl{void setutent(void)}
989 \fdesc{Apre il file del registro.}
990 \fdecl{void endutent(void)}
991 \fdesc{Chiude il file del registro.}
994 {Le funzioni non ritornano nulla.}
997 Si tenga presente che le funzioni non restituiscono nessun valore, pertanto
998 non è possibile accorgersi di eventuali errori, ad esempio se si è impostato
999 un nome di file sbagliato con \func{utmpname}.
1001 Nel caso non si sia utilizzata \func{utmpname} per specificare un file di
1002 registro alternativo, sia \func{setutent} che \func{endutent} operano usando
1003 il default che è \sysfile{/var/run/utmp} il cui nome, così come una serie di
1004 altri valori di default per i \textit{pathname} di uso più comune, viene
1005 mantenuto nei valori di una serie di costanti definite includendo
1006 \headfile{paths.h}, in particolare quelle che ci interessano sono:
1007 \begin{basedescript}{\desclabelwidth{2.0cm}}
1008 \item[\const{\_PATH\_UTMP}] specifica il file che contiene il registro per gli
1009 utenti correntemente collegati, questo è il valore che viene usato se non si
1010 è utilizzato \func{utmpname} per modificarlo;
1011 \item[\const{\_PATH\_WTMP}] specifica il file che contiene il registro per
1012 l'archivio storico degli utenti collegati;
1014 che nel caso di Linux hanno un valore corrispondente ai file
1015 \sysfile{/var/run/utmp} e \sysfile{/var/log/wtmp} citati in precedenza.
1017 Una volta aperto il file del registro degli utenti si può eseguire una
1018 scansione leggendo o scrivendo una voce con le funzioni \funcd{getutent},
1019 \funcd{getutid}, \funcd{getutline} e \funcd{pututline}, i cui prototipi sono:
1024 \fdecl{struct utmp *getutent(void)}
1025 \fdesc{Legge una voce dalla posizione corrente nel registro.}
1026 \fdecl{struct utmp *getutid(struct utmp *ut)}
1027 \fdesc{Ricerca una voce sul registro.}
1028 \fdecl{struct utmp *getutline(struct utmp *ut)}
1029 \fdesc{Ricerca una voce sul registro attinente a un terminale.}
1030 \fdecl{struct utmp *pututline(struct utmp *ut)}
1031 \fdesc{Scrive una voce nel registro.}
1034 {Le funzioni ritornano il puntatore ad una struttura \struct{utmp} in caso di
1035 successo e \val{NULL} in caso di errore, nel qual caso \var{errno} assumerà
1036 il valore riportato dalle funzioni sottostanti.}
1039 Tutte queste funzioni fanno riferimento ad una struttura di tipo
1040 \struct{utmp}, la cui definizione in Linux è riportata in
1041 fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
1042 voce dal registro: \func{getutent} legge semplicemente la prima voce
1043 disponibile, le altre due permettono di eseguire una ricerca. Aprendo il
1044 registro con \func{setutent} ci si posiziona al suo inizio, ogni chiamata di
1045 queste funzioni eseguirà la lettura sulle voci seguenti, portanto la posizione
1046 sulla voce appena letta, in modo da consentire una scansione del file. Questo
1047 vale anche per \func{getutid} e \func{getutline}, il che comporta che queste
1048 funzioni effettuano comunque una ricerca ``\textsl{in avanti}''.
1050 \begin{figure}[!htb]
1053 \begin{minipage}[c]{0.9\textwidth}
1054 \includestruct{listati/utmp.h}
1057 \caption{La struttura \structd{utmp} contenente le informazioni di una voce
1058 del registro di \textsl{contabilità}.}
1059 \label{fig:sys_utmp_struct}
1062 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1063 campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
1064 riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
1065 \const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
1066 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1067 invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
1068 \const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
1069 corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1074 \begin{tabular}[c]{|l|p{8cm}|}
1076 \textbf{Valore} & \textbf{Significato}\\
1079 \const{EMPTY} & Non contiene informazioni valide.\\
1080 \const{RUN\_LVL} & Identica il runlevel del sistema.\\
1081 \const{BOOT\_TIME} & Identifica il tempo di avvio del sistema.\\
1082 \const{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
1084 \const{NEW\_TIME} & Identifica da quanto è stato modificato il
1086 \const{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
1087 \const{LOGIN\_PROCESS}& Identifica un processo di login.\\
1088 \const{USER\_PROCESS} & Identifica un processo utente.\\
1089 \const{DEAD\_PROCESS} & Identifica un processo terminato.\\
1090 % \const{ACCOUNTING} & ??? \\
1093 \caption{Classificazione delle voci del registro a seconda dei
1094 possibili valori del campo \var{ut\_type}.}
1095 \label{tab:sys_ut_type}
1098 La funzione \func{getutline} esegue la ricerca sulle voci che hanno
1099 \var{ut\_type} uguale a \const{LOGIN\_PROCESS} o \const{USER\_PROCESS},
1100 restituendo la prima che corrisponde al valore di \var{ut\_line}, che
1101 specifica il dispositivo di terminale che interessa, da indicare senza il
1102 \file{/dev/} iniziale. Lo stesso criterio di ricerca è usato da
1103 \func{pututline} per trovare uno spazio dove inserire la voce specificata;
1104 qualora questo spazio non venga trovato la voce viene aggiunta in coda al
1107 In generale occorre però tenere conto che queste funzioni non sono
1108 completamente standardizzate, e che in sistemi diversi possono esserci
1109 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1110 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1111 fornita dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1112 introdotto delle nuove strutture (e relativi file) di tipo \struct{utmpx}, che
1113 sono un sovrainsieme della \struct{utmp} usata tradizionalmente ed altrettante
1114 funzioni che le usano al posto di quelle citate.
1116 Le \acr{glibc} utilizzavano già una versione estesa di \struct{utmp}, che
1117 rende inutili queste nuove strutture, per questo su Linux \struct{utmpx} viene
1118 definita esattamente come \struct{utmp}, con gli stessi campi di
1119 fig.~\ref{fig:sys_utmp_struct}. Altrettanto dicasi per le nuove funzioni di
1120 gestione previste dallo standard: \funcm{getutxent}, \funcm{getutxid},
1121 \funcm{getutxline}, \funcm{pututxline}, \funcm{setutxent} e \funcm{endutxent}.
1123 Tutte queste funzioni, definite con \struct{utmpx} dal file di dichiarazione
1124 \headfile{utmpx.h}, su Linux sono ridefinite come sinonimi delle funzioni
1125 appena viste, con argomento di tipo \struct{utmpx} anziché \struct{utmp} ed
1126 hanno lo stesso identico comportamento. Per completezza viene definita anche
1127 \funcm{utmpxname} che non è prevista da POSIX.1-2001.
1129 Come già visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
1130 staticamente rende le funzioni di lettura dei dati appena illustrate non
1131 \index{funzioni!rientranti} rientranti. Per questo motivo le \acr{glibc}
1132 forniscono anche delle versioni \index{funzioni!rientranti} rientranti:
1133 \func{getutent\_r}, \func{getutid\_r}, \func{getutline\_r}, che invece di
1134 restituire un puntatore restituiscono un intero e prendono due argomenti
1135 aggiuntivi, i rispettivi prototipi sono:
1139 \fdecl{int *getutent\_r(struct utmp *buffer, struct utmp **result)}
1140 \fdesc{Legge una voce dalla posizione corrente nel registro.}
1141 \fdecl{int *getutid\_r(struct utmp *buffer, struct utmp **result, struct utmp
1143 \fdesc{Ricerca una voce sul registro.}
1144 \fdecl{int *getutline\_r(struct utmp *buffer, struct utmp **result, struct utmp
1146 \fdesc{Ricerca una voce sul registro attinente a un terminale.}
1149 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
1150 caso \var{errno} assumerà il valore riportato dalle funzioni sottostanti.}
1153 Le funzioni si comportano esattamente come le precedenti analoghe non
1154 \index{funzioni!rientranti} rientranti, solo che restituiscono il risultato
1155 all'indirizzo specificato dal primo argomento aggiuntivo \param{buffer} mentre
1156 il secondo, \param{result)} viene usato per restituire il puntatore al buffer
1159 Infine le \acr{glibc} forniscono altre due funzioni, \funcd{updwtmp} e
1160 \funcd{logwtmp}, come estensione per scrivere direttamente delle voci nel file
1161 sul registro storico \sysfile{/var/log/wtmp}; i rispettivi prototipi sono:
1165 \fdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1166 \fdesc{Aggiunge una voce in coda al registro.}
1167 \fdecl{void logwtmp(const char *line, const char *name, const char *host)}
1168 \fdesc{Aggiunge nel registro una voce con i valori specificati.}
1171 {Le funzioni non restituiscono nulla.}
1174 La prima funzione permette l'aggiunta di una voce in coda al file del registro
1175 storico, indicato dal primo argomento, specificando direttamente una struttura
1176 \struct{utmp}. La seconda invece utilizza gli argomenti \param{line},
1177 \param{name} e \param{host} per costruire la voce che poi aggiunge chiamando
1180 Queste funzioni non sono previste da POSIX.1-2001, anche se sono presenti in
1181 altri sistemi (ad esempio Solaris e NetBSD), per mantenere una coerenza con le
1182 altre funzioni definite nello standard che usano la struttura \struct{utmpx}
1183 la \acr{glibc} definisce anche una funzione \funcm{updwtmpx}, che come in
1184 precedenza è identica a \func{updwtmp} con la sola differenza di richiedere
1185 l'uso di \headfile{utmpx.h} e di una struttura \struct{utmpx} come secondo
1189 \subsection{La gestione dello spegnimento e del riavvio}
1190 \label{sec:sys_reboot}
1192 Una delle operazioni di gestione generale del sistema è quella che attiene
1193 alle modalità con cui se ne può gestire lo spegnimento ed il riavvio. Perché
1194 questo avvenga in maniera corretta, in particolare per le parti che comportano
1195 lo spegnimento effettivo della macchina, occorre che il kernel effettui le
1196 opportune operazioni interagendo con il BIOS ed i dispositivi che controllano
1197 l'erogazione della potenza.
1199 La funzione di sistema che controlla lo spegnimento ed il riavvio (ed altri
1200 aspetti della relativa procedura) è \funcd{reboot},\footnote{la funzione
1201 illustrata è quella fornita dalla \acr{glibc} che maschera i dettagli di
1202 basso livello della \textit{system call} la quale richiede quattro
1203 argomenti, di cui due \textit{magic number} interi che possono assumere solo
1204 alcuni valori predefiniti, un comando, corrispondente all'unico argomento
1205 della funzione della \acr{glibc} e un puntatore generico ad ulteriori dati.}
1210 \fhead{sys/reboot.h}
1211 \fdecl{int reboot(int cmd)}
1212 \fdesc{Controlla il riavvio o l'arresto della macchina.}
1215 {La funzione non ritorna o ritorna $0$ in caso di successo e $-1$ per un
1216 errore, nel qual caso \var{errno} assumerà uno dei valori:
1218 \item[\errcode{EFAULT}] c'è un indirizzo non valido nel passaggio degli
1219 argomenti con il comando \const{LINUX\_REBOOT\_CMD\_RESTART2}.
1220 \item[\errcode{EINVAL}] si sono specificati valori non validi per gli
1222 \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
1223 \textit{capability} \const{CAP\_SYS\_BOOT}).
1228 La funzione, oltre al riavvio ed allo spegnimento, consente anche di
1229 controllare l'uso della combinazione di tasti tradizionalmente usata come
1230 scorciatoia da tastiera per richiedere il riavvio (\texttt{Ctrl-Alt-Del},
1231 denominata in breve nella documentazione CAD) ed i suoi effetti specifici
1232 dipendono dalla architettura hardware.
1237 Il comportamento della funzione viene controllato dall'argomento \param{cmd}
1238 che deve assumere indicato con una delle costanti seguente elenco, che
1239 illustra i comandi attualmente disponibili:
1241 \begin{basedescript}{\desclabelwidth{2.cm}\desclabelstyle{\nextlinelabel}}
1242 \item[\const{LINUX\_REBOOT\_CMD\_CAD\_OFF}] Disabilita l'uso diretto della
1243 combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce nell'invio
1244 del segnale \const{SIGINT} a \texttt{init} (o più in generale al processo
1245 con \ids{PID} 1) il cui effetto dipende dalla configurazione di
1247 \item[\const{LINUX\_REBOOT\_CMD\_CAD\_ON}] Attiva l'uso diretto della
1248 combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce
1249 nell'esecuzione dell'azione che si avrebbe avuto chiamando \func{reboot} con
1250 il comando \const{LINUX\_REBOOT\_CMD\_RESTART}.
1251 \item[\const{LINUX\_REBOOT\_CMD\_HALT}] Viene inviato sulla console il
1252 messaggio ``\textit{System halted.}'' l'esecuzione viene bloccata
1253 immediatamente ed il controllo passato al monitor nella ROM (se esiste e
1254 l'architettura lo consente). Se non si è eseguita una sincronizzazione dei
1255 dati su disco con \func{sync} questo saranno perduti.
1256 \item[\const{LINUX\_REBOOT\_CMD\_KEXEC}]
1257 \item[\const{LINUX\_REBOOT\_CMD\_POWER\_OFF}] Viene inviato sulla console il
1258 messaggio ``\textit{Power down.}'' l'esecuzione viene bloccata
1259 immediatamente e la macchina, se possibile, viene spenta. Se non si è
1260 eseguita una sincronizzazione dei dati su disco con \func{sync} questi
1262 \item[\const{LINUX\_REBOOT\_CMD\_RESTART}] Viene inviato sulla console il
1263 messaggio ``\textit{Restarting system.}'' ed avviata immediatamente la
1264 procedura di riavvio ordinaria. Se non si è eseguita una sincronizzazione
1265 dei dati su disco con \func{sync} questi saranno perduti.
1266 \item[\const{LINUX\_REBOOT\_CMD\_RESTART2}] Viene inviato sulla console il
1267 messaggio ``\textit{Restarting system with command '\%s'.}'' ed avviata
1268 immediatamente la procedura di riavvio usando il comando fornito
1269 nell'argomento \param{arg} che viene stampato al posto di \textit{'\%s'}. Se
1270 non si è eseguita una sincronizzazione dei dati su disco con \func{sync}
1271 questi saranno perduti.
1275 % TODO trattare reboot, kexec_load, ...
1280 % TODO documentare keyctl ????
1281 % (fare sezione dedicata ????)
1282 %\subsection{La gestione delle chiavi crittografiche}
1283 %\label{sec:keyctl_management}
1286 \section{Il controllo dell'uso delle risorse}
1287 \label{sec:sys_res_limits}
1290 Dopo aver esaminato le funzioni che permettono di controllare le varie
1291 caratteristiche, capacità e limiti del sistema a livello globale, in questa
1292 sezione tratteremo le varie funzioni che vengono usate per quantificare le
1293 risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
1294 permettono di imporre a ciascuno di essi vincoli e limiti di
1298 \subsection{L'uso delle risorse}
1299 \label{sec:sys_resource_use}
1301 Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
1302 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1303 di tipo \struct{rusage}, la cui definizione (che si trova in
1304 \headfile{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
1306 \begin{figure}[!htb]
1309 \begin{minipage}[c]{\textwidth}
1310 \includestruct{listati/rusage.h}
1313 \caption{La struttura \structd{rusage} per la lettura delle informazioni dei
1314 delle risorse usate da un processo.}
1315 \label{fig:sys_rusage_struct}
1318 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
1319 da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
1320 \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si trova
1321 nelle opzioni di compilazione del kernel (e di norma è disabilitato) che
1322 serve per mantenere una contabilità delle risorse usate da ciascun processo
1323 in maniera molto più dettagliata.} ma attualmente (con i kernel della serie
1324 2.4.x e 2.6.x) i soli campi che sono mantenuti sono: \var{ru\_utime},
1325 \var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I
1326 primi due indicano rispettivamente il tempo impiegato dal processo
1327 nell'eseguire le istruzioni in user space, e quello impiegato dal kernel nelle
1328 system call eseguite per conto del processo.
1330 Gli altri tre campi servono a quantificare l'uso della memoria
1331 virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
1332 \itindex{page~fault} \textit{page fault} (vedi sez.~\ref{sec:proc_mem_gen})
1333 avvenuti senza richiedere I/O su disco (i cosiddetti \textit{minor page
1334 fault}), a quelli che invece han richiesto I/O su disco (detti invece
1335 \textit{major page fault}) ed al numero di volte che il processo è stato
1336 completamente tolto dalla memoria per essere inserito nello swap.
1338 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
1339 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
1340 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
1341 ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
1342 \struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
1344 Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
1345 visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di risorse
1346 impiegate dal processo di cui si è letto lo stato di terminazione, ma essa può
1347 anche essere letta direttamente utilizzando la funzione \funcd{getrusage}, il
1350 \headdecl{sys/time.h}
1351 \headdecl{sys/resource.h}
1354 \funcdecl{int getrusage(int who, struct rusage *usage)}
1355 Legge la quantità di risorse usate da un processo.
1358 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1359 nel qual caso \var{errno} può essere \errval{EINVAL} o \errval{EFAULT}.}
1362 L'argomento \param{who} permette di specificare il processo di cui si vuole
1363 leggere l'uso delle risorse; esso può assumere solo i due valori
1364 \const{RUSAGE\_SELF} per indicare il processo corrente e
1365 \const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
1366 ricevuto lo stato di terminazione.
1368 % TODO previsto in futuro \const{RUSAGE\_THREAD}, verificare.
1370 \subsection{Limiti sulle risorse}
1371 \label{sec:sys_resource_limit}
1373 Come accennato nell'introduzione il kernel mette a disposizione delle
1374 funzionalità che permettono non solo di mantenere dati statistici relativi
1375 all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
1376 utilizzo da parte dei vari processi o degli utenti.
1378 Per far questo esistono una serie di risorse e ad ogni processo vengono
1379 associati due diversi limiti per ciascuna di esse; questi sono il
1380 \textsl{limite corrente} (o \textit{current limit}) che esprime un valore
1381 massimo che il processo non può superare ad un certo momento, ed il
1382 \textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
1383 valore massimo che può assumere il \textsl{limite corrente}. In generale il
1384 primo viene chiamato anche \textit{soft limit} dato che il suo valore può
1385 essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
1386 fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
1389 %TODO: tabella troppo grossa, trasformare in lista
1394 \begin{tabular}[c]{|l|p{12cm}|}
1396 \textbf{Valore} & \textbf{Significato}\\
1399 \const{RLIMIT\_AS} & La dimensione massima della memoria virtuale di
1400 un processo, il cosiddetto \textit{Address
1401 Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se
1402 il limite viene superato dall'uso di funzioni
1403 come \func{brk}, \func{mremap} o \func{mmap}
1404 esse falliranno con un errore di
1405 \errcode{ENOMEM}, mentre se il superamento viene
1406 causato dalla crescita dello \itindex{stack}
1407 \textit{stack} il processo riceverà un segnale di
1409 \const{RLIMIT\_CORE} & La massima dimensione per di un file di
1410 \itindex{core~dump} \textit{core dump} (vedi
1411 sez.~\ref{sec:sig_prog_error}) creato nella
1412 terminazione di un processo; file di dimensioni
1413 maggiori verranno troncati a questo valore,
1414 mentre con un valore si bloccherà la creazione
1415 dei \itindex{core~dump} \textit{core dump}.\\
1416 \const{RLIMIT\_CPU} & Il massimo tempo di CPU (vedi
1417 sez.~\ref{sec:sys_cpu_times}) che il processo può
1418 usare. Il superamento del limite corrente
1419 comporta l'emissione di un segnale di
1420 \signal{SIGXCPU}, la cui azione predefinita (vedi
1421 sez.~\ref{sec:sig_classification}) è terminare
1422 il processo, una volta al secondo fino al
1423 raggiungimento del limite massimo. Il
1424 superamento del limite massimo
1425 comporta l'emissione di un segnale di
1426 \signal{SIGKILL}.\footnotemark\\
1427 \const{RLIMIT\_DATA} & La massima dimensione del \index{segmento!dati}
1429 processo (vedi sez.~\ref{sec:proc_mem_layout}).
1430 Il tentativo di allocare più memoria di quanto
1431 indicato dal limite corrente causa il fallimento
1432 della funzione di allocazione (\func{brk} o
1433 \func{sbrk}) con un errore di \errcode{ENOMEM}.\\
1434 \const{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
1435 può creare. Se il processo cerca di scrivere
1436 oltre questa dimensione riceverà un segnale di
1437 \signal{SIGXFSZ}, che di norma termina il
1438 processo; se questo viene intercettato la
1439 system call che ha causato l'errore fallirà con
1440 un errore di \errcode{EFBIG}.\\
1441 \const{RLIMIT\_LOCKS}& È un limite presente solo nelle prime versioni
1442 del kernel 2.4 sul numero massimo di
1443 \itindex{file~locking} \textit{file lock} (vedi
1444 sez.~\ref{sec:file_locking}) che un
1445 processo poteva effettuare.\\
1446 \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
1447 bloccata in RAM da un processo (vedi
1448 sez.~\ref{sec:proc_mem_lock}). Dal kernel 2.6.9
1449 questo limite comprende anche la memoria che può
1450 essere bloccata da ciascun utente nell'uso della
1451 memoria condivisa (vedi
1452 sez.~\ref{sec:ipc_sysv_shm}) che viene
1453 contabilizzata separatamente ma sulla quale
1454 viene applicato questo stesso limite.\\
1455 % TODO trattare i seguenti...
1456 % \const{RLIMIT\_MSGQUEUE}& Il numero massimo di \\
1457 % \const{RLIMIT\_NICE}& Il numero massimo di \\
1458 % \const{RLIMIT\_RTPRIO}& Il numero massimo di \\
1459 % aggiungere i limiti che mancano come RLIMIT_RTTIME introdotto con il 2.6.25
1460 % vedi file include/asm-generic/resource.h
1461 \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
1462 aprire. L'apertura di un ulteriore file farà
1463 fallire la funzione (\func{open}, \func{dup} o
1464 \func{pipe}) con un errore \errcode{EMFILE}.\\
1465 \const{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
1466 creati sullo stesso user id real. Se il limite
1467 viene raggiunto \func{fork} fallirà con un
1469 \const{RLIMIT\_SIGPENDING}& Il numero massimo di segnali che possono
1470 essere mantenuti in coda per ciascun utente,
1471 considerando sia i segnali normali che real-time
1472 (vedi sez.~\ref{sec:sig_real_time}). Il limite è
1473 attivo solo per \func{sigqueue}, con \func{kill}
1474 si potrà sempre inviare un segnale che non sia
1475 già presente su una coda.\footnotemark\\
1476 \const{RLIMIT\_STACK} & La massima dimensione dello \itindex{stack}
1477 \textit{stack} del processo. Se il processo
1478 esegue operazioni che estendano lo
1479 \textit{stack} oltre questa dimensione
1480 riceverà un segnale di \signal{SIGSEGV}.\\
1481 % TODO dal 2.6.23 il significato è cambiato, vedi anche man execve
1482 \const{RLIMIT\_RSS} & L'ammontare massimo di pagine di memoria dato al
1483 \index{segmento!testo} testo del processo. Il
1484 limite è solo una indicazione per il kernel,
1485 qualora ci fosse un surplus di memoria questa
1486 verrebbe assegnata.\\
1487 % TODO: aggiungere a \const{RLIMIT\_STACK} i dati di execve:
1488 % Questi fino al kernel 2.6.23 erano fissi e costituiti da
1489 % 32 pagine di memoria (corrispondenti per la gran parte delle architetture a
1490 % 128kb di dati). Dal 2.6.23 su molte architettire il limite viene stabilito in
1491 % base al valore della risorsa \const{RLIMIT\_STACK} (vedi
1492 % sez.~\ref{sec:sys_resource_limit}), ad un quarto dello spazio da essa
1493 % indicato). Dal 2.6.25 viene comunque garantito uno spazio base di 32 pagine.
1495 % TODO integrare con la roba di madvise
1496 % TODO integrare con le ultime aggiunte, vedi pagina di manuale
1499 \caption{Valori possibili dell'argomento \param{resource} delle funzioni
1500 \func{getrlimit} e \func{setrlimit}.}
1501 \label{tab:sys_rlimit_values}
1504 \footnotetext[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
1505 oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
1506 avviene quando viene superato il \textit{soft limit}; perciò per avere
1507 operazioni portabili è sempre opportuno intercettare il primo
1508 \signal{SIGXCPU} e terminare in maniera ordinata il processo.}
1510 \footnotetext{il limite su questa risorsa è stato introdotto con il kernel
1513 % TODO trattare prlimit64 introdotta con il 2.6.36 che dovrebbe sostituire
1517 In generale il superamento di un limite corrente\footnote{di norma quanto
1518 riportato in tab.~\ref{tab:sys_rlimit_values} fa riferimento a quanto
1519 avviene al superamento del limite corrente, con l'eccezione
1520 \const{RLIMIT\_CPU} in cui si ha in comportamento diverso per il superamento
1521 dei due limiti.} comporta o l'emissione di un segnale o il fallimento della
1522 system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
1523 \const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
1524 creazione) dei file di \itindex{core~dump} \textit{core dump}.} per
1525 permettere di leggere e di impostare i limiti di utilizzo delle risorse da
1526 parte di un processo sono previste due funzioni, \funcd{getrlimit} e
1527 \funcd{setrlimit}, i cui prototipi sono:
1529 \headdecl{sys/time.h}
1530 \headdecl{sys/resource.h}
1533 \funcdecl{int getrlimit(int resource, struct rlimit *rlim)}
1535 Legge il limite corrente per la risorsa \param{resource}.
1537 \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)}
1539 Imposta il limite per la risorsa \param{resource}.
1541 \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
1542 errore, nel qual caso \var{errno} assumerà uno dei valori:
1544 \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi.
1545 \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1546 cercato di innalzare i propri limiti.
1548 ed \errval{EFAULT}.}
1552 Entrambe le funzioni permettono di specificare, attraverso l'argomento
1553 \param{resource}, su quale risorsa si vuole operare: i possibili valori di
1554 questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
1555 (rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
1556 poi effettuato attraverso la struttura \struct{rlimit} puntata da
1557 \param{rlim}, la cui definizione è riportata in
1558 fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
1559 limite corrente e limite massimo.
1562 \begin{figure}[!htb]
1565 \begin{minipage}[c]{\textwidth}
1566 \includestruct{listati/rlimit.h}
1569 \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
1570 delle risorse usate da un processo.}
1571 \label{fig:sys_rlimit_struct}
1575 Nello specificare un limite, oltre a fornire dei valori specifici, si può
1576 anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
1577 di una risorsa; ma si ricordi che solo un processo con i privilegi di
1578 amministratore\footnote{per essere precisi in questo caso quello che serve è
1579 la \itindex{capabilities} \textit{capability} \const{CAP\_SYS\_RESOURCE}
1580 (vedi sez.~\ref{sec:proc_capabilities}).} può innalzare un limite al di
1581 sopra del valore corrente del limite massimo ed usare un valore qualsiasi per
1582 entrambi i limiti. Si tenga conto infine che tutti i limiti vengono ereditati
1583 dal processo padre attraverso una \func{fork} (vedi sez.~\ref{sec:proc_fork})
1584 e mantenuti per gli altri programmi eseguiti attraverso una \func{exec} (vedi
1585 sez.~\ref{sec:proc_exec}).
1588 \subsection{Le risorse di memoria e processore}
1589 \label{sec:sys_memory_res}
1591 La gestione della memoria è già stata affrontata in dettaglio in
1592 sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1593 meccanismo della \index{memoria~virtuale} memoria virtuale attraverso la
1594 divisione della memoria fisica in pagine.
1596 In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
1597 casi, come per l'I/O mappato in memoria (vedi sez.~\ref{sec:file_memory_map})
1598 che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
1599 dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
1600 gestire in maniera ottimale l'interazione della memoria che si sta allocando
1601 con il meccanismo della \index{paginazione} paginazione.
1603 Di solito la dimensione delle pagine di memoria è fissata dall'architettura
1604 hardware, per cui il suo valore di norma veniva mantenuto in una costante che
1605 bastava utilizzare in fase di compilazione, ma oggi, con la presenza di alcune
1606 architetture (ad esempio Sun Sparc) che permettono di variare questa
1607 dimensione, per non dover ricompilare i programmi per ogni possibile modello e
1608 scelta di dimensioni, è necessario poter utilizzare una funzione.
1610 Dato che si tratta di una caratteristica generale del sistema, questa
1611 dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
1612 \func{sysconf}, \footnote{nel caso specifico si dovrebbe utilizzare il
1613 parametro \const{\_SC\_PAGESIZE}.} ma in BSD 4.2 è stata introdotta una
1614 apposita funzione, \funcd{getpagesize}, che restituisce la dimensione delle
1615 pagine di memoria; il suo prototipo è:
1616 \begin{prototype}{unistd.h}{int getpagesize(void)}
1617 Legge le dimensioni delle pagine di memoria.
1619 \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
1620 sono previsti errori.}
1623 La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
1624 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1625 ha eliminata. In Linux è implementata come una system call nelle architetture
1626 in cui essa è necessaria, ed in genere restituisce il valore del simbolo
1627 \const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
1628 se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
1629 implementavano questa funzione restituendo sempre un valore statico.
1631 % TODO verificare meglio la faccenda di const{PAGE\_SIZE}
1633 Le \textsl{glibc} forniscono, come specifica estensione GNU, altre due
1634 funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
1635 di ottenere informazioni riguardo la memoria; i loro prototipi sono:
1637 \headdecl{sys/sysinfo.h}
1639 \funcdecl{long int get\_phys\_pages(void)}
1641 Legge il numero totale di pagine di memoria disponibili per il sistema.
1643 \funcdecl{long int get\_avphys\_pages(void)}
1645 Legge il numero di pagine di memoria disponibili nel sistema.
1647 \bodydesc{Le funzioni restituiscono un numero di pagine.}
1650 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1651 rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
1652 \const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1653 corrispondenti alla RAM della macchina; la seconda invece la memoria
1654 effettivamente disponibile per i processi.
1656 Le \acr{glibc} supportano inoltre, come estensioni GNU, due funzioni che
1657 restituiscono il numero di processori della macchina (e quello dei processori
1658 attivi); anche queste sono informazioni comunque ottenibili attraverso
1659 \func{sysconf} utilizzando rispettivamente i parametri
1660 \const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
1662 Infine le \acr{glibc} riprendono da BSD la funzione \funcd{getloadavg} che
1663 permette di ottenere il carico di processore della macchina, in questo modo è
1664 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1666 \begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
1667 Legge il carico medio della macchina.
1669 \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
1673 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1674 di processi attivi sulla coda dello \itindex{scheduler} scheduler, calcolato
1675 su diversi intervalli di tempo. Il numero di intervalli che si vogliono
1676 leggere è specificato da \param{nelem}, dato che nel caso di Linux il carico
1677 viene valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti),
1678 questo è anche il massimo valore che può essere assegnato a questo argomento.
1681 \subsection{La \textsl{contabilità} in stile BSD}
1682 \label{sec:sys_bsd_accounting}
1684 Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
1685 kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
1686 compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
1687 cosiddetto \textit{BSD accounting}, che consente di registrare su file una
1688 serie di informazioni\footnote{contenute nella struttura \texttt{acct}
1689 definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
1690 riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
1691 che viene terminato.
1693 Linux consente di salvare la contabilità delle informazioni relative alle
1694 risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
1696 \begin{prototype}{unistd.h}{int acct(const char *filename)}
1697 Abilita il \textit{BSD accounting}.
1699 \bodydesc{La funzione ritorna 0 in caso di successo o $-1$ in caso di
1700 errore, nel qual caso \var{errno} assumerà uno dei valori:
1702 \item[\errcode{EACCES}] non si hanno i permessi per accedere a
1704 \item[\errcode{EPERM}] il processo non ha privilegi sufficienti ad
1705 abilitare il \textit{BSD accounting}.
1706 \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
1707 \item[\errcode{EUSERS}] non sono disponibili nel kernel strutture per il
1708 file o si è finita la memoria.
1710 ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
1711 \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
1712 \errval{ENOTDIR}, \errval{EROFS}.}
1715 La funzione attiva il salvataggio dei dati sul file indicato dal
1716 \textit{pathname} contenuti nella stringa puntata da \param{filename}; la
1717 funzione richiede che il processo abbia i privilegi di amministratore (è
1718 necessaria la \itindex{capabilities} capability \const{CAP\_SYS\_PACCT}, vedi
1719 sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \val{NULL} per
1720 \param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
1721 semplice esempio per l'uso di questa funzione è riportato nel programma
1722 \texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
1724 Quando si attiva la contabilità, il file che si indica deve esistere; esso
1725 verrà aperto in sola scrittura; le informazioni verranno registrate in
1726 \itindex{append~mode} \textit{append} in coda al file tutte le volte che un
1727 processo termina. Le informazioni vengono salvate in formato binario, e
1728 corrispondono al contenuto della apposita struttura dati definita all'interno
1731 Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
1732 parametro di sistema, modificabile attraverso \sysctlfile{kernel/acct}
1733 (o tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi,
1734 il primo indica la percentuale di spazio disco libero sopra il quale viene
1735 ripresa una registrazione che era stata sospesa per essere scesi sotto il
1736 minimo indicato dal secondo valore (sempre in percentuale di spazio disco
1737 libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
1738 essere controllata detta percentuale.
1741 \section{La gestione dei tempi del sistema}
1742 \label{sec:sys_time}
1744 In questa sezione, una volta introdotti i concetti base della gestione dei
1745 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
1746 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
1747 veri tempi di sistema associati ai processi, a quelle per convertire i vari
1748 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
1749 gestione di data e ora.
1752 \subsection{La misura del tempo in Unix}
1753 \label{sec:sys_unix_time}
1755 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
1756 dati per la misure dei tempi all'interno del sistema: essi sono
1757 rispettivamente chiamati \itindex{calendar~time} \textit{calendar time} e
1758 \itindex{process~time} \textit{process time}, secondo le definizioni:
1759 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1760 \item[\textit{calendar time}] \itindex{calendar~time} detto anche
1761 \textsl{tempo di calendario}. È il numero di secondi dalla mezzanotte del
1762 primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
1763 usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
1764 Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
1765 dato che l'UTC corrisponde all'ora locale di Greenwich. È il tempo su cui
1766 viene mantenuto l'orologio del kernel, e viene usato ad esempio per indicare
1767 le date di modifica dei file o quelle di avvio dei processi. Per memorizzare
1768 questo tempo è stato riservato il tipo primitivo \type{time\_t}.
1769 \item[\textit{process time}] \itindex{process~time} detto talvolta
1770 \textsl{tempo di processore}. Viene misurato in \itindex{clock~tick}
1771 \textit{clock tick}. Un tempo questo corrispondeva al numero di interruzioni
1772 effettuate dal timer di sistema, adesso lo standard POSIX richiede che esso
1773 sia pari al valore della costante \const{CLOCKS\_PER\_SEC}, che deve essere
1774 definita come 1000000, qualunque sia la risoluzione reale dell'orologio di
1775 sistema e la frequenza delle interruzioni del timer.\footnote{quest'ultima,
1776 come accennato in sez.~\ref{sec:proc_hierarchy}, è invece data dalla
1777 costante \const{HZ}.} Il dato primitivo usato per questo tempo è
1778 \type{clock\_t}, che ha quindi una risoluzione del microsecondo. Il numero
1779 di \itindex{clock~tick} \textit{tick} al secondo può essere ricavato anche
1780 attraverso \func{sysconf} (vedi sez.~\ref{sec:sys_limits}). Il vecchio
1781 simbolo \const{CLK\_TCK} definito in \headfile{time.h} è ormai considerato
1785 In genere si usa il \itindex{calendar~time} \textit{calendar time} per
1786 esprimere le date dei file e le informazioni analoghe che riguardano i
1787 cosiddetti \textsl{tempi di orologio}, che vengono usati ad esempio per i
1788 demoni che compiono lavori amministrativi ad ore definite, come \cmd{cron}.
1790 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
1791 tempo locale, utilizzando le opportune informazioni di localizzazione
1792 (specificate in \conffile{/etc/timezone}). E da tenere presente che questo
1793 tempo è mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
1794 dall'orologio hardware del calcolatore.
1796 Anche il \itindex{process~time} \textit{process time} di solito si esprime in
1797 secondi, ma fornisce una precisione ovviamente superiore al \textit{calendar
1798 time} (che è mantenuto dal sistema con una granularità di un secondo) e
1799 viene usato per tenere conto dei tempi di esecuzione dei processi. Per ciascun
1800 processo il kernel calcola tre tempi diversi:
1801 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
1802 \item[\textit{clock time}] il tempo \textsl{reale} (viene chiamato anche
1803 \textit{wall clock time} o \textit{elapsed time}) passato dall'avvio del
1804 processo. Chiaramente tale tempo dipende anche dal carico del sistema e da
1805 quanti altri processi stavano girando nello stesso periodo.
1807 \item[\textit{user time}] il tempo effettivo che il processore ha impiegato
1808 nell'esecuzione delle istruzioni del processo in user space. È quello
1809 riportato nella risorsa \var{ru\_utime} di \struct{rusage} vista in
1810 sez.~\ref{sec:sys_resource_use}.
1812 \item[\textit{system time}] il tempo effettivo che il processore ha impiegato
1813 per eseguire codice delle system call nel kernel per conto del processo. È
1814 quello riportato nella risorsa \var{ru\_stime} di \struct{rusage} vista in
1815 sez.~\ref{sec:sys_resource_use}.
1818 In genere la somma di \textit{user time} e \textit{system time} indica il
1819 tempo di processore totale che il sistema ha effettivamente utilizzato per
1820 eseguire un certo processo, questo viene chiamato anche \textit{CPU time} o
1821 \textsl{tempo di CPU}. Si può ottenere un riassunto dei valori di questi tempi
1822 quando si esegue un qualsiasi programma lanciando quest'ultimo come argomento
1823 del comando \cmd{time}.
1827 \subsection{La gestione del \textit{process time}}
1828 \label{sec:sys_cpu_times}
1830 \itindbeg{process~time}
1832 Di norma tutte le operazioni del sistema fanno sempre riferimento al
1833 \itindex{calendar~time} \textit{calendar time}, l'uso del \textit{process
1834 time} è riservato a quei casi in cui serve conoscere i tempi di esecuzione
1835 di un processo (ad esempio per valutarne l'efficienza). In tal caso infatti
1836 fare ricorso al \textit{calendar time} è inutile in quanto il tempo può essere
1837 trascorso mentre un altro processo era in esecuzione o in attesa del risultato
1838 di una operazione di I/O.
1840 La funzione più semplice per leggere il \textit{process time} di un processo è
1841 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
1842 utilizzato dallo stesso; il suo prototipo è:
1843 \begin{prototype}{time.h}{clock\_t clock(void)}
1844 Legge il valore corrente del tempo di CPU.
1846 \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
1850 La funzione restituisce il tempo in \itindex{clock~tick} \texttt{clock tick},
1851 quindi se si vuole il tempo in secondi occorre dividere il risultato per la
1852 costante \const{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard
1853 ANSI C, POSIX richiede che \const{CLOCKS\_PER\_SEC} sia definito pari a
1854 1000000 indipendentemente dalla risoluzione del timer di sistema.} In genere
1855 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
1856 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
1857 riprenderà lo stesso valore iniziale.
1859 % TODO questi valori sono obsoleti, verificare il tutto.
1861 Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di CPU è la somma di
1862 altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
1863 quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
1864 possono essere letti attraverso la funzione \funcd{times}, il cui prototipo è:
1865 \begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
1866 Legge in \param{buf} il valore corrente dei tempi di processore.
1868 \bodydesc{La funzione ritorna il numero di \itindex{clock~tick}
1869 \textit{clock tick} dall'avvio del sistema in caso di successo e -1 in
1873 La funzione restituisce i valori di \textit{process time} del processo
1874 corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
1875 in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
1876 due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
1877 \textit{system time} del processo, così come definiti in
1878 sez.~\ref{sec:sys_unix_time}.
1880 \begin{figure}[!htb]
1883 \begin{minipage}[c]{\textwidth}
1884 \includestruct{listati/tms.h}
1887 \caption{La struttura \structd{tms} dei tempi di processore associati a un
1889 \label{fig:sys_tms_struct}
1892 Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
1893 time} ed del \textit{system time} di tutti i processi figli che sono
1894 terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
1895 \var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
1896 ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.
1898 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
1899 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
1900 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
1901 lo stato di terminazione di tutti i suoi figli, questi processi
1902 ``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi.
1904 \itindend{process~time}
1907 \subsection{Le funzioni per il \textit{calendar time}}
1908 \label{sec:sys_time_base}
1910 \itindbeg{calendar~time}
1912 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
1913 mantenuto dal kernel in una variabile di tipo \type{time\_t},\footnote{in
1914 realtà il kernel usa una rappresentazione interna di che fornisce una
1915 precisione molto maggiore, e consente per questo anche di usare
1916 rappresentazioni diverse del \textit{calendar time}.} che usualmente
1917 corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
1918 che di norma corrisponde a 32 bit). Il valore corrente del \textit{calendar
1919 time}, che indicheremo come \textsl{tempo di sistema}, può essere ottenuto
1920 con la funzione \funcd{time} che lo restituisce nel suddetto formato; il suo
1922 \begin{prototype}{time.h}{time\_t time(time\_t *t)}
1923 Legge il valore corrente del \textit{calendar time}.
1925 \bodydesc{La funzione ritorna il valore del \textit{calendar time} in caso
1926 di successo e -1 in caso di errore, che può essere solo \errval{EFAULT}.}
1928 \noindent dove \param{t}, se non nullo, deve essere l'indirizzo di una
1929 variabile su cui duplicare il valore di ritorno.
1931 Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
1932 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
1933 sia necessario; il suo prototipo è:
1934 \begin{prototype}{time.h}{int stime(time\_t *t)}
1935 Imposta a \param{t} il valore corrente del \textit{calendar time}.
1937 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
1938 che può essere \errval{EFAULT} o \errval{EPERM}.}
1940 \noindent dato che modificare l'ora ha un impatto su tutto il sistema
1941 il cambiamento dell'orologio è una operazione privilegiata e questa funzione
1942 può essere usata solo da un processo con i privilegi di amministratore,
1943 altrimenti la chiamata fallirà con un errore di \errcode{EPERM}.
1945 Data la scarsa precisione nell'uso di \type{time\_t} (che ha una risoluzione
1946 massima di un secondo) quando si devono effettuare operazioni sui tempi di
1947 norma l'uso delle funzioni precedenti è sconsigliato, ed esse sono di solito
1948 sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le due
1949 funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
1950 \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
1951 in BSD4.3 sono indicate come sostitute delle precedenti.} i cui prototipi
1954 \headdecl{sys/time.h}
1957 \funcdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
1959 Legge il tempo corrente del sistema.
1961 \funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
1964 Imposta il tempo di sistema.
1966 \bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
1967 caso di errore, nel qual caso \var{errno} può assumere i valori
1968 \errval{EINVAL} \errval{EFAULT} e per \func{settimeofday} anche
1972 Si noti come queste funzioni utilizzino per indicare il tempo una struttura di
1973 tipo \struct{timeval}, la cui definizione si è già vista in
1974 fig.~\ref{fig:sys_timeval_struct}, questa infatti permette una espressione
1975 alternativa dei valori del \textit{calendar time}, con una precisione,
1976 rispetto a \type{time\_t}, fino al microsecondo.\footnote{la precisione è solo
1977 teorica, la precisione reale della misura del tempo dell'orologio di sistema
1978 non dipende dall'uso di queste strutture.}
1980 Come nel caso di \func{stime} anche \func{settimeofday} (la cosa continua a
1981 valere per qualunque funzione che vada a modificare l'orologio di sistema,
1982 quindi anche per quelle che tratteremo in seguito) può essere utilizzata solo
1983 da un processo coi privilegi di amministratore.\footnote{più precisamente la
1984 capabitity \const{CAP\_SYS\_TIME}.}
1986 Il secondo argomento di entrambe le funzioni è una struttura
1987 \struct{timezone}, che storicamente veniva utilizzata per specificare appunto
1988 la \textit{time zone}, cioè l'insieme del fuso orario e delle convenzioni per
1989 l'ora legale che permettevano il passaggio dal tempo universale all'ora
1990 locale. Questo argomento oggi è obsoleto ed in Linux non è mai stato
1991 utilizzato; esso non è supportato né dalle vecchie \textsl{libc5}, né dalle
1992 \textsl{glibc}: pertanto quando si chiama questa funzione deve essere sempre
1993 impostato a \val{NULL}.
1995 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
1996 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
1997 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
1998 conseguenze indesiderate. Ad esempio se si porta avanti l'orologio si possono
1999 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
2000 saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
2001 delle operazioni previste nell'intervallo di tempo che viene ripetuto.
2003 Per questo motivo la modalità più corretta per impostare l'ora è quella di
2004 usare la funzione \funcd{adjtime}, il cui prototipo è:
2005 \begin{prototype}{sys/time.h}
2006 {int adjtime(const struct timeval *delta, struct timeval *olddelta)}
2008 Aggiusta del valore \param{delta} l'orologio di sistema.
2010 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
2011 errore, nel qual caso \var{errno} assumerà il valore \errcode{EPERM}.}
2014 Questa funzione permette di avere un aggiustamento graduale del tempo di
2015 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
2016 di \param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
2017 positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
2018 il tempo richiesto, altrimenti sarà rallentato. Il secondo argomento viene
2019 usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
2023 \begin{figure}[!htb]
2024 \footnotesize \centering
2025 \begin{minipage}[c]{\textwidth}
2026 \includestruct{listati/timex.h}
2029 \caption{La struttura \structd{timex} per il controllo dell'orologio di
2031 \label{fig:sys_timex_struct}
2034 Linux poi prevede un'altra funzione, che consente un aggiustamento molto più
2035 dettagliato del tempo, permettendo ad esempio anche di modificare anche la
2036 velocità dell'orologio di sistema. La funzione è \funcd{adjtimex} ed il suo
2038 \begin{prototype}{sys/timex.h}
2039 {int adjtimex(struct timex *buf)}
2041 Aggiusta del valore \param{delta} l'orologio di sistema.
2043 \bodydesc{La funzione restituisce lo stato dell'orologio (un valore $>0$) in
2044 caso di successo e -1 in caso di errore, nel qual caso \var{errno}
2045 assumerà i valori \errval{EFAULT}, \errval{EINVAL} ed \errval{EPERM}.}
2048 La funzione richiede una struttura di tipo \struct{timex}, la cui definizione,
2049 così come effettuata in \headfile{sys/timex.h}, è riportata in
2050 fig.~\ref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore
2051 del campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
2052 specificato in un opportuno campo di \struct{timex}, deve essere impostato. Un
2053 valore nullo serve per leggere i parametri correnti; i valori diversi da zero
2054 devono essere specificati come OR binario delle costanti riportate in
2055 tab.~\ref{tab:sys_timex_mode}.
2057 La funzione utilizza il meccanismo di David L. Mills, descritto
2058 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
2059 protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
2060 portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
2061 \func{ntp\_adjtime}. La trattazione completa di questa funzione necessita di
2062 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
2063 a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
2064 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
2065 campi della struttura \struct{timex} può essere ritrovato in \cite{GlibcMan}.
2070 \begin{tabular}[c]{|l|c|p{8.5cm}|}
2072 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2075 \const{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
2076 reale e l'orologio di sistema:
2077 deve essere indicata in microsecondi
2078 nel campo \var{offset} di
2080 \const{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenze in frequenza
2081 fra il tempo reale e l'orologio di
2082 sistema: deve essere indicata
2083 in parti per milione nel campo
2084 \var{frequency} di \struct{timex}.\\
2085 \const{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo
2087 sul tempo, espresso in microsecondi
2088 nel campo \var{maxerror} di
2090 \const{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
2091 sul tempo, espresso in microsecondi
2092 nel campo \var{esterror} di
2094 \const{ADJ\_STATUS} & 0x0010 & Imposta alcuni
2095 valori di stato interni usati dal
2096 sistema nella gestione
2097 dell'orologio specificati nel campo
2098 \var{status} di \struct{timex}.\\
2099 \const{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del
2100 PLL implementato dal kernel,
2101 specificato nel campo
2102 \var{constant} di \struct{timex}.\\
2103 \const{ADJ\_TICK} & 0x4000 & Imposta il valore dei \textit{tick}
2104 \itindex{clock~tick} del timer in
2105 microsecondi, espresso nel campo
2106 \var{tick} di \struct{timex}.\\
2107 \const{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Imposta uno spostamento una tantum
2108 dell'orologio secondo il valore del
2109 campo \var{offset} simulando il
2110 comportamento di \func{adjtime}.\\
2113 \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
2114 struttura \struct{timex}.}
2115 \label{tab:sys_timex_mode}
2118 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
2119 sintassi specificata per la forma equivalente di questa funzione definita come
2120 \func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
2126 \begin{tabular}[c]{|l|c|l|}
2128 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2131 \const{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
2132 \const{TIME\_INS} & 1 & Insert leap second.\\
2133 \const{TIME\_DEL} & 2 & Delete leap second.\\
2134 \const{TIME\_OOP} & 3 & Leap second in progress.\\
2135 \const{TIME\_WAIT} & 4 & Leap second has occurred.\\
2136 \const{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
2139 \caption{Possibili valori di ritorno di \func{adjtimex}.}
2140 \label{tab:sys_adjtimex_return}
2143 La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
2144 sistema; questo può assumere i valori riportati in
2145 tab.~\ref{tab:sys_adjtimex_return}. Un valore di -1 viene usato per riportare
2146 un errore; al solito se si cercherà di modificare l'orologio di sistema
2147 (specificando un \var{mode} diverso da zero) senza avere i privilegi di
2148 amministratore si otterrà un errore di \errcode{EPERM}.
2152 \subsection{La gestione delle date.}
2153 \label{sec:sys_date}
2155 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
2156 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
2157 illustrate, se han senso per specificare un intervallo, non sono molto
2158 intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
2159 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2160 time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2161 time} usuale in ore, minuti, secondi, ecc.
2163 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
2164 definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
2165 struttura che si utilizza quando si deve specificare un tempo a partire dai
2166 dati naturali (ora e data), dato che essa consente anche di trattare la
2167 gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
2168 \var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste da BSD e dalle
2169 \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
2170 fig.~\ref{fig:sys_tm_struct}.}
2172 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2173 da quelle usate per convertire gli altri formati in questo, usando o meno
2174 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2175 tempo in una stringa contenente data ed ora, i loro prototipi sono:
2178 \funcdecl{char *\funcd{asctime}(const struct tm *tm)}
2179 Produce una stringa con data e ora partendo da un valore espresso in
2180 \textit{broken-down time}.
2182 \funcdecl{char *\funcd{ctime}(const time\_t *timep)}
2183 Produce una stringa con data e ora partendo da un valore espresso in
2184 in formato \type{time\_t}.
2186 \funcdecl{struct tm *\funcd{gmtime}(const time\_t *timep)}
2187 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2188 \textit{broken-down time} espresso in UTC.
2190 \funcdecl{struct tm *\funcd{localtime}(const time\_t *timep)}
2191 Converte il \textit{calendar time} dato in formato \type{time\_t} in un
2192 \textit{broken-down time} espresso nell'ora locale.
2194 \funcdecl{time\_t \funcd{mktime}(struct tm *tm)}
2195 Converte il \textit{broken-down time} in formato \type{time\_t}.
2197 \bodydesc{Tutte le funzioni restituiscono un puntatore al risultato in caso
2198 di successo e \val{NULL} in caso di errore, tranne che \func{mktime} che
2199 restituisce direttamente il valore o -1 in caso di errore.}
2202 \begin{figure}[!htb]
2203 \footnotesize \centering
2204 \begin{minipage}[c]{\textwidth}
2205 \includestruct{listati/tm.h}
2208 \caption{La struttura \structd{tm} per una rappresentazione del tempo in
2209 termini di ora, minuti, secondi, ecc.}
2210 \label{fig:sys_tm_struct}
2215 Le prime due funzioni, \func{asctime} e \func{ctime} servono per poter
2216 stampare in forma leggibile un tempo; esse restituiscono il puntatore ad una
2217 stringa, allocata staticamente, nella forma:
2219 "Wed Jun 30 21:49:08 1993\n"
2221 e impostano anche la variabile \var{tzname} con l'informazione della
2222 \textit{time zone} corrente; \func{ctime} è banalmente definita in termini di
2223 \func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
2224 statica rende le funzioni non \index{funzioni!rientranti} rientranti POSIX.1c
2225 e SUSv2 prevedono due sostitute \index{funzioni!rientranti} rientranti, il cui
2226 nome è al solito ottenuto aggiungendo un \code{\_r}, che prendono un secondo
2227 argomento \code{char *buf}, in cui l'utente deve specificare il buffer su cui
2228 la stringa deve essere copiata (deve essere di almeno 26 caratteri).
2230 Le altre tre funzioni, \func{gmtime}, \func{localtime} e \func{mktime} servono
2231 per convertire il tempo dal formato \type{time\_t} a quello di \struct{tm} e
2232 viceversa; \func{gmtime} effettua la conversione usando il tempo coordinato
2233 universale (UTC), cioè l'ora di Greenwich; mentre \func{localtime} usa l'ora
2234 locale; \func{mktime} esegue la conversione inversa.
2236 Anche in questo caso le prime due funzioni restituiscono l'indirizzo di una
2237 struttura allocata staticamente, per questo sono state definite anche altre
2238 due versioni \index{funzioni!rientranti} rientranti (con la solita estensione
2239 \code{\_r}), che prevedono un secondo argomento \code{struct tm *result},
2240 fornito dal chiamante, che deve preallocare la struttura su cui sarà
2241 restituita la conversione.
2243 Come mostrato in fig.~\ref{fig:sys_tm_struct} il \textit{broken-down time}
2244 permette di tenere conto anche della differenza fra tempo universale e ora
2245 locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
2246 \index{variabili!globali} variabili globali mostrate in
2247 fig.~\ref{fig:sys_tzname}, cui si accede quando si include
2248 \headfile{time.h}. Queste variabili vengono impostate quando si chiama una
2249 delle precedenti funzioni di conversione, oppure invocando direttamente la
2250 funzione \funcd{tzset}, il cui prototipo è:
2251 \begin{prototype}{sys/timex.h}
2254 Imposta le variabili globali della \textit{time zone}.
2256 \bodydesc{La funzione non ritorna niente e non dà errori.}
2259 La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire
2260 dal valore della variabile di ambiente \envvar{TZ}, se quest'ultima non è
2261 definita verrà usato il file \conffile{/etc/localtime}.
2263 \begin{figure}[!htb]
2266 \begin{minipage}[c]{\textwidth}
2267 \includestruct{listati/time_zone_var.c}
2270 \caption{Le \index{variabili!globali} variabili globali usate per la
2271 gestione delle \textit{time zone}.}
2272 \label{fig:sys_tzname}
2275 La variabile \var{tzname} contiene due stringhe, che indicano i due nomi
2276 standard della \textit{time zone} corrente. La prima è il nome per l'ora
2277 solare, la seconda per l'ora legale.\footnote{anche se sono indicati come
2278 \code{char *} non è il caso di modificare queste stringhe.} La variabile
2279 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2280 \var{daylight} indica se è attiva o meno l'ora legale.
2282 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2283 stampare un tempo o una data, la flessibilità non fa parte delle sue
2284 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2285 giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
2287 \begin{prototype}{time.h}
2288 {size\_t strftime(char *s, size\_t max, const char *format,
2289 const struct tm *tm)}
2291 Stampa il tempo \param{tm} nella stringa \param{s} secondo il formato
2294 \bodydesc{La funzione ritorna il numero di caratteri stampati in \param{s},
2295 altrimenti restituisce 0.}
2298 La funzione converte opportunamente il tempo \param{tm} in una stringa di
2299 testo da salvare in \param{s}, purché essa sia di dimensione, indicata da
2300 \param{size}, sufficiente. I caratteri generati dalla funzione vengono
2301 restituiti come valore di ritorno, ma non tengono conto del terminatore
2302 finale, che invece viene considerato nel computo della dimensione; se
2303 quest'ultima è eccessiva viene restituito 0 e lo stato di \param{s} è
2309 \begin{tabular}[c]{|c|l|p{6cm}|}
2311 \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2314 \var{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
2315 \var{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
2316 \var{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
2317 \var{\%B}&\texttt{April} & Nome del mese, completo.\\
2318 \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
2319 \var{\%d}&\texttt{24} & Giorno del mese.\\
2320 \var{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
2321 \var{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
2322 \var{\%j}&\texttt{114} & Giorno dell'anno.\\
2323 \var{\%m}&\texttt{04} & Mese dell'anno.\\
2324 \var{\%M}&\texttt{40} & Minuto.\\
2325 \var{\%p}&\texttt{PM} & AM/PM.\\
2326 \var{\%S}&\texttt{50} & Secondo.\\
2327 \var{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
2329 \var{\%w}&\texttt{3} & Giorno della settimana. \\
2330 \var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
2332 \var{\%x}&\texttt{04/24/02} & La data.\\
2333 \var{\%X}&\texttt{18:40:50} & L'ora.\\
2334 \var{\%y}&\texttt{02} & Anno nel secolo.\\
2335 \var{\%Y}&\texttt{2002} & Anno.\\
2336 \var{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
2337 \var{\%\%}&\texttt{\%} & Il carattere \%.\\
2340 \caption{Valori previsti dallo standard ANSI C per modificatore della
2341 stringa di formato di \func{strftime}.}
2342 \label{tab:sys_strftime_format}
2345 Il risultato della funzione è controllato dalla stringa di formato
2346 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2347 viene utilizzato come modificatore; alcuni\footnote{per la precisione quelli
2348 definiti dallo standard ANSI C, che sono anche quelli riportati da POSIX.1;
2349 le \acr{glibc} provvedono tutte le estensioni introdotte da POSIX.2 per il
2350 comando \cmd{date}, i valori introdotti da SVID3 e ulteriori estensioni GNU;
2351 l'elenco completo dei possibili valori è riportato nella pagina di manuale
2352 della funzione.} dei possibili valori che esso può assumere sono riportati
2353 in tab.~\ref{tab:sys_strftime_format}. La funzione tiene conto anche della
2354 presenza di una localizzazione per stampare in maniera adeguata i vari nomi.
2356 \itindend{calendar~time}
2359 \section{La gestione degli errori}
2360 \label{sec:sys_errors}
2362 In questa sezione esamineremo le caratteristiche principali della gestione
2363 degli errori in un sistema unix-like. Infatti a parte il caso particolare di
2364 alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
2365 unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
2366 un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
2367 semplicemente usando un opportuno valore di ritorno della funzione invocata.
2368 Inoltre il sistema di classificazione degli errori è basato sull'architettura
2369 a processi, e presenta una serie di problemi nel caso lo si debba usare con i
2370 \itindex{thread} \textit{thread}.
2373 \subsection{La variabile \var{errno}}
2374 \label{sec:sys_errno}
2376 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2377 riportare condizioni di errore, ed è una norma fondamentale di buona
2378 programmazione controllare \textbf{sempre} che le funzioni chiamate si siano
2379 concluse correttamente.
2381 In genere le funzioni di libreria usano un valore speciale per indicare che
2382 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
2383 costante \val{EOF} (a seconda della funzione); ma questo valore segnala solo
2384 che c'è stato un errore, non il tipo di errore.
2386 Per riportare il tipo di errore il sistema usa \index{variabili!globali} la
2387 variabile globale \var{errno},\footnote{l'uso di una variabile globale può
2388 comportare alcuni problemi (ad esempio nel caso dei \itindex{thread}
2389 \textit{thread}) ma lo standard ISO C consente anche di definire \var{errno}
2390 come un \textit{modifiable lvalue}, quindi si può anche usare una macro, e
2391 questo è infatti il modo usato da Linux per renderla locale ai singoli
2392 \itindex{thread} \textit{thread}.} definita nell'header \headfile{errno.h};
2393 la variabile è in genere definita come \direct{volatile} dato che può essere
2394 cambiata in modo asincrono da un segnale (si veda sez.~\ref{sec:sig_sigchld}
2395 per un esempio, ricordando quanto trattato in sez.~\ref{sec:proc_race_cond}),
2396 ma dato che un gestore di segnale scritto bene salva e ripristina il valore
2397 della variabile, di questo non è necessario preoccuparsi nella programmazione
2400 I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
2401 nell'header \headfile{errno.h} sono anche definiti i nomi simbolici per le
2402 costanti numeriche che identificano i vari errori; essi iniziano tutti per
2403 \val{E} e si possono considerare come nomi riservati. In seguito faremo sempre
2404 riferimento a tali valori, quando descriveremo i possibili errori restituiti
2405 dalle funzioni. Il programma di esempio \cmd{errcode} stampa il codice
2406 relativo ad un valore numerico con l'opzione \cmd{-l}.
2408 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
2409 programma, gran parte delle funzioni di libreria impostano \var{errno} ad un
2410 valore diverso da zero in caso di errore. Il valore è invece indefinito in
2411 caso di successo, perché anche se una funzione ha successo, può chiamarne
2412 altre al suo interno che falliscono, modificando così \var{errno}.
2414 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
2415 essere il risultato di un errore precedente) e non lo si può usare per
2416 determinare quando o se una chiamata a funzione è fallita. La procedura da
2417 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
2418 verificato il fallimento della funzione attraverso il suo codice di ritorno.
2421 \subsection{Le funzioni \func{strerror} e \func{perror}}
2422 \label{sec:sys_strerror}
2424 Benché gli errori siano identificati univocamente dal valore numerico di
2425 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
2426 riportare in opportuni messaggi le condizioni di errore verificatesi. La
2427 prima funzione che si può usare per ricavare i messaggi di errore è
2428 \funcd{strerror}, il cui prototipo è:
2429 \begin{prototype}{string.h}{char *strerror(int errnum)}
2430 Restituisce una stringa con il messaggio di errore relativo ad
2433 \bodydesc{La funzione ritorna il puntatore ad una stringa di errore.}
2437 La funzione ritorna il puntatore alla stringa contenente il messaggio di
2438 errore corrispondente al valore di \param{errnum}, se questo non è un valore
2439 valido verrà comunque restituita una stringa valida contenente un messaggio
2440 che dice che l'errore è sconosciuto, e \var{errno} verrà modificata assumendo
2441 il valore \errval{EINVAL}.
2443 In generale \func{strerror} viene usata passando \var{errno} come argomento,
2444 ed il valore di quest'ultima non verrà modificato. La funzione inoltre tiene
2445 conto del valore della variabile di ambiente \envvar{LC\_MESSAGES} per usare
2446 le appropriate traduzioni dei messaggi d'errore nella localizzazione presente.
2448 La funzione utilizza una stringa statica che non deve essere modificata dal
2449 programma; essa è utilizzabile solo fino ad una chiamata successiva a
2450 \func{strerror} o \func{perror}, nessun'altra funzione di libreria tocca
2451 questa stringa. In ogni caso l'uso di una stringa statica rende la funzione
2452 non \index{funzioni!rientranti} rientrante, per cui nel caso si usino i
2453 \itindex{thread} \textit{thread} le librerie forniscono\footnote{questa
2454 funzione è la versione prevista dalle \acr{glibc}, ed effettivamente
2455 definita in \headfile{string.h}, ne esiste una analoga nello standard SUSv3
2456 (quella riportata dalla pagina di manuale), che restituisce \code{int} al
2457 posto di \code{char *}, e che tronca la stringa restituita a
2458 \param{size}.} una apposita versione \index{funzioni!rientranti} rientrante
2459 \funcd{strerror\_r}, il cui prototipo è:
2460 \begin{prototype}{string.h}
2461 {char * strerror\_r(int errnum, char *buf, size\_t size)}
2463 Restituisce una stringa con il messaggio di errore relativo ad
2466 \bodydesc{La funzione restituisce l'indirizzo del messaggio in caso di
2467 successo e \val{NULL} in caso di errore; nel qual caso \var{errno}
2470 \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
2472 \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
2473 contenere la stringa di errore.
2478 La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
2479 nel buffer \param{buf} che il singolo \itindex{thread} \textit{thread} deve
2480 allocare autonomamente per evitare i problemi connessi alla condivisione del
2481 buffer statico. Il messaggio è copiato fino alla dimensione massima del
2482 buffer, specificata dall'argomento
2483 \param{size}, che deve comprendere pure il carattere di terminazione;
2484 altrimenti la stringa viene troncata.
2486 Una seconda funzione usata per riportare i codici di errore in maniera
2487 automatizzata sullo standard error è \funcd{perror}, il cui prototipo è:
2488 \begin{prototype}{stdio.h}{void perror(const char *message)}
2489 Stampa il messaggio di errore relativo al valore corrente di \var{errno}
2490 sullo standard error; preceduto dalla stringa \param{message}.
2493 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
2494 in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
2495 riferiscono all'ultimo errore avvenuto. La stringa specificata con
2496 \param{message} viene stampato prima del messaggio d'errore, seguita dai due
2497 punti e da uno spazio, il messaggio è terminato con un a capo.
2499 Il messaggio può essere riportato anche usando le due
2500 \index{variabili!globali} variabili globali:
2501 \includecodesnip{listati/errlist.c}
2502 dichiarate in \headfile{errno.h}. La prima contiene i puntatori alle stringhe
2503 di errore indicizzati da \var{errno}; la seconda esprime il valore più alto
2504 per un codice di errore, l'utilizzo di questa stringa è sostanzialmente
2505 equivalente a quello di \func{strerror}.
2507 \begin{figure}[!htbp]
2508 \footnotesize \centering
2509 \begin{minipage}[c]{\codesamplewidth}
2510 \includecodesample{listati/errcode_mess.c}
2513 \caption{Codice per la stampa del messaggio di errore standard.}
2514 \label{fig:sys_err_mess}
2517 In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
2518 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
2519 errore e le costanti usate per identificare i singoli errori; il sorgente
2520 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
2521 gestione delle opzioni e tutte le definizioni necessarie ad associare il
2522 valore numerico alla costante simbolica. In particolare si è riportata la
2523 sezione che converte la stringa passata come argomento in un intero
2524 (\texttt{\small 1--2}), controllando con i valori di ritorno di \funcm{strtol}
2525 che la conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi
2526 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
2527 11--14}) o la macro (\texttt{\small 15--17}) associate a quel codice.
2531 \subsection{Alcune estensioni GNU}
2532 \label{sec:sys_err_GNU}
2534 Le precedenti funzioni sono quelle definite ed usate nei vari standard; le
2535 \acr{glibc} hanno però introdotto una serie di estensioni ``GNU'' che
2536 forniscono alcune funzionalità aggiuntive per una gestione degli errori
2537 semplificata e più efficiente.
2539 La prima estensione consiste in due variabili, \code{char *
2540 program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
2541 servono per ricavare il nome del programma; queste sono utili quando si deve
2542 aggiungere il nome del programma (cosa comune quando si ha un programma che
2543 non viene lanciato da linea di comando e salva gli errori in un file di log)
2544 al messaggio d'errore. La prima contiene il nome usato per lanciare il
2545 programma (ed è equivalente ad \code{argv[0]}); la seconda mantiene solo il
2546 nome del programma (senza eventuali directory in testa).
2548 Uno dei problemi che si hanno con l'uso di \func{perror} è che non c'è
2549 flessibilità su quello che si può aggiungere al messaggio di errore, che può
2550 essere solo una stringa. In molte occasioni invece serve poter scrivere dei
2551 messaggi con maggiore informazione; ad esempio negli standard di
2552 programmazione GNU si richiede che ogni messaggio di errore sia preceduto dal
2553 nome del programma, ed in generale si può voler stampare il contenuto di
2554 qualche variabile; per questo le \acr{glibc} definiscono la funzione
2555 \funcd{error}, il cui prototipo è:
2556 \begin{prototype}{stdio.h}
2557 {void error(int status, int errnum, const char *format, ...)}
2559 Stampa un messaggio di errore formattato.
2561 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2564 La funzione fa parte delle estensioni GNU per la gestione degli errori,
2565 l'argomento \param{format} prende la stessa sintassi di \func{printf}, ed i
2566 relativi argomenti devono essere forniti allo stesso modo, mentre
2567 \param{errnum} indica l'errore che si vuole segnalare (non viene quindi usato
2568 il valore corrente di \var{errno}); la funzione stampa sullo standard error il
2569 nome del programma, come indicato dalla \index{variabili!globali} variabile
2570 globale \var{program\_name}, seguito da due punti ed uno spazio, poi dalla
2572 \param{format} e dagli argomenti seguenti, seguita da due punti ed uno spazio
2573 infine il messaggio di errore relativo ad \param{errnum}, il tutto è terminato
2576 Il comportamento della funzione può essere ulteriormente controllato se si
2577 definisce una variabile \var{error\_print\_progname} come puntatore ad una
2578 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
2579 il nome del programma.
2581 L'argomento \param{status} può essere usato per terminare direttamente il
2582 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
2583 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
2584 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
2585 un'altra \index{variabili!globali} variabile globale,
2586 \var{error\_message\_count}, che tiene conto di quanti errori ci sono stati.
2588 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
2589 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
2590 l'errore è \funcd{error\_at\_line}; il suo prototipo è:
2591 \begin{prototype}{stdio.h}
2592 {void error\_at\_line(int status, int errnum, const char *fname,
2593 unsigned int lineno, const char *format, ...)}
2595 Stampa un messaggio di errore formattato.
2597 \bodydesc{La funzione non restituisce nulla e non riporta errori.}
2599 \noindent ed il suo comportamento è identico a quello di \func{error} se non
2600 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
2601 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
2602 stampa del nome del programma. Inoltre essa usa un'altra
2603 \index{variabili!globali} variabile globale, \var{error\_one\_per\_line}, che
2604 impostata ad un valore diverso da zero fa si che errori relativi alla stessa
2605 linea non vengano ripetuti.
2608 % LocalWords: filesystem like kernel saved header limits sysconf sez tab float
2609 % LocalWords: FOPEN stdio MB LEN CHAR char UCHAR unsigned SCHAR MIN signed INT
2610 % LocalWords: SHRT short USHRT int UINT LONG long ULONG LLONG ULLONG POSIX ARG
2611 % LocalWords: Stevens exec CHILD STREAM stream TZNAME timezone NGROUPS SSIZE
2612 % LocalWords: ssize LISTIO JOB CONTROL job control IDS VERSION YYYYMML bits bc
2613 % LocalWords: dall'header posix lim nell'header glibc run unistd name errno
2614 % LocalWords: NGROUP CLK TCK clock tick process PATH pathname BUF CANON path
2615 % LocalWords: pathconf fpathconf descriptor fd uname sys struct utsname info
2616 % LocalWords: EFAULT fig SOURCE NUL LENGTH DOMAIN NMLN UTSLEN system call proc
2617 % LocalWords: domainname sysctl BSD nlen void oldval size oldlenp newval EPERM
2618 % LocalWords: newlen ENOTDIR EINVAL ENOMEM linux array oldvalue paging stack
2619 % LocalWords: TCP shell Documentation ostype hostname osrelease version mount
2620 % LocalWords: const source filesystemtype mountflags ENODEV ENOTBLK block read
2621 % LocalWords: device EBUSY only EACCES NODEV ENXIO major
2622 % LocalWords: number EMFILE dummy ENAMETOOLONG ENOENT ELOOP virtual devfs MGC
2623 % LocalWords: magic MSK RDONLY NOSUID suid sgid NOEXEC SYNCHRONOUS REMOUNT MNT
2624 % LocalWords: MANDLOCK mandatory locking WRITE APPEND append IMMUTABLE NOATIME
2625 % LocalWords: access NODIRATIME BIND MOVE umount flags FORCE statfs fstatfs ut
2626 % LocalWords: buf ENOSYS EIO EBADF type fstab mntent home shadow username uid
2627 % LocalWords: passwd PAM Pluggable Authentication Method Service Switch pwd ru
2628 % LocalWords: getpwuid getpwnam NULL buflen result ERANGE getgrnam getgrgid AS
2629 % LocalWords: grp group gid SVID fgetpwent putpwent getpwent setpwent endpwent
2630 % LocalWords: fgetgrent putgrent getgrent setgrent endgrent accounting init HZ
2631 % LocalWords: runlevel Hierarchy logout setutent endutent utmpname utmp paths
2632 % LocalWords: WTMP getutent getutid getutline pututline LVL OLD DEAD EMPTY dev
2633 % LocalWords: line libc XPG utmpx getutxent getutxid getutxline pututxline who
2634 % LocalWords: setutxent endutxent wmtp updwtmp logwtmp wtmp host rusage utime
2635 % LocalWords: minflt majflt nswap fault swap timeval wait getrusage usage SELF
2636 % LocalWords: CHILDREN current limit soft RLIMIT address brk mremap mmap dump
2637 % LocalWords: SIGSEGV SIGXCPU SIGKILL sbrk FSIZE SIGXFSZ EFBIG LOCKS lock dup
2638 % LocalWords: MEMLOCK NOFILE NPROC fork EAGAIN SIGPENDING sigqueue kill RSS tv
2639 % LocalWords: resource getrlimit setrlimit rlimit rlim INFINITY capabilities
2640 % LocalWords: capability CAP l'I Sun Sparc PAGESIZE getpagesize SVr SUSv get
2641 % LocalWords: phys pages avphys NPROCESSORS CONF ONLN getloadavg stdlib double
2642 % LocalWords: loadavg nelem scheduler CONFIG ACCT acct filename EUSER
2643 % LocalWords: ENFILE EROFS PACCT AcctCtrl cap calendar UTC Jan the Epoch GMT
2644 % LocalWords: Greenwich Mean l'UTC timer CLOCKS SEC cron wall elapsed times tz
2645 % LocalWords: tms cutime cstime waitpid gettimeofday settimeofday timex
2646 % LocalWords: timespec adjtime olddelta adjtimex David Mills RFC NTP ntp
2647 % LocalWords: nell'RFC ADJ FREQUENCY frequency MAXERROR maxerror ESTERROR PLL
2648 % LocalWords: esterror TIMECONST constant SINGLESHOT MOD INS insert leap OOP
2649 % LocalWords: second delete progress has occurred BAD broken tm gmtoff asctime
2650 % LocalWords: ctime timep gmtime localtime mktime tzname tzset daylight format
2651 % LocalWords: strftime thread EOF modifiable lvalue app errcode strerror LC at
2652 % LocalWords: perror string errnum MESSAGES error message ErrCode strtol log
2653 % LocalWords: program invocation argv printf print progname exit count fname
2654 % LocalWords: lineno one standardese Di page Wed Wednesday Apr April PM AM
2659 %%% Local Variables:
2661 %%% TeX-master: "gapil"