3 %% Copyright (C) 2000-2019 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 caratteristiche 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 \constd{MB\_LEN\_MAX}& 16 & Massima dimensione di un
82 \constd{CHAR\_BIT} & 8 & Numero di bit di \ctyp{char}.\\
83 \constd{UCHAR\_MAX}& 255 & Massimo di \ctyp{unsigned char}.\\
84 \constd{SCHAR\_MIN}& -128 & Minimo di \ctyp{signed char}.\\
85 \constd{SCHAR\_MAX}& 127 & Massimo di \ctyp{signed char}.\\
86 \constd{CHAR\_MIN} & 0 o -128 & Minimo di \ctyp{char}.\footnotemark\\
87 \constd{CHAR\_MAX} & 127 o 255 & Massimo di \ctyp{char}.\footnotemark\\
88 \constd{SHRT\_MIN} & -32768 & Minimo di \ctyp{short}.\\
89 \constd{SHRT\_MAX} & 32767 & Massimo di \ctyp{short}.\\
90 \constd{USHRT\_MAX}& 65535 & Massimo di \ctyp{unsigned short}.\\
91 \constd{INT\_MAX} & 2147483647 & Minimo di \ctyp{int}.\\
92 \constd{INT\_MIN} &-2147483648 & Minimo di \ctyp{int}.\\
93 \constd{UINT\_MAX} & 4294967295 & Massimo di \ctyp{unsigned int}.\\
94 \constd{LONG\_MAX} & 2147483647 & Massimo di \ctyp{long}.\\
95 \constd{LONG\_MIN} &-2147483648 & Minimo di \ctyp{long}.\\
96 \constd{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 \headfiled{float.h}.
121 \begin{tabular}[c]{|l|r|l|}
123 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
126 \constd{LLONG\_MAX} & 9223372036854775807& Massimo di \ctyp{long long}.\\
127 \constd{LLONG\_MIN} &-9223372036854775808& Minimo di \ctyp{long long}.\\
128 \constd{ULLONG\_MAX}&18446744073709551615& Massimo di \ctyp{unsigned 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, \constd{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 \constd{ARG\_MAX} &131072& Dimensione massima degli argomenti
160 passati ad una funzione della famiglia
162 \constd{CHILD\_MAX} & 999& Numero massimo di processi contemporanei
163 che un utente può eseguire.\\
164 \constd{OPEN\_MAX} & 256& Numero massimo di file che un processo
165 può mantenere aperti in contemporanea.\\
166 \constd{STREAM\_MAX}& 8& Massimo numero di stream aperti per
167 processo in contemporanea.\\
168 \constd{TZNAME\_MAX}& 6& Dimensione massima del nome di una
169 \textit{timezone} (vedi
170 sez.~\ref{sec:sys_time_base})).\\
171 \constd{NGROUPS\_MAX}& 32& Numero di gruppi supplementari per
172 processo (vedi sez.~\ref{sec:proc_access_id}).\\
173 \constd{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 \macrod{\_POSIX\_ARG\_MAX} & 4096& Dimensione massima degli argomenti
196 passati ad una funzione della famiglia
198 \macrod{\_POSIX\_CHILD\_MAX} & 6& Numero massimo di processi
199 contemporanei che un utente può
201 \macrod{\_POSIX\_OPEN\_MAX} & 16& Numero massimo di file che un processo
202 può mantenere aperti in
204 \macrod{\_POSIX\_STREAM\_MAX}& 8& Massimo numero di stream aperti per
205 processo in contemporanea.\\
206 \macrod{\_POSIX\_TZNAME\_MAX}& 6& Dimensione massima del nome di una
208 (vedi sez.~\ref{sec:sys_date}). \\
209 \macrod{\_POSIX\_RTSIG\_MAX} & 8& Numero massimo di segnali
210 \textit{real-time} (vedi
211 sez.~\ref{sec:sig_real_time}).\\
212 \macrod{\_POSIX\_NGROUPS\_MAX}& 0& Numero di gruppi supplementari per
214 sez.~\ref{sec:proc_access_id}).\\
215 \macrod{\_POSIX\_SSIZE\_MAX} &32767& Valore massimo del tipo
217 % \macrod{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
218 % \macrod{\_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 \macrod{\_POSIX\_JOB\_CONTROL}& Il sistema supporta il
256 \textit{job control} (vedi
257 sez.~\ref{sec:sess_job_control}).\\
258 \macrod{\_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 \macrod{\_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 della \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 della \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 \const{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 \textit{clock tick} al secondo,
348 cioè l'unità di misura del
349 \textit{process time} (vedi
350 sez.~\ref{sec:sys_unix_time}).\\
351 \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
352 Indica se è supportato il \textit{job
354 sez.~\ref{sec:sess_job_control}) in stile
356 \texttt{\_SC\_SAVED\_IDS} & \macro{\_POSIX\_SAVED\_IDS}&
357 Indica se il sistema supporta i
358 \textit{saved id} (vedi
359 sez.~\ref{sec:proc_access_id}).\\
360 \texttt{\_SC\_VERSION} & \macro{\_POSIX\_VERSION} &
361 Indica il mese e l'anno di approvazione
362 della revisione dello standard POSIX.1 a cui
363 il sistema fa riferimento, nel formato
364 YYYYMML, la revisione più recente è 199009L,
365 che indica il Settembre 1990.\\
368 \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
369 \label{tab:sys_sysconf_par}
372 In generale ogni limite o caratteristica del sistema per cui è definita una
373 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
374 essere ottenuto attraverso una chiamata a \func{sysconf}. Il nome della
375 costante da utilizzare come valore dell'argomento \param{name} si otterrà
376 aggiungendo \code{\_SC\_} ai nomi delle costanti definite dai primi due
377 standard (quelle di tab.~\ref{tab:sys_generic_macro}), o sostituendolo a
378 \code{\_POSIX\_} per le costanti definite dagli altri due standard (quelle di
379 tab.~\ref{tab:sys_posix1_general}).
381 In linea teorica si dovrebbe fare uso di \func{sysconf} solo quando la
382 relativa costante di sistema non è definita, quindi con un codice analogo al
384 \includecodesnip{listati/get_child_max.c}
385 ma in realtà con Linux queste costanti sono comunque definite, indicando però
386 un limite generico che non è detto sia corretto; per questo motivo è sempre
387 meglio usare i valori restituiti da \func{sysconf}.
390 \subsection{Limiti e caratteristiche dei file}
391 \label{sec:sys_file_limits}
393 Come per le caratteristiche generali del sistema anche per i file esistono una
394 serie di limiti (come la lunghezza del nome del file o il numero massimo di
395 link) che dipendono sia dall'implementazione che dal filesystem in uso. Anche
396 in questo caso lo standard prevede alcune macro che ne specificano il valore,
397 riportate in tab.~\ref{tab:sys_file_macro}.
402 \begin{tabular}[c]{|l|r|l|}
404 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
407 \constd{LINK\_MAX} &8 & Numero massimo di link a un file.\\
408 \constd{NAME\_MAX}& 14 & Lunghezza in byte di un nome di file. \\
409 \constd{PATH\_MAX}& 256 & Lunghezza in byte di un \textit{pathname}.\\
410 \constd{PIPE\_BUF}&4096 & Byte scrivibili atomicamente in una \textit{pipe}
411 (vedi sez.~\ref{sec:ipc_pipes}).\\
412 \constd{MAX\_CANON}&255 & Dimensione di una riga di terminale in modo
413 canonico (vedi sez.~\ref{sec:term_io_design}).\\
414 \constd{MAX\_INPUT}&255 & Spazio disponibile nella coda di input
416 sez.~\ref{sec:term_io_design}).\\
419 \caption{Costanti per i limiti sulle caratteristiche dei file.}
420 \label{tab:sys_file_macro}
423 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
424 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
425 conforme deve rispettare. Le relative macro sono riportate in
426 tab.~\ref{tab:sys_posix1_file} e per esse vale lo stesso discorso fatto per le
427 analoghe di tab.~\ref{tab:sys_posix1_general}.
432 \begin{tabular}[c]{|l|r|l|}
434 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
437 \macrod{\_POSIX\_LINK\_MAX} &8 & Numero massimo di link a un file.\\
438 \macrod{\_POSIX\_NAME\_MAX}& 14 & Lunghezza in byte di un nome di file.\\
439 \macrod{\_POSIX\_PATH\_MAX}& 256 & Lunghezza in byte di un
441 \macrod{\_POSIX\_PIPE\_BUF}& 512 & Byte scrivibili atomicamente in una
443 \macrod{\_POSIX\_MAX\_CANON}&255 & Dimensione di una riga di
444 terminale in modo canonico.\\
445 \macrod{\_POSIX\_MAX\_INPUT}&255 & Spazio disponibile nella coda di input
447 % \macrod{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
448 % \macrod{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
449 % \macrod{\_POSIX\_FD\_SETSIZE}& 16 & \\
450 % \macrod{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
453 \caption{Costanti dei valori minimi delle caratteristiche dei file per la
454 conformità allo standard POSIX.1.}
455 \label{tab:sys_posix1_file}
458 Tutti questi limiti sono definiti in \headfile{limits.h}; come nel caso
459 precedente il loro uso è di scarsa utilità in quanto ampiamente superati in
460 tutte le implementazioni moderne. In generale i limiti per i file sono molto
461 più soggetti ad essere variabili rispetto ai limiti generali del sistema; ad
462 esempio parametri come la lunghezza del nome del file o il numero di link
463 possono variare da filesystem a filesystem.
465 Per questo motivo quando si ha a che fare con limiti relativi ai file questi
466 devono essere sempre controllati con la funzione \funcd{pathconf}, il cui
471 \fdecl{long pathconf(char *path, int name)}
472 \fdesc{Restituisce il valore di un parametro dei file.}
475 {La funzione ritorna il valore del parametro richiesto in caso di successo e
476 $-1$ per un errore, nel qual caso \var{errno} viene impostata ad uno degli
477 errori possibili relativi all'accesso a \param{path}.}
480 La funzione richiede che si specifichi il limite che si vuole controllare con
481 l'argomento \param{name}, per il quale si deve usare la relativa costante
482 identificativa, il cui nome si ottiene da quelle descritte in
483 tab.~\ref{tab:sys_file_macro} e tab.~\ref{tab:sys_posix1_file} con la stessa
484 convenzione già vista con \func{sysconf}, ma un questo caso con l'uso del
485 suffisso ``\texttt{\_PC\_}''.
487 In questo caso la funzione richiede anche un secondo argomento \param{path}
488 che specifichi a quale file si fa riferimento, dato che il valore del limite
489 cercato può variare a seconda del filesystem su cui si trova il file. Una
490 seconda versione della funzione, \funcd{fpathconf}, opera su un file
491 descriptor invece che su un \textit{pathname}, il suo prototipo è:
495 \fdecl{long fpathconf(int fd, int name)}
496 \fdesc{Restituisce il valore di un parametro dei file.}
499 {È identica a \func{pathconf} solo che utilizza un file descriptor invece di
500 un \textit{pathname}; pertanto gli errori restituiti in \var{errno} cambiano
503 \noindent ed il suo comportamento è identico a quello di \func{pathconf} a
504 parte quello di richiedere l'indicazione di un file descriptor
505 nell'argomento \param{fd}.
509 \subsection{I parametri del kernel ed il filesystem \texttt{/proc}}
510 \label{sec:sys_sysctl}
512 Tradizionalmente la funzione che permette la lettura ed l'impostazione dei
513 parametri del sistema è \funcm{sysctl}. Si tratta di una funzione derivata da
514 BSD4.4 ed introdotta su Linux a partire dal kernel 1.3.57, ma oggi il suo uso
515 è totalmente deprecato. Una \textit{system call} \funcm{\_sysctl} continua ad
516 esistere, ma non dispone più di una interfaccia nella \acr{glibc} ed il suo
517 utilizzo può essere effettuato solo tramite \func{syscall}, ma di nuovo questo
518 viene sconsigliato in quanto la funzionalità non è più mantenuta e molto
519 probabilmente sarà rimossa nel prossimo futuro. Per questo motivo eviteremo di
520 trattarne i particolari.
522 Lo scopo di \funcm{sysctl} era quello di fornire ai programmi una modalità per
523 modificare i parametri di sistema. Questi erano organizzati in maniera
524 gerarchica all'interno di un albero e per accedere a ciascuno di essi
525 occorreva specificare un percorso attraverso i vari nodi dell'albero, in
526 maniera analoga a come avviene per la risoluzione di un \textit{pathname}.
528 I parametri accessibili e modificabili attraverso questa funzione sono
529 moltissimi, dipendendo anche dallo stato corrente del kernel, ad esempio dai
530 moduli che sono stati caricati nel sistema. Inoltre non essendo standardizzati
531 i loro nomi possono variare da una versione di kernel all'altra, alcuni esempi
532 di questi parametri sono:
534 \item il nome di dominio
535 \item i parametri del meccanismo di \textit{paging}.
536 \item il filesystem montato come radice
537 \item la data di compilazione del kernel
538 \item i parametri dello stack TCP
539 \item il numero massimo di file aperti
544 \index{file!filesystem~\texttt {/proc}!definizione|(}
546 Dato che fin dall'inizio i parametri erano organizzati in una struttura
547 albero, è parso naturale rimappare questa organizzazione utilizzando il
548 filesystem \file{/proc}. Questo è un filesystem completamente virtuale, il cui
549 contenuto è generato direttamente dal kernel, che non fa riferimento a nessun
550 dispositivo fisico, ma presenta in forma di file e directory i dati di alcune
551 delle strutture interne del kernel stesso. Il suo utilizzo principale, come
552 denuncia il nome stesso, è quello di fornire una interfaccia per ottenere i
553 dati relativi ai processi (venne introdotto a questo scopo su BSD), ma nel
554 corso del tempo il suo uso è stato ampliato.
556 All'interno di questo filesystem sono pertanto presenti una serie di file che
557 riflettono il contenuto dei parametri del kernel (molti dei quali accessibili
558 in sola lettura) e in altrettante directory, nominate secondo il relativo
559 \ids{PID}, vengono mantenute le informazioni relative a ciascun processo
562 In particolare l'albero dei valori dei parametri di sistema impostabili con
563 \func{sysctl} viene presentato in forma di una gerarchia di file e directory a
564 partire dalla directory \file{/proc/sys}, cosicché è possibile accedere al
565 valore di un parametro del kernel tramite il \textit{pathname} ad un file
566 sotto \file{/proc/sys} semplicemente leggendone il contenuto, così come si può
567 modificare un parametro scrivendo sul file ad esso corrispondente.
569 Il kernel si occupa di generare al volo il contenuto ed i nomi dei file
570 corrispondenti ai vari parametri che sono presenti, e questo ha il grande
571 vantaggio di rendere accessibili gli stessi ad un qualunque comando di shell e
572 di permettere la navigazione dell'albero in modo da riconoscere quali
573 parametri sono presenti senza dover cercare un valore all'interno di una
576 Inizialmente l'uso del filesystem \file{/proc} serviva soltanto a replicare
577 l'accesso, con altrettante corrispondenze ai file presenti in
578 \file{/proc/sys}, ai parametri impostabili tradizionalmente con \func{sysctl},
579 ma vista la assoluta naturalità dell'interfaccia, e la sua maggiore
580 efficienza, nelle versioni più recenti del kernel questa è diventata la
581 modalità canonica per modificare i parametri del kernel, evitando di dover
582 ricorrere all'uso di una \textit{system call} specifica che pur essendo ancora
583 presente, prima o poi verrà eliminata.
585 Nonostante la semplificazione nella gestione ottenuta con l'uso di
586 \file{/proc/sys} resta il problema generale di conoscere il significato di
587 ciascuno degli innumerevoli parametri che vi si trovano. Purtroppo la
588 documentazione degli stessi spesso risulta incompleta e non aggiornata, ma
589 buona parte di quelli può importanti sono descritti dalla documentazione
590 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
592 Ma oltre alle informazioni che sostituiscono quelle ottenibili dalla ormai
593 deprecata \func{sysctl} dentro \file{/proc} sono disponibili moltissime altre
594 informazioni, fra cui ad esempio anche quelle fornite dalla funzione di
595 sistema \funcd{uname},\footnote{con Linux ci sono in realtà 3 \textit{system
596 call} diverse per le dimensioni delle stringhe restituite, le prime due
597 usano rispettivamente delle lunghezze di 9 e 65 byte, la terza usa anch'essa
598 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con una
599 lunghezza di 257 byte, la \acr{glibc} provvede a mascherare questi dettagli
600 usando la versione più recente disponibile.} il cui prototipo è:
603 \fhead{sys/utsname.h}
604 \fdecl{int uname(struct utsname *info)}
605 \fdesc{Restituisce informazioni generali sul sistema.}
608 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
609 caso \var{errno} può assumere solo il valore \errval{EFAULT}.}
612 La funzione, che viene usata dal comando \cmd{uname}, restituisce una serie di
613 informazioni relative al sistema nelle stringhe che costituiscono i campi
614 della struttura \struct{utsname} (la cui definizione è riportata in
615 fig.~\ref{fig:sys_utsname}) che viene scritta nel buffer puntato
616 dall'argomento \param{info}.
618 \begin{figure}[!ht!b]
619 \footnotesize \centering
620 \begin{minipage}[c]{0.85\textwidth}
621 \includestruct{listati/ustname.h}
624 \caption{La struttura \structd{utsname}.}
625 \label{fig:sys_utsname}
628 Si noti come in fig.~\ref{fig:sys_utsname} le dimensioni delle stringhe di
629 \struct{utsname} non sono specificate. Il manuale della \acr{glibc} indica
630 due costanti per queste dimensioni, \constd{\_UTSNAME\_LENGTH} per i campi
631 standard e \constd{\_UTSNAME\_DOMAIN\_LENGTH} per quello relativo al nome di
632 dominio, altri sistemi usano nomi diversi come \constd{SYS\_NMLN} o
633 \constd{\_SYS\_NMLN} o \constd{UTSLEN} che possono avere valori diversi. Dato
634 che il buffer per \struct{utsname} deve essere preallocato l'unico modo per
635 farlo in maniera sicura è allora usare come dimensione il valore ottenuto con
636 \code{sizeof(utsname)}.
638 Le informazioni vengono restituite in ciascuno dei singoli campi di
639 \struct{utsname} in forma di stringhe terminate dal carattere NUL. In
640 particolare dette informazioni sono:
642 \item il nome del sistema operativo;
643 \item il nome della macchine (l'\textit{hostname});
644 \item il nome della release del kernel;
645 \item il nome della versione del kernel;
646 \item il tipo di hardware della macchina;
647 \item il nome del domino (il \textit{domainname});
649 ma l'ultima di queste informazioni è stata aggiunta di recente e non è
650 prevista dallo standard POSIX, per questo essa è accessibile, come mostrato in
651 fig.~\ref{fig:sys_utsname}, solo se si è definita la macro
652 \macro{\_GNU\_SOURCE}.
654 Come accennato queste stesse informazioni, anche se a differenza di
655 \func{sysctl} la funzione continua ad essere mantenuta, si possono ottenere
656 direttamente tramite il filesystem \file{/proc}, esse infatti sono mantenute
657 rispettivamente nei file \sysctlrelfiled{kernel}{ostype},
658 \sysctlrelfiled{kernel}{hostname}, \sysctlrelfiled{kernel}{osrelease},
659 \sysctlrelfiled{kernel}{version} e \sysctlrelfiled{kernel}{domainname} che si
660 trovano sotto la directory \file{/proc/sys/kernel/}.
662 \index{file!filesystem~\texttt {/proc}!definizione|)}
666 \section{La gestione del sistema}
667 \label{sec:sys_management}
669 In questa sezione prenderemo in esame le interfacce di programmazione messe a
670 disposizione per affrontare una serie di tematiche attinenti la gestione
671 generale del sistema come quelle relative alla gestione di utenti e gruppi, al
672 trattamento delle informazioni relative ai collegamenti al sistema, alle
673 modalità per effettuare lo spegnimento o il riavvio di una macchina.
676 \subsection{La gestione delle informazioni su utenti e gruppi}
677 \label{sec:sys_user_group}
679 Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
680 (password, corrispondenze fra nomi simbolici e \ids{UID} numerici, home
681 directory, ecc.) venivano registrate all'interno dei due file di testo
682 \conffiled{/etc/passwd} ed \conffiled{/etc/group}, il cui formato è descritto
683 dalle relative pagine del manuale\footnote{nella quinta sezione, quella dei
684 file di configurazione (esistono comandi corrispondenti), una trattazione
685 sistemistica dell'intero argomento coperto in questa sezione si consulti
686 sez.~4.3 di \cite{AGL}.} e tutte le funzioni che richiedevano l'accesso a
687 queste informazione andavano a leggere direttamente il contenuto di questi
690 In realtà oltre a questi due file da molto tempo gran parte dei sistemi
691 unix-like usano il cosiddetto sistema delle \textit{shadow password} che
692 prevede anche i due file \conffiled{/etc/shadow} e \conffiled{/etc/gshadow}, in
693 cui sono state spostate le informazioni di autenticazione (ed inserite alcune
694 estensioni di gestione avanzata) per toglierle dagli altri file che devono
695 poter essere letti da qualunque processo per poter effettuare l'associazione
696 fra username e \ids{UID}.
698 Col tempo però questa impostazione ha incominciato a mostrare dei limiti. Da
699 una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
700 la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
701 che sta per \textit{Pluggable Authentication Method}) che fornisce una
702 interfaccia comune per i processi di autenticazione, svincolando completamente
703 le singole applicazioni dai dettagli del come questa viene eseguita e di dove
704 vengono mantenuti i dati relativi. Si tratta di un sistema modulare, in cui è
705 possibile utilizzare anche più meccanismi insieme, diventa così possibile
706 avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
707 diversi formati per le password e diversi supporti per le informazioni. Il
708 tutto avviene in maniera trasparente per le applicazioni purché per ciascun
709 meccanismo si disponga della opportuna libreria che implementa l'interfaccia
712 Dall'altra parte, il diffondersi delle reti e la necessità di centralizzare le
713 informazioni degli utenti e dei gruppi per insiemi di macchine e servizi
714 all'interno di una stessa organizzazione, in modo da mantenere coerenti i
715 dati, ha portato anche alla necessità di poter recuperare e memorizzare dette
716 informazioni su supporti diversi dai file citati, introducendo il sistema del
717 \textit{Name Service Switch} (che tratteremo brevemente in
718 sez.~\ref{sec:sock_resolver}) dato che la sua applicazione è cruciale nella
719 procedura di risoluzione di nomi di rete.
721 In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
722 per la lettura delle informazioni relative a utenti e gruppi tralasciando
723 completamente quelle relative all'autenticazione.
724 % Per questo non tratteremo
725 % affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
726 % \textit{Name Service Switch}, un meccanismo messo a disposizione dalla
727 % \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
728 % necessario trovare una corrispondenza fra un nome ed un numero (od altra
729 % informazione) ad esso associato, come appunto, quella fra uno username ed un
730 % \ids{UID} o fra un \ids{GID} ed il nome del gruppo corrispondente.
731 Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
732 queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
733 Service Switch}, per cui sono in grado di ricevere informazioni qualunque
734 sia il supporto su cui esse vengono mantenute. Per leggere le informazioni
735 relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
736 \funcd{getpwnam}, i cui prototipi sono:
741 \fdecl{struct passwd *getpwuid(uid\_t uid)}
742 \fdecl{struct passwd *getpwnam(const char *name)}
743 \fdesc{Restituiscono le informazioni relative all'utente specificato.}
746 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
747 in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
748 utente corrispondente a quanto specificato, nel qual caso \var{errno}
749 assumerà il valore riportato dalle funzioni di sistema sottostanti.}
752 Le due funzioni forniscono le informazioni memorizzate nel registro degli
753 utenti (che nelle versioni più recenti per la parte di credenziali di
754 autenticazione vengono ottenute attraverso PAM) relative all'utente
755 specificato attraverso il suo \ids{UID} o il nome di login. Entrambe le
756 funzioni restituiscono un puntatore ad una struttura di tipo \struct{passwd}
757 la cui definizione (anch'essa eseguita in \headfiled{pwd.h}) è riportata in
758 fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente illustrato il
759 significato dei vari campi.
764 \begin{minipage}[c]{0.8\textwidth}
765 \includestruct{listati/passwd.h}
768 \caption{La struttura \structd{passwd} contenente le informazioni relative
769 ad un utente del sistema.}
770 \label{fig:sys_passwd_struct}
773 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
774 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
775 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
776 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
777 essere rientranti; per questo motivo ne esistono anche due versioni
778 alternative (denotate dalla solita estensione \code{\_r}), i cui prototipi
784 \fdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
786 \phantom{struct passwd *getpwuid\_r(}size\_t buflen, struct passwd **result)}
787 \fdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
788 *password, char *buffer,\\
789 \phantom{struct passwd *getpwnam\_r(}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 di sistema funzioni
798 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
799 la memoria necessaria a contenere le informazioni. In particolare i valori
800 della struttura \struct{passwd} saranno restituiti all'indirizzo
801 \param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
802 un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
803 puntate dai campi di \param{password}. Infine all'indirizzo puntato da
804 \param{result} viene restituito il puntatore ai dati ottenuti, cioè
805 \param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti. Qualora i
806 dati non possano essere contenuti nei byte specificati da \param{buflen}, la
807 funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
808 impostato a \val{NULL}).
810 Sia queste versioni rientranti che precedenti gli errori eventualmente
811 riportati in \var{errno} in caso di fallimento dipendono dalla sottostanti
812 funzioni di sistema usate per ricavare le informazioni (si veda quanto
813 illustrato in sez.~\ref{sec:sys_errno}) per cui se lo si vuole utilizzare è
814 opportuno inizializzarlo a zero prima di invocare le funzioni per essere
815 sicuri di non avere un residuo di errore da una chiamata precedente. Il non
816 aver trovato l'utente richiesto infatti può essere dovuto a diversi motivi (a
817 partire dal fatto che non esista) per cui si possono ottenere i valori di
818 errore più vari a seconda dei casi.
820 Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
821 \funcd{getgrgid} che permettono di leggere le informazioni relative ai gruppi,
822 i loro prototipi sono:
827 \fdecl{struct group *getgrgid(gid\_t gid)}
828 \fdecl{struct group *getgrnam(const char *name)}
829 \fdesc{Restituiscono le informazioni relative al gruppo specificato.}
832 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
833 in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
834 utente corrispondente a quanto specificato, nel qual caso \var{errno}
835 assumerà il valore riportato dalle funzioni di sistema sottostanti.}
838 Come per le precedenti per gli utenti esistono anche le analoghe versioni
839 rientranti che di nuovo utilizzano la stessa estensione \code{\_r}; i loro
845 \fdecl{int getgrgid\_r(gid\_t gid, struct group *grp, char *buf,
847 \phantom{int getgrgid\_r(}struct group **result)}
848 \fdecl{int getgrnam\_r(const char *name, struct group *grp, char *buf,
850 \phantom{int getgrnam\_r(}struct group **result)}
851 \fdesc{Restituiscono le informazioni relative al gruppo specificato.}
854 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
855 caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
859 Il comportamento di tutte queste funzioni è assolutamente identico alle
860 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
861 in questo caso le informazioni vengono restituite in una struttura di tipo
862 \struct{group}, la cui definizione è riportata in
863 fig.~\ref{fig:sys_group_struct}.
868 \begin{minipage}[c]{0.8\textwidth}
869 \includestruct{listati/group.h}
872 \caption{La struttura \structd{group} contenente le informazioni relative ad
873 un gruppo del sistema.}
874 \label{fig:sys_group_struct}
877 Le funzioni viste finora sono in grado di leggere le informazioni sia
878 direttamente dal file delle password in \conffile{/etc/passwd} che tramite il
879 sistema del \textit{Name Service Switch} e sono completamente generiche. Si
880 noti però che non c'è una funzione che permetta di impostare direttamente una
881 password.\footnote{in realtà questo può essere fatto ricorrendo alle funzioni
882 della libreria PAM, ma questo non è un argomento che tratteremo qui.} Dato
883 che POSIX non prevede questa possibilità esiste un'altra interfaccia che lo
884 fa, derivata da SVID le cui funzioni sono riportate in
885 tab.~\ref{tab:sys_passwd_func}. Questa interfaccia però funziona soltanto
886 quando le informazioni sono mantenute su un apposito file di \textsl{registro}
887 di utenti e gruppi, con il formato classico di \conffile{/etc/passwd} e
888 \conffile{/etc/group}.
893 \begin{tabular}[c]{|l|p{8cm}|}
895 \textbf{Funzione} & \textbf{Significato}\\
898 \funcm{fgetpwent} & Legge una voce dal file di registro degli utenti
900 \funcm{fgetpwent\_r}& Come la precedente, ma rientrante.\\
901 \funcm{putpwent} & Immette una voce in un file di registro degli
903 \funcm{getpwent} & Legge una voce da \conffile{/etc/passwd}.\\
904 \funcm{getpwent\_r} & Come la precedente, ma rientrante.\\
905 \funcm{setpwent} & Ritorna all'inizio di \conffile{/etc/passwd}.\\
906 \funcm{endpwent} & Chiude \conffile{/etc/passwd}.\\
907 \funcm{fgetgrent} & Legge una voce dal file di registro dei gruppi
909 \funcm{fgetgrent\_r}& Come la precedente, ma rientrante.\\
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 rientrante.\\
913 \funcm{setgrent} & Ritorna all'inizio di \conffile{/etc/group}.\\
914 \funcm{endgrent} & Chiude \conffile{/etc/group}.\\
917 \caption{Funzioni per la manipolazione dei campi di un file usato come
918 registro per utenti o gruppi nel formato di \conffile{/etc/passwd} e
919 \conffile{/etc/group}.}
920 \label{tab:sys_passwd_func}
923 % TODO mancano i prototipi di alcune delle funzioni
925 Dato che oramai tutte le distribuzioni di GNU/Linux utilizzano le
926 \textit{shadow password} (quindi con delle modifiche rispetto al formato
927 classico del file \conffile{/etc/passwd}), si tenga presente che le funzioni
928 di questa interfaccia che permettono di scrivere delle voci in un
929 \textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
930 hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
933 Per questo motivo l'uso di queste funzioni è deprecato, in quanto comunque non
934 funzionale rispetto ad un sistema attuale, pertanto ci limiteremo a fornire
935 soltanto l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
936 ulteriore. Chi volesse insistere ad usare questa interfaccia può fare
937 riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
938 della \acr{glibc} per i dettagli del funzionamento.
942 \subsection{Il registro della \textsl{contabilità} degli utenti}
943 \label{sec:sys_accounting}
945 Un altro insieme di funzioni relative alla gestione del sistema che
946 esamineremo è quello che permette di accedere ai dati del registro della
947 cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti. In esso
948 vengono mantenute una serie di informazioni storiche relative sia agli utenti
949 che si sono collegati al sistema, tanto per quelli correntemente collegati,
950 che per la registrazione degli accessi precedenti, sia relative all'intero
951 sistema, come il momento di lancio di processi da parte di \cmd{init}, il
952 cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
955 I dati vengono usualmente memorizzati nei due file \file{/var/run/utmp} e
956 \file{/var/log/wtmp}. che sono quelli previsti dal \textit{Linux Filesystem
957 Hierarchy Standard}, adottato dalla gran parte delle distribuzioni. Quando
958 un utente si collega viene aggiunta una voce a \file{/var/run/utmp} in cui
959 viene memorizzato il nome di login, il terminale da cui ci si collega,
960 l'\ids{UID} della shell di login, l'orario della connessione ed altre
961 informazioni. La voce resta nel file fino al logout, quando viene cancellata
962 e spostata in \file{/var/log/wtmp}.
964 In questo modo il primo file viene utilizzato per registrare chi sta
965 utilizzando il sistema al momento corrente, mentre il secondo mantiene la
966 registrazione delle attività degli utenti. A quest'ultimo vengono anche
967 aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
968 come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
969 informazioni sono descritte in dettaglio nel manuale della \acr{glibc}.
971 Questi file non devono mai essere letti direttamente, ma le informazioni che
972 contengono possono essere ricavate attraverso le opportune funzioni di
973 libreria. Queste sono analoghe alle precedenti funzioni (vedi
974 tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
975 solo che in questo caso la struttura del registro della \textsl{contabilità} è
976 molto più complessa, dato che contiene diversi tipi di informazione.
978 Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
979 servono rispettivamente a aprire e a chiudere il file che contiene il registro
980 della \textsl{contabilità} degli, e a specificare su quale file esso viene
981 mantenuto. I loro prototipi sono:
985 \fdecl{void utmpname(const char *file)}
986 \fdesc{Specifica il file da usare come registro.}
987 \fdecl{void setutent(void)}
988 \fdesc{Apre il file del registro.}
989 \fdecl{void endutent(void)}
990 \fdesc{Chiude il file del registro.}
993 {Le funzioni non ritornano nulla.}
996 Si tenga presente che le funzioni non restituiscono nessun valore, pertanto
997 non è possibile accorgersi di eventuali errori, ad esempio se si è impostato
998 un nome di file sbagliato con \func{utmpname}.
1000 Nel caso non si sia utilizzata \func{utmpname} per specificare un file di
1001 registro alternativo, sia \func{setutent} che \func{endutent} operano usando
1002 il default che è \sysfile{/var/run/utmp} il cui nome, così come una serie di
1003 altri valori di default per i \textit{pathname} di uso più comune, viene
1004 mantenuto nei valori di una serie di costanti definite includendo
1005 \headfiled{paths.h}, in particolare quelle che ci interessano sono:
1006 \begin{basedescript}{\desclabelwidth{2.0cm}}
1007 \item[\constd{\_PATH\_UTMP}] specifica il file che contiene il registro per
1008 gli utenti correntemente collegati, questo è il valore che viene usato se
1009 non si è utilizzato \func{utmpname} per modificarlo;
1010 \item[\constd{\_PATH\_WTMP}] specifica il file che contiene il registro per
1011 l'archivio storico degli utenti collegati;
1013 che nel caso di Linux hanno un valore corrispondente ai file
1014 \sysfile{/var/run/utmp} e \sysfile{/var/log/wtmp} citati in precedenza.
1016 Una volta aperto il file del registro degli utenti si può eseguire una
1017 scansione leggendo o scrivendo una voce con le funzioni \funcd{getutent},
1018 \funcd{getutid}, \funcd{getutline} e \funcd{pututline}, i cui prototipi sono:
1023 \fdecl{struct utmp *getutent(void)}
1024 \fdesc{Legge una voce dalla posizione corrente nel registro.}
1025 \fdecl{struct utmp *getutid(struct utmp *ut)}
1026 \fdesc{Ricerca una voce sul registro.}
1027 \fdecl{struct utmp *getutline(struct utmp *ut)}
1028 \fdesc{Ricerca una voce sul registro attinente a un terminale.}
1029 \fdecl{struct utmp *pututline(struct utmp *ut)}
1030 \fdesc{Scrive una voce nel registro.}
1033 {Le funzioni ritornano il puntatore ad una struttura \struct{utmp} in caso di
1034 successo e \val{NULL} in caso di errore, nel qual caso \var{errno} assumerà
1035 il valore riportato dalle funzioni di sistema sottostanti.}
1038 Tutte queste funzioni fanno riferimento ad una struttura di tipo
1039 \struct{utmp}, la cui definizione in Linux è riportata in
1040 fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
1041 voce dal registro: \func{getutent} legge semplicemente la prima voce
1042 disponibile, le altre due permettono di eseguire una ricerca. Aprendo il
1043 registro con \func{setutent} ci si posiziona al suo inizio, ogni chiamata di
1044 queste funzioni eseguirà la lettura sulle voci seguenti, pertanto la posizione
1045 sulla voce appena letta, in modo da consentire una scansione del file. Questo
1046 vale anche per \func{getutid} e \func{getutline}, il che comporta che queste
1047 funzioni effettuano comunque una ricerca ``\textsl{in avanti}''.
1049 \begin{figure}[!htb]
1052 \begin{minipage}[c]{0.9\textwidth}
1053 \includestruct{listati/utmp.h}
1056 \caption{La struttura \structd{utmp} contenente le informazioni di una voce
1057 del registro di \textsl{contabilità}.}
1058 \label{fig:sys_utmp_struct}
1061 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1062 campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
1063 riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
1064 \const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
1065 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1066 invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
1067 \const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
1068 corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1073 \begin{tabular}[c]{|l|p{8cm}|}
1075 \textbf{Valore} & \textbf{Significato}\\
1078 \constd{EMPTY} & Non contiene informazioni valide.\\
1079 \constd{RUN\_LVL} & Identica il runlevel del sistema.\\
1080 \constd{BOOT\_TIME} & Identifica il tempo di avvio del sistema.\\
1081 \constd{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
1083 \constd{NEW\_TIME} & Identifica da quanto è stato modificato il
1085 \constd{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
1086 \constd{LOGIN\_PROCESS}& Identifica un processo di login.\\
1087 \constd{USER\_PROCESS} & Identifica un processo utente.\\
1088 \constd{DEAD\_PROCESS} & Identifica un processo terminato.\\
1089 % \constd{ACCOUNTING} & ??? \\
1092 \caption{Classificazione delle voci del registro a seconda dei
1093 possibili valori del campo \var{ut\_type}.}
1094 \label{tab:sys_ut_type}
1097 La funzione \func{getutline} esegue la ricerca sulle voci che hanno un
1098 \var{ut\_type} con valore uguale a \const{LOGIN\_PROCESS} o
1099 \const{USER\_PROCESS}, restituendo la prima che corrisponde al valore di
1100 \var{ut\_line}, che specifica il dispositivo di terminale che interessa, da
1101 indicare senza il \file{/dev/} iniziale. Lo stesso criterio di ricerca è usato
1102 da \func{pututline} per trovare uno spazio dove inserire la voce specificata;
1103 qualora questo spazio non venga trovato la voce viene aggiunta in coda al
1106 In generale occorre però tenere conto che queste funzioni non sono
1107 completamente standardizzate, e che in sistemi diversi possono esserci
1108 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1109 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1110 fornita dalla \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1111 introdotto delle nuove strutture (e relativi file) di tipo \struct{utmpx}, che
1112 sono un sovrainsieme della \struct{utmp} usata tradizionalmente ed altrettante
1113 funzioni che le usano al posto di quelle citate.
1115 La \acr{glibc} utilizzava già una versione estesa di \struct{utmp}, che
1116 rende inutili queste nuove strutture, per questo su Linux \struct{utmpx} viene
1117 definita esattamente come \struct{utmp}, con gli stessi campi di
1118 fig.~\ref{fig:sys_utmp_struct}. Altrettanto dicasi per le nuove funzioni di
1119 gestione previste dallo standard: \funcm{getutxent}, \funcm{getutxid},
1120 \funcm{getutxline}, \funcm{pututxline}, \funcm{setutxent} e \funcm{endutxent}.
1122 Tutte queste funzioni, definite con \struct{utmpx} dal file di dichiarazione
1123 \headfile{utmpx.h}, su Linux sono ridefinite come sinonimi delle funzioni
1124 appena viste, con argomento di tipo \struct{utmpx} anziché \struct{utmp} ed
1125 hanno lo stesso identico comportamento. Per completezza viene definita anche
1126 \funcm{utmpxname} che non è prevista da POSIX.1-2001.
1128 Come già visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
1129 staticamente rende le funzioni di lettura dei dati appena illustrate non
1130 rientranti. Per questo motivo la \acr{glibc} fornisce anche delle versioni
1131 rientranti: \func{getutent\_r}, \func{getutid\_r}, \func{getutline\_r}, che
1132 invece di restituire un puntatore restituiscono un intero e prendono due
1133 argomenti aggiuntivi, i rispettivi prototipi sono:
1137 \fdecl{int *getutent\_r(struct utmp *buffer, struct utmp **result)}
1138 \fdesc{Legge una voce dalla posizione corrente nel registro.}
1139 \fdecl{int *getutid\_r(struct utmp *buffer, struct utmp **result, struct utmp
1141 \fdesc{Ricerca una voce sul registro.}
1142 \fdecl{int *getutline\_r(struct utmp *buffer, struct utmp **result, struct utmp
1144 \fdesc{Ricerca una voce sul registro attinente a un terminale.}
1147 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
1148 caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
1152 Le funzioni si comportano esattamente come le precedenti analoghe non
1153 rientranti, solo che restituiscono il risultato all'indirizzo specificato dal
1154 primo argomento aggiuntivo \param{buffer} mentre il secondo, \param{result)}
1155 viene usato per restituire il puntatore al buffer stesso.
1157 Infine la \acr{glibc} fornisce altre due funzioni, \funcd{updwtmp} e
1158 \funcd{logwtmp}, come estensione per scrivere direttamente delle voci nel file
1159 sul registro storico \sysfile{/var/log/wtmp}; i rispettivi prototipi sono:
1163 \fdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1164 \fdesc{Aggiunge una voce in coda al registro.}
1165 \fdecl{void logwtmp(const char *line, const char *name, const char *host)}
1166 \fdesc{Aggiunge nel registro una voce con i valori specificati.}
1169 {Le funzioni non restituiscono nulla.}
1172 La prima funzione permette l'aggiunta di una voce in coda al file del registro
1173 storico, indicato dal primo argomento, specificando direttamente una struttura
1174 \struct{utmp}. La seconda invece utilizza gli argomenti \param{line},
1175 \param{name} e \param{host} per costruire la voce che poi aggiunge chiamando
1178 Queste funzioni non sono previste da POSIX.1-2001, anche se sono presenti in
1179 altri sistemi (ad esempio Solaris e NetBSD), per mantenere una coerenza con le
1180 altre funzioni definite nello standard che usano la struttura \struct{utmpx}
1181 la \acr{glibc} definisce anche una funzione \funcm{updwtmpx}, che come in
1182 precedenza è identica a \func{updwtmp} con la sola differenza di richiedere
1183 l'uso di \headfiled{utmpx.h} e di una struttura \struct{utmpx} come secondo
1187 \subsection{La gestione dello spegnimento e del riavvio}
1188 \label{sec:sys_reboot}
1190 Una delle operazioni di gestione generale del sistema è quella che attiene
1191 alle modalità con cui se ne può gestire lo spegnimento ed il riavvio. Perché
1192 questo avvenga in maniera corretta, in particolare per le parti che comportano
1193 lo spegnimento effettivo della macchina, occorre che il kernel effettui le
1194 opportune operazioni interagendo con il BIOS ed i dispositivi che controllano
1195 l'erogazione della potenza.
1197 La funzione di sistema che controlla lo spegnimento ed il riavvio (ed altri
1198 aspetti della relativa procedura) è \funcd{reboot},\footnote{la funzione
1199 illustrata è quella fornita dalla \acr{glibc} che maschera i dettagli di
1200 basso livello della \textit{system call} la quale richiede attualmente tre
1201 argomenti; fino al kernel 2.1.30 la \textit{system call} richiedeva un
1202 ulteriore quarto argomento, i primi due indicano dei \textit{magic number}
1203 interi che possono assumere solo alcuni valori predefiniti, il terzo un
1204 comando, corrispondente all'unico argomento della funzione della \acr{glibc}
1205 ed il quarto argomento aggiuntivo, ora ignorato, un puntatore generico ad
1206 ulteriori dati.} il cui prototipo è:
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} (obsoleto).
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. Se si è richiesto un riavvio o uno
1233 spegnimento in caso di successo la funzione, non esistendo più il programma,
1234 ovviamente non ritorna, pertanto bisogna avere cura di aver effettuato tutte
1235 le operazioni preliminari allo spegnimento prima di eseguirla.
1237 Il comportamento della funzione viene controllato dall'argomento \param{cmd}
1238 e 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[\constd{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 \signal{SIGINT} a \texttt{init} (o più in generale al processo
1245 con \ids{PID} 1) il cui effetto dipende dalla configurazione di
1247 \item[\constd{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[\constd{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} questi saranno perduti.
1256 \item[\constd{LINUX\_REBOOT\_CMD\_KEXEC}] viene eseguito direttamente il nuovo
1257 kernel che è stato opportunamente caricato in memoria da una
1258 \func{kexec\_load} (che tratteremo a breve) eseguita in precedenza. La
1259 funzionalità è disponibile solo a partire dal kernel 2.6.13 e se il kernel
1260 corrente è stato compilato includendo il relativo supporto.\footnote{deve
1261 essere stata abilitata l'opzione di compilazione \texttt{CONFIG\_KEXEC}.}
1262 Questo meccanismo consente di eseguire una sorta di riavvio rapido che evita
1263 di dover ripassare dalla inizializzazione da parte del BIOS ed il lancio del
1264 kernel attraverso un bootloader. Se non si è eseguita una sincronizzazione
1265 dei dati su disco con \func{sync} questi saranno perduti.
1266 \item[\constd{LINUX\_REBOOT\_CMD\_POWER\_OFF}] Viene inviato sulla console il
1267 messaggio ``\textit{Power down.}'' l'esecuzione viene bloccata
1268 immediatamente e la macchina, se possibile, viene spenta. Se non si è
1269 eseguita una sincronizzazione dei dati su disco con \func{sync} questi
1271 \item[\constd{LINUX\_REBOOT\_CMD\_RESTART}] Viene inviato sulla console il
1272 messaggio ``\textit{Restarting system.}'' ed avviata immediatamente la
1273 procedura di riavvio ordinaria. Se non si è eseguita una sincronizzazione
1274 dei dati su disco con \func{sync} questi saranno perduti.
1275 \item[\constd{LINUX\_REBOOT\_CMD\_RESTART2}] Viene inviato sulla console il
1276 messaggio ``\textit{Restarting system with command '\%s'.}'' ed avviata
1277 immediatamente la procedura di riavvio usando il comando fornito
1278 nell'argomento \param{arg} che viene stampato al posto di \textit{'\%s'}
1279 (veniva usato per lanciare un altro programma al posto di \cmd{init}). Nelle
1280 versioni recenti questo argomento viene ignorato ed il riavvio può essere
1281 controllato dall'argomento di avvio del kernel \texttt{reboot=...} Se non
1282 si è eseguita una sincronizzazione dei dati su disco con \func{sync} questi
1287 Come appena illustrato usando il comando \const{LINUX\_REBOOT\_CMD\_KEXEC} si
1288 può eseguire un riavvio immediato pre-caricando una immagine del kernel, che
1289 verrà eseguita direttamente. Questo meccanismo consente di evitare la
1290 reinizializzazione della macchina da parte del BIOS, ed oltre a velocizzare un
1291 eventuale riavvio, ha il vantaggio poter accedere allo stato corrente della
1292 macchina e della memoria, per cui viene usato spesso per installare un kernel
1293 di emergenza da eseguire in caso di crollo del sistema per recuperare il
1294 maggior numero di informazioni possibili.
1296 La funzione di sistema che consente di caricare questa immagine del kernel è
1297 \funcd{kexec\_load}, la funzione non viene definita nella \acr{glibc} e deve
1298 pertanto essere invocata con \func{syscall}, il suo prototipo è:
1301 \fhead{linux/kexec.h}
1302 \fdecl{long kexec\_load(unsigned long entry, unsigned long nr\_segments,
1303 struct kexec\_segment\\
1304 \phantom{long kexec\_load(}*segments, unsigned long flags)}
1306 \fdesc{Carica un kernel per un riavvio immediato.}
1309 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1310 caso \var{errno} assumerà uno dei valori:
1312 \item[\errcode{EBUSY}] c'è già un caricamento in corso, o un altro kernel è
1314 \item[\errcode{EINVAL}] il valore di \param{flags} non è valido o si è
1315 indicato un valore eccessivo per \param{nr\_segments}.
1316 \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
1317 \textit{capability} \const{CAP\_SYS\_BOOT}).
1322 Il primo argomento indica l'indirizzo fisico di esecuzione del nuovo kernel
1323 questo viene caricato usando un vettore di strutture \struct{kexec\_segment}
1324 (la cui definizione è riportata in fig.~\ref{fig:kexec_segment}) che
1325 contengono i singoli segmenti dell'immagine. I primi due campi indicano
1326 indirizzo e dimensione del segmento di memoria in \textit{user space}, i
1327 secondi indirizzo e dimensione in \textit{kernel space}.
1330 \begin{figure}[!htb]
1333 \begin{minipage}[c]{0.8\textwidth}
1334 \includestruct{listati/kexec_segment.h}
1337 \caption{La struttura \structd{kexec\_segment} per il caricamento di un
1338 segmento di immagine del kernel.}
1339 \label{fig:kexec_segment}
1342 L'argomento \param{flags} è una maschera binaria contenente i flag che
1343 consentono di indicare le modalità con cui dovrà essere eseguito il nuovo
1344 kernel. La parte meno significativa viene usata per impostare l'architettura
1345 di esecuzione. Il valore \const{KEXEC\_ARCH\_DEFAULT} indica l'architettura
1346 corrente, ma se ne può specificare anche una diversa, con i valori della
1347 seconda parte di tab.~\ref{tab:kexec_load_flags}, e questa verrà usato posto
1348 che sia effettivamente eseguibile sul proprio processore.
1353 \begin{tabular}[c]{|l|p{8cm}|}
1355 \textbf{Valore} & \textbf{Significato}\\
1358 \constd{KEXEC\_ON\_CRASH} & Il kernel caricato sarà eseguito
1359 automaticamente in caso di crollo del
1361 \constd{KEXEC\_PRESERVE\_CONTEXT}& Viene preservato lo stato dei programmi
1362 e dei dispositivi prima dell'esecuzione
1363 del nuovo kernel. Viene usato
1364 principalmente per l'ibernazione del
1365 sistema ed ha senso solo se si è
1366 indicato un numero di segmento maggiore
1369 \constd{KEXEC\_ARCH\_DEFAULT} & Il kernel caricato verrà eseguito nella
1370 architettura corrente. \\
1371 \texttt{KEXEC\_ARCH\_XXX} & Il kernel caricato verrà eseguito nella
1372 architettura indicata (con \texttt{XXX}
1373 che può essere: \texttt{386},
1374 \texttt{X86\_64}, \texttt{PPC},
1375 \texttt{PPC64}, \texttt{IA\_64},
1376 \texttt{ARM}, \texttt{S390},
1377 \texttt{SH}\texttt{MIPS}
1378 e \texttt{MIPS\_LE}).\\
1382 \caption{Valori per l'argomento \param{flags} di \func{kexec\_load}.}
1383 \label{tab:kexec_load_flags}
1386 I due valori più importanti sono però quelli della parte più significativa
1387 (riportati nella prima sezione di tab.~\ref{tab:kexec_load_flags}). Il primo,
1388 \const{KEXEC\_ON\_CRASH}, consente di impostare l'esecuzione automatica del
1389 nuovo kernel caricato in caso di crollo del sistema, e viene usato quando si
1390 carica un kernel di emergenza da utilizzare per poter raccogliere informazioni
1391 diagnostiche che altrimenti verrebbero perdute non essendo il kernel ordinario
1392 più in grado di essere eseguito in maniera coerente. Il secondo valore,
1393 \const{KEXEC\_PRESERVE\_CONTEXT}, indica invece di preservare lo stato dei
1394 programmi e dei dispositivi, e viene in genere usato per realizzare la
1395 cosiddetta ibernazione in RAM.
1397 % TODO: introdotta con il kernel 3.17 è stata introdotta
1398 % kexec_file_load, per caricare immagine firmate per il secure boot,
1399 % vedi anche http://lwn.net/Articles/603116/
1401 % TODO documentare keyctl ????
1402 % (fare sezione dedicata ????)
1404 % TODO documentare la Crypto API del kernel
1406 % TODO documentare la syscall getrandom, introdotta con il kernel 3.17, vedi
1407 % http://lwn.net/Articles/606141/, ed introdotta con le glibc solo con la
1408 % versione 2.25, vedi https://lwn.net/Articles/711013/
1410 %\subsection{La gestione delle chiavi crittografiche}
1411 %\label{sec:keyctl_management}
1413 %TODO non è chiaro se farlo qui, ma documentare la syscall bpf aggiunta con il
1414 % kernel 3.18, vedi http://lwn.net/Articles/612878/; al riguardo vedi anche
1415 % https://lwn.net/Articles/660331/
1417 \section{Il controllo dell'uso delle risorse}
1418 \label{sec:sys_res_limits}
1421 Dopo aver esaminato in sez.~\ref{sec:sys_management} le funzioni che
1422 permettono di controllare le varie caratteristiche, capacità e limiti del
1423 sistema a livello globale, in questa sezione tratteremo le varie funzioni che
1424 vengono usate per quantificare le risorse (CPU, memoria, ecc.) utilizzate da
1425 ogni singolo processo e quelle che permettono di imporre a ciascuno di essi
1426 vincoli e limiti di utilizzo.
1429 \subsection{L'uso delle risorse}
1430 \label{sec:sys_resource_use}
1432 Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
1433 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1434 di tipo \struct{rusage}, la cui definizione (che si trova in
1435 \headfiled{sys/resource.h}) è riportata in
1436 fig.~\ref{fig:sys_rusage_struct}. Si ricordi che questa è una delle
1437 informazioni preservate attraverso una \func{exec}.
1439 \begin{figure}[!htb]
1442 \begin{minipage}[c]{0.8\textwidth}
1443 \includestruct{listati/rusage.h}
1446 \caption{La struttura \structd{rusage} per la lettura delle informazioni dei
1447 delle risorse usate da un processo.}
1448 \label{fig:sys_rusage_struct}
1451 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
1452 da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
1453 \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si
1454 trova nelle opzioni di compilazione del kernel (e di norma è disabilitato)
1455 che serve per mantenere una contabilità delle risorse usate da ciascun
1456 processo in maniera molto più dettagliata.} ma attualmente solo alcuni dei
1457 campi definiti sono effettivamente mantenuti. Con i kernel della serie 2.4 i
1458 soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
1459 \var{ru\_minflt} e \var{ru\_majflt}. Con i kernel della serie 2.6 si
1460 aggiungono anche \var{ru\_nvcsw} e \var{ru\_nivcsw}, a partire dal 2.6.22
1461 anche \var{ru\_inblock} e \var{ru\_oublock} e dal 2.6.32 anche
1464 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
1465 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
1466 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
1467 ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
1468 \struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
1470 La struttura \struct{rusage} è la struttura utilizzata da \func{wait4} (si
1471 ricordi quando visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di
1472 risorse impiegate dal processo di cui si è letto lo stato di terminazione, ma
1473 essa può anche essere letta direttamente utilizzando la funzione di sistema
1474 \funcd{getrusage}, il cui prototipo è:
1478 \fhead{sys/resource.h}
1480 \fdecl{int getrusage(int who, struct rusage *usage)}
1482 \fdesc{Legge la quantità di risorse usate da un processo.}
1485 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1486 caso \var{errno} assumerà uno dei valori:
1488 \item[\errcode{EINVAL}] l'argomento \param{who} non è valido
1490 ed inoltre \errval{EFAULT} nel suo significato generico.
1494 La funzione ritorna i valori per l'uso delle risorse nella struttura
1495 \struct{rusage} puntata dall'argomento \param{usage}. L'argomento \param{who}
1496 permette di specificare il soggetto di cui si vuole leggere l'uso delle
1497 risorse; esso può assumere solo i valori illustrati in
1498 tab.~\ref{tab:getrusage_who}, di questi \const{RUSAGE\_THREAD} è specifico di
1499 Linux ed è disponibile solo a partire dal kernel 2.6.26. La funzione è stata
1500 recepita nello standard POSIX.1-2001, che però indica come campi di
1501 \struct{rusage} soltanto \var{ru\_utime} e \var{ru\_stime}.
1506 \begin{tabular}[c]{|l|p{8cm}|}
1508 \textbf{Valore} & \textbf{Significato}\\
1511 \constd{RUSAGE\_SELF} & Ritorna l'uso delle risorse del processo
1512 corrente, che in caso di uso dei
1513 \textit{thread} ammonta alla somma delle
1514 risorse utilizzate da tutti i \textit{thread}
1516 \constd{RUSAGE\_CHILDREN} & Ritorna l'uso delle risorse dell'insieme dei
1517 processi figli di cui è ricevuto lo stato di
1518 terminazione, che a loro volta comprendono
1519 quelle dei loro figli e così via.\\
1520 \constd{RUSAGE\_THREAD} & Ritorna l'uso delle risorse del \textit{thread}
1524 \caption{Valori per l'argomento \param{who} di \func{getrusage}.}
1525 \label{tab:getrusage_who}
1528 I campi più utilizzati sono comunque \var{ru\_utime} e \var{ru\_stime} che
1529 indicano rispettivamente il tempo impiegato dal processo nell'eseguire le
1530 istruzioni in \textit{user space}, e quello impiegato dal kernel nelle
1531 \textit{system call} eseguite per conto del processo (vedi
1532 sez.~\ref{sec:sys_unix_time}). I campi \var{ru\_minflt} e \var{ru\_majflt}
1533 servono a quantificare l'uso della memoria virtuale e corrispondono
1534 rispettivamente al numero di \textit{page fault} (vedi
1535 sez.~\ref{sec:proc_mem_gen}) avvenuti senza richiedere I/O su disco (i
1536 cosiddetti \textit{minor page fault}), a quelli che invece han richiesto I/O
1537 su disco (detti invece \textit{major page
1538 fault}).% mentre \var{ru\_nswap} ed al numero di volte che
1539 % il processo è stato completamente tolto dalla memoria per essere inserito
1541 % TODO verificare \var{ru\_nswap} non citato nelle pagine di manuali recenti e
1542 % dato per non utilizzato.
1544 I campi \var{ru\_nvcsw} e \var{ru\_nivcsw} indicano il numero di volte che un
1545 processo ha subito un \textit{context switch} da parte dello
1546 \textit{scheduler} rispettivamente nel caso un cui questo avviene prima
1547 dell'esaurimento della propria \textit{time-slice} (in genere a causa di una
1548 \textit{system call} bloccante), o per averla esaurita o essere stato
1549 interrotto da un processo a priorità maggiore. I campi \var{ru\_inblock} e
1550 \var{ru\_oublock} indicano invece il numero di volte che è stata eseguita una
1551 attività di I/O su un filesystem (rispettivamente in lettura e scrittura) ed
1552 infine \var{ru\_maxrss} indica il valore più alto della \textit{Resident Set
1553 Size} raggiunto dal processo stesso o, nel caso sia stato usato
1554 \const{RUSAGE\_CHILDREN}, da uno dei suoi figli.
1556 Si tenga conto che per un errore di implementazione nei i kernel precedenti il
1557 2.6.9, nonostante questo fosse esplicitamente proibito dallo standard POSIX.1,
1558 l'uso di \const{RUSAGE\_CHILDREN} comportava l'inserimento dell'ammontare
1559 delle risorse usate dai processi figli anche quando si era impostata una
1560 azione di \const{SIG\_IGN} per il segnale \signal{SIGCHLD} (per i segnali si
1561 veda cap.~\ref{cha:signals}). Il comportamento è stato corretto per aderire
1562 allo standard a partire dal kernel 2.6.9.
1565 \subsection{Limiti sulle risorse}
1566 \label{sec:sys_resource_limit}
1568 Come accennato nell'introduzione il kernel mette a disposizione delle
1569 funzionalità che permettono non solo di mantenere dati statistici relativi
1570 all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
1571 utilizzo da parte sia dei singoli processi che degli utenti.
1573 Per far questo sono definite una serie di risorse e ad ogni processo vengono
1574 associati due diversi limiti per ciascuna di esse; questi sono il
1575 \textsl{limite corrente} (o \textit{current limit}) che esprime un valore
1576 massimo che il processo non può superare ad un certo momento, ed il
1577 \textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
1578 valore massimo che può assumere il \textsl{limite corrente}. In generale il
1579 primo viene chiamato anche \textit{soft limit} dato che il suo valore può
1580 essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
1581 fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
1584 In generale il superamento di un limite corrente comporta o l'emissione di uno
1585 specifico segnale o il fallimento della \textit{system call} che lo ha
1586 provocato. A questo comportamento generico fanno eccezione \const{RLIMIT\_CPU}
1587 in cui si ha in comportamento diverso per il superamento dei due limiti e
1588 \const{RLIMIT\_CORE} che influenza soltanto la dimensione o l'eventuale
1589 creazione dei file di \textit{core dump} (vedi sez.~\ref{sec:sig_standard}).
1591 Per permettere di leggere e di impostare i limiti di utilizzo delle risorse da
1592 parte di un processo sono previste due funzioni di sistema, \funcd{getrlimit}
1593 e \funcd{setrlimit}, i cui prototipi sono:
1597 \fhead{sys/resource.h}
1599 \fdecl{int getrlimit(int resource, struct rlimit *rlim)}
1600 \fdesc{Legge i limiti di una risorsa.}
1601 \fdecl{int setrlimit(int resource, const struct rlimit *rlim)}
1602 \fdesc{Imposta i limiti di una risorsa.}
1605 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
1606 caso \var{errno} assumerà uno dei valori:
1608 \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
1609 nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
1610 \var{rlim->rlim\_max}.
1611 \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1612 cercato di innalzare i propri limiti.
1614 ed inoltre \errval{EFAULT} nel suo significato generico.
1618 Entrambe le funzioni permettono di specificare attraverso l'argomento
1619 \param{resource} su quale risorsa si vuole operare. L'accesso (rispettivamente
1620 in lettura e scrittura) ai valori effettivi dei limiti viene poi effettuato
1621 attraverso la struttura \struct{rlimit} puntata da
1622 \param{rlim}, la cui definizione è riportata in
1623 fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
1624 limite corrente e limite massimo.
1626 \begin{figure}[!htb]
1629 \begin{minipage}[c]{0.8\textwidth}
1630 \includestruct{listati/rlimit.h}
1633 \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
1634 delle risorse usate da un processo.}
1635 \label{fig:sys_rlimit_struct}
1638 Come accennato processo ordinario può alzare il proprio limite corrente fino
1639 al valore del limite massimo, può anche ridurre, irreversibilmente, il valore
1640 di quest'ultimo. Nello specificare un limite, oltre a fornire dei valori
1641 specifici, si può anche usare la costante \const{RLIM\_INFINITY} che permette
1642 di sbloccare completamente l'uso di una risorsa. Si ricordi però che solo un
1643 processo con i privilegi di amministratore\footnote{per essere precisi in
1644 questo caso quello che serve è la \textit{capability}
1645 \const{CAP\_SYS\_RESOURCE} (vedi sez.~\ref{sec:proc_capabilities}).} può
1646 innalzare un limite al di sopra del valore corrente del limite massimo ed
1647 usare un valore qualsiasi per entrambi i limiti.
1649 Ciascuna risorsa su cui si possono applicare dei limiti è identificata da uno
1650 specifico valore dell'argomento \param{resource}, i valori possibili per
1651 questo argomento, ed il significato della risorsa corrispondente, dei
1652 rispettivi limiti e gli effetti causati dal superamento degli stessi sono
1653 riportati nel seguente elenco:
1655 \begin{basedescript}{\desclabelwidth{2.2cm}}%\desclabelstyle{\nextlinelabel}}
1656 \item[\constd{RLIMIT\_AS}] Questa risorsa indica, in byte, la dimensione
1657 massima consentita per la memoria virtuale di un processo, il cosiddetto
1658 \textit{Address Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se il limite
1659 viene superato dall'uso di funzioni come \func{brk}, \func{mremap} o
1660 \func{mmap} esse falliranno con un errore di \errcode{ENOMEM}, mentre se il
1661 superamento viene causato dalla crescita dello \textit{stack} il processo
1662 riceverà un segnale di \signal{SIGSEGV}. Dato che il valore usato è un
1663 intero di tipo \ctyp{long} nelle macchine a 32 bit questo può assumere un
1664 valore massimo di 2Gb (anche se la memoria disponibile può essere maggiore),
1665 in tal caso il limite massimo indicabile resta 2Gb, altrimenti la risorsa si
1666 dà per non limitata.
1668 \item[\constd{RLIMIT\_CORE}] Questa risorsa indica, in byte, la massima
1669 dimensione per un file di \textit{core dump} (vedi
1670 sez.~\ref{sec:sig_standard}) creato nella terminazione di un processo. File
1671 di dimensioni maggiori verranno troncati a questo valore, mentre con un
1672 valore nullo si bloccherà la creazione dei \textit{core dump}.
1674 \item[\constd{RLIMIT\_CPU}] Questa risorsa indica, in secondi, il massimo tempo
1675 di CPU (vedi sez.~\ref{sec:sys_cpu_times}) che il processo può usare. Il
1676 superamento del limite corrente comporta l'emissione di un segnale di
1677 \signal{SIGXCPU}, la cui azione predefinita (vedi
1678 sez.~\ref{sec:sig_classification}) è terminare il processo. Il segnale però
1679 può essere intercettato e ignorato, in tal caso esso verrà riemesso una
1680 volta al secondo fino al raggiungimento del limite massimo. Il superamento
1681 del limite massimo comporta comunque l'emissione di un segnale di
1682 \signal{SIGKILL}. Si tenga presente che questo è il comportamento presente
1683 su Linux dai kernel della serie 2.2 ad oggi, altri kernel possono avere
1684 comportamenti diversi per quanto avviene quando viene superato il
1685 \textit{soft limit}, pertanto per avere operazioni portabili è suggerito di
1686 intercettare sempre \signal{SIGXCPU} e terminare in maniera ordinata il
1687 processo con la prima ricezione.
1689 \item[\constd{RLIMIT\_DATA}] Questa risorsa indica, in byte, la massima
1690 dimensione del segmento dati di un processo (vedi
1691 sez.~\ref{sec:proc_mem_layout}). Il tentativo di allocare più memoria di
1692 quanto indicato dal limite corrente causa il fallimento della funzione di
1693 allocazione eseguita (\func{brk} o \func{sbrk}) con un errore di
1696 \item[\constd{RLIMIT\_FSIZE}] Questa risorsa indica, in byte, la massima
1697 dimensione di un file che un processo può usare. Se il processo cerca di
1698 scrivere o di estendere il file oltre questa dimensione riceverà un segnale
1699 di \signal{SIGXFSZ}, che di norma termina il processo. Se questo segnale
1700 viene intercettato la \textit{system call} che ha causato l'errore fallirà
1701 con un errore di \errcode{EFBIG}.
1703 \item[\constd{RLIMIT\_LOCKS}] Questa risorsa indica il numero massimo di
1704 \textit{file lock} (vedi sez.~\ref{sec:file_locking}) e di \textit{file
1705 lease} (vedi sez.~\ref{sec:file_asyncronous_lease}) che un processo poteva
1706 effettuare. È un limite presente solo nelle prime versioni del kernel 2.4,
1707 pertanto non deve essere più utilizzato.
1709 \item[\constd{RLIMIT\_MEMLOCK}] Questa risorsa indica, in byte, l'ammontare
1710 massimo di memoria che può essere bloccata in RAM da un processo (vedi
1711 sez.~\ref{sec:proc_mem_lock}). Dato che il \textit{memory locking} viene
1712 effettuato sulle pagine di memoria, il valore indicato viene automaticamente
1713 arrotondato al primo multiplo successivo della dimensione di una pagina di
1714 memoria. Il limite comporta il fallimento delle \textit{system call} che
1715 eseguono il \textit{memory locking} (\func{mlock}, \func{mlockall} ed anche,
1716 vedi sez.~\ref{sec:file_memory_map}, \func{mmap} con l'operazione
1717 \const{MAP\_LOCKED}).
1719 Dal kernel 2.6.9 questo limite comprende anche la memoria che può essere
1720 bloccata da ciascun utente nell'uso della memoria condivisa (vedi
1721 sez.~\ref{sec:ipc_sysv_shm}) con \func{shmctl}, che viene contabilizzata
1722 separatamente ma sulla quale viene applicato questo stesso limite. In
1723 precedenza invece questo limite veniva applicato sulla memoria condivisa per
1724 processi con privilegi amministrativi, il limite su questi è stato rimosso e
1725 la semantica della risorsa cambiata.
1728 \item[\constd{RLIMIT\_MSGQUEUE}] Questa risorsa indica il numero massimo di
1729 byte che possono essere utilizzati da un utente, identificato con
1730 l'\ids{UID} reale del processo chiamante, per le code di messaggi POSIX
1731 (vedi sez.~\ref{sec:ipc_posix_mq}). Per ciascuna coda che viene creata viene
1732 calcolata un'occupazione pari a:
1733 \includecodesnip{listati/mq_occupation.c}
1734 dove \var{attr} è la struttura \struct{mq\_attr} (vedi
1735 fig.~\ref{fig:ipc_mq_attr}) usata nella creazione della coda. Il primo addendo
1736 consente di evitare la creazione di una coda con un numero illimitato di
1737 messaggi vuoti che comunque richiede delle risorse di gestione. Questa risorsa
1738 è stata introdotta con il kernel 2.6.8.
1740 \item[\constd{RLIMIT\_NICE}] Questa risorsa indica il numero massimo a cui può
1741 essere il portato il valore di \textit{nice} (vedi
1742 sez.~\ref{sec:proc_sched_stand}). Dato che non possono essere usati numeri
1743 negativi per specificare un limite, il valore di \textit{nice} viene
1744 calcolato come \code{20-rlim\_cur}. Questa risorsa è stata introdotta con il
1747 \item[\constd{RLIMIT\_NOFILE}] Questa risorsa indica il numero massimo di file
1748 che un processo può aprire. Il tentativo di creazione di un ulteriore file
1749 descriptor farà fallire la funzione (\func{open}, \func{dup}, \func{pipe},
1750 ecc.) con un errore \errcode{EMFILE}.
1752 \item[\constd{RLIMIT\_NPROC}] Questa risorsa indica il numero massimo di
1753 processi che possono essere creati dallo stesso utente, che viene
1754 identificato con l'\ids{UID} reale (vedi sez.~\ref{sec:proc_access_id}) del
1755 processo chiamante. Se il limite viene raggiunto \func{fork} fallirà con un
1758 \item[\constd{RLIMIT\_RSS}] Questa risorsa indica, in pagine di memoria, la
1759 dimensione massima della memoria residente (il cosiddetto RSS
1760 \itindex{Resident~Set~Size~(RSS)} \textit{Resident Set Size}) cioè
1761 l'ammontare della memoria associata al processo che risiede effettivamente
1762 in RAM e non a quella eventualmente portata sulla \textit{swap} o non ancora
1763 caricata dal filesystem per il segmento testo del programma. Ha effetto
1764 solo sulle chiamate a \func{madvise} con \const{MADV\_WILLNEED} (vedi
1765 sez.~\ref{sec:file_memory_map}). Presente solo sui i kernel precedenti il
1768 \item[\constd{RLIMIT\_RTPRIO}] Questa risorsa indica il valore massimo della
1769 priorità statica che un processo può assegnarsi o assegnare con
1770 \func{sched\_setscheduler} e \func{sched\_setparam} (vedi
1771 sez.~\ref{sec:proc_real_time}). Il limite è stato introdotto a partire dal
1772 kernel 2.6.12 (ma per un bug è effettivo solo a partire dal 2.6.13). In
1773 precedenza solo i processi con privilegi amministrativi potevano avere una
1774 priorità statica ed utilizzare una politica di \textit{scheduling} di tipo
1777 \item[\constd{RLIMIT\_RTTIME}] Questa risorsa indica, in microsecondi, il tempo
1778 massimo di CPU che un processo eseguito con una priorità statica può
1779 consumare. Il superamento del limite corrente comporta l'emissione di un
1780 segnale di \signal{SIGXCPU}, e quello del limite massimo di \signal{SIGKILL}
1781 con le stesse regole viste \const{RLIMIT\_CPU}: se \signal{SIGXCPU} viene
1782 intercettato ed ignorato il segnale verrà riemesso ogni secondo fino al
1783 superamento del limite massimo. Questo limite è stato introdotto con il
1784 kernel 2.6.25 per impedire che un processo \textit{real-time} possa bloccare
1787 \item[\constd{RLIMIT\_SIGPENDING}] Questa risorsa indica il numero massimo di
1788 segnali che possono essere mantenuti in coda per ciascun utente,
1789 identificato per \ids{UID} reale. Il limite comprende sia i segnali normali
1790 che quelli \textit{real-time} (vedi sez.~\ref{sec:sig_real_time}) ed è
1791 attivo solo per \func{sigqueue}, con \func{kill} si potrà sempre inviare un
1792 segnale che non sia già presente su una coda. Questo limite è stato
1793 introdotto con il kernel 2.6.8.
1795 \item[\constd{RLIMIT\_STACK}] Questa risorsa indica, in byte, la massima
1796 dimensione dello \textit{stack} del processo. Se il processo esegue
1797 operazioni che estendano lo \textit{stack} oltre questa dimensione riceverà
1798 un segnale di \signal{SIGSEGV}.
1800 A partire dal kernel 2.6.23 questo stesso limite viene applicato per la gran
1801 parte delle architetture anche ai dati che possono essere passati come
1802 argomenti e variabili di ambiente ad un programma posto in esecuzione con
1803 \func{execve}, nella misura di un quarto del valore indicato per lo
1804 \textit{stack}. Questo valore in precedenza era fisso e pari a 32 pagine di
1805 memoria, corrispondenti per la gran parte delle architetture a 128kb di
1806 dati, dal 2.6.25, per evitare problemi di compatibilità quando
1807 \const{RLIMIT\_STACK} è molto basso, viene comunque garantito uno spazio
1808 base di 32 pagine qualunque sia l'architettura.
1812 Si tenga conto infine che tutti i limiti eventualmente presenti su un processo
1813 vengono ereditati dai figli da esso creati attraverso una \func{fork} (vedi
1814 sez.~\ref{sec:proc_fork}) e mantenuti invariati per i programmi messi in
1815 esecuzione attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
1817 Si noti come le due funzioni \func{getrlimit} e \func{setrlimit} consentano di
1818 operare solo sul processo corrente. Per questo motivo a partire dal kernel
1819 2.6.36 (e dalla \acr{glibc} 2.13) è stata introdotta un'altra funzione di
1820 sistema \funcd{prlimit} il cui scopo è quello di estendere e sostituire le
1821 precedenti. Il suo prototipo è:
1824 \fhead{sys/resource.h}
1825 \fdecl{int prlimit(pid\_t pid, int resource, const struct rlimit *new\_limit,\\
1826 \phantom{int prlimit(}struct rlimit *old\_limit}
1827 \fdesc{Legge e imposta i limiti di una risorsa.}
1830 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1831 caso \var{errno} assumerà uno dei valori:
1833 \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
1834 nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
1835 \var{rlim->rlim\_max}.
1836 \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1837 cercato di innalzare i propri limiti o si è cercato di modificare i limiti
1838 di un processo di un altro utente.
1839 \item [\errcode{ESRCH}] il process \param{pid} non esiste.
1841 ed inoltre \errval{EFAULT} nel suo significato generico.
1845 La funzione è specifica di Linux e non portabile; per essere usata richiede
1846 che sia stata definita la macro \macro{\_GNU\_SOURCE}. Il primo argomento
1847 indica il \ids{PID} del processo di cui si vogliono cambiare i limiti e si può
1848 usare un valore nullo per indicare il processo chiamante. Per modificare i
1849 limiti di un altro processo, a meno di non avere privilegi
1850 amministrativi,\footnote{anche in questo caso la \textit{capability}
1851 necessaria è \const{CAP\_SYS\_RESOURCE} (vedi
1852 sez.~\ref{sec:proc_capabilities}).} l'\ids{UID} ed il \ids{GID} reale del
1853 chiamante devono coincidere con \ids{UID} e \ids{GID} del processo indicato
1854 per i tre gruppi reale, effettivo e salvato.
1856 Se \param{new\_limit} non è \val{NULL} verrà usato come puntatore alla
1857 struttura \struct{rlimit} contenente i valori dei nuovi limiti da impostare,
1858 mentre se \param{old\_limit} non è \val{NULL} verranno letti i valori correnti
1859 del limiti nella struttura \struct{rlimit} da esso puntata. In questo modo è
1860 possibile sia leggere che scrivere, anche in contemporanea, i valori dei
1861 limiti. Il significato dell'argomento \param{resource} resta identico rispetto
1862 a \func{getrlimit} e \func{setrlimit}, così come i restanti requisiti.
1865 \subsection{Le informazioni sulle risorse di memoria e processore}
1866 \label{sec:sys_memory_res}
1868 La gestione della memoria è già stata affrontata in dettaglio in
1869 sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1870 meccanismo della memoria virtuale attraverso la divisione della memoria fisica
1871 in pagine. In genere tutto ciò è del tutto trasparente al singolo processo,
1872 ma in certi casi, come per l'I/O mappato in memoria (vedi
1873 sez.~\ref{sec:file_memory_map}) che usa lo stesso meccanismo per accedere ai
1874 file, è necessario conoscere le dimensioni delle pagine usate dal kernel. Lo
1875 stesso vale quando si vuole gestire in maniera ottimale l'interazione della
1876 memoria che si sta allocando con il meccanismo della paginazione.
1878 Un tempo la dimensione delle pagine di memoria era fissata una volta per tutte
1879 dall'architettura hardware, per cui il relativo valore veniva mantenuto in una
1880 costante che bastava utilizzare in fase di compilazione. Oggi invece molte
1881 architetture permettono di variare questa dimensione (ad esempio sui PC
1882 recenti si possono usare pagine di 4kb e di 4 Mb) per cui per non dover
1883 ricompilare i programmi per ogni possibile caso e relativa scelta di
1884 dimensioni, è necessario poter utilizzare una funzione che restituisca questi
1885 valori quando il programma viene eseguito.
1887 Dato che si tratta di una caratteristica generale del sistema come abbiamo
1888 visto in sez.~\ref{sec:sys_characteristics} questa dimensione può essere
1889 ottenuta come tutte le altre attraverso una chiamata a \func{sysconf}, nel
1890 caso specifico si dovrebbe utilizzare il parametro \const{\_SC\_PAGESIZE}. Ma
1891 in BSD 4.2 è stata introdotta una apposita funzione di sistema
1892 \funcd{getpagesize} che restituisce la dimensione delle pagine di memoria. La
1893 funzione è disponibile anche su Linux (ma richiede che sia definita la macro
1894 \macro{\_BSD\_SOURCE}) ed il suo prototipo è:
1898 \fdecl{int getpagesize(void)}
1899 \fdesc{Legge la dimensione delle pagine di memoria.}
1902 {La funzione ritorna la dimensione di una pagina in byte, e non sono previsti
1906 La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
1907 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1908 ha eliminata, ed i programmi che intendono essere portabili devono ricorrere
1909 alla chiamata a \func{sysconf}.
1911 In Linux è implementata come una \textit{system call} nelle architetture in
1912 cui essa è necessaria, ed in genere restituisce il valore del simbolo
1913 \const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
1914 se le versioni delle librerie del C precedenti la \acr{glibc} 2.1
1915 implementavano questa funzione restituendo sempre un valore statico.
1917 % TODO verificare meglio la faccenda di const{PAGE\_SIZE}
1919 La \textsl{glibc} fornisce, come specifica estensione GNU, altre due
1920 funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
1921 di ottenere informazioni riguardo le pagine di memoria; i loro prototipi sono:
1924 \fhead{sys/sysinfo.h}
1925 \fdecl{long int get\_phys\_pages(void)}
1926 \fdesc{Legge il numero totale di pagine di memoria.}
1927 \fdecl{long int get\_avphys\_pages(void)}
1928 \fdesc{Legge il numero di pagine di memoria disponibili nel sistema.}
1931 {La funzioni ritornano il numero di pagine, e non sono previsti
1935 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1936 rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
1937 \const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1938 corrispondenti alla RAM della macchina; la seconda invece la memoria
1939 effettivamente disponibile per i processi.
1941 La \acr{glibc} supporta inoltre, come estensioni GNU, due funzioni che
1942 restituiscono il numero di processori della macchina (e quello dei processori
1943 attivi); anche queste sono informazioni comunque ottenibili attraverso
1944 \func{sysconf} utilizzando rispettivamente i parametri
1945 \const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
1947 Infine la \acr{glibc} riprende da BSD la funzione \funcd{getloadavg} che
1948 permette di ottenere il carico di processore della macchina, in questo modo è
1949 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1954 \fdecl{int getloadavg(double loadavg[], int nelem)}
1955 \fdesc{Legge il carico medio della macchina.}
1958 {La funzione ritorna il numero di campionamenti restituiti e $-1$ se non
1959 riesce ad ottenere il carico medio, \var{errno} non viene modificata.}
1962 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1963 di processi attivi sulla coda dello \textit{scheduler}, calcolato su diversi
1964 intervalli di tempo. Il numero di intervalli che si vogliono leggere è
1965 specificato da \param{nelem}, dato che nel caso di Linux il carico viene
1966 valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti), questo è
1967 anche il massimo valore che può essere assegnato a questo argomento.
1970 \subsection{La \textsl{contabilità} in stile BSD}
1971 \label{sec:sys_bsd_accounting}
1973 Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
1974 kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
1975 compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
1976 cosiddetto \textit{BSD accounting}, che consente di registrare su file una
1977 serie di informazioni\footnote{contenute nella struttura \texttt{acct}
1978 definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
1979 riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
1980 che viene terminato.
1982 Linux consente di salvare la contabilità delle informazioni relative alle
1983 risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
1988 \fdecl{int acct(const char *filename)}
1989 \fdesc{Abilita il \textit{BSD accounting}.}
1992 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1993 caso \var{errno} assumerà uno dei valori:
1995 \item[\errcode{EACCES}] non si hanno i permessi per accedere a
1997 \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
1998 \item[\errcode{EPERM}] il processo non ha privilegi sufficienti ad
1999 abilitare il \textit{BSD accounting}.
2000 \item[\errcode{EUSERS}] non sono disponibili nel kernel strutture per il
2001 file o si è finita la memoria.
2003 ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
2004 \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
2005 \errval{ENOTDIR}, \errval{EROFS} nel loro significato generico.}
2008 La funzione attiva il salvataggio dei dati sul file indicato dal
2009 \textit{pathname} contenuti nella stringa puntata da \param{filename}; la
2010 funzione richiede che il processo abbia i privilegi di amministratore (è
2011 necessaria la \textit{capability} \const{CAP\_SYS\_PACCT}, vedi
2012 sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \val{NULL} per
2013 \param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
2014 semplice esempio per l'uso di questa funzione è riportato nel programma
2015 \texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
2017 Quando si attiva la contabilità, il file che si indica deve esistere; esso
2018 verrà aperto in sola scrittura e le informazioni verranno registrate in
2019 \textit{append} in coda al file tutte le volte che un processo termina. Le
2020 informazioni vengono salvate in formato binario, e corrispondono al contenuto
2021 della apposita struttura dati definita all'interno del kernel.
2023 Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
2024 parametro di sistema, modificabile attraverso \sysctlfiled{kernel/acct} (o
2025 tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi, il
2026 primo indica la percentuale di spazio disco libero sopra il quale viene
2027 ripresa una registrazione che era stata sospesa per essere scesi sotto il
2028 minimo indicato dal secondo valore (sempre in percentuale di spazio disco
2029 libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
2030 essere controllata detta percentuale.
2032 % TODO: bassa priorità, trattare la lettura del file di accounting, da
2033 % programma, vedi man 5 acct
2036 \section{La gestione dei tempi del sistema}
2037 \label{sec:sys_time}
2039 In questa sezione, una volta introdotti i concetti base della gestione dei
2040 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
2041 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
2042 veri tempi di sistema associati ai processi, a quelle per convertire i vari
2043 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
2044 gestione di data e ora.
2047 \subsection{La misura del tempo in Unix}
2048 \label{sec:sys_unix_time}
2050 \itindbeg{calendar~time}
2051 \itindbeg{process~time}
2053 Tradizionalmente nei sistemi unix-like sono sempre stati previsti due tipi
2054 distinti di tempi, caratterizzati da altrettante modalità di misura ed
2055 espressi con diversi tipi di dati, chiamati rispettivamente \textit{calendar
2056 time} e \textit{process time}, secondo le seguenti definizioni:
2057 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
2059 \item[\textit{calendar time}] detto anche \textsl{tempo di calendario},
2060 \textsl{tempo d'orologio} o \textit{tempo reale}. Si tratta di un
2061 tempo assoluto o di un intervallo di tempo come lo intende
2062 normalmente per le misure fatte con un orologio. Per esprimere
2063 questo tempo è stato riservato il tipo \type{time\_t}, e viene
2064 tradizionalmente misurato in secondi a partire dalla mezzanotte del
2065 primo gennaio 1970, data che viene chiamata \textit{the Epoch}.
2067 \item[\textit{process time}] detto anche \textsl{tempo di processore} o
2068 \textsl{tempo di CPU}. Si tratta del tempo impiegato da un processore
2069 nell'esecuzione del codice di un programma all'interno di un processo. Per
2070 esprimere questo tempo è stato riservato il tipo \type{clock\_t}, e viene
2071 misurato nei cosiddetti \textit{clock tick}, tradizionalmente corrispondenti
2072 al numero di interruzioni del processore da parte del timer di sistema. A
2073 differenza del precedente indica soltanto un intervallo di durata.
2076 Il \textit{calendar time} viene sempre mantenuto facendo riferimento
2077 al cosiddetto \textit{tempo universale coordinato} UTC, anche se
2078 talvolta viene usato il cosiddetto GMT (\textit{Greenwich Mean Time})
2079 dato che l'UTC corrisponde all'ora locale di Greenwich. Si tratta del
2080 tempo su cui viene mantenuto il cosiddetto \textsl{orologio di
2081 sistema}, e viene usato per indicare i tempi dei file (quelli di
2082 sez.~\ref{sec:file_file_times}) o le date di avvio dei processi, ed è
2083 il tempo che viene usato dai demoni che compiono lavori amministrativi
2084 ad orari definito, come \cmd{cron}.
2086 Si tenga presente che questo tempo è mantenuto dal kernel e non è detto che
2087 corrisponda al tempo misurato dall'orologio hardware presente su praticamente
2088 tutte le piastre madri dei computer moderni (il cosiddetto \textit{hardware
2089 clock}), il cui valore viene gestito direttamente dall'hardware in maniera
2090 indipendente e viene usato dal kernel soltanto all'avvio per impostare un
2091 valore iniziale dell'orologio di sistema. La risoluzione tradizionale data dal
2092 tipo di dato \type{time\_t} è di un secondo, ma nei sistemi più recenti sono
2093 disponibili altri tipi di dati con precisioni maggiori.
2095 Si tenga presente inoltre che a differenza di quanto avviene con altri sistemi
2096 operativi,\footnote{è possibile, ancorché assolutamente sconsigliabile,
2097 forzare l'orologio di sistema all'ora locale per compatibilità con quei
2098 sistemi operativi che han fatto questa deprecabile scelta.} l'orologio di
2099 sistema viene mantenuto sempre in UTC e che la conversione all'ora locale del
2100 proprio fuso orario viene effettuata dalle funzioni di libreria utilizzando le
2101 opportune informazioni di localizzazione (specificate in
2102 \conffiled{/etc/timezone}). In questo modo si ha l'assicurazione che l'orologio
2103 di sistema misuri sempre un tempo monotono crescente come nella realtà, anche
2104 in presenza di cambi di fusi orari.
2106 \itindend{calendar~time}
2108 Il \textit{process time} invece indica sempre una misura di un lasso di tempo
2109 e viene usato per tenere conto dei tempi di esecuzione dei processi. Esso
2110 viene sempre diviso in \textit{user time} e \textit{system time}, per misurare
2111 la durata di ciascun processo il kernel infatti calcola tre tempi:
2112 \begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
2113 \item[\textit{clock time}] il tempo \textsl{reale}, viene chiamato anche
2114 \textit{wall clock time} o \textit{elapsed time}, passato dall'avvio del
2115 processo. Questo tempo fa riferimento al
2116 \textit{calendar time} e dice la durata effettiva dell'esecuzione del
2117 processo, ma chiaramente dipende dal carico del sistema e da quanti altri
2118 processi stanno girando nello stesso momento.
2120 \item[\textit{user time}] il tempo effettivo che il processore ha impiegato
2121 nell'esecuzione delle istruzioni del programma in \textit{user space}. È
2122 anche quello riportato nella risorsa \var{ru\_utime} di \struct{rusage}
2123 vista in sez.~\ref{sec:sys_resource_use}.
2125 \item[\textit{system time}] il tempo effettivo che il processore ha impiegato
2126 per eseguire codice delle \textit{system call} nel kernel per conto del
2127 processo. È anche quello riportato nella risorsa \var{ru\_stime} di
2128 \struct{rusage} vista in sez.~\ref{sec:sys_resource_use}.
2131 La somma di \textit{user time} e \textit{system time} indica il
2132 \textit{process time}, vale a dire il tempo di processore totale che il
2133 sistema ha effettivamente utilizzato per eseguire il programma di un certo
2134 processo. Si può ottenere un riassunto dei valori di questi tempi quando si
2135 esegue un qualsiasi programma lanciando quest'ultimo come argomento del
2138 \itindend{process~time}
2139 \itindbeg{clock~tick}
2141 Come accennato il \textit{process time} viene misurato nei cosiddetti
2142 \textit{clock tick}. Un tempo questo corrispondeva al numero di interruzioni
2143 effettuate dal timer di sistema, oggi lo standard POSIX richiede che esso sia
2144 espresso come multiplo della costante \constd{CLOCKS\_PER\_SEC} che deve
2145 essere definita come 1000000, qualunque sia la risoluzione reale dell'orologio
2146 di sistema e la frequenza delle interruzioni del timer che, come accennato in
2147 sez.~\ref{sec:proc_hierarchy} e come vedremo a breve, è invece data dalla
2148 costante \const{HZ}.
2150 Il tipo di dato usato per questo tempo, \type{clock\_t}, con questa
2151 convenzione ha una risoluzione del microsecondo. Ma non tutte le funzioni di
2152 sistema come vedremo seguono questa convenzione, in tal caso il numero di
2153 \textit{clock tick} al secondo può essere ricavato anche attraverso
2154 \func{sysconf} richiedendo il valore della costante \const{\_SC\_CLK\_TCK}
2155 (vedi sez.~\ref{sec:sys_limits}). Il vecchio simbolo \const{CLK\_TCK}
2156 definito in \headfile{time.h} è ormai considerato obsoleto e non deve essere
2161 In realtà tutti calcoli dei tempi vengono effettuati dal kernel per il
2162 cosiddetto \textit{software clock}, utilizzando il \textit{timer di sistema} e
2163 facendo i conti in base al numero delle interruzioni generate dello stesso, i
2164 cosiddetti \itindex{jiffies} ``\textit{jiffies}''. La durata di un
2165 ``\textit{jiffy}'' è determinata dalla frequenza di interruzione del timer,
2166 indicata in Hertz, come accennato in sez.~\ref{sec:proc_hierarchy}, dal valore
2167 della costante \const{HZ} del kernel, definita in \file{asm/param.h}.
2169 Fino al kernel 2.4 il valore di \const{HZ} era 100 su tutte le architetture
2170 tranne l'alpha, per cui era 1000. Con il 2.6.0 è stato portato a 1000 su tutte
2171 le architetture, ma dal 2.6.13 il valore è diventato una opzione di
2172 compilazione del kernel, con un default di 250 e valori possibili di 100, 250,
2173 1000. Dal 2.6.20 è stato aggiunto anche il valore 300 che è divisibile per le
2174 frequenze di refresh della televisione (50 o 60 Hz). Si può pensare che questi
2175 valori determinino anche la corrispondente durata dei \textit{clock tick}, ma
2176 in realtà questa granularità viene calcolata in maniera indipendente usando la
2177 costante del kernel \const{USER\_HZ}.
2181 Fino al kernel 2.6.21 la durata di un \textit{jiffy} costituiva la risoluzione
2182 massima ottenibile nella misura dei tempi impiegabile in una \textit{system
2183 call} (ad esempio per i timeout). Con il 2.6.21 e l'introduzione degli
2184 \textit{high-resolution timers} (HRT) è divenuto possibile ottenere, per le
2185 funzioni di attesa ed i timer, la massima risoluzione possibile fornita
2186 dall'hardware. Torneremo su questo in sez.~\ref{sec:sig_timer_adv}.
2188 \itindend{clock~tick}
2191 \subsection{La gestione del \textit{process time}}
2192 \label{sec:sys_cpu_times}
2194 Di norma tutte le operazioni del sistema fanno sempre riferimento al
2195 \textit{calendar time}, l'uso del \textit{process time} è riservato a
2196 quei casi in cui serve conoscere i tempi di esecuzione di un processo
2197 (ad esempio per valutarne l'efficienza). In tal caso infatti fare
2198 ricorso al \textit{calendar time} è inutile in quanto il tempo può
2199 essere trascorso mentre un altro processo era in esecuzione o in
2200 attesa del risultato di una operazione di I/O.
2202 La funzione più semplice per leggere il \textit{process time} di un processo è
2203 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
2204 utilizzato dallo stesso; il suo prototipo è:
2208 \fdecl{clock\_t clock(void)}
2209 \fdesc{Legge il valore corrente del tempo di CPU.}
2212 {La funzione ritorna il tempo di CPU in caso di successo e $-1$ se questo non
2213 è ottenibile o rappresentabile in un valore di tipo \type{clock\_t},
2214 \var{errno} non viene usata.}
2217 La funzione restituisce il tempo in \textit{clock tick} ma la \acr{glibc}
2218 segue lo standard POSIX e quindi se si vuole il tempo in secondi occorre
2219 dividere il risultato per la costante \const{CLOCKS\_PER\_SEC}. In genere
2220 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
2221 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
2222 riprenderà lo stesso valore iniziale.
2224 La funzione è presente anche nello standard ANSI C, ma in tal caso non è
2225 previsto che il valore ritornato indichi un intervallo di tempo ma solo un
2226 valore assoluto, per questo se si vuole la massima portabilità anche al di
2227 fuori di kernel unix-like, può essere opportuno chiamare la funzione
2228 all'inizio del programma ed ottenere il valore del tempo con una differenza.
2230 Si tenga presente inoltre che con altri kernel unix-like il valore riportato
2231 dalla funzione può includere anche il tempo di processore usato dai processi
2232 figli di cui si è ricevuto lo stato di terminazione con \func{wait} e
2233 affini. Questo non vale per Linux, in cui questa informazione deve essere
2234 ottenuta separatamente.
2236 Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di processore è la
2237 somma di altri due tempi, l'\textit{user time} ed il \textit{system time}, che
2238 sono quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
2239 possono essere letti separatamente attraverso la funzione \funcd{times}, il
2244 \fdecl{clock\_t times(struct tms *buf)}
2245 \fdesc{Legge il valore corrente dei tempi di processore.}
2248 {La funzione ritorna un numero di \textit{clock tick} in caso di successo e
2249 $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il valore
2250 \errval{EFAULT} nel suo significato generico.}
2253 La funzione restituisce i valori di \textit{process time} del processo
2254 corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
2255 in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
2256 due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
2257 \textit{system time} del processo, così come definiti in
2258 sez.~\ref{sec:sys_unix_time}. Gli altri due campi, \var{tms\_cutime} e
2259 \var{tms\_cstime}, riportano la somma dell'\textit{user time} e del
2260 \textit{system time} di tutti processi figli di cui si è ricevuto lo stato di
2263 \begin{figure}[!htb]
2266 \begin{minipage}[c]{0.8\textwidth}
2267 \includestruct{listati/tms.h}
2270 \caption{La struttura \structd{tms} dei tempi di processore associati a un
2272 \label{fig:sys_tms_struct}
2276 Si tenga presente che i tempi di processore dei processi figli di un processo
2277 vengono sempre sommati al valore corrente ogni volta che se ne riceve lo stato
2278 di terminazione, e detto valore è quello che viene a sua volta ottenuto dal
2279 processo padre. Pertanto nei campi \var{tms\_cutime} e \var{tms\_cstime} si
2280 sommano anche i tempi di ulteriori discendenti di cui i rispettivi genitori
2281 abbiano ricevuto lo stato di terminazione.
2283 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
2284 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
2285 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
2286 lo stato di terminazione di tutti i suoi figli, questi processi
2287 ``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi e
2288 così via per i relativi ``\textsl{discendenti}''.
2290 Come accennato in sez.~\ref{sec:sys_resource_use} per i kernel precedenti la
2291 versione 2.6.9 il tempo di processore dei processi figli veniva sommato
2292 comunque chiedendo di ignorare \signal{SIGCHLD} anche se lo standard POSIX
2293 richiede esplicitamente che questo avvenga solo quando si riceve lo stato di
2294 uscita con una funzione della famiglia delle \func{wait}, anche in questo caso
2295 il comportamento è stato adeguato allo standard a partire dalla versione
2298 A differenza di quanto avviene per \func{clock} i valori restituiti nei campi
2299 di una struttura \struct{tms} sono misurati in numero di \textit{clock tick}
2300 effettivi e non in multipli di \const{CLOCKS\_PER\_SEC}, pertanto per ottenere
2301 il valore effettivo del tempo in secondi occorrerà dividere per il risultato
2302 di \code{sysconf(\_SC\_CLK\_TCK)}.
2304 Lo stesso vale per il valore di ritorno della funzione, il cui significato fa
2305 riferimento ad un tempo relativo ad un certo punto nel passato la cui
2306 definizione dipende dalle diverse implementazioni, e varia anche fra diverse
2307 versioni del kernel. Fino al kernel 2.4 si faceva infatti riferimento al
2308 momento dell'avvio del kernel. Con il kernel 2.6 si fa riferimento a
2309 $2^{32}/\mathtt{HZ}-300$ secondi prima dell'avvio.
2311 Considerato che il numero dei \textit{clock tick} per un kernel che è attivo
2312 da molto tempo può eccedere le dimensioni per il tipo \type{clock\_t} il
2313 comportamento più opportuno per i programmi è di ignorare comunque il valore
2314 di ritorno della funzione e ricorrere alle funzioni per il tempo di calendario
2315 del prossimo paragrafo qualora si voglia calcolare il tempo effettivamente
2316 trascorso dall'inizio del programma.
2318 Infine si tenga presente che per dei limiti nelle convenzioni per il ritorno
2319 dei valori delle \textit{system call} su alcune architetture hardware (ed in
2320 particolare la \texttt{i386} dei PC a 32 bit) nel kernel della serie 2.6 il
2321 valore di ritorno della funzione può risultare erroneamente uguale a $-1$,
2322 indicando un errore, nei primi secondi dopo il boot (per la precisione nei
2323 primi 41 secondi) e se il valore del contatore eccede le dimensione del tipo
2327 \subsection{Le funzioni per il \textit{calendar time}}
2328 \label{sec:sys_time_base}
2330 \itindbeg{calendar~time}
2332 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time}
2333 viene espresso normalmente con una variabile di tipo \type{time\_t}, che
2334 usualmente corrisponde ad un tipo elementare; in Linux è definito come
2335 \ctyp{long int}, che di norma corrisponde a 32 bit. Il valore corrente del
2336 \textit{calendar time}, che indicheremo come \textsl{tempo di sistema}, può
2337 essere ottenuto con la funzione \funcd{time} che lo restituisce nel suddetto
2338 formato, il suo prototipo è:
2342 \fdecl{time\_t time(time\_t *t)}
2343 \fdesc{Legge il valore corrente del \textit{calendar time}.}
2346 {La funzione ritorna il valore del \textit{calendar time} in caso di successo
2347 e $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il
2348 valore \errval{EFAULT} nel suo significato generico.}
2351 L'argomento \param{t}, se non nullo, deve essere l'indirizzo di una variabile
2352 su cui duplicare il valore di ritorno.
2354 Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
2355 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
2356 sia necessario; il suo prototipo è:
2360 \fdecl{int stime(time\_t *t)}
2361 \fdesc{Imposta il valore corrente del \textit{calendar time}.}
2364 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
2365 caso \var{errno} assumerà uno dei valori:
2367 \item[\errcode{EPERM}] non si hanno i permessi di amministrazione.
2369 ed inoltre \errval{EFAULT} nel suo significato generico.}
2373 Dato che modificare l'ora ha un impatto su tutto il sistema il cambiamento
2374 dell'orologio è una operazione privilegiata e questa funzione può essere usata
2375 solo da un processo con i privilegi di amministratore (per la precisione la
2376 \textit{capability} \const{CAP\_SYS\_TIME}), altrimenti la chiamata fallirà
2377 con un errore di \errcode{EPERM}.
2379 Data la scarsa precisione nell'uso di \type{time\_t}, che ha una risoluzione
2380 massima di un secondo, quando si devono effettuare operazioni sui tempi di
2381 norma l'uso delle due funzioni precedenti è sconsigliato, ed esse sono di
2382 solito sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le
2383 due funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
2384 \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
2385 in BSD4.3 sono indicate come sostitute delle precedenti, \func{gettimeofday}
2386 viene descritta anche in POSIX.1-2001.} i cui prototipi sono:
2391 \fdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
2392 \fdesc{Legge il tempo corrente del sistema.}
2393 \fdecl{int settimeofday(const struct timeval *tv, const struct timezone *tz)}
2394 \fdesc{Imposta il tempo di sistema.}
2397 {La funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
2398 caso \var{errno} assumerà i valori \errval{EINVAL}, \errval{EFAULT} e per
2399 \func{settimeofday} anche \errval{EPERM}, nel loro significato generico.}
2403 Si noti come queste funzioni utilizzino per indicare il tempo una struttura di
2404 tipo \struct{timeval}, la cui definizione si è già vista in
2405 fig.~\ref{fig:sys_timeval_struct}, questa infatti permette una espressione
2406 alternativa dei valori del \textit{calendar time}, con una precisione,
2407 rispetto a \type{time\_t}, fino al microsecondo, ma la precisione è solo
2408 teorica, e la precisione reale della misura del tempo dell'orologio di sistema
2409 non dipende dall'uso di queste strutture.
2411 Come nel caso di \func{stime} anche \func{settimeofday} può essere utilizzata
2412 solo da un processo coi privilegi di amministratore e più precisamente con la
2413 capacità \const{CAP\_SYS\_TIME}. Si tratta comunque di una condizione generale
2414 che continua a valere per qualunque funzione che vada a modificare l'orologio
2415 di sistema, comprese tutte quelle che tratteremo in seguito.
2419 Il secondo argomento di entrambe le funzioni è una struttura
2420 \struct{timezone}, che storicamente veniva utilizzata per specificare appunto
2421 la cosiddetta \textit{timezone}, cioè l'insieme del fuso orario e delle
2422 convenzioni per l'ora legale che permettevano il passaggio dal tempo
2423 universale all'ora locale. Questo argomento oggi è obsoleto ed in Linux non è
2424 mai stato utilizzato; esso non è supportato né dalla vecchia \textsl{libc5},
2425 né dalla \textsl{glibc}: pertanto quando si chiama questa funzione deve essere
2426 sempre impostato a \val{NULL}.
2430 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
2431 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
2432 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
2433 conseguenze indesiderate. Ad esempio se si porta avanti l'orologio si possono
2434 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
2435 saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
2436 delle operazioni previste nell'intervallo di tempo che viene ripetuto.
2438 Per questo motivo la modalità più corretta per impostare l'ora è quella di
2439 usare la funzione \funcd{adjtime}, il cui prototipo è:
2443 \fdecl{int adjtime(const struct timeval *delta, struct timeval *olddelta)}
2444 \fdesc{Aggiusta l'orologio di sistema.}
2447 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
2448 caso \var{errno} assumerà uno dei valori:
2450 \item[\errcode{EINVAL}] il valore di \param{delta} eccede il massimo
2452 \item[\errcode{EPERM}] il processo non i privilegi di amministratore.
2458 Questa funzione permette di avere un aggiustamento graduale del tempo di
2459 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
2460 indicato nella struttura \struct{timeval} puntata da \param{delta} esprime il
2461 valore di cui si vuole spostare l'orologio. Se è positivo l'orologio sarà
2462 accelerato per un certo tempo in modo da guadagnare il tempo richiesto,
2463 altrimenti sarà rallentato.
2465 La funzione è intesa per piccoli spostamenti del tempo di sistema, ed esistono
2466 pertanto dei limiti massimi per i valori che si possono specificare
2467 per \param{delta}. La \acr{glibc} impone un intervallo compreso fra
2468 \code{INT\_MIN/1000000 + 2} e \code{INT\_MAX/1000000 - 2}, corrispondente, su
2469 una architettura PC ordinaria a 32 bit, ad un valore compreso fra $-2145$ e
2472 Inoltre se si invoca la funzione prima che una precedente richiesta di
2473 aggiustamento sia stata completata, specificando un altro valore, il
2474 precedente aggiustamento viene interrotto, ma la parte dello stesso che è già
2475 stata completata non viene rimossa. Però è possibile in questo caso farsi
2476 restituire nella struttura puntata da \param{olddelta} il tempo restante della
2477 precedente richiesta. Fino al kernel 2.6.26 ed alla \acr{glibc} 2.8 questo
2478 però era possibile soltanto specificando un diverso aggiustamento
2479 per \param{delta}, il bug è stato corretto a partire dalle versioni citate e
2480 si può ottenere l'informazione relativa alla frazione di aggiustamento
2481 mancante usando il valore \val{NULL} per \param{delta}.
2483 Linux poi prevede una specifica funzione di sistema che consente un
2484 aggiustamento molto più dettagliato del tempo, permettendo ad esempio anche di
2485 regolare anche la velocità e le derive dell'orologio di sistema. La funzione
2486 è \funcd{adjtimex} ed il suo prototipo è:
2490 \fdecl{int adjtimex(struct timex *buf)}
2491 \fdesc{Regola l'orologio di sistema.}
2494 {La funzione ritorna lo stato dell'orologio (un valore $\ge 0$) in caso di
2495 successo e $-1$ per un errore, nel qual caso \var{errno} assumerà uno dei
2498 \item[\errcode{EINVAL}] si sono indicati valori fuori dall'intervallo
2499 consentito per qualcuno dei campi di \param{buf}.
2500 \item[\errcode{EPERM}] si è richiesta una modifica dei parametri ed il
2501 processo non ha i privilegi di amministratore.
2503 ed inoltre \errval{EFAULT} nel suo significato generico.}
2506 In caso di successo la funzione restituisce un valore numerico non negativo
2507 che indica lo stato dell'orologio, che può essere controllato con i valori
2508 delle costanti elencate in tab.~\ref{tab:adjtimex_return}.
2513 \begin{tabular}[c]{|l|c|l|}
2515 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2518 \constd{TIME\_OK} & 0 & Orologio sincronizzato.\\
2519 \constd{TIME\_INS} & 1 & Inserimento di un \textit{leap second}.\\
2520 \constd{TIME\_DEL} & 2 & Cancellazione di un \textit{leap second}.\\
2521 \constd{TIME\_OOP} & 3 & \textit{leap second} in corso.\\
2522 \constd{TIME\_WAIT} & 4 & \textit{leap second} avvenuto.\\
2523 \constd{TIME\_BAD} & 5 & Orologio non sincronizzato.\\
2526 \caption{Possibili valori ritornati da \func{adjtimex} in caso di successo.}
2527 \label{tab:adjtimex_return}
2530 La funzione richiede come argomento il puntatore ad una struttura di tipo
2531 \struct{timex}, la cui definizione, effettuata in \headfiled{sys/timex.h}, è
2532 riportata in fig.~\ref{fig:sys_timex_struct} per i campi che interessano la
2533 possibilità di essere modificati documentati anche nella pagina di manuale. In
2534 realtà la struttura è stata estesa con ulteriori campi, i cui valori sono
2535 utilizzabili solo in lettura, la cui definizione si può trovare direttamente
2537 \begin{figure}[!htb]
2538 \footnotesize \centering
2539 \begin{minipage}[c]{\textwidth}
2540 \includestruct{listati/timex.h}
2543 \caption{La struttura \structd{timex} per il controllo dell'orologio di
2545 \label{fig:sys_timex_struct}
2548 L'azione della funzione dipende dal valore del campo \var{mode}
2549 di \param{buf}, che specifica quale parametro dell'orologio di sistema,
2550 specificato nel corrispondente campo di \struct{timex}, deve essere
2551 impostato. Un valore nullo serve per leggere i parametri correnti, i valori
2552 diversi da zero devono essere specificati come OR binario delle costanti
2553 riportate in tab.~\ref{tab:sys_timex_mode}.
2558 \begin{tabular}[c]{|l|c|p{8cm}|}
2560 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2563 \constd{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
2564 reale e l'orologio di sistema:
2565 deve essere indicata in microsecondi
2566 nel campo \var{offset} di
2568 \constd{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenza in frequenza
2569 fra il tempo reale e l'orologio di
2570 sistema: deve essere indicata
2571 in parti per milione nel campo
2572 \var{frequency} di \struct{timex}.\\
2573 \constd{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo
2574 dell'errore sul tempo, espresso in
2575 microsecondi nel campo
2576 \var{maxerror} di \struct{timex}.\\
2577 \constd{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
2578 sul tempo, espresso in microsecondi
2579 nel campo \var{esterror} di
2581 \constd{ADJ\_STATUS} & 0x0010 & Imposta alcuni valori di stato
2583 sistema nella gestione
2584 dell'orologio specificati nel campo
2585 \var{status} di \struct{timex}.\\
2586 \constd{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del
2587 PLL implementato dal kernel,
2588 specificato nel campo
2589 \var{constant} di \struct{timex}.\\
2590 \constd{ADJ\_TICK} & 0x4000 & Imposta il valore dei \textit{tick}
2592 microsecondi, espresso nel campo
2593 \var{tick} di \struct{timex}.\\
2594 \constd{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Chiede uno spostamento una tantum
2595 dell'orologio secondo il valore del
2596 campo \var{offset} simulando il
2597 comportamento di \func{adjtime}.\\
2600 \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
2601 struttura \struct{timex}.}
2602 \label{tab:sys_timex_mode}
2605 La funzione utilizza il meccanismo di David L. Mills, descritto
2606 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
2607 protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
2608 portabilità è un requisito, la \acr{glibc} provvede anche un suo omonimo
2609 \func{ntp\_adjtime}. La trattazione completa di questa funzione necessita di
2610 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
2611 a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
2612 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
2613 campi della struttura \struct{timex} può essere ritrovato in \cite{GlibcMan}.
2615 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
2616 sintassi specificata per la forma equivalente di questa funzione definita come
2617 \func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
2620 Si tenga presente infine che con l'introduzione a partire dal kernel 2.6.21
2621 degli \textit{high-resolution timer} ed il supporto per i cosiddetti POSIX
2622 \textit{real-time clock}, si può ottenere il \textit{calendar time}
2623 direttamente da questi, come vedremo in sez.~\ref{sec:sig_timer_adv}, con la
2624 massima risoluzione possibile per l'hardware della macchina.
2628 \subsection{La gestione delle date.}
2629 \label{sec:sys_date}
2631 \itindbeg{broken-down~time}
2633 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
2634 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
2635 illustrate, se han senso per specificare un intervallo, non sono molto
2636 intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
2637 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2638 time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2639 time} usuale in ore, minuti, secondi, ecc. e viene usata tenendo conto
2640 anche dell'eventuale utilizzo di un fuso orario.
2642 \begin{figure}[!htb]
2643 \footnotesize \centering
2644 \begin{minipage}[c]{.8\textwidth}
2645 \includestruct{listati/tm.h}
2648 \caption{La struttura \structd{tm} per una rappresentazione del tempo in
2649 termini di ora, minuti, secondi, ecc.}
2650 \label{fig:sys_tm_struct}
2653 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
2654 definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
2655 struttura che si utilizza quando si deve specificare un tempo a partire dai
2656 dati naturali (ora e data), dato che essa consente anche di tenere conto della
2657 gestione del fuso orario e dell'ora legale. In particolare gli ultimi due
2658 campi, \var{tm\_gmtoff} e \var{tm\_zone}, sono estensioni previste da BSD e
2659 supportate dalla \acr{glibc} quando è definita la macro \macro{\_BSD\_SOURCE}.
2661 Ciascuno dei campi di \struct{tm} ha dei precisi intervalli di valori
2662 possibili, con convenzioni purtroppo non troppo coerenti. Ad esempio
2663 \var{tm\_sec} che indica i secondi deve essere nell'intervallo da 0 a 59, ma è
2664 possibile avere anche il valore 60 per un cosiddetto \textit{leap second} (o
2665 \textsl{secondo intercalare}), cioè uno di quei secondi aggiunti al calcolo
2666 dell'orologio per effettuare gli aggiustamenti del calendario per tenere conto
2667 del disallineamento con il tempo solare.\footnote{per dettagli si consulti
2668 \url{http://it.wikipedia.org/wiki/Leap_second}.}
2670 I campi \var{tm\_min} e\var{tm\_hour} che indicano rispettivamente minuti ed
2671 ore hanno valori compresi rispettivamente fra 0 e 59 e fra 0 e 23. Il campo
2672 \var{tm\_mday} che indica il giorno del mese prevede invece un valore compreso
2673 fra 1 e 31, ma la \acr{glibc} supporta pure il valore 0 come indicazione
2674 dell'ultimo giorno del mese precedente. Il campo \var{tm\_mon} indica il mese
2675 dell'anno a partire da gennaio con valori compresi fra 0 e 11.
2677 I campi \var{tm\_wday} e \var{tm\_yday} indicano invece rispettivamente il
2678 giorno della settimana, a partire dalla Domenica, ed il giorno dell'anno, a
2679 partire del primo gennaio, ed hanno rispettivamente valori compresi fra 0 e 6
2680 e fra 0 e 365. L'anno espresso da \var{tm\_year} viene contato come numero di
2681 anni a partire dal 1900. Infine \var{tm\_isdst} è un valore che indica se per
2682 gli altri campi si intende come attiva l'ora legale ed influenza il
2683 comportamento di \func{mktime}.
2686 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2687 da quelle usate per convertire gli altri formati in questo, usando o meno
2688 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2689 tempo in una stringa contenente data ed ora. Le prime due funzioni,
2690 \funcd{asctime} e \funcd{ctime} servono per poter stampare in forma leggibile
2691 un tempo, i loro prototipi sono:
2695 \fdecl{char * asctime(const struct tm *tm)}
2696 \fdesc{Converte un \textit{broken-down time} in una stringa.}
2697 \fdecl{char * ctime(const time\_t *timep)}
2698 \fdesc{Converte un \textit{calendar time} in una stringa.}
2701 {Le funzioni ritornano un puntatore al risultato in caso di successo e
2702 \val{NULL} per un errore, \var{errno} non viene modificata.}
2705 Le funzioni prendono rispettivamente come argomenti i puntatori ad una
2706 struttura \struct{tm} contenente un \textit{broken-down time} o ad una
2707 variabile di tipo \type{time\_t} che esprime il \textit{calendar time},
2708 restituendo il puntatore ad una stringa che esprime la data, usando le
2709 abbreviazioni standard di giorni e mesi in inglese, nella forma:
2711 Sun Apr 29 19:47:44 2012\n"
2714 Nel caso di \func{ctime} la funzione tiene conto della eventuale impostazione
2715 di una \textit{timezone} e effettua una chiamata preventiva a \func{tzset}
2716 (che vedremo a breve), in modo che la data espressa tenga conto del fuso
2717 orario. In realtà \func{ctime} è banalmente definita in termini di
2718 \func{asctime} come \code{asctime(localtime(t)}.
2720 Dato che l'uso di una stringa statica rende le funzioni non rientranti
2721 POSIX.1c e SUSv2 prevedono due sostitute rientranti, il cui nome è al solito
2722 ottenuto aggiungendo un \code{\_r}, che prendono un secondo argomento
2723 \code{char *buf}, in cui l'utente deve specificare il buffer su cui la stringa
2724 deve essere copiata (deve essere di almeno 26 caratteri).
2726 Per la conversione fra \textit{broken-down time} e \textit{calendar time} sono
2727 invece disponibili altre tre funzioni, \funcd{gmtime}, \funcd{localtime} e
2728 \funcd{mktime} i cui prototipi sono:
2731 \fdecl{struct tm * gmtime(const time\_t *timep)}
2732 \fdesc{Converte un \textit{calendar time} in un \textit{broken-down time} in
2734 \fdecl{struct tm * localtime(const time\_t *timep)}
2735 \fdesc{Converte un \textit{calendar time} in un \textit{broken-down time}
2737 \fdecl{time\_t mktime(struct tm *tm)}
2738 \fdesc{Converte un \textit{broken-down time} in un \textit{calendar time}.}
2742 {Le funzioni ritornano un puntatore al risultato in caso di successo e
2743 \val{NULL} per un errore, tranne che \func{mktime} che restituisce
2744 direttamente il valore o $-1$ in caso di errore, \var{errno} non viene
2748 Le le prime funzioni, \func{gmtime}, \func{localtime} servono per convertire
2749 il tempo in \textit{calendar time} specificato da un argomento di tipo
2750 \type{time\_t} restituendo un \textit{broken-down time} con il puntatore ad
2751 una struttura \struct{tm}. La prima effettua la conversione senza tenere conto
2752 del fuso orario, esprimendo la data in tempo coordinato universale (UTC), cioè
2753 l'ora di Greenwich, mentre \func{localtime} usa l'ora locale e per questo
2754 effettua una chiamata preventiva a \func{tzset}.
2756 Anche in questo caso le due funzioni restituiscono l'indirizzo di una
2757 struttura allocata staticamente, per questo sono state definite anche altre
2758 due versioni rientranti (con la solita estensione \code{\_r}), che prevedono
2759 un secondo argomento \code{struct tm *result}, fornito dal chiamante, che deve
2760 preallocare la struttura su cui sarà restituita la conversione. La versione
2761 rientrante di \func{localtime} però non effettua la chiamata preventiva a
2762 \func{tzset} che deve essere eseguita a cura dell'utente.
2764 Infine \func{mktime} esegue la conversione di un \textit{broken-down time} a
2765 partire da una struttura \struct{tm} restituendo direttamente un valore di
2766 tipo \type{time\_t} con il \textit{calendar time}. La funzione ignora i campi
2767 \var{tm\_wday} e \var{tm\_yday} e per gli altri campi normalizza eventuali
2768 valori fuori degli intervalli specificati in precedenza: se cioè si indica un
2769 12 per \var{tm\_mon} si prenderà il gennaio dell'anno successivo. Inoltre la
2770 funzione tiene conto del valore di \var{tm\_isdst} per effettuare le
2771 correzioni relative al fuso orario: un valore positivo indica che deve essere
2772 tenuta in conto l'ora legale, un valore nullo che non deve essere applicata
2773 nessuna correzione, un valore negativo che si deve far ricorso alle
2774 informazioni relative al proprio fuso orario per determinare lo stato dell'ora
2777 La funzione inoltre modifica i valori della struttura \struct{tm} in forma di
2778 \textit{value result argument}, normalizzando i valori dei vari campi,
2779 impostando i valori risultanti per \var{tm\_wday} e \var{tm\_yday} e
2780 assegnando a \var{tm\_isdst} il valore (positivo o nullo) corrispondente allo
2781 stato dell'ora legale. La funzione inoltre provvede ad impostare il valore
2782 della variabile globale \var{tzname}.
2784 \itindend{calendar~time}
2786 \begin{figure}[!htb]
2789 \begin{minipage}[c]{.75\textwidth}
2790 \includestruct{listati/time_zone_var.c}
2793 \caption{Le variabili globali usate per la gestione delle
2795 \label{fig:sys_tzname}
2798 Come accennato l'uso del \textit{broken-down time} permette di tenere conto
2799 anche della differenza fra tempo universale e ora locale, compresa l'eventuale
2800 ora legale. Questo viene fatto dalle funzioni di conversione grazie alle
2801 informazioni riguardo la propria \textit{timezone} mantenute nelle tre
2802 variabili globali mostrate in fig.~\ref{fig:sys_tzname}, cui si può accedere
2803 direttamente includendo \headfile{time.h}. Come illustrato queste variabili
2804 vengono impostate internamente da alcune delle precedenti funzioni di
2805 conversione, ma lo si può fare esplicitamente chiamando direttamente la
2806 funzione \funcd{tzset}, il cui prototipo è:
2810 \fdecl{void tzset(void)}
2811 \fdesc{Imposta le variabili globali della \textit{timezone}.}
2814 {La funzione non ritorna niente e non dà errori.}
2817 La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire
2818 dal valore della variabile di ambiente \envvar{TZ}, se quest'ultima non è
2819 definita verrà usato il file \conffiled{/etc/localtime}. La variabile
2820 \var{tzname} contiene due stringhe, che indicano i due nomi standard della
2821 \textit{timezone} corrente. La prima è il nome per l'ora solare, la seconda
2822 per l'ora legale. Anche se in fig.~\ref{fig:sys_tzname} sono indicate come
2823 \code{char *} non è il caso di modificare queste stringhe. La variabile
2824 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2825 \var{daylight} indica se è attiva o meno l'ora legale.
2827 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2828 stampare un tempo o una data, la flessibilità non fa parte delle sue
2829 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2830 giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
2835 \fdecl{size\_t strftime(char *s, size\_t max, const char *format,
2836 const struct tm *tm)}
2837 \fdesc{Crea una stringa con una data secondo il formato indicato.}
2840 {La funzione ritorna il numero di caratteri inseriti nella stringa \param{s}
2841 oppure $0$, \var{errno} non viene modificata.}
2845 La funzione converte il \textit{broken-down time} indicato nella struttura
2846 puntata dall'argomento \param{tm} in una stringa di testo da salvare
2847 all'indirizzo puntato dall'argomento \param{s}, purché essa sia di dimensione
2848 inferiore al massimo indicato dall'argomento \param{max}. Il numero di
2849 caratteri generati dalla funzione viene restituito come valore di ritorno,
2850 senza tener però conto del terminatore finale, che invece viene considerato
2851 nel computo della dimensione. Se quest'ultima è eccessiva viene restituito 0 e
2852 lo stato di \param{s} è indefinito.
2857 \begin{tabular}[c]{|c|l|p{6cm}|}
2859 \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2862 \var{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
2863 \var{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
2864 \var{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
2865 \var{\%B}&\texttt{April} & Nome del mese, completo.\\
2866 \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
2867 \var{\%d}&\texttt{24} & Giorno del mese.\\
2868 \var{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
2869 \var{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
2870 \var{\%j}&\texttt{114} & Giorno dell'anno.\\
2871 \var{\%m}&\texttt{04} & Mese dell'anno.\\
2872 \var{\%M}&\texttt{40} & Minuto.\\
2873 \var{\%p}&\texttt{PM} & AM/PM.\\
2874 \var{\%S}&\texttt{50} & Secondo.\\
2875 \var{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
2877 \var{\%w}&\texttt{3} & Giorno della settimana.\\
2878 \var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
2880 \var{\%x}&\texttt{04/24/02} & La data.\\
2881 \var{\%X}&\texttt{18:40:50} & L'ora.\\
2882 \var{\%y}&\texttt{02} & Anno nel secolo.\\
2883 \var{\%Y}&\texttt{2002} & Anno.\\
2884 \var{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
2885 \var{\%\%}&\texttt{\%} & Il carattere \%.\\
2888 \caption{Valori previsti dallo standard ANSI C per modificatore della
2889 stringa di formato di \func{strftime}.}
2890 \label{tab:sys_strftime_format}
2893 Il risultato della funzione è controllato dalla stringa di formato
2894 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2895 viene utilizzato come modificatore. Alcuni dei possibili valori che esso può
2896 assumere sono riportati in tab.~\ref{tab:sys_strftime_format}.\footnote{per la
2897 precisione si sono riportati definiti dallo standard ANSI C, che sono anche
2898 quelli ripresi in POSIX.1; la \acr{glibc} fornisce anche le estensioni
2899 introdotte da POSIX.2 per il comando \cmd{date}, i valori introdotti da
2900 SVID3 e ulteriori estensioni GNU; l'elenco completo dei possibili valori è
2901 riportato nella pagina di manuale della funzione.} La funzione tiene conto
2902 anche delle eventuali impostazioni di localizzazione per stampare i vari nomi
2903 in maniera adeguata alla lingua scelta, e con le convenzioni nazionali per i
2904 formati di data ed ora.
2906 Infine per effettuare l'operazione di conversione inversa, da una stringa ad
2907 un \textit{broken-down time}, si può utilizzare la funzione \funcd{strptime},
2912 \fdecl{char *strptime(const char *s, const char *format, struct tm *tm)}
2913 \fdesc{Converte una stringa con in un \textit{broken-down time} secondo un
2917 {La funzione ritorna il puntatore al primo carattere non processato della
2918 stringa o al terminatore finale qualora questa sia processata interamente,
2919 \var{errno} non viene modificata.}
2922 La funzione processa la stringa puntata dall'argomento \param{s} da sinistra a
2923 destra, utilizzando il formato contenuto nella stringa puntata
2924 dall'argomento \param{format}, avvalorando volta volta i corrispondenti campi
2925 della struttura puntata dall'argomento \param{tm}. La scansione si interrompe
2926 immediatamente in caso di mancata corrispondenza a quanto indicato nella
2927 stringa di formato, che usa una sintassi analoga a quella già vista per
2928 \func{strftime}. La funzione supporta i modificatori di
2929 tab.~\ref{tab:sys_strftime_format} più altre estensioni, ma per i dettagli a
2930 questo riguardo si rimanda alla lettura della pagina di manuale.
2932 Si tenga presente comunque che anche in caso di scansione completamente
2933 riuscita la funzione sovrascrive soltanto i campi di \param{tm} indicati dal
2934 formato, la struttura originaria infatti non viene inizializzati e gli altri
2935 campi restano ai valori che avevano in precedenza.
2938 \itindend{broken-down~time}
2940 \section{La gestione degli errori}
2941 \label{sec:sys_errors}
2943 In questa sezione esamineremo le caratteristiche principali della gestione
2944 degli errori in un sistema unix-like. Infatti a parte il caso particolare di
2945 alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
2946 unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
2947 un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
2948 semplicemente usando un opportuno valore di ritorno della funzione invocata.
2949 Inoltre il sistema di classificazione degli errori è stato progettato
2950 sull'architettura a processi, e presenta una serie di problemi nel caso lo si
2951 debba usare con i \textit{thread}.
2954 \subsection{La variabile \var{errno}}
2955 \label{sec:sys_errno}
2957 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2958 riportare condizioni di errore, ed è una norma fondamentale di buona
2959 programmazione controllare \textsl{sempre} che le funzioni chiamate si siano
2960 concluse correttamente.
2962 In genere le funzioni di libreria usano un valore speciale per indicare che
2963 c'è stato un errore. Di solito questo valore, a seconda della funzione, è $-1$
2964 o un puntatore nullo o la costante \val{EOF}; ma questo valore segnala solo
2965 che c'è stato un errore, e non il tipo di errore.
2967 Per riportare il tipo di errore il sistema usa la variabile globale
2968 \var{errno}, definita nell'header \headfile{errno.h}. Come accennato l'uso di
2969 una variabile globale può comportare problemi nel caso dei \textit{thread}, ma
2970 lo standard ISO C consente anche di definire \var{errno} come un cosiddetto
2971 ``\textit{modifiable lvalue}'', cosa che consente di usare anche una macro, e
2972 questo è infatti il metodo usato da Linux per renderla locale ai singoli
2975 La variabile è in genere definita come \dirct{volatile} dato che può essere
2976 cambiata in modo asincrono da un segnale, per un esempio si veda
2977 sez.~\ref{sec:sig_sigchld} ricordando quanto trattato in
2978 sez.~\ref{sec:proc_race_cond}). Dato che un gestore di segnale scritto bene si
2979 cura di salvare e ripristinare il valore della variabile all'uscita, nella
2980 programmazione normale, quando si può fare l'assunzione che i gestori di
2981 segnali siano ben scritti, di questo non è necessario preoccuparsi.
2983 I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
2984 nell'header \headfile{errno.h} sono anche definiti i nomi simbolici per le
2985 costanti numeriche che identificano i vari errori che abbiamo citato fin
2986 dall'inizio nelle descrizioni delle funzioni. Essi iniziano tutti per \val{E}
2987 e si possono considerare come nomi riservati, per questo abbiamo sempre fatto
2988 riferimento a questi nomi, e lo faremo più avanti quando descriveremo i
2989 possibili errori restituiti dalle funzioni. Il programma di esempio
2990 \cmd{errcode} stampa il codice relativo ad un valore numerico con l'opzione
2993 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
2994 programma, e la gran parte delle funzioni di libreria impostano \var{errno} ad
2995 un valore diverso da zero in caso di errore. Il valore è invece indefinito in
2996 caso di successo, perché anche se una funzione di libreria ha successo,
2997 potrebbe averne chiamate altre al suo interno che potrebbero essere fallite
2998 anche senza compromettere il risultato finale, modificando però \var{errno}.
3000 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
3001 essere il risultato di un errore precedente) e non lo si può usare per
3002 determinare quando o se una chiamata a funzione è fallita. La procedura
3003 corretta da seguire per identificare un errore è sempre quella di controllare
3004 \var{errno} immediatamente dopo aver verificato il fallimento della funzione
3005 attraverso il suo codice di ritorno.
3008 \subsection{Le funzioni \func{strerror} e \func{perror}}
3009 \label{sec:sys_strerror}
3011 Benché gli errori siano identificati univocamente dal valore numerico di
3012 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
3013 riportare in opportuni messaggi le condizioni di errore verificatesi. La
3014 prima funzione che si può usare per ricavare i messaggi di errore è
3015 \funcd{strerror}, il cui prototipo è:
3019 \fdecl{char *strerror(int errnum)}
3020 \fdesc{Restituisce una stringa con un messaggio di errore.}
3023 {La funzione ritorna il puntatore alla stringa con il messaggio di errore,
3024 \var{errno} non viene modificato.}
3027 La funzione ritorna il puntatore alla stringa contenente il messaggio di
3028 errore corrispondente al valore di \param{errnum}, se questo non è un valore
3029 valido verrà comunque restituita una stringa valida contenente un messaggio
3030 che dice che l'errore è sconosciuto nella forma. La versione della \acr{glibc}
3031 non modifica il valore di \var{errno} in caso di errore, ma questo non è detto
3032 valga per altri sistemi in quanto lo standard POSIX.1-2001 permette che ciò
3033 avvenga. Non si faccia affidamento su questa caratteristica se si vogliono
3034 scrivere programmi portabili.
3036 In generale \func{strerror} viene usata passando direttamente \var{errno} come
3037 argomento, ed il valore di quest'ultima non verrà modificato. La funzione
3038 inoltre tiene conto del valore della variabile di ambiente
3039 \envvar{LC\_MESSAGES} per usare le appropriate traduzioni dei messaggi
3040 d'errore nella localizzazione presente.
3042 La funzione \func{strerror} utilizza una stringa statica che non deve essere
3043 modificata dal programma; essa è utilizzabile solo fino ad una chiamata
3044 successiva a \func{strerror} o \func{perror} e nessun'altra funzione di
3045 libreria tocca questa stringa. In ogni caso l'uso di una stringa statica rende
3046 la funzione non rientrante, per cui nel caso si usino i \textit{thread} la
3047 \acr{glibc} fornisce una apposita versione rientrante \funcd{strerror\_r}, il
3052 \fdecl{char * strerror\_r(int errnum, char *buf, size\_t size)}
3053 \fdesc{Restituisce una stringa con un messaggio di errore.}
3056 {La funzione ritorna l'indirizzo del messaggio in caso di successo e
3057 \val{NULL} per un errore, nel qual caso \var{errno} assumerà uno dei valori:
3059 \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
3061 \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
3062 contenere la stringa di errore.
3067 Si tenga presente che questa è la versione prevista normalmente nella
3068 \acr{glibc}, ed effettivamente definita in \headfile{string.h}, ne esiste una
3069 analoga nello standard SUSv3 (riportata anche nella pagina di manuale), che
3070 restituisce \code{int} al posto di \code{char *}, e che tronca la stringa
3071 restituita a \param{size}, a cui si accede definendo le opportune macro (per
3072 le quali si rimanda alla lettura della pagina di manuale).
3074 La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
3075 nel buffer \param{buf} che il singolo \textit{thread} deve allocare
3076 autonomamente per evitare i problemi connessi alla condivisione del buffer
3077 statico. Il messaggio è copiato fino alla dimensione massima del buffer,
3078 specificata dall'argomento \param{size}, che deve comprendere pure il
3079 carattere di terminazione; altrimenti la stringa risulterà troncata.
3081 Una seconda funzione usata per riportare i codici di errore in maniera
3082 automatizzata sullo standard error è \funcd{perror}, il cui prototipo è:
3086 \fdecl{void perror(const char *message)}
3087 \fdesc{Stampa un messaggio di errore personalizzato.}
3090 {La funzione non ritorna nulla e non modifica \var{errno}.}
3094 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
3095 in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
3096 riferiscono all'ultimo errore avvenuto. La stringa specificata con
3097 \param{message} viene stampata prima del messaggio d'errore, consentono una
3098 personalizzazione (ad esempio l'indicazione del contesto in cui si è
3099 verificato), seguita dai due punti e da uno spazio, il messaggio è terminato
3100 con un a capo. Il messaggio può essere riportato anche usando le due
3102 \includecodesnip{listati/errlist.c}
3103 dichiarate in \headfile{errno.h}. La prima contiene i puntatori alle stringhe
3104 di errore indicizzati da \var{errno}; la seconda esprime il valore più alto
3105 per un codice di errore, l'utilizzo di una di queste stringhe è
3106 sostanzialmente equivalente a quello di \func{strerror}.
3108 \begin{figure}[!htbp]
3109 \footnotesize \centering
3110 \begin{minipage}[c]{\codesamplewidth}
3111 \includecodesample{listati/errcode_mess.c}
3114 \caption{Codice per la stampa del messaggio di errore standard.}
3115 \label{fig:sys_err_mess}
3118 In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
3119 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
3120 errore e le costanti usate per identificare i singoli errori. Il sorgente
3121 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
3122 gestione delle opzioni e tutte le definizioni necessarie ad associare il
3123 valore numerico alla costante simbolica. In particolare si è riportata la
3124 sezione che converte la stringa passata come argomento in un intero
3125 (\texttt{\small 1-2}), controllando con i valori di ritorno di \funcm{strtol}
3126 che la conversione sia avvenuta correttamente (\texttt{\small 4-10}), e poi
3127 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
3128 11-14}) o la macro (\texttt{\small 15-17}) associate a quel codice.
3132 \subsection{Alcune estensioni GNU}
3133 \label{sec:sys_err_GNU}
3135 Le precedenti funzioni sono quelle definite ed usate nei vari standard; la
3136 \acr{glibc} ha però introdotto una serie di estensioni ``GNU'' che
3137 forniscono alcune funzionalità aggiuntive per una gestione degli errori
3138 semplificata e più efficiente.
3140 La prima estensione consiste in due variabili, \code{char *
3141 program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
3142 che consentono di ricavare il nome del proprio programma. Queste sono utili
3143 quando si deve aggiungere il nome del programma al messaggio d'errore, cosa
3144 comune quando si ha un programma che non viene lanciato da linea di comando e
3145 salva gli errori in un file di log. La prima contiene il nome usato per
3146 lanciare il programma dalla shell ed in sostanza è equivalente ad
3147 \code{argv[0]}; la seconda mantiene solo il nome del programma eliminando
3148 eventuali directory qualora questo sia stato lanciato con un
3151 Una seconda estensione cerca di risolvere uno dei problemi che si hanno con
3152 l'uso di \func{perror}, dovuto al fatto che non c'è flessibilità su quello che
3153 si può aggiungere al messaggio di errore, che può essere solo una stringa. In
3154 molte occasioni invece serve poter scrivere dei messaggi con maggiori
3155 informazioni. Ad esempio negli standard di programmazione GNU si richiede che
3156 ogni messaggio di errore sia preceduto dal nome del programma, ed in generale
3157 si può voler stampare il contenuto di qualche variabile per facilitare la
3158 comprensione di un eventuale problema. Per questo la \acr{glibc} definisce
3159 la funzione \funcd{error}, il cui prototipo è:
3163 \fdecl{void error(int status, int errnum, const char *format, ...)}
3164 \fdesc{Stampa un messaggio di errore formattato.}
3167 {La funzione non ritorna nulla e non riporta errori.}
3170 La funzione fa parte delle estensioni GNU per la gestione degli errori,
3171 l'argomento \param{format} segue la stessa sintassi di \func{printf} (vedi
3172 sez.~\ref{sec:file_formatted_io}), ed i relativi argomenti devono essere
3173 forniti allo stesso modo, mentre \param{errnum} indica l'errore che si vuole
3174 segnalare (non viene quindi usato il valore corrente di \var{errno}).
3176 La funzione stampa sullo \textit{standard error} il nome del programma, come
3177 indicato dalla variabile globale \var{program\_name}, seguito da due punti ed
3178 uno spazio, poi dalla stringa generata da \param{format} e dagli argomenti
3179 seguenti, seguita da due punti ed uno spazio infine il messaggio di errore
3180 relativo ad \param{errnum}, il tutto è terminato da un a capo.
3182 Il comportamento della funzione può essere ulteriormente controllato se si
3183 definisce una variabile \var{error\_print\_progname} come puntatore ad una
3184 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
3185 il nome del programma.
3187 L'argomento \param{status} può essere usato per terminare direttamente il
3188 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
3189 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
3190 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
3191 un'altra variabile globale, \var{error\_message\_count}, che tiene conto di
3192 quanti errori ci sono stati.
3194 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
3195 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
3196 l'errore è \funcd{error\_at\_line}; il suo prototipo è:
3200 \fdecl{void error\_at\_line(int status, int errnum, const char *fname,
3201 unsigned int lineno, \\
3202 \phantom{void error\_at\_line(}const char *format, ...)}
3203 \fdesc{Stampa un messaggio di errore formattato.}
3206 {La funzione non ritorna nulla e non riporta errori.}
3209 \noindent ed il suo comportamento è identico a quello di \func{error} se non
3210 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
3211 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
3212 stampa del nome del programma. Inoltre essa usa un'altra variabile globale,
3213 \var{error\_one\_per\_line}, che impostata ad un valore diverso da zero fa sì
3214 che errori relativi alla stessa linea non vengano ripetuti.
3217 % LocalWords: filesystem like kernel saved header limits sysconf sez tab float
3218 % LocalWords: FOPEN stdio MB LEN CHAR char UCHAR unsigned SCHAR MIN signed INT
3219 % LocalWords: SHRT short USHRT int UINT LONG long ULONG LLONG ULLONG POSIX ARG
3220 % LocalWords: Stevens exec CHILD STREAM stream TZNAME timezone NGROUPS SSIZE
3221 % LocalWords: ssize LISTIO JOB CONTROL job control IDS VERSION YYYYMML bits bc
3222 % LocalWords: dall'header posix lim nell'header glibc run unistd name errno SC
3223 % LocalWords: NGROUP CLK TCK clock tick process PATH pathname BUF CANON path
3224 % LocalWords: pathconf fpathconf descriptor fd uname sys struct utsname info
3225 % LocalWords: EFAULT fig SOURCE NUL LENGTH DOMAIN NMLN UTSLEN system call proc
3226 % LocalWords: domainname sysctl BSD nlen void oldval size oldlenp newval EPERM
3227 % LocalWords: newlen ENOTDIR EINVAL ENOMEM linux array oldvalue paging stack
3228 % LocalWords: TCP shell Documentation ostype hostname osrelease version mount
3229 % LocalWords: const source filesystemtype mountflags ENODEV ENOTBLK block read
3230 % LocalWords: device EBUSY only EACCES NODEV ENXIO major RTSIG syscall PID
3231 % LocalWords: number EMFILE dummy ENAMETOOLONG ENOENT ELOOP virtual devfs MGC
3232 % LocalWords: magic MSK RDONLY NOSUID suid sgid NOEXEC SYNCHRONOUS REMOUNT MNT
3233 % LocalWords: MANDLOCK mandatory locking WRITE APPEND append IMMUTABLE NOATIME
3234 % LocalWords: access NODIRATIME BIND MOVE umount flags FORCE statfs fstatfs ut
3235 % LocalWords: buf ENOSYS EIO EBADF type fstab mntent home shadow username uid
3236 % LocalWords: passwd PAM Pluggable Authentication Method Service Switch pwd ru
3237 % LocalWords: getpwuid getpwnam NULL buflen result ERANGE getgrnam getgrgid AS
3238 % LocalWords: grp group gid SVID fgetpwent putpwent getpwent setpwent endpwent
3239 % LocalWords: fgetgrent putgrent getgrent setgrent endgrent accounting init HZ
3240 % LocalWords: runlevel Hierarchy logout setutent endutent utmpname utmp paths
3241 % LocalWords: WTMP getutent getutid getutline pututline LVL OLD DEAD EMPTY dev
3242 % LocalWords: line libc XPG utmpx getutxent getutxid getutxline pututxline who
3243 % LocalWords: setutxent endutxent wmtp updwtmp logwtmp wtmp host rusage utime
3244 % LocalWords: minflt majflt nswap fault swap timeval wait getrusage usage SELF
3245 % LocalWords: CHILDREN current limit soft RLIMIT address brk mremap mmap dump
3246 % LocalWords: SIGSEGV SIGXCPU SIGKILL sbrk FSIZE SIGXFSZ EFBIG LOCKS lock dup
3247 % LocalWords: MEMLOCK NOFILE NPROC fork EAGAIN SIGPENDING sigqueue kill RSS tv
3248 % LocalWords: resource getrlimit setrlimit rlimit rlim INFINITY capabilities
3249 % LocalWords: capability CAP Sun Sparc PAGESIZE getpagesize SVr SUSv get IGN
3250 % LocalWords: phys pages avphys NPROCESSORS CONF ONLN getloadavg stdlib double
3251 % LocalWords: loadavg nelem scheduler CONFIG ACCT acct filename EUSER sizeof
3252 % LocalWords: ENFILE EROFS PACCT AcctCtrl cap calendar UTC Jan the Epoch GMT
3253 % LocalWords: Greenwich Mean l'UTC timer CLOCKS SEC cron wall elapsed times tz
3254 % LocalWords: tms cutime cstime waitpid gettimeofday settimeofday timex NetBSD
3255 % LocalWords: timespec adjtime olddelta adjtimex David Mills RFC NTP ntp cmd
3256 % LocalWords: nell'RFC ADJ FREQUENCY frequency MAXERROR maxerror ESTERROR PLL
3257 % LocalWords: esterror TIMECONST constant SINGLESHOT MOD INS insert leap OOP
3258 % LocalWords: second delete progress has occurred BAD broken tm gmtoff asctime
3259 % LocalWords: ctime timep gmtime localtime mktime tzname tzset daylight format
3260 % LocalWords: strftime thread EOF modifiable lvalue app errcode strerror LC at
3261 % LocalWords: perror string errnum MESSAGES error message strtol log jiffy asm
3262 % LocalWords: program invocation argv printf print progname exit count fname
3263 % LocalWords: lineno one standardese Di page Wed Wednesday Apr April PM AM CAD
3264 % LocalWords: CEST utmpxname Solaris updwtmpx reboot RESTART Ctrl OFF SIGINT
3265 % LocalWords: HALT halted sync KEXEC kexec load bootloader POWER Power with nr
3266 % LocalWords: Restarting command arg entry segments segment ARCH CRASH CONTEXT
3267 % LocalWords: PRESERVE PPC IA ARM SH MIPS nvcsw nivcsw inblock oublock maxrss
3268 % LocalWords: context switch slice Resident SIG SIGCHLD cur Gb lease mlock Hz
3269 % LocalWords: memory mlockall MAP LOCKED shmctl MSGQUEUE attr NICE nice MADV
3270 % LocalWords: madvise WILLNEED RTPRIO sched setscheduler setparam scheduling
3271 % LocalWords: RTTIME execve kb prlimit pid new old ESRCH EUSERS refresh high
3272 % LocalWords: resolution HRT jiffies strptime
3274 %%% Local Variables:
3276 %%% TeX-master: "gapil"