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 fornire 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, con risultati spesso tutt'altro che chiari. Daremo
39 comunque una descrizione dei principali metodi previsti dai vari standard per
40 ricavare sia le caratteristiche specifiche del sistema che quelle della
41 gestione dei file, e prenderemo in esame le modalità con cui è possibile
42 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 file di
62 intestazione che contengono le costanti necessarie definite come macro di
63 preprocessore, per la seconda invece sono ovviamente necessarie delle
64 funzioni. La situazione è complicata dal fatto che ci sono molti casi in cui
65 alcuni di questi limiti sono fissi in un'implementazione mentre possono
66 variare in un altra: tutto questo crea una ambiguità che non è sempre
67 possibile risolvere in maniera chiara. In generale quello che succede è che
68 quando i limiti del sistema sono fissi essi vengono definiti come macro di
69 preprocessore nel file \headfile{limits.h}, se invece possono variare, il loro
70 valore sarà ottenibile tramite la funzione \func{sysconf} (che esamineremo a
76 \begin{tabular}[c]{|l|r|l|}
78 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
81 \constd{MB\_LEN\_MAX}& 16 & Massima dimensione di un
83 \constd{CHAR\_BIT} & 8 & Numero di bit di \ctyp{char}.\\
84 \constd{UCHAR\_MAX}& 255 & Massimo di \ctyp{unsigned char}.\\
85 \constd{SCHAR\_MIN}& -128 & Minimo di \ctyp{signed char}.\\
86 \constd{SCHAR\_MAX}& 127 & Massimo di \ctyp{signed char}.\\
87 \constd{CHAR\_MIN} & 0 o -128 & Minimo di \ctyp{char}.\footnotemark\\
88 \constd{CHAR\_MAX} & 127 o 255 & Massimo di \ctyp{char}.\footnotemark\\
89 \constd{SHRT\_MIN} & -32768 & Minimo di \ctyp{short}.\\
90 \constd{SHRT\_MAX} & 32767 & Massimo di \ctyp{short}.\\
91 \constd{USHRT\_MAX}& 65535 & Massimo di \ctyp{unsigned short}.\\
92 \constd{INT\_MAX} & 2147483647 & Minimo di \ctyp{int}.\\
93 \constd{INT\_MIN} &-2147483648 & Minimo di \ctyp{int}.\\
94 \constd{UINT\_MAX} & 4294967295 & Massimo di \ctyp{unsigned int}.\\
95 \constd{LONG\_MAX} & 2147483647 & Massimo di \ctyp{long}.\\
96 \constd{LONG\_MIN} &-2147483648 & Minimo di \ctyp{long}.\\
97 \constd{ULONG\_MAX}& 4294967295 & Massimo di \ctyp{unsigned long}.\\
100 \caption{Costanti definite in \headfile{limits.h} in conformità allo standard
102 \label{tab:sys_ansic_macro}
105 \footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
106 sistema usi caratteri con segno o meno.}
108 \footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
109 a seconda che il sistema usi caratteri con segno o meno.}
111 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
112 saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
113 da \headfile{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si
114 può vedere per la maggior parte questi limiti attengono alle dimensioni dei
115 dati interi, che sono in genere fissati dall'architettura hardware, le
116 analoghe informazioni per i dati in virgola mobile sono definite a parte, ed
117 accessibili includendo \headfiled{float.h}.
122 \begin{tabular}[c]{|l|r|l|}
124 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
127 \constd{LLONG\_MAX} & 9223372036854775807& Massimo di \ctyp{long long}.\\
128 \constd{LLONG\_MIN} &-9223372036854775808& Minimo di \ctyp{long long}.\\
129 \constd{ULLONG\_MAX}&18446744073709551615& Massimo di \ctyp{unsigned long
133 \caption{Macro definite in \headfile{limits.h} in conformità allo standard
135 \label{tab:sys_isoc90_macro}
138 Lo standard prevede anche un'altra costante, \constd{FOPEN\_MAX}, che può non
139 essere fissa e che pertanto non è definita in \headfile{limits.h}, essa deve
140 essere definita in \headfile{stdio.h} ed avere un valore minimo di 8. A questi
141 valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo \ctyp{long
142 long} introdotto con il nuovo standard, i relativi valori sono in
143 tab.~\ref{tab:sys_isoc90_macro}.
145 Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
146 delle caratteristiche del sistema; mancano completamente tutte quelle che
147 dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
148 sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
149 limiti relativi alle caratteristiche dei file che vedremo in
150 sez.~\ref{sec:sys_file_limits}.
155 \begin{tabular}[c]{|l|r|p{9cm}|}
157 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
160 \constd{ARG\_MAX} &131072& Dimensione massima degli argomenti
161 passati ad una funzione della famiglia
163 \constd{CHILD\_MAX} & 999& Numero massimo di processi contemporanei
164 che un utente può eseguire.\\
165 \constd{OPEN\_MAX} & 256& Numero massimo di file che un processo
166 può mantenere aperti in contemporanea.\\
167 \constd{STREAM\_MAX}& 8& Massimo numero di stream aperti per
168 processo in contemporanea.\\
169 \constd{TZNAME\_MAX}& 6& Dimensione massima del nome di una
170 \textit{timezone} (vedi
171 sez.~\ref{sec:sys_time_base})).\\
172 \constd{NGROUPS\_MAX}& 32& Numero di gruppi supplementari per
173 processo (vedi sez.~\ref{sec:proc_access_id}).\\
174 \constd{SSIZE\_MAX}&32767& Valore massimo del tipo \type{ssize\_t}.\\
177 \caption{Costanti per i limiti del sistema.}
178 \label{tab:sys_generic_macro}
181 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
182 meno chiare, tanto che Stevens, in \cite{APUE}, la porta come esempio di
183 ``\textsl{standardese}''. Lo standard prevede che ci siano 13 macro che
184 descrivono le caratteristiche del sistema: 7 per le caratteristiche generiche,
185 riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
186 file, riportate in tab.~\ref{tab:sys_file_macro}.
191 \begin{tabular}[c]{|l|r|p{9cm}|}
193 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
196 \macrod{\_POSIX\_ARG\_MAX} & 4096& Dimensione massima degli argomenti
197 passati ad una funzione della famiglia
199 \macrod{\_POSIX\_CHILD\_MAX} & 6& Numero massimo di processi
200 contemporanei che un utente può
202 \macrod{\_POSIX\_OPEN\_MAX} & 16& Numero massimo di file che un processo
203 può mantenere aperti in
205 \macrod{\_POSIX\_STREAM\_MAX}& 8& Massimo numero di stream aperti per
206 processo in contemporanea.\\
207 \macrod{\_POSIX\_TZNAME\_MAX}& 6& Dimensione massima del nome di una
209 (vedi sez.~\ref{sec:sys_date}). \\
210 \macrod{\_POSIX\_RTSIG\_MAX} & 8& Numero massimo di segnali
211 \textit{real-time} (vedi
212 sez.~\ref{sec:sig_real_time}).\\
213 \macrod{\_POSIX\_NGROUPS\_MAX}& 0& Numero di gruppi supplementari per
215 sez.~\ref{sec:proc_access_id}).\\
216 \macrod{\_POSIX\_SSIZE\_MAX} &32767& Valore massimo del tipo
218 % \macrod{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
219 % \macrod{\_POSIX\_AIO\_MAX} & 1& \\
222 \caption{Macro dei valori minimi di alcune caratteristiche generali del
223 sistema per la conformità allo standard POSIX.1.}
224 \label{tab:sys_posix1_general}
227 Lo standard dice che queste macro devono essere definite in
228 \headfile{limits.h} quando i valori a cui fanno riferimento sono fissi, e
229 altrimenti devono essere lasciate indefinite, ed i loro valori dei limiti
230 devono essere accessibili solo attraverso \func{sysconf}. In realtà queste
231 vengono sempre definite ad un valore generico. Si tenga presente poi che
232 alcuni di questi limiti possono assumere valori molto elevati (come
233 \const{CHILD\_MAX}), e non è pertanto il caso di utilizzarli per allocare
234 staticamente della memoria.
236 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
237 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
238 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
239 implementazione possa dichiararsi conforme allo standard, alcuni dei questi
240 valori sono riportati in tab.~\ref{tab:sys_posix1_general}.
242 In genere questi valori non servono a molto, la loro unica utilità è quella di
243 indicare un limite superiore che assicura la portabilità senza necessità di
244 ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
245 i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
246 valori ottenuti da \func{sysconf}.
251 \begin{tabular}[c]{|l|p{9cm}|}
253 \textbf{Macro}&\textbf{Significato}\\
256 \macrod{\_POSIX\_JOB\_CONTROL}& Il sistema supporta il
257 \textit{job control} (vedi
258 sez.~\ref{sec:sess_job_control}).\\
259 \macrod{\_POSIX\_SAVED\_IDS} & Il sistema supporta gli identificatori del
260 gruppo \textit{saved} (vedi
261 sez.~\ref{sec:proc_access_id})
262 per il controllo di accesso dei processi.\\
263 \macrod{\_POSIX\_VERSION} & Fornisce la versione dello standard POSIX.1
264 supportata nel formato YYYYMML (ad esempio
268 \caption{Alcune macro definite in \headfile{limits.h} in conformità allo
270 \label{tab:sys_posix1_other}
273 Oltre ai precedenti valori e a quelli relativi ai file elencati in
274 tab.~\ref{tab:sys_posix1_file}, che devono essere obbligatoriamente definiti,
275 lo standard POSIX.1 ne prevede molti altri. La lista completa si trova
276 dall'header file \file{bits/posix1\_lim.h}, da non usare mai direttamente (è
277 incluso automaticamente all'interno di \headfile{limits.h}). Di questi vale la
278 pena menzionarne alcune macro di uso comune, riportate in
279 tab.~\ref{tab:sys_posix1_other}, che non indicano un valore specifico, ma
280 denotano la presenza di alcune funzionalità nel sistema, come il supporto del
281 \textit{job control} o degli identificatori del gruppo \textit{saved}.
283 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
284 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
285 alle applicazioni di sistema presenti, come quelli su alcuni parametri delle
286 espressioni regolari o del comando \cmd{bc}, non li tratteremo esplicitamente,
287 se ne trova una menzione completa nell'header file \file{bits/posix2\_lim.h},
288 e alcuni di loro sono descritti nella pagina di manuale di \func{sysconf} e
289 nel manuale della \acr{glibc}.
291 Quando uno dei limiti o delle caratteristiche del sistema può variare, per non
292 dover essere costretti a ricompilare un programma tutte le volte che si
293 cambiano le opzioni con cui è compilato il kernel, o alcuni dei parametri
294 modificabili al momento dell'esecuzione, è necessario ottenerne il valore
295 attraverso la funzione \funcd{sysconf}, cui prototipo è:
299 \fdecl{long sysconf(int name)}
300 \fdesc{Restituisce il valore di un parametro di sistema.}
303 {La funzione ritorna in caso di successo il valore del parametro richiesto, o
304 1 se si tratta di un'opzione disponibile, 0 se l'opzione non è disponibile e
305 $-1$ per un errore, nel qual caso però \var{errno} non viene impostata.}
308 La funzione prende come argomento un intero che specifica quale dei limiti si
309 vuole conoscere. Uno specchietto contenente i principali valori disponibili in
310 Linux è riportato in tab.~\ref{tab:sys_sysconf_par}, l'elenco completo è
311 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
312 relative spiegazioni, si può trovare nel manuale della \acr{glibc}.
317 \begin{tabular}[c]{|l|l|p{8cm}|}
319 \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
322 \texttt{\_SC\_ARG\_MAX} & \const{ARG\_MAX}&
323 La dimensione massima degli argomenti passati
324 ad una funzione della famiglia \func{exec}.\\
325 \texttt{\_SC\_CHILD\_MAX} & \const{CHILD\_MAX}&
326 Il numero massimo di processi contemporanei
327 che un utente può eseguire.\\
328 \texttt{\_SC\_OPEN\_MAX} & \const{OPEN\_MAX}&
329 Il numero massimo di file che un processo può
330 mantenere aperti in contemporanea.\\
331 \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
332 Il massimo numero di stream che un processo
333 può mantenere aperti in contemporanea. Questo
334 limite è previsto anche dallo standard ANSI C,
335 che specifica la macro \const{FOPEN\_MAX}.\\
336 \texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
337 La dimensione massima di un nome di una
338 \texttt{timezone} (vedi
339 sez.~\ref{sec:sys_date}).\\
340 \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
341 Massimo numero di gruppi supplementari che
342 può avere un processo (vedi
343 sez.~\ref{sec:proc_access_id}).\\
344 \texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}&
345 Valore massimo del tipo di dato
347 \texttt{\_SC\_CLK\_TCK} & \const{CLK\_TCK} &
348 Il numero di \textit{clock tick} al secondo,
349 cioè l'unità di misura del
350 \textit{process time} (vedi
351 sez.~\ref{sec:sys_unix_time}).\\
352 \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
353 Indica se è supportato il \textit{job
355 sez.~\ref{sec:sess_job_control}) in stile
357 \texttt{\_SC\_SAVED\_IDS} & \macro{\_POSIX\_SAVED\_IDS}&
358 Indica se il sistema supporta i
359 \textit{saved id} (vedi
360 sez.~\ref{sec:proc_access_id}).\\
361 \texttt{\_SC\_VERSION} & \macro{\_POSIX\_VERSION} &
362 Indica il mese e l'anno di approvazione
363 della revisione dello standard POSIX.1 a cui
364 il sistema fa riferimento, nel formato
365 YYYYMML, la revisione più recente è 199009L,
366 che indica il Settembre 1990.\\
369 \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
370 \label{tab:sys_sysconf_par}
373 In generale ogni limite o caratteristica del sistema per cui è definita una
374 macro, sia da ANSI C e ISO C90 che da POSIX.1 e POSIX.2, può essere ottenuto
375 attraverso una chiamata a \func{sysconf}. Il nome della costante da utilizzare
376 come valore dell'argomento \param{name} si otterrà aggiungendo \code{\_SC\_}
377 ai nomi delle costanti definite dai primi due standard (quelle di
378 tab.~\ref{tab:sys_generic_macro}), o sostituendolo a \code{\_POSIX\_} per le
379 costanti definite dagli altri due standard (quelle di
380 tab.~\ref{tab:sys_posix1_general}).
382 In linea teorica si dovrebbe fare uso di \func{sysconf} solo quando la
383 relativa costante di sistema non è definita, quindi con un codice analogo al
385 \includecodesnip{listati/get_child_max.c}
386 ma in realtà con Linux queste costanti sono comunque definite, indicando però
387 un limite generico che non è detto sia corretto; per questo motivo è sempre
388 meglio usare i valori restituiti da \func{sysconf}.
391 \subsection{Limiti e caratteristiche dei file}
392 \label{sec:sys_file_limits}
394 Come per le caratteristiche generali del sistema anche per i file esistono una
395 serie di limiti (come la lunghezza del nome del file o il numero massimo di
396 link) che dipendono sia dall'implementazione che dal filesystem in uso. Anche
397 in questo caso lo standard prevede alcune macro che ne specificano il valore,
398 riportate in tab.~\ref{tab:sys_file_macro}.
403 \begin{tabular}[c]{|l|r|l|}
405 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
408 \constd{LINK\_MAX} &8 & Numero massimo di link a un file.\\
409 \constd{NAME\_MAX}& 14 & Lunghezza in byte di un nome di file. \\
410 \constd{PATH\_MAX}& 256 & Lunghezza in byte di un \textit{pathname}.\\
411 \constd{PIPE\_BUF}&4096 & Byte scrivibili atomicamente in una \textit{pipe}
412 (vedi sez.~\ref{sec:ipc_pipes}).\\
413 \constd{MAX\_CANON}&255 & Dimensione di una riga di terminale in modo
414 canonico (vedi sez.~\ref{sec:term_io_design}).\\
415 \constd{MAX\_INPUT}&255 & Spazio disponibile nella coda di input
417 sez.~\ref{sec:term_io_design}).\\
420 \caption{Costanti per i limiti sulle caratteristiche dei file.}
421 \label{tab:sys_file_macro}
424 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
425 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
426 conforme deve rispettare. Le relative macro sono riportate in
427 tab.~\ref{tab:sys_posix1_file} e per esse vale lo stesso discorso fatto per le
428 analoghe di tab.~\ref{tab:sys_posix1_general}.
433 \begin{tabular}[c]{|l|r|l|}
435 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
438 \macrod{\_POSIX\_LINK\_MAX} &8 & Numero massimo di link a un file.\\
439 \macrod{\_POSIX\_NAME\_MAX}& 14 & Lunghezza in byte di un nome di file.\\
440 \macrod{\_POSIX\_PATH\_MAX}& 256 & Lunghezza in byte di un
442 \macrod{\_POSIX\_PIPE\_BUF}& 512 & Byte scrivibili atomicamente in una
444 \macrod{\_POSIX\_MAX\_CANON}&255 & Dimensione di una riga di
445 terminale in modo canonico.\\
446 \macrod{\_POSIX\_MAX\_INPUT}&255 & Spazio disponibile nella coda di input
448 % \macrod{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
449 % \macrod{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
450 % \macrod{\_POSIX\_FD\_SETSIZE}& 16 & \\
451 % \macrod{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
454 \caption{Costanti dei valori minimi delle caratteristiche dei file per la
455 conformità allo standard POSIX.1.}
456 \label{tab:sys_posix1_file}
459 Tutti questi limiti sono definiti in \headfile{limits.h}; come nel caso
460 precedente il loro uso è di scarsa utilità in quanto ampiamente superati in
461 tutte le implementazioni moderne. In generale i limiti per i file sono molto
462 più soggetti ad essere variabili rispetto ai limiti generali del sistema; ad
463 esempio parametri come la lunghezza del nome del file o il numero di link
464 possono variare da filesystem a filesystem.
466 Per questo motivo quando si ha a che fare con limiti relativi ai file questi
467 devono essere sempre controllati con la funzione \funcd{pathconf}, il cui
472 \fdecl{long pathconf(char *path, int name)}
473 \fdesc{Restituisce il valore di un parametro dei file.}
476 {La funzione ritorna il valore del parametro richiesto in caso di successo e
477 $-1$ per un errore, nel qual caso \var{errno} viene impostata ad uno degli
478 errori possibili relativi all'accesso a \param{path}.}
481 La funzione richiede che si specifichi il limite che si vuole controllare con
482 l'argomento \param{name}, per il quale si deve usare la relativa costante
483 identificativa, il cui nome si ottiene da quelle descritte in
484 tab.~\ref{tab:sys_file_macro} e tab.~\ref{tab:sys_posix1_file} con la stessa
485 convenzione già vista con \func{sysconf}, ma un questo caso con l'uso del
486 suffisso ``\texttt{\_PC\_}''.
488 In questo caso la funzione richiede anche un secondo argomento \param{path}
489 che specifichi a quale file si fa riferimento, dato che il valore del limite
490 cercato può variare a seconda del filesystem su cui si trova il file. Una
491 seconda versione della funzione, \funcd{fpathconf}, opera su un file
492 descriptor invece che su un \textit{pathname}, il suo prototipo è:
496 \fdecl{long fpathconf(int fd, int name)}
497 \fdesc{Restituisce il valore di un parametro dei file.}
500 {È identica a \func{pathconf} solo che utilizza un file descriptor invece di
501 un \textit{pathname}; pertanto gli errori restituiti in \var{errno} cambiano
504 \noindent ed il suo comportamento è identico a quello di \func{pathconf} a
505 parte quello di richiedere l'indicazione di un file descriptor
506 nell'argomento \param{fd}.
510 \subsection{I parametri del kernel ed il filesystem \texttt{/proc}}
511 \label{sec:sys_sysctl}
513 Tradizionalmente la funzione che permette la lettura ed l'impostazione dei
514 parametri del sistema è \funcm{sysctl}. Si tratta di una funzione derivata da
515 BSD4.4 ed introdotta su Linux a partire dal kernel 1.3.57, ma oggi il suo uso
516 è totalmente deprecato. Una \textit{system call} \funcm{\_sysctl} continua ad
517 esistere, ma non dispone più di una interfaccia nella \acr{glibc} ed il suo
518 utilizzo può essere effettuato solo tramite \func{syscall}, ma di nuovo questo
519 viene sconsigliato in quanto la funzionalità non è più mantenuta e molto
520 probabilmente sarà rimossa nel prossimo futuro.\footnote{a partire dal kernel
521 2.6.34 la funzione viene inserita nella compilazione del kernel previa
522 esplicita richiesta, ed il suo uso produce avvertimenti nei log del kernel.}
523 Per questo motivo eviteremo di trattarne i particolari.
525 Lo scopo di \funcm{sysctl} era quello di fornire ai programmi una modalità per
526 modificare i parametri di sistema. Questi erano organizzati in maniera
527 gerarchica all'interno di un albero e per accedere a ciascuno di essi
528 occorreva specificare un percorso attraverso i vari nodi dell'albero, in
529 maniera analoga a come avviene per la risoluzione di un \textit{pathname}.
531 I parametri accessibili e modificabili attraverso questa funzione sono
532 moltissimi, dipendendo anche dallo stato corrente del kernel, ad esempio dai
533 moduli che sono stati caricati nel sistema. Inoltre non essendo standardizzati
534 i loro nomi possono variare da una versione di kernel all'altra, alcuni esempi
535 di questi parametri sono:
537 \item il nome di dominio,
538 \item i parametri del meccanismo di \textit{paging},
539 \item il filesystem montato come radice,
540 \item la data di compilazione del kernel,
541 \item i parametri dello stack TCP,
542 \item il numero massimo di file aperti,
543 \item il numero massimo di processi,
544 \item i parametri del \textit{SystemV IPC} (vedi sez.~\ref{sec:ipc_sysv}).
546 %\noindent e molti altri che abbiamo già incontrato
548 \index{file!filesystem~\texttt {/proc}!definizione|(}
550 Dato che fin dall'inizio i parametri erano organizzati in una struttura
551 albero, è parso naturale riportare questa organizzazione all'interno del
552 filesystem \file{/proc}. Questo è un filesystem virtuale il cui contenuto è
553 generato direttamente dal kernel, che non fa riferimento a nessun dispositivo
554 fisico, ma presenta in forma di file e directory i dati di alcune delle
555 strutture interne del kernel. Il suo utilizzo principale, come denuncia il
556 nome stesso, è quello di fornire una interfaccia per ottenere i dati relativi
557 ai processi (venne introdotto a questo scopo su BSD), ma nel corso del tempo
558 il suo uso è stato ampliato.
560 All'interno di questo filesystem sono pertanto presenti una serie di file che
561 riflettono il contenuto dei parametri del kernel (molti dei quali accessibili
562 in sola lettura) e in altrettante directory, nominate secondo il relativo
563 \ids{PID}, vengono mantenute le informazioni relative a ciascun processo
564 attivo nel sistema (abbiamo già incontrato questa caratteristica in
565 sez.~\ref{sec:file_openat} per accedere ai filedescriptor del processo
568 In particolare l'albero dei valori dei parametri di sistema impostabili con
569 \func{sysctl} viene presentato in forma di una gerarchia di file e directory a
570 partire dalla directory \file{/proc/sys}, cosicché è possibile accedere al
571 valore di un parametro del kernel tramite il \textit{pathname} ad un file
572 sotto \file{/proc/sys} semplicemente leggendone il contenuto, così come si può
573 modificare un parametro scrivendo sul file ad esso corrispondente.
575 Il kernel si occupa di generare al volo il contenuto ed i nomi dei file
576 corrispondenti ai vari parametri che sono presenti, e questo ha il grande
577 vantaggio di rendere accessibili gli stessi ad un qualunque comando di shell e
578 di permettere la navigazione dell'albero in modo da riconoscere quali
579 parametri sono presenti senza dover cercare un valore all'interno di una
582 Inizialmente l'uso del filesystem \file{/proc} serviva soltanto a replicare
583 l'accesso, con altrettante corrispondenze ai file presenti in
584 \file{/proc/sys}, ai parametri impostabili tradizionalmente con \func{sysctl},
585 ma vista la assoluta naturalità dell'interfaccia, e la sua maggiore
586 efficienza, nelle versioni più recenti del kernel questa è diventata la
587 modalità canonica per modificare i parametri del kernel, evitando di dover
588 ricorrere all'uso di una \textit{system call} specifica, che pur essendo
589 ancora presente prima o poi verrà eliminata.
591 Nonostante la semplificazione nella gestione ottenuta con l'uso di
592 \file{/proc/sys} resta il problema generale di conoscere il significato di
593 ciascuno degli innumerevoli parametri che vi si trovano. Purtroppo la
594 documentazione degli stessi spesso risulta incompleta e non aggiornata, ma
595 buona parte di quelli può importanti sono descritti dalla documentazione
596 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
598 Ma oltre alle informazioni che sostituiscono quelle ottenibili dalla ormai
599 deprecata \func{sysctl} dentro \file{/proc} sono disponibili moltissime altre
600 informazioni, fra cui ad esempio anche quelle fornite dalla funzione di
601 sistema \funcd{uname},\footnote{con Linux ci sono in realtà 3 \textit{system
602 call} diverse per le dimensioni delle stringhe restituite, le prime due
603 usano rispettivamente delle lunghezze di 9 e 65 byte, la terza usa anch'essa
604 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con una
605 lunghezza di 257 byte, la \acr{glibc} provvede a mascherare questi dettagli
606 usando la versione più recente disponibile.} il cui prototipo è:
609 \fhead{sys/utsname.h}
610 \fdecl{int uname(struct utsname *info)}
611 \fdesc{Restituisce informazioni generali sul sistema.}
614 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
615 caso \var{errno} può assumere solo il valore \errval{EFAULT}.}
618 La funzione, che viene usata dal comando \cmd{uname}, restituisce una serie di
619 informazioni relative al sistema nelle stringhe che costituiscono i campi
620 della struttura \struct{utsname} (la cui definizione è riportata in
621 fig.~\ref{fig:sys_utsname}) che viene scritta nel buffer puntato
622 dall'argomento \param{info}.
624 \begin{figure}[!ht!b]
625 \footnotesize \centering
626 \begin{minipage}[c]{0.85\textwidth}
627 \includestruct{listati/ustname.h}
630 \caption{La struttura \structd{utsname}.}
631 \label{fig:sys_utsname}
634 Si noti come in fig.~\ref{fig:sys_utsname} le dimensioni delle stringhe di
635 \struct{utsname} non sono specificate. Il manuale della \acr{glibc} indica
636 due costanti per queste dimensioni, \constd{\_UTSNAME\_LENGTH} per i campi
637 standard e \constd{\_UTSNAME\_DOMAIN\_LENGTH} per quello relativo al nome di
638 dominio, altri sistemi usano nomi diversi come \constd{SYS\_NMLN} o
639 \constd{\_SYS\_NMLN} o \constd{UTSLEN} che possono avere valori diversi. Dato
640 che il buffer per \struct{utsname} deve essere preallocato l'unico modo per
641 farlo in maniera sicura è allora usare come dimensione il valore ottenuto con
642 \code{sizeof(utsname)}.
644 Le informazioni vengono restituite in ciascuno dei singoli campi di
645 \struct{utsname} in forma di stringhe terminate dal carattere NUL. In
646 particolare dette informazioni sono:
648 \item il nome del sistema operativo;
649 \item il nome della macchine (l'\textit{hostname});
650 \item il nome della release del kernel;
651 \item il nome della versione del kernel;
652 \item il tipo di hardware della macchina;
653 \item il nome del domino (il \textit{domainname});
655 ma l'ultima di queste informazioni è stata aggiunta di recente e non è
656 prevista dallo standard POSIX, per questo essa è accessibile, come mostrato in
657 fig.~\ref{fig:sys_utsname}, solo se si è definita la macro
658 \macro{\_GNU\_SOURCE}.
660 Come accennato queste stesse informazioni, anche se a differenza di
661 \func{sysctl} la funzione continua ad essere mantenuta, si possono ottenere
662 direttamente tramite il filesystem \file{/proc}, esse infatti sono mantenute
663 rispettivamente nei file \sysctlrelfiled{kernel}{ostype},
664 \sysctlrelfiled{kernel}{hostname}, \sysctlrelfiled{kernel}{osrelease},
665 \sysctlrelfiled{kernel}{version} e \sysctlrelfiled{kernel}{domainname} che si
666 trovano sotto la directory \file{/proc/sys/kernel/}.
668 \index{file!filesystem~\texttt {/proc}!definizione|)}
670 \section{La gestione del sistema}
671 \label{sec:sys_management}
673 In questa sezione prenderemo in esame le interfacce di programmazione messe a
674 disposizione per affrontare una serie di tematiche attinenti la gestione
675 generale del sistema come quelle relative alla gestione di utenti e gruppi, al
676 trattamento delle informazioni relative ai collegamenti al sistema, alle
677 modalità per effettuare lo spegnimento o il riavvio di una macchina.
680 \subsection{La gestione delle informazioni su utenti e gruppi}
681 \label{sec:sys_user_group}
683 Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
684 (password, corrispondenze fra nomi simbolici e \ids{UID} numerici, home
685 directory, ecc.) venivano registrate all'interno dei due file di testo
686 \conffiled{/etc/passwd} ed \conffiled{/etc/group}, il cui formato è descritto
687 dalle relative pagine del manuale\footnote{nella quinta sezione, quella dei
688 file di configurazione, dato che esistono comandi corrispondenti; per una
689 trattazione sistemistica dell'intero argomento coperto in questa sezione si
690 consulti sez.~4.3 di \cite{AGL}.} e tutte le funzioni che richiedevano
691 l'accesso a queste informazione andavano a leggere direttamente il contenuto
694 In realtà oltre a questi due file da molto tempo gran parte dei sistemi
695 unix-like usano il cosiddetto sistema delle \textit{shadow password} che
696 prevede anche i due file \conffiled{/etc/shadow} e \conffiled{/etc/gshadow}, in
697 cui sono state spostate le informazioni di autenticazione (ed inserite alcune
698 estensioni di gestione avanzata) per toglierle dagli altri file che devono
699 poter essere letti da qualunque processo per poter effettuare l'associazione
700 fra username e \ids{UID}.
702 Col tempo però questa impostazione ha incominciato a mostrare dei limiti. Da
703 una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
704 la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
705 che sta per \textit{Pluggable Authentication Method}) che fornisce una
706 interfaccia comune per i processi di autenticazione, svincolando completamente
707 le singole applicazioni dai dettagli del come questa viene eseguita e di dove
708 vengono mantenuti i dati relativi.
710 Si tratta di un sistema modulare, in cui è possibile utilizzare anche più
711 meccanismi insieme, diventa così possibile avere vari sistemi di
712 riconoscimento (biometria, chiavi hardware, ecc.), diversi formati per le
713 password e diversi supporti per le informazioni. Il tutto avviene in maniera
714 trasparente per le applicazioni purché per ciascun meccanismo si disponga
715 della opportuna libreria che implementa l'interfaccia di PAM.
717 Dall'altra parte, il diffondersi delle reti e la necessità di centralizzare le
718 informazioni degli utenti e dei gruppi per insiemi di macchine e servizi
719 all'interno di una stessa organizzazione, in modo da mantenere coerenti i
720 dati, ha portato anche alla necessità di poter recuperare e memorizzare dette
721 informazioni su supporti diversi dai file citati, introducendo il sistema del
722 \textit{Name Service Switch}, che tratteremo brevemente in
723 sez.~\ref{sec:sock_resolver} dato che la sua applicazione è cruciale nella
724 procedura di risoluzione di nomi di rete.
726 In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
727 per la lettura delle informazioni relative a utenti e gruppi tralasciando
728 completamente quelle relative all'autenticazione.\footnote{la cui
729 programmazione ormai attiene all'uso dell'interfaccia di PAM, che va al di
730 la dello scopo di questo testo.}
731 % Per questo non tratteremo
732 % affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
733 % \textit{Name Service Switch}, un meccanismo messo a disposizione dalla
734 % \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
735 % necessario trovare una corrispondenza fra un nome ed un numero (od altra
736 % informazione) ad esso associato, come appunto, quella fra uno username ed un
737 % \ids{UID} o fra un \ids{GID} ed il nome del gruppo corrispondente.
738 Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
739 queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
740 Service Switch}, per cui sono in grado di ricevere informazioni qualunque
741 sia il supporto su cui esse vengono mantenute. Per leggere le informazioni
742 relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
743 \funcd{getpwnam}, i cui prototipi sono:
748 \fdecl{struct passwd *getpwuid(uid\_t uid)}
749 \fdecl{struct passwd *getpwnam(const char *name)}
750 \fdesc{Restituiscono le informazioni relative all'utente specificato.}
753 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
754 in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
755 utente corrispondente a quanto specificato, nel qual caso \var{errno}
756 assumerà il valore riportato dalle funzioni di sistema sottostanti.}
759 Le due funzioni forniscono le informazioni memorizzate nel registro degli
760 utenti (che nelle versioni più recenti per la parte di credenziali di
761 autenticazione vengono ottenute attraverso PAM) relative all'utente
762 specificato attraverso il suo \ids{UID} o il nome di login. Entrambe le
763 funzioni restituiscono un puntatore ad una struttura di tipo \struct{passwd}
764 la cui definizione (anch'essa eseguita in \headfiled{pwd.h}) è riportata in
765 fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente illustrato il
766 significato dei vari campi.
771 \begin{minipage}[c]{0.8\textwidth}
772 \includestruct{listati/passwd.h}
775 \caption{La struttura \structd{passwd} contenente le informazioni relative
776 ad un utente del sistema.}
777 \label{fig:sys_passwd_struct}
780 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
781 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
782 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
783 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
784 essere rientranti; per questo motivo ne esistono anche due versioni
785 alternative (denotate dalla solita estensione \code{\_r}), i cui prototipi
791 \fdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
793 \phantom{struct passwd *getpwuid\_r(}size\_t buflen, struct passwd **result)}
794 \fdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
795 *password, char *buffer,\\
796 \phantom{struct passwd *getpwnam\_r(}size\_t buflen, struct passwd **result)}
797 \fdesc{Restituiscono le informazioni relative all'utente specificato.}
800 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
801 caso \var{errno} assumerà il valore riportato dalle di sistema funzioni
805 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
806 la memoria necessaria a contenere le informazioni. In particolare i valori
807 della struttura \struct{passwd} saranno restituiti all'indirizzo
808 \param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
809 un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
810 puntate dai campi di \param{password}. Infine all'indirizzo puntato da
811 \param{result} viene restituito il puntatore ai dati ottenuti, cioè
812 \param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti. Qualora i
813 dati non possano essere contenuti nei byte specificati da \param{buflen}, la
814 funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
815 impostato a \val{NULL}).
817 Sia queste versioni rientranti che precedenti gli errori eventualmente
818 riportati in \var{errno} in caso di fallimento dipendono dalla sottostanti
819 funzioni di sistema usate per ricavare le informazioni (si veda quanto
820 illustrato in sez.~\ref{sec:sys_errno}) per cui se lo si vuole utilizzare è
821 opportuno inizializzarlo a zero prima di invocare le funzioni per essere
822 sicuri di non avere un residuo di errore da una chiamata precedente. Il non
823 aver trovato l'utente richiesto infatti può essere dovuto a diversi motivi (a
824 partire dal fatto che non esista) per cui si possono ottenere i codici di
825 errore più vari a seconda dei casi.
827 Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
828 \funcd{getgrgid} che permettono di leggere le informazioni relative ai gruppi,
829 i loro prototipi sono:
834 \fdecl{struct group *getgrgid(gid\_t gid)}
835 \fdecl{struct group *getgrnam(const char *name)}
836 \fdesc{Restituiscono le informazioni relative al gruppo specificato.}
839 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
840 in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
841 utente corrispondente a quanto specificato, nel qual caso \var{errno}
842 assumerà il valore riportato dalle funzioni di sistema sottostanti.}
845 Come per le precedenti per gli utenti esistono anche le analoghe versioni
846 rientranti che di nuovo utilizzano la stessa estensione \code{\_r}; i loro
852 \fdecl{int getgrgid\_r(gid\_t gid, struct group *grp, char *buf,
854 \phantom{int getgrgid\_r(}struct group **result)}
855 \fdecl{int getgrnam\_r(const char *name, struct group *grp, char *buf,
857 \phantom{int getgrnam\_r(}struct group **result)}
858 \fdesc{Restituiscono le informazioni relative al gruppo specificato.}
861 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
862 caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
866 Il comportamento di tutte queste funzioni è assolutamente identico alle
867 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
868 in questo caso le informazioni vengono restituite in una struttura di tipo
869 \struct{group}, la cui definizione è riportata in
870 fig.~\ref{fig:sys_group_struct}.
875 \begin{minipage}[c]{0.8\textwidth}
876 \includestruct{listati/group.h}
879 \caption{La struttura \structd{group} contenente le informazioni relative ad
880 un gruppo del sistema.}
881 \label{fig:sys_group_struct}
884 Le funzioni viste finora sono in grado di leggere le informazioni sia
885 direttamente dal file delle password in \conffile{/etc/passwd} che tramite il
886 sistema del \textit{Name Service Switch} e sono completamente generiche. Si
887 noti però che non c'è una funzione che permetta di impostare direttamente una
888 password.\footnote{in realtà questo può essere fatto ricorrendo alle funzioni
889 della libreria PAM, ma questo non è un argomento che tratteremo qui.} Dato
890 che POSIX non prevede questa possibilità esiste un'altra interfaccia che lo
891 fa, derivata da SVID le cui funzioni sono riportate in
892 tab.~\ref{tab:sys_passwd_func}. Questa interfaccia però funziona soltanto
893 quando le informazioni sono mantenute su un apposito file di \textsl{registro}
894 di utenti e gruppi, con il formato classico di \conffile{/etc/passwd} e
895 \conffile{/etc/group}.
900 \begin{tabular}[c]{|l|p{8cm}|}
902 \textbf{Funzione} & \textbf{Significato}\\
905 \funcm{fgetpwent} & Legge una voce dal file di registro degli utenti
907 \funcm{fgetpwent\_r}& Come la precedente, ma rientrante.\\
908 \funcm{putpwent} & Immette una voce in un file di registro degli
910 \funcm{getpwent} & Legge una voce da \conffile{/etc/passwd}.\\
911 \funcm{getpwent\_r} & Come la precedente, ma rientrante.\\
912 \funcm{setpwent} & Ritorna all'inizio di \conffile{/etc/passwd}.\\
913 \funcm{endpwent} & Chiude \conffile{/etc/passwd}.\\
914 \funcm{fgetgrent} & Legge una voce dal file di registro dei gruppi
916 \funcm{fgetgrent\_r}& Come la precedente, ma rientrante.\\
917 \funcm{putgrent} & Immette una voce in un file di registro dei gruppi.\\
918 \funcm{getgrent} & Legge una voce da \conffile{/etc/group}.\\
919 \funcm{getgrent\_r} & Come la precedente, ma rientrante.\\
920 \funcm{setgrent} & Ritorna all'inizio di \conffile{/etc/group}.\\
921 \funcm{endgrent} & Chiude \conffile{/etc/group}.\\
924 \caption{Funzioni per la manipolazione dei campi di un file usato come
925 registro per utenti o gruppi nel formato di \conffile{/etc/passwd} e
926 \conffile{/etc/group}.}
927 \label{tab:sys_passwd_func}
930 % TODO mancano i prototipi di alcune delle funzioni
932 Dato che oramai tutte le distribuzioni di GNU/Linux utilizzano le
933 \textit{shadow password} (quindi con delle modifiche rispetto al formato
934 classico del file \conffile{/etc/passwd}), si tenga presente che le funzioni
935 di questa interfaccia che permettono di scrivere delle voci in un
936 \textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
937 hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
940 Per questo motivo l'uso di queste funzioni è deprecato, in quanto comunque non
941 funzionale rispetto ad un sistema attuale, pertanto ci limiteremo a fornire
942 soltanto l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
943 ulteriore. Chi volesse insistere ad usare questa interfaccia può fare
944 riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
945 della \acr{glibc} per i dettagli del funzionamento.
949 \subsection{Il registro della \textsl{contabilità} degli utenti}
950 \label{sec:sys_accounting}
952 Un altro insieme di funzioni relative alla gestione del sistema che
953 esamineremo è quello che permette di accedere ai dati del registro della
954 cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti. In esso
955 vengono mantenute una serie di informazioni storiche relative sia agli utenti
956 che si sono collegati al sistema, tanto per quelli correntemente collegati,
957 che per la registrazione degli accessi precedenti, sia relative all'intero
958 sistema, come il momento di lancio di processi da parte di \cmd{init}, il
959 cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
962 I dati vengono usualmente memorizzati nei due file \file{/var/run/utmp} e
963 \file{/var/log/wtmp}. che sono quelli previsti dal \textit{Linux Filesystem
964 Hierarchy Standard}, adottato dalla gran parte delle distribuzioni. Quando
965 un utente si collega viene aggiunta una voce a \file{/var/run/utmp} in cui
966 viene memorizzato il nome di login, il terminale da cui ci si collega,
967 l'\ids{UID} della shell di login, l'orario della connessione ed altre
968 informazioni. La voce resta nel file fino al logout, quando viene cancellata
969 e spostata in \file{/var/log/wtmp}.
971 In questo modo il primo file viene utilizzato per registrare chi sta
972 utilizzando il sistema al momento corrente, mentre il secondo mantiene la
973 registrazione delle attività degli utenti. A quest'ultimo vengono anche
974 aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
975 come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
976 informazioni sono descritte in dettaglio nel manuale della \acr{glibc}.
978 Questi file non devono mai essere letti direttamente, ma le informazioni che
979 contengono possono essere ricavate attraverso le opportune funzioni di
980 libreria. Queste sono analoghe alle precedenti funzioni usate per accedere al
981 registro degli utenti (vedi tab.~\ref{tab:sys_passwd_func}), solo che in
982 questo caso la struttura del registro della \textsl{contabilità} è molto più
983 complessa, dato che contiene diversi tipi di informazione.
985 Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
986 servono rispettivamente a aprire e a chiudere il file che contiene il registro
987 della \textsl{contabilità} degli, e a specificare su quale file esso viene
988 mantenuto; i loro prototipi sono:
992 \fdecl{void utmpname(const char *file)}
993 \fdesc{Specifica il file da usare come registro.}
994 \fdecl{void setutent(void)}
995 \fdesc{Apre il file del registro.}
996 \fdecl{void endutent(void)}
997 \fdesc{Chiude il file del registro.}
1000 {Le funzioni non ritornano nulla.}
1003 Si tenga presente che le funzioni non restituiscono nessun valore, pertanto
1004 non è possibile accorgersi di eventuali errori, ad esempio se si è impostato
1005 un nome di file sbagliato con \func{utmpname}.
1007 Nel caso non si sia utilizzata \func{utmpname} per specificare un file di
1008 registro alternativo, sia \func{setutent} che \func{endutent} operano usando
1009 il default che è \sysfile{/var/run/utmp} il cui nome, così come una serie di
1010 altri valori di default per i \textit{pathname} di uso più comune, viene
1011 mantenuto nei valori di una serie di costanti definite includendo
1012 \headfiled{paths.h}, in particolare quelle che ci interessano sono:
1013 \begin{basedescript}{\desclabelwidth{2.0cm}}
1014 \item[\constd{\_PATH\_UTMP}] specifica il file che contiene il registro per
1015 gli utenti correntemente collegati, questo è il valore che viene usato se
1016 non si è utilizzato \func{utmpname} per modificarlo;
1017 \item[\constd{\_PATH\_WTMP}] specifica il file che contiene il registro per
1018 l'archivio storico degli utenti collegati;
1020 che nel caso di Linux hanno un valore corrispondente ai file
1021 \sysfile{/var/run/utmp} e \sysfile{/var/log/wtmp} citati in precedenza.
1023 Una volta aperto il file del registro degli utenti si può eseguire una
1024 scansione leggendo o scrivendo una voce con le funzioni \funcd{getutent},
1025 \funcd{getutid}, \funcd{getutline} e \funcd{pututline}, i cui prototipi sono:
1030 \fdecl{struct utmp *getutent(void)}
1031 \fdesc{Legge una voce dalla posizione corrente nel registro.}
1032 \fdecl{struct utmp *getutid(struct utmp *ut)}
1033 \fdesc{Ricerca una voce sul registro.}
1034 \fdecl{struct utmp *getutline(struct utmp *ut)}
1035 \fdesc{Ricerca una voce sul registro attinente a un terminale.}
1036 \fdecl{struct utmp *pututline(struct utmp *ut)}
1037 \fdesc{Scrive una voce nel registro.}
1040 {Le funzioni ritornano il puntatore ad una struttura \struct{utmp} in caso di
1041 successo e \val{NULL} in caso di errore, nel qual caso \var{errno} assumerà
1042 il valore riportato dalle funzioni di sistema sottostanti.}
1045 Tutte queste funzioni fanno riferimento ad una struttura di tipo
1046 \struct{utmp}, la cui definizione in Linux è riportata in
1047 fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
1048 voce dal registro: \func{getutent} legge semplicemente la prima voce
1049 disponibile, le altre due permettono di eseguire una ricerca. Aprendo il
1050 registro con \func{setutent} ci si posiziona al suo inizio, ogni chiamata di
1051 queste funzioni eseguirà la lettura sulle voci seguenti, pertanto la posizione
1052 sulla voce appena letta, in modo da consentire una scansione del file. Questo
1053 vale anche per \func{getutid} e \func{getutline}, il che comporta che queste
1054 funzioni effettuano comunque una ricerca ``\textsl{in avanti}''.
1056 \begin{figure}[!htb]
1059 \begin{minipage}[c]{0.9\textwidth}
1060 \includestruct{listati/utmp.h}
1063 \caption{La struttura \structd{utmp} contenente le informazioni di una voce
1064 del registro di \textsl{contabilità}.}
1065 \label{fig:sys_utmp_struct}
1068 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
1069 campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
1070 riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
1071 \const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
1072 verrà restituito la prima voce che corrisponde al tipo determinato; quando
1073 invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
1074 \const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
1075 corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
1080 \begin{tabular}[c]{|l|p{8cm}|}
1082 \textbf{Valore} & \textbf{Significato}\\
1085 \constd{EMPTY} & Non contiene informazioni valide.\\
1086 \constd{RUN\_LVL} & Identica il runlevel del sistema.\\
1087 \constd{BOOT\_TIME} & Identifica il tempo di avvio del sistema.\\
1088 \constd{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
1090 \constd{NEW\_TIME} & Identifica da quanto è stato modificato il
1092 \constd{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
1093 \constd{LOGIN\_PROCESS}& Identifica un processo di login.\\
1094 \constd{USER\_PROCESS} & Identifica un processo utente.\\
1095 \constd{DEAD\_PROCESS} & Identifica un processo terminato.\\
1096 % \constd{ACCOUNTING} & ??? \\
1099 \caption{Classificazione delle voci del registro a seconda dei
1100 possibili valori del campo \var{ut\_type}.}
1101 \label{tab:sys_ut_type}
1104 La funzione \func{getutline} esegue la ricerca sulle voci che hanno un
1105 \var{ut\_type} con valore uguale a \const{LOGIN\_PROCESS} o
1106 \const{USER\_PROCESS}, restituendo la prima che corrisponde al valore di
1107 \var{ut\_line}, che specifica il dispositivo di terminale che interessa, da
1108 indicare senza il \file{/dev/} iniziale. Lo stesso criterio di ricerca è usato
1109 da \func{pututline} per trovare uno spazio dove inserire la voce specificata;
1110 qualora questo spazio non venga trovato la voce viene aggiunta in coda al
1113 In generale occorre però tenere conto che queste funzioni non sono
1114 completamente standardizzate, e che in sistemi diversi possono esserci
1115 differenze; ad esempio \func{pututline} restituisce \code{void} in vari
1116 sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
1117 fornita dalla \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
1118 introdotto delle nuove strutture (e relativi file) di tipo \struct{utmpx}, che
1119 sono un sovrainsieme della \struct{utmp} usata tradizionalmente ed altrettante
1120 funzioni che le usano al posto di quelle citate.
1122 La \acr{glibc} utilizzava già una versione estesa di \struct{utmp}, che
1123 rende inutili queste nuove strutture, per questo su Linux \struct{utmpx} viene
1124 definita esattamente come \struct{utmp}, con gli stessi campi di
1125 fig.~\ref{fig:sys_utmp_struct}. Altrettanto dicasi per le nuove funzioni di
1126 gestione previste dallo standard: \funcm{getutxent}, \funcm{getutxid},
1127 \funcm{getutxline}, \funcm{pututxline}, \funcm{setutxent} e \funcm{endutxent}.
1129 Tutte queste funzioni, definite con \struct{utmpx} dal file di dichiarazione
1130 \headfile{utmpx.h}, su Linux sono ridefinite come sinonimi delle funzioni
1131 appena viste, con argomento di tipo \struct{utmpx} anziché \struct{utmp} ed
1132 hanno lo stesso identico comportamento. Per completezza viene definita anche
1133 \funcm{utmpxname} che non è prevista da POSIX.1-2001.
1135 Come già visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
1136 staticamente rende le funzioni di lettura dei dati appena illustrate non
1137 rientranti. Per questo motivo la \acr{glibc} fornisce anche delle versioni
1138 rientranti: \func{getutent\_r}, \func{getutid\_r}, \func{getutline\_r}, che
1139 invece di restituire un puntatore restituiscono un intero e prendono due
1140 argomenti aggiuntivi, i rispettivi prototipi sono:
1144 \fdecl{int *getutent\_r(struct utmp *buffer, struct utmp **result)}
1145 \fdesc{Legge una voce dalla posizione corrente nel registro.}
1146 \fdecl{int *getutid\_r(struct utmp *buffer, struct utmp **result, struct utmp
1148 \fdesc{Ricerca una voce sul registro.}
1149 \fdecl{int *getutline\_r(struct utmp *buffer, struct utmp **result, struct utmp
1151 \fdesc{Ricerca una voce sul registro attinente a un terminale.}
1154 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
1155 caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
1159 Le funzioni si comportano esattamente come le precedenti analoghe non
1160 rientranti, solo che restituiscono il risultato all'indirizzo specificato dal
1161 primo argomento aggiuntivo \param{buffer} mentre il secondo, \param{result},
1162 viene usato per restituire il puntatore al buffer stesso.
1164 Infine la \acr{glibc} fornisce altre due funzioni, \funcd{updwtmp} e
1165 \funcd{logwtmp}, come estensione per scrivere direttamente delle voci nel file
1166 sul registro storico \sysfile{/var/log/wtmp}; i rispettivi prototipi sono:
1170 \fdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1171 \fdesc{Aggiunge una voce in coda al registro.}
1172 \fdecl{void logwtmp(const char *line, const char *name, const char *host)}
1173 \fdesc{Aggiunge nel registro una voce con i valori specificati.}
1176 {Le funzioni non restituiscono nulla.}
1179 La prima funzione permette l'aggiunta di una voce in coda al file del registro
1180 storico, indicato dal primo argomento, specificando direttamente una struttura
1181 \struct{utmp}. La seconda invece utilizza gli argomenti \param{line},
1182 \param{name} e \param{host} per costruire la voce che poi aggiunge chiamando
1185 Queste funzioni non sono previste da POSIX.1-2001, anche se sono presenti in
1186 altri sistemi (ad esempio Solaris e NetBSD), per mantenere una coerenza con le
1187 altre funzioni definite nello standard che usano la struttura \struct{utmpx}
1188 la \acr{glibc} definisce anche una funzione \funcm{updwtmpx}, che come in
1189 precedenza è identica a \func{updwtmp} con la sola differenza di richiedere
1190 l'uso di \headfiled{utmpx.h} e di una struttura \struct{utmpx} come secondo
1194 \subsection{La gestione dello spegnimento e del riavvio}
1195 \label{sec:sys_reboot}
1197 Una delle operazioni di gestione generale del sistema è quella che attiene
1198 alle modalità con cui se ne può gestire lo spegnimento ed il riavvio. Perché
1199 questo avvenga in maniera corretta, in particolare per le parti che comportano
1200 lo spegnimento effettivo della macchina, occorre che il kernel effettui le
1201 opportune operazioni interagendo con il BIOS ed i dispositivi che controllano
1202 l'erogazione della potenza.
1204 La funzione di sistema che controlla lo spegnimento ed il riavvio (ed altri
1205 aspetti della relativa procedura) è \funcd{reboot},\footnote{la funzione
1206 illustrata è quella fornita dalla \acr{glibc} che maschera i dettagli di
1207 basso livello della \textit{system call} la quale richiede attualmente tre
1208 argomenti; fino al kernel 2.1.30 la \textit{system call} richiedeva un
1209 ulteriore quarto argomento, i primi due indicano dei \textit{magic number}
1210 interi che possono assumere solo alcuni valori predefiniti, il terzo un
1211 comando, corrispondente all'unico argomento della funzione della \acr{glibc}
1212 ed il quarto argomento aggiuntivo, ora ignorato, un puntatore generico ad
1213 ulteriori dati.} il cui prototipo è:
1217 \fhead{sys/reboot.h}
1218 \fdecl{int reboot(int cmd)}
1219 \fdesc{Controlla il riavvio o l'arresto della macchina.}
1222 {La funzione non ritorna o ritorna $0$ in caso di successo e $-1$ per un
1223 errore, nel qual caso \var{errno} assumerà uno dei valori:
1225 \item[\errcode{EFAULT}] c'è un indirizzo non valido nel passaggio degli
1226 argomenti con il comando \const{LINUX\_REBOOT\_CMD\_RESTART2} (obsoleto).
1227 \item[\errcode{EINVAL}] si sono specificati valori non validi per gli
1229 \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
1230 \textit{capability} \const{CAP\_SYS\_BOOT}).
1235 La funzione, oltre al riavvio ed allo spegnimento, consente anche di
1236 controllare l'uso della combinazione di tasti tradizionalmente usata come
1237 scorciatoia da tastiera per richiedere il riavvio (\texttt{Ctrl-Alt-Del},
1238 denominata in breve nella documentazione CAD) ed i suoi effetti specifici
1239 dipendono dalla architettura hardware. Se si è richiesto un riavvio o uno
1240 spegnimento in caso di successo la funzione, non esistendo più il programma,
1241 ovviamente non ritorna, pertanto bisogna avere cura di aver effettuato tutte
1242 le operazioni preliminari allo spegnimento prima di eseguirla.
1244 Il comportamento della funzione viene controllato dall'argomento \param{cmd}
1245 e deve assumere indicato con una delle costanti seguente elenco, che
1246 illustra i comandi attualmente disponibili:
1248 \begin{basedescript}{\desclabelwidth{2.cm}\desclabelstyle{\nextlinelabel}}
1249 \item[\constd{LINUX\_REBOOT\_CMD\_CAD\_OFF}] Disabilita l'uso diretto della
1250 combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce nell'invio
1251 del segnale \signal{SIGINT} a \texttt{init} (o più in generale al processo
1252 con \ids{PID} 1) il cui effetto dipende dalla configurazione di
1254 \item[\constd{LINUX\_REBOOT\_CMD\_CAD\_ON}] Attiva l'uso diretto della
1255 combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce
1256 nell'esecuzione dell'azione che si avrebbe avuto chiamando \func{reboot} con
1257 il comando \const{LINUX\_REBOOT\_CMD\_RESTART}.
1258 \item[\constd{LINUX\_REBOOT\_CMD\_HALT}] Viene inviato sulla console il
1259 messaggio ``\textit{System halted.}'' l'esecuzione viene bloccata
1260 immediatamente ed il controllo passato al monitor nella ROM (se esiste e
1261 l'architettura lo consente). Se non si è eseguita una sincronizzazione dei
1262 dati su disco con \func{sync} questi saranno perduti.
1263 \item[\constd{LINUX\_REBOOT\_CMD\_KEXEC}] viene eseguito direttamente il nuovo
1264 kernel che è stato opportunamente caricato in memoria da una
1265 \func{kexec\_load} (che tratteremo a breve) eseguita in precedenza. La
1266 funzionalità è disponibile solo a partire dal kernel 2.6.13 e se il kernel
1267 corrente è stato compilato includendo il relativo supporto.\footnote{deve
1268 essere stata abilitata l'opzione di compilazione \texttt{CONFIG\_KEXEC}.}
1269 Questo meccanismo consente di eseguire una sorta di riavvio rapido che evita
1270 di dover ripassare dalla inizializzazione da parte del BIOS ed il lancio del
1271 kernel attraverso un bootloader. Se non si è eseguita una sincronizzazione
1272 dei dati su disco con \func{sync} questi saranno perduti.
1273 \item[\constd{LINUX\_REBOOT\_CMD\_POWER\_OFF}] Viene inviato sulla console il
1274 messaggio ``\textit{Power down.}'' l'esecuzione viene bloccata
1275 immediatamente e la macchina, se possibile, viene spenta. Se non si è
1276 eseguita una sincronizzazione dei dati su disco con \func{sync} questi
1278 \item[\constd{LINUX\_REBOOT\_CMD\_RESTART}] Viene inviato sulla console il
1279 messaggio ``\textit{Restarting system.}'' ed avviata immediatamente la
1280 procedura di riavvio ordinaria. Se non si è eseguita una sincronizzazione
1281 dei dati su disco con \func{sync} questi saranno perduti.
1282 \item[\constd{LINUX\_REBOOT\_CMD\_RESTART2}] Viene inviato sulla console il
1283 messaggio ``\textit{Restarting system with command '\%s'.}'' ed avviata
1284 immediatamente la procedura di riavvio usando il comando fornito
1285 nell'argomento \param{arg} che viene stampato al posto di \texttt{'\%s'}
1286 (veniva usato per lanciare un altro programma al posto di \cmd{init}). Nelle
1287 versioni recenti questo argomento viene ignorato ed il riavvio può essere
1288 controllato dall'argomento di avvio del kernel \texttt{reboot=...} Se non
1289 si è eseguita una sincronizzazione dei dati su disco con \func{sync} questi
1291 % TODO: trattare LINUX_REBOOT_CMD_SW_SUSPEND
1292 % TODO: rimandare agli effetti di reboot sui namespace
1295 Come appena illustrato usando il comando \const{LINUX\_REBOOT\_CMD\_KEXEC} si
1296 può eseguire un riavvio immediato pre-caricando una immagine del kernel, che
1297 verrà eseguita direttamente. Questo meccanismo consente di evitare la
1298 reinizializzazione della macchina da parte del BIOS, ed oltre a velocizzare un
1299 eventuale riavvio, ha il vantaggio poter accedere allo stato corrente della
1300 macchina e della memoria, per cui viene usato spesso per installare un kernel
1301 di emergenza da eseguire in caso di crollo del sistema per recuperare il
1302 maggior numero di informazioni possibili.
1304 La funzione di sistema che consente di caricare questa immagine del kernel è
1305 \funcd{kexec\_load}, la funzione non viene definita nella \acr{glibc} e deve
1306 pertanto essere invocata con \func{syscall}, il suo prototipo è:
1309 \fhead{linux/kexec.h}
1310 \fdecl{long kexec\_load(unsigned long entry, unsigned long nr\_segments,
1311 struct kexec\_segment\\
1312 \phantom{long kexec\_load(}*segments, unsigned long flags)}
1314 \fdesc{Carica un kernel per un riavvio immediato.}
1317 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1318 caso \var{errno} assumerà uno dei valori:
1320 \item[\errcode{EBUSY}] c'è già un caricamento in corso, o un altro kernel è
1322 \item[\errcode{EINVAL}] il valore di \param{flags} non è valido o si è
1323 indicato un valore eccessivo per \param{nr\_segments}.
1324 \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
1325 \textit{capability} \const{CAP\_SYS\_BOOT}).
1330 Il primo argomento indica l'indirizzo fisico di esecuzione del nuovo kernel
1331 questo viene caricato usando un vettore di strutture \struct{kexec\_segment}
1332 (la cui definizione è riportata in fig.~\ref{fig:kexec_segment}) che
1333 contengono i singoli segmenti dell'immagine. I primi due campi indicano
1334 indirizzo e dimensione del segmento di memoria in \textit{user space}, i
1335 secondi indirizzo e dimensione in \textit{kernel space}.
1338 \begin{figure}[!htb]
1341 \begin{minipage}[c]{0.8\textwidth}
1342 \includestruct{listati/kexec_segment.h}
1345 \caption{La struttura \structd{kexec\_segment} per il caricamento di un
1346 segmento di immagine del kernel.}
1347 \label{fig:kexec_segment}
1350 L'argomento \param{flags} è una maschera binaria contenente i flag che
1351 consentono di indicare le modalità con cui dovrà essere eseguito il nuovo
1352 kernel. La parte meno significativa viene usata per impostare l'architettura
1353 di esecuzione. Il valore \const{KEXEC\_ARCH\_DEFAULT} indica l'architettura
1354 corrente, ma se ne può specificare anche una diversa, con i valori della
1355 seconda parte di tab.~\ref{tab:kexec_load_flags}, e questa verrà usato posto
1356 che sia effettivamente eseguibile sul proprio processore.
1361 \begin{tabular}[c]{|l|p{8cm}|}
1363 \textbf{Valore} & \textbf{Significato}\\
1366 \constd{KEXEC\_ON\_CRASH} & Il kernel caricato sarà eseguito
1367 automaticamente in caso di crollo del
1368 sistema (dal kernel 2.6.13).\\
1369 \constd{KEXEC\_PRESERVE\_CONTEXT}& Viene preservato lo stato dei programmi
1370 e dei dispositivi prima dell'esecuzione
1371 del nuovo kernel. Viene usato
1372 principalmente per l'ibernazione del
1373 sistema ed ha senso solo se si è
1374 indicato un numero di segmento maggiore
1375 di zero (dal kernel 2.6.27).\\
1377 \constd{KEXEC\_ARCH\_DEFAULT} & Il kernel caricato verrà eseguito nella
1378 architettura corrente. \\
1379 \texttt{KEXEC\_ARCH\_XXX} & Il kernel caricato verrà eseguito nella
1380 architettura indicata (con \texttt{XXX}
1381 che può essere: \texttt{386},
1382 \texttt{X86\_64}, \texttt{PPC},
1383 \texttt{PPC64}, \texttt{IA\_64},
1384 \texttt{ARM}, \texttt{S390},
1385 \texttt{SH}\texttt{MIPS}
1386 e \texttt{MIPS\_LE}).\\
1390 \caption{Valori per l'argomento \param{flags} di \func{kexec\_load}.}
1391 \label{tab:kexec_load_flags}
1394 I due valori più importanti sono però quelli della parte più significativa
1395 (riportati nella prima sezione di tab.~\ref{tab:kexec_load_flags}). Il primo,
1396 \const{KEXEC\_ON\_CRASH}, consente di impostare l'esecuzione automatica del
1397 nuovo kernel caricato in caso di crollo del sistema, e viene usato quando si
1398 carica un kernel di emergenza da utilizzare per poter raccogliere informazioni
1399 diagnostiche che altrimenti verrebbero perdute non essendo il kernel ordinario
1400 più in grado di essere eseguito in maniera coerente. Il secondo valore,
1401 \const{KEXEC\_PRESERVE\_CONTEXT}, indica invece di preservare lo stato dei
1402 programmi e dei dispositivi, e viene in genere usato per realizzare la
1403 cosiddetta ibernazione in RAM.
1405 % TODO: con il kernel 3.17 è stata introdotta kexec_file_load, per caricare
1406 % immagine firmate per il secure boot, vedi anche
1407 % http://lwn.net/Articles/603116/
1410 \section{Il controllo dell'uso delle risorse}
1411 \label{sec:sys_res_limits}
1413 Dopo aver esaminato in sez.~\ref{sec:sys_management} le funzioni che
1414 permettono di controllare le varie caratteristiche, capacità e limiti del
1415 sistema a livello globale, in questa sezione tratteremo le varie funzioni che
1416 vengono usate per quantificare le risorse (CPU, memoria, ecc.) utilizzate da
1417 ogni singolo processo e quelle che permettono di imporre a ciascuno di essi
1418 vincoli e limiti di utilizzo.
1421 \subsection{L'uso delle risorse}
1422 \label{sec:sys_resource_use}
1424 Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
1425 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1426 di tipo \struct{rusage}, la cui definizione (che si trova in
1427 \headfiled{sys/resource.h}) è riportata in
1428 fig.~\ref{fig:sys_rusage_struct}. Si ricordi che questa è una delle
1429 informazioni preservate attraverso una \func{exec}.
1431 \begin{figure}[!htb]
1434 \begin{minipage}[c]{0.8\textwidth}
1435 \includestruct{listati/rusage.h}
1438 \caption{La struttura \structd{rusage} per la lettura delle informazioni dei
1439 delle risorse usate da un processo.}
1440 \label{fig:sys_rusage_struct}
1443 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
1444 da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
1445 \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si
1446 trova nelle opzioni di compilazione del kernel (e di norma è disabilitato)
1447 che serve per mantenere una contabilità delle risorse usate da ciascun
1448 processo in maniera molto più dettagliata.} ma attualmente solo alcuni dei
1449 campi definiti sono effettivamente mantenuti. Con i kernel della serie 2.4 i
1450 soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
1451 \var{ru\_minflt} e \var{ru\_majflt}. Con i kernel della serie 2.6 si
1452 aggiungono anche \var{ru\_nvcsw} e \var{ru\_nivcsw}, a partire dal 2.6.22
1453 anche \var{ru\_inblock} e \var{ru\_oublock} e dal 2.6.32 anche
1456 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
1457 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
1458 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
1459 ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
1460 \struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
1462 La struttura \struct{rusage} è la struttura utilizzata da \func{wait4} (si
1463 ricordi quando visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di
1464 risorse impiegate dal processo di cui si è letto lo stato di terminazione, ma
1465 essa può anche essere letta direttamente utilizzando la funzione di sistema
1466 \funcd{getrusage}, il cui prototipo è:
1470 \fhead{sys/resource.h}
1472 \fdecl{int getrusage(int who, struct rusage *usage)}
1474 \fdesc{Legge la quantità di risorse usate da un processo.}
1477 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1478 caso \var{errno} assumerà uno dei valori:
1480 \item[\errcode{EINVAL}] l'argomento \param{who} non è valido
1482 ed inoltre \errval{EFAULT} nel suo significato generico.
1486 La funzione ritorna i valori per l'uso delle risorse nella struttura
1487 \struct{rusage} puntata dall'argomento \param{usage}. L'argomento \param{who}
1488 permette di specificare il soggetto di cui si vuole leggere l'uso delle
1489 risorse; esso può assumere solo i valori illustrati in
1490 tab.~\ref{tab:getrusage_who}, di questi \const{RUSAGE\_THREAD} è specifico di
1491 Linux ed è disponibile solo a partire dal kernel 2.6.26. La funzione è stata
1492 recepita nello standard POSIX.1-2001, che però indica come campi di
1493 \struct{rusage} soltanto \var{ru\_utime} e \var{ru\_stime}.
1498 \begin{tabular}[c]{|l|p{8cm}|}
1500 \textbf{Valore} & \textbf{Significato}\\
1503 \constd{RUSAGE\_SELF} & Ritorna l'uso delle risorse del processo
1504 corrente, che in caso di uso dei
1505 \textit{thread} ammonta alla somma delle
1506 risorse utilizzate da tutti i \textit{thread}
1508 \constd{RUSAGE\_CHILDREN} & Ritorna l'uso delle risorse dell'insieme dei
1509 processi figli di cui è ricevuto lo stato di
1510 terminazione, che a loro volta comprendono
1511 quelle dei loro figli e così via.\\
1512 \constd{RUSAGE\_THREAD} & Ritorna l'uso delle risorse del \textit{thread}
1516 \caption{Valori per l'argomento \param{who} di \func{getrusage}.}
1517 \label{tab:getrusage_who}
1520 I campi più utilizzati sono comunque \var{ru\_utime} e \var{ru\_stime} che
1521 indicano rispettivamente il tempo impiegato dal processo nell'eseguire le
1522 istruzioni in \textit{user space}, e quello impiegato dal kernel nelle
1523 \textit{system call} eseguite per conto del processo (vedi
1524 sez.~\ref{sec:sys_unix_time}). I campi \var{ru\_minflt} e \var{ru\_majflt}
1525 servono a quantificare l'uso della memoria virtuale e corrispondono
1526 rispettivamente al numero di \textit{page fault} (vedi
1527 sez.~\ref{sec:proc_mem_gen}) avvenuti senza richiedere I/O su disco (i
1528 cosiddetti \textit{minor page fault}), e a quelli che invece han richiesto I/O
1529 su disco (detti invece \textit{major page
1530 fault}).% mentre \var{ru\_nswap} ed al numero di volte che
1531 % il processo è stato completamente tolto dalla memoria per essere inserito
1533 % TODO verificare \var{ru\_nswap} non citato nelle pagine di manuali recenti e
1534 % dato per non utilizzato.
1536 I campi \var{ru\_nvcsw} e \var{ru\_nivcsw} indicano il numero di volte che un
1537 processo ha subito un \textit{context switch} da parte dello
1538 \textit{scheduler} rispettivamente nel caso un cui questo avviene prima
1539 dell'esaurimento della propria \textit{time-slice} (in genere a causa di una
1540 \textit{system call} bloccante), o per averla esaurita o essere stato
1541 interrotto da un processo a priorità maggiore. I campi \var{ru\_inblock} e
1542 \var{ru\_oublock} indicano invece il numero di volte che è stata eseguita una
1543 attività di I/O su un filesystem (rispettivamente in lettura e scrittura) ed
1544 infine \var{ru\_maxrss} indica il valore più alto della \textit{Resident Set
1545 Size} raggiunto dal processo stesso o, nel caso sia stato usato
1546 \const{RUSAGE\_CHILDREN}, da uno dei suoi figli.
1548 Si tenga conto che per un errore di implementazione nei i kernel precedenti il
1549 2.6.9, nonostante questo fosse esplicitamente proibito dallo standard POSIX.1,
1550 l'uso di \const{RUSAGE\_CHILDREN} comportava l'inserimento dell'ammontare
1551 delle risorse usate dai processi figli anche quando si era impostata una
1552 azione di \const{SIG\_IGN} per il segnale \signal{SIGCHLD} (per i segnali si
1553 veda cap.~\ref{cha:signals}). Il comportamento è stato corretto per aderire
1554 allo standard a partire dal kernel 2.6.9.
1557 \subsection{Limiti sulle risorse}
1558 \label{sec:sys_resource_limit}
1560 Come accennato nell'introduzione il kernel mette a disposizione delle
1561 funzionalità che permettono non solo di mantenere dati statistici relativi
1562 all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
1563 utilizzo da parte sia dei singoli processi che degli utenti.
1565 Per far questo sono definite una serie di risorse e ad ogni processo vengono
1566 associati due diversi limiti per ciascuna di esse; questi sono il
1567 \textsl{limite corrente} (o \textit{current limit}) che esprime un valore
1568 massimo che il processo non può superare ad un certo momento, ed il
1569 \textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
1570 valore massimo che può assumere il \textsl{limite corrente}. In generale il
1571 primo viene chiamato anche \textit{soft limit} dato che il suo valore può
1572 essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
1573 fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
1576 In generale il superamento di un limite corrente comporta o l'emissione di uno
1577 specifico segnale o il fallimento della \textit{system call} che lo ha
1578 provocato. A questo comportamento generico fanno eccezione \const{RLIMIT\_CPU}
1579 in cui si ha in comportamento diverso per il superamento dei due limiti e
1580 \const{RLIMIT\_CORE} che influenza soltanto la dimensione o l'eventuale
1581 creazione dei file di \textit{core dump} (vedi sez.~\ref{sec:sig_standard}).
1583 Per permettere di leggere e di impostare i limiti di utilizzo delle risorse da
1584 parte di un processo sono previste due funzioni di sistema, \funcd{getrlimit}
1585 e \funcd{setrlimit}, i cui prototipi sono:
1589 \fhead{sys/resource.h}
1591 \fdecl{int getrlimit(int resource, struct rlimit *rlim)}
1592 \fdesc{Legge i limiti di una risorsa.}
1593 \fdecl{int setrlimit(int resource, const struct rlimit *rlim)}
1594 \fdesc{Imposta i limiti di una risorsa.}
1597 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
1598 caso \var{errno} assumerà uno dei valori:
1600 \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
1601 nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
1602 \var{rlim->rlim\_max}.
1603 \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1604 cercato di innalzare i propri limiti.
1606 ed inoltre \errval{EFAULT} nel suo significato generico.
1610 Entrambe le funzioni permettono di specificare attraverso l'argomento
1611 \param{resource} su quale risorsa si vuole operare. L'accesso (rispettivamente
1612 in lettura e scrittura) ai valori effettivi dei limiti viene poi effettuato
1613 attraverso la struttura \struct{rlimit} puntata da
1614 \param{rlim}, la cui definizione è riportata in
1615 fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
1616 limite corrente e limite massimo.
1618 \begin{figure}[!htb]
1621 \begin{minipage}[c]{0.8\textwidth}
1622 \includestruct{listati/rlimit.h}
1625 \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
1626 delle risorse usate da un processo.}
1627 \label{fig:sys_rlimit_struct}
1630 Come accennato un processo ordinario può alzare il proprio limite corrente
1631 fino al valore del limite massimo, e può anche ridurre, irreversibilmente, il
1632 valore di quest'ultimo. Nello specificare un limite, oltre a fornire dei
1633 valori specifici, si può anche usare la costante \const{RLIM\_INFINITY} che
1634 permette di sbloccare completamente l'uso di una risorsa. Si ricordi però che
1635 solo un processo con i privilegi di amministratore\footnote{per essere precisi
1636 in questo caso quello che serve è la \textit{capability}
1637 \const{CAP\_SYS\_RESOURCE} (vedi sez.~\ref{sec:proc_capabilities}).} può
1638 innalzare un limite al di sopra del valore corrente del limite massimo ed
1639 usare un valore qualsiasi per entrambi i limiti.
1641 Ciascuna risorsa su cui si possono applicare dei limiti è identificata da uno
1642 specifico valore dell'argomento \param{resource}, i valori possibili per
1643 questo argomento, ed il significato della risorsa corrispondente, dei
1644 rispettivi limiti e gli effetti causati dal superamento degli stessi sono
1645 riportati nel seguente elenco.
1647 \begin{basedescript}{\desclabelwidth{2.2cm}}%\desclabelstyle{\nextlinelabel}}
1648 \item[\constd{RLIMIT\_AS}] Questa risorsa indica, in byte, la dimensione
1649 massima consentita per la memoria virtuale di un processo, il cosiddetto
1650 \textit{Address Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se il limite
1651 viene superato dall'uso di funzioni come \func{brk}, \func{mremap} o
1652 \func{mmap} esse falliranno con un errore di \errcode{ENOMEM}, mentre se il
1653 superamento viene causato dalla crescita dello \textit{stack} il processo
1654 riceverà un segnale di \signal{SIGSEGV}. Dato che il valore usato è un
1655 intero di tipo \ctyp{long} nelle macchine a 32 bit questo può assumere un
1656 valore massimo di 2Gb (anche se la memoria disponibile può essere maggiore),
1657 in tal caso il limite massimo indicabile resta 2Gb, altrimenti la risorsa si
1658 dà per non limitata.
1660 \item[\constd{RLIMIT\_CORE}] Questa risorsa indica, in byte, la massima
1661 dimensione per un file di \textit{core dump} (vedi
1662 sez.~\ref{sec:sig_standard}) creato nella terminazione di un processo. File
1663 di dimensioni maggiori verranno troncati a questo valore, mentre con un
1664 valore nullo si bloccherà la creazione dei \textit{core dump}.
1666 \item[\constd{RLIMIT\_CPU}] Questa risorsa indica, in secondi, il massimo tempo
1667 di CPU (vedi sez.~\ref{sec:sys_cpu_times}) che il processo può usare. Il
1668 superamento del limite corrente comporta l'emissione di un segnale di
1669 \signal{SIGXCPU}, la cui azione predefinita (vedi
1670 sez.~\ref{sec:sig_classification}) è terminare il processo. Il segnale però
1671 può essere intercettato e ignorato, in tal caso esso verrà riemesso una
1672 volta al secondo fino al raggiungimento del limite massimo. Il superamento
1673 del limite massimo comporta comunque l'emissione di un segnale di
1674 \signal{SIGKILL}. Si tenga presente che questo è il comportamento presente
1675 su Linux dai kernel della serie 2.2 ad oggi, altri kernel possono avere
1676 comportamenti diversi per quanto avviene quando viene superato il
1677 \textit{soft limit}, pertanto per avere operazioni portabili è suggerito di
1678 intercettare sempre \signal{SIGXCPU} e terminare in maniera ordinata il
1679 processo con la prima ricezione.
1681 \item[\constd{RLIMIT\_DATA}] Questa risorsa indica, in byte, la massima
1682 dimensione del segmento dati di un processo (vedi
1683 sez.~\ref{sec:proc_mem_layout}). Il tentativo di allocare più memoria di
1684 quanto indicato dal limite corrente causa il fallimento della funzione di
1685 allocazione eseguita (\func{brk} o \func{sbrk} e dal kernel 4.7 anche
1686 \func{mmap}) con un errore di \errcode{ENOMEM}.
1688 \item[\constd{RLIMIT\_FSIZE}] Questa risorsa indica, in byte, la massima
1689 dimensione di un file che un processo può usare. Se il processo cerca di
1690 scrivere o di estendere il file oltre questa dimensione riceverà un segnale
1691 di \signal{SIGXFSZ}, che di norma termina il processo. Se questo segnale
1692 viene intercettato la \textit{system call} che ha causato l'errore fallirà
1693 con un errore di \errcode{EFBIG}.
1695 \item[\constd{RLIMIT\_LOCKS}] Questa risorsa indica il numero massimo di
1696 \textit{file lock} (vedi sez.~\ref{sec:file_locking}) e di \textit{file
1697 lease} (vedi sez.~\ref{sec:file_asyncronous_lease}) che un processo poteva
1698 effettuare. È un limite presente solo nelle prime versioni del kernel 2.4,
1699 pertanto non deve essere più utilizzato.
1701 \item[\constd{RLIMIT\_MEMLOCK}] Questa risorsa indica, in byte, l'ammontare
1702 massimo di memoria che può essere bloccata in RAM da un processo (vedi
1703 sez.~\ref{sec:proc_mem_lock}). Dato che il \textit{memory locking} viene
1704 effettuato sulle pagine di memoria, il valore indicato viene automaticamente
1705 arrotondato al primo multiplo successivo della dimensione di una pagina di
1706 memoria. Il limite comporta il fallimento delle \textit{system call} che
1707 eseguono il \textit{memory locking} (\func{mlock}, \func{mlockall} ed anche,
1708 vedi sez.~\ref{sec:file_memory_map}, \func{mmap} con l'operazione
1709 \const{MAP\_LOCKED}).
1711 Dal kernel 2.6.9 questo limite comprende anche la memoria che può essere
1712 bloccata da ciascun utente nell'uso della memoria condivisa (vedi
1713 sez.~\ref{sec:ipc_sysv_shm}) con \func{shmctl}, che viene contabilizzata
1714 separatamente ma sulla quale viene applicato questo stesso limite. In
1715 precedenza invece questo limite veniva applicato sulla memoria condivisa per
1716 processi con privilegi amministrativi, il limite su questi è stato rimosso e
1717 la semantica della risorsa cambiata.
1720 \item[\constd{RLIMIT\_MSGQUEUE}] Questa risorsa indica il numero massimo di
1721 byte che possono essere utilizzati da un utente, identificato con
1722 l'\ids{UID} reale del processo chiamante, per le code di messaggi POSIX
1723 (vedi sez.~\ref{sec:ipc_posix_mq}). Per ciascuna coda che viene creata viene
1724 calcolata un'occupazione pari a:
1725 \includecodesnip{listati/mq_occupation.c}
1726 dove \var{attr} è la struttura \struct{mq\_attr} (vedi
1727 fig.~\ref{fig:ipc_mq_attr}) usata nella creazione della coda. Il primo addendo
1728 consente di evitare la creazione di una coda con un numero illimitato di
1729 messaggi vuoti che comunque richiede delle risorse di gestione. Questa risorsa
1730 è stata introdotta con il kernel 2.6.8.
1732 \item[\constd{RLIMIT\_NICE}] Questa risorsa indica il numero massimo a cui può
1733 essere il portato il valore di \textit{nice} (vedi
1734 sez.~\ref{sec:proc_sched_stand}). Dato che non possono essere usati numeri
1735 negativi per specificare un limite, il valore di \textit{nice} viene
1736 calcolato come \code{20-rlim\_cur}. Questa risorsa è stata introdotta con il
1739 \item[\constd{RLIMIT\_NOFILE}] Questa risorsa indica il numero massimo di file
1740 che un processo può aprire. Il tentativo di creazione di un ulteriore file
1741 descriptor farà fallire la funzione (\func{open}, \func{dup}, \func{pipe},
1742 ecc.) con un errore \errcode{EMFILE}.
1744 % TODO: aggiungere Dal 4.5 definisce anche il limite sul numero massimo di
1745 % file descriptor che un processo non privilegiato (senza la capacità
1746 % \const{CAP\_SYS\_RESOURCE}, vedi sez.~\ref{sec:proc_capabilities}) può
1747 % avere in corso di trasmissione verso altri
1748 % processi usando i socket Unix-domain (vedi sez.XXX), il limite si applica
1749 % si applica a \func{sendmsg}.
1751 \item[\constd{RLIMIT\_NPROC}] Questa risorsa indica il numero massimo di
1752 processi che possono essere creati dallo stesso utente, che viene
1753 identificato con l'\ids{UID} reale (vedi sez.~\ref{sec:proc_access_id}) del
1754 processo chiamante. Se il limite viene raggiunto \func{fork} fallirà con un
1757 \item[\constd{RLIMIT\_RSS}] Questa risorsa indica, in pagine di memoria, la
1758 dimensione massima della memoria residente (il cosiddetto RSS
1759 \itindex{Resident~Set~Size~(RSS)} \textit{Resident Set Size}) cioè
1760 l'ammontare della memoria associata al processo che risiede effettivamente
1761 in RAM e non a quella eventualmente portata sulla \textit{swap} o non ancora
1762 caricata dal filesystem per il segmento testo del programma. Ha effetto
1763 solo sulle chiamate a \func{madvise} con \const{MADV\_WILLNEED} (vedi
1764 sez.~\ref{sec:file_memory_map}). Presente solo sui i kernel precedenti il
1767 \item[\constd{RLIMIT\_RTPRIO}] Questa risorsa indica il valore massimo della
1768 priorità statica che un processo può assegnarsi o assegnare con
1769 \func{sched\_setscheduler} e \func{sched\_setparam} (vedi
1770 sez.~\ref{sec:proc_real_time}). Il limite è stato introdotto a partire dal
1771 kernel 2.6.12 (ma per un bug è effettivo solo a partire dal 2.6.13). In
1772 precedenza solo i processi con privilegi amministrativi potevano avere una
1773 priorità statica ed utilizzare una politica di \textit{scheduling} di tipo
1776 \item[\constd{RLIMIT\_RTTIME}] Questa risorsa indica, in microsecondi, il tempo
1777 massimo di CPU che un processo eseguito con una priorità statica può
1778 consumare. Il superamento del limite corrente comporta l'emissione di un
1779 segnale di \signal{SIGXCPU}, e quello del limite massimo di \signal{SIGKILL}
1780 con le stesse regole viste \const{RLIMIT\_CPU}: se \signal{SIGXCPU} viene
1781 intercettato ed ignorato il segnale verrà riemesso ogni secondo fino al
1782 superamento del limite massimo. Questo limite è stato introdotto con il
1783 kernel 2.6.25 per impedire che un processo \textit{real-time} possa bloccare
1786 \item[\constd{RLIMIT\_SIGPENDING}] Questa risorsa indica il numero massimo di
1787 segnali che possono essere mantenuti in coda per ciascun utente,
1788 identificato per \ids{UID} reale. Il limite comprende sia i segnali normali
1789 che quelli \textit{real-time} (vedi sez.~\ref{sec:sig_real_time}) ed è
1790 attivo solo per \func{sigqueue}, con \func{kill} si potrà sempre inviare un
1791 segnale che non sia già presente su una coda. Questo limite è stato
1792 introdotto con il kernel 2.6.8.
1794 \item[\constd{RLIMIT\_STACK}] Questa risorsa indica, in byte, la massima
1795 dimensione dello \textit{stack} del processo. Se il processo esegue
1796 operazioni che estendano lo \textit{stack} oltre questa dimensione riceverà
1797 un segnale di \signal{SIGSEGV}.
1799 A partire dal kernel 2.6.23 questo stesso limite viene applicato per la gran
1800 parte delle architetture anche ai dati che possono essere passati come
1801 argomenti e variabili di ambiente ad un programma posto in esecuzione con
1802 \func{execve}, nella misura di un quarto del valore indicato per lo
1803 \textit{stack}. Questo valore in precedenza era fisso e pari a 32 pagine di
1804 memoria, corrispondenti per la gran parte delle architetture a 128kb di
1805 dati, dal 2.6.25, per evitare problemi di compatibilità quando
1806 \const{RLIMIT\_STACK} è molto basso, viene comunque garantito uno spazio
1807 base di 32 pagine qualunque sia l'architettura.
1811 Si tenga conto infine che tutti i limiti eventualmente presenti su un processo
1812 vengono ereditati dai figli da esso creati attraverso una \func{fork} (vedi
1813 sez.~\ref{sec:proc_fork}) e mantenuti invariati per i programmi messi in
1814 esecuzione attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
1816 Si noti come le due funzioni \func{getrlimit} e \func{setrlimit} consentano di
1817 operare solo sul processo corrente. Per questo motivo a partire dal kernel
1818 2.6.36 (e dalla \acr{glibc} 2.13) è stata introdotta un'altra funzione di
1819 sistema \funcd{prlimit} il cui scopo è quello di estendere e sostituire le
1820 precedenti; il suo prototipo è:
1823 \fhead{sys/resource.h}
1824 \fdecl{int prlimit(pid\_t pid, int resource, const struct rlimit *new\_limit,\\
1825 \phantom{int prlimit(}struct rlimit *old\_limit)}
1826 \fdesc{Legge e imposta i limiti di una risorsa.}
1829 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1830 caso \var{errno} assumerà uno dei valori:
1832 \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
1833 nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
1834 \var{rlim->rlim\_max}.
1835 \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1836 cercato di innalzare i propri limiti o si è cercato di modificare i limiti
1837 di un processo di un altro utente.
1838 \item [\errcode{ESRCH}] il process \param{pid} non esiste.
1840 ed inoltre \errval{EFAULT} nel suo significato generico.
1844 La funzione è specifica di Linux e non portabile, per essere usata richiede
1845 che sia stata definita la macro \macro{\_GNU\_SOURCE}. Il primo argomento
1846 indica il \ids{PID} del processo di cui si vogliono cambiare i limiti e si può
1847 usare un valore nullo per indicare il processo chiamante. Per modificare i
1848 limiti di un altro processo, a meno di non avere privilegi
1849 amministrativi,\footnote{anche in questo caso la \textit{capability}
1850 necessaria è \const{CAP\_SYS\_RESOURCE} (vedi
1851 sez.~\ref{sec:proc_capabilities}).} l'\ids{UID} ed il \ids{GID} reale del
1852 chiamante devono coincidere con \ids{UID} e \ids{GID} del processo indicato
1853 per i tre gruppi reale, effettivo e salvato.
1855 Se \param{new\_limit} non è \val{NULL} verrà usato come puntatore alla
1856 struttura \struct{rlimit} contenente i valori dei nuovi limiti da impostare,
1857 mentre se \param{old\_limit} non è \val{NULL} verranno letti i valori correnti
1858 del limiti nella struttura \struct{rlimit} da esso puntata. In questo modo è
1859 possibile sia leggere che scrivere, anche in contemporanea, i valori dei
1860 limiti. Il significato dell'argomento \param{resource} resta identico rispetto
1861 a \func{getrlimit} e \func{setrlimit}, così come i restanti requisiti.
1863 % TODO: a bassa priorità, documentare i vari problemi e cambiamenti nella
1864 % implementazione di queste funzioni dettagliati nella pagina di manuale
1866 \subsection{Le informazioni sulle risorse di memoria e processore}
1867 \label{sec:sys_memory_res}
1869 La gestione della memoria è già stata affrontata in dettaglio in
1870 sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1871 meccanismo della memoria virtuale attraverso la divisione della memoria fisica
1872 in pagine. In genere tutto ciò è del tutto trasparente al singolo processo,
1873 ma in certi casi, come per l'I/O mappato in memoria (vedi
1874 sez.~\ref{sec:file_memory_map}) che usa lo stesso meccanismo per accedere ai
1875 file, è necessario conoscere le dimensioni delle pagine usate dal kernel. Lo
1876 stesso vale quando si vuole gestire in maniera ottimale l'interazione della
1877 memoria che si sta allocando con il meccanismo della paginazione.
1879 Un tempo la dimensione delle pagine di memoria era fissata una volta per tutte
1880 dall'architettura hardware, per cui il relativo valore veniva mantenuto in una
1881 costante che bastava utilizzare in fase di compilazione. Oggi invece molte
1882 architetture permettono di variare questa dimensione (ad esempio sui PC
1883 recenti si possono usare pagine di 4kb e di 4 Mb) per cui per non dover
1884 ricompilare i programmi per ogni possibile caso e relativa scelta di
1885 dimensioni, è necessario poter utilizzare una funzione che restituisca questi
1886 valori quando il programma viene eseguito.
1888 Dato che si tratta di una caratteristica generale del sistema come abbiamo
1889 visto in sez.~\ref{sec:sys_characteristics} questa dimensione può essere
1890 ottenuta come tutte le altre attraverso una chiamata a \func{sysconf}, nel
1891 caso specifico si dovrebbe utilizzare il parametro \const{\_SC\_PAGESIZE}. Ma
1892 in BSD 4.2 è stata introdotta una apposita funzione di sistema
1893 \funcd{getpagesize} che restituisce la dimensione delle pagine di memoria. La
1894 funzione è disponibile anche su Linux (ma richiede che sia definita la macro
1895 \macro{\_BSD\_SOURCE}) ed il suo prototipo è:
1899 \fdecl{int getpagesize(void)}
1900 \fdesc{Legge la dimensione delle pagine di memoria.}
1903 {La funzione ritorna la dimensione di una pagina in byte, e non sono previsti
1907 La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
1908 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1909 ha eliminata, ed i programmi che intendono essere portabili devono ricorrere
1910 alla chiamata a \func{sysconf}.
1912 In Linux è implementata come una \textit{system call} nelle architetture in
1913 cui essa è necessaria, ed in genere restituisce il valore del simbolo
1914 \const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
1915 se le versioni delle librerie del C precedenti la \acr{glibc} 2.1
1916 implementavano questa funzione restituendo sempre un valore statico.
1918 % TODO verificare meglio la faccenda di const{PAGE\_SIZE}
1920 La \textsl{glibc} fornisce, come specifica estensione GNU, altre due
1921 funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
1922 di ottenere informazioni riguardo le pagine di memoria; i loro prototipi sono:
1925 \fhead{sys/sysinfo.h}
1926 \fdecl{long int get\_phys\_pages(void)}
1927 \fdesc{Legge il numero totale di pagine di memoria.}
1928 \fdecl{long int get\_avphys\_pages(void)}
1929 \fdesc{Legge il numero di pagine di memoria disponibili nel sistema.}
1932 {La funzioni ritornano il numero di pagine, e non sono previsti
1936 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1937 rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
1938 \const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1939 corrispondenti alla RAM della macchina; la seconda invece la memoria
1940 effettivamente disponibile per i processi.
1942 La \acr{glibc} supporta inoltre, come estensioni GNU, due funzioni che
1943 restituiscono il numero di processori della macchina (e quello dei processori
1944 attivi); anche queste sono informazioni comunque ottenibili attraverso
1945 \func{sysconf} utilizzando rispettivamente i parametri
1946 \const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
1948 Infine la \acr{glibc} riprende da BSD la funzione \funcd{getloadavg} che
1949 permette di ottenere il carico di processore della macchina, in questo modo è
1950 possibile prendere decisioni su quando far partire eventuali nuovi processi,
1955 \fdecl{int getloadavg(double loadavg[], int nelem)}
1956 \fdesc{Legge il carico medio della macchina.}
1959 {La funzione ritorna il numero di campionamenti restituiti e $-1$ se non
1960 riesce ad ottenere il carico medio, \var{errno} non viene modificata.}
1963 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1964 di processi attivi sulla coda dello \textit{scheduler}, calcolato su diversi
1965 intervalli di tempo. Il numero di intervalli che si vogliono leggere è
1966 specificato da \param{nelem}, dato che nel caso di Linux il carico viene
1967 valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti), questo è
1968 anche il massimo valore che può essere assegnato a questo argomento.
1971 \subsection{La \textsl{contabilità} in stile BSD}
1972 \label{sec:sys_bsd_accounting}
1974 Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
1975 kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
1976 compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
1977 cosiddetto \textit{BSD accounting}, che consente di registrare su file una
1978 serie di informazioni\footnote{contenute nella struttura \texttt{acct}
1979 definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
1980 riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
1981 che viene terminato.
1983 Linux consente di salvare la contabilità delle informazioni relative alle
1984 risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
1989 \fdecl{int acct(const char *filename)}
1990 \fdesc{Abilita il \textit{BSD accounting}.}
1993 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1994 caso \var{errno} assumerà uno dei valori:
1996 \item[\errcode{EACCES}] non si hanno i permessi per accedere a
1998 \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
1999 \item[\errcode{EPERM}] il processo non ha privilegi sufficienti ad
2000 abilitare il \textit{BSD accounting}.
2001 \item[\errcode{EUSERS}] non sono disponibili nel kernel strutture per il
2002 file o si è finita la memoria.
2004 ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
2005 \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
2006 \errval{ENOTDIR}, \errval{EROFS} nel loro significato generico.}
2009 La funzione attiva il salvataggio dei dati sul file indicato dal
2010 \textit{pathname} contenuto nella stringa puntata da \param{filename}; la
2011 funzione richiede che il processo abbia i privilegi di amministratore (è
2012 necessaria la \textit{capability} \const{CAP\_SYS\_PACCT}, vedi
2013 sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \val{NULL} per
2014 \param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
2015 semplice esempio per l'uso di questa funzione è riportato nel programma
2016 \texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
2018 Quando si attiva la contabilità, il file che si indica deve esistere; esso
2019 verrà aperto in sola scrittura e le informazioni verranno registrate in
2020 \textit{append} in coda al file tutte le volte che un processo termina. Le
2021 informazioni vengono salvate in formato binario, e corrispondono al contenuto
2022 della apposita struttura dati definita all'interno del kernel.
2024 Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
2025 parametro di sistema, modificabile attraverso \sysctlfiled{kernel/acct} (o
2026 tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi, il
2027 primo indica la percentuale di spazio disco libero sopra il quale viene
2028 ripresa una registrazione che era stata sospesa per essere scesi sotto il
2029 minimo indicato dal secondo valore (sempre in percentuale di spazio disco
2030 libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
2031 essere controllata detta percentuale.
2033 % TODO: bassa priorità, trattare la lettura del file di accounting, da
2034 % programma, vedi man 5 acct
2037 \section{La gestione dei tempi del sistema}
2038 \label{sec:sys_time}
2040 In questa sezione, una volta introdotti i concetti base della gestione dei
2041 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
2042 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
2043 veri tempi di sistema associati ai processi, a quelle per convertire i vari
2044 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
2045 gestione di data e ora.
2048 \subsection{La misura del tempo in Unix}
2049 \label{sec:sys_unix_time}
2051 \itindbeg{calendar~time}
2052 \itindbeg{process~time}
2054 Tradizionalmente nei sistemi unix-like sono sempre stati previsti due tipi
2055 distinti di tempi, caratterizzati da altrettante modalità di misura ed
2056 espressi con diversi tipi di dati, chiamati rispettivamente \textit{calendar
2057 time} e \textit{process time}, secondo le seguenti definizioni:
2058 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
2060 \item[\textit{calendar time}] detto anche \textsl{tempo di calendario},
2061 \textsl{tempo d'orologio} o \textit{tempo reale}. Si tratta di un tempo
2062 assoluto o di un intervallo di tempo come lo intende normalmente per le
2063 misure fatte con un orologio. Per esprimere questo tempo è stato riservato
2064 il tipo \type{time\_t}, e viene tradizionalmente misurato nel cosiddetto
2065 \itindex{unix-time} \textit{unix-time}, espresso in secondi a partire dalla
2066 mezzanotte del primo gennaio 1970, data che viene chiamata \textit{the
2069 \item[\textit{process time}] detto anche \textsl{tempo di processore} o
2070 \textsl{tempo di CPU}. Si tratta del tempo impiegato da un processore
2071 nell'esecuzione del codice di un programma all'interno di un processo. Per
2072 esprimere questo tempo è stato riservato il tipo \type{clock\_t}, e viene
2073 misurato nei cosiddetti \textit{clock tick}, tradizionalmente corrispondenti
2074 al numero di interruzioni del processore da parte del timer di sistema. A
2075 differenza del precedente indica soltanto un intervallo di durata.
2078 Il \textit{calendar time} viene sempre mantenuto facendo riferimento
2079 al cosiddetto \textit{tempo universale coordinato} UTC, anche se
2080 talvolta viene usato il cosiddetto GMT (\textit{Greenwich Mean Time})
2081 dato che l'UTC corrisponde all'ora locale di Greenwich. Si tratta del
2082 tempo su cui viene mantenuto il cosiddetto \textsl{orologio di
2083 sistema}, e viene usato per indicare i tempi dei file (quelli di
2084 sez.~\ref{sec:file_file_times}) o le date di avvio dei processi, ed è
2085 il tempo che viene usato dai demoni che compiono lavori amministrativi
2086 ad orari definito, come \cmd{cron}.
2088 Si tenga presente che questo tempo è mantenuto dal kernel e non è detto che
2089 corrisponda al tempo misurato dall'orologio hardware presente su praticamente
2090 tutte le piastre madri dei computer moderni (il cosiddetto \textit{hardware
2091 clock}), il cui valore viene gestito direttamente dall'hardware in maniera
2092 indipendente e viene usato dal kernel soltanto all'avvio per impostare un
2093 valore iniziale dell'orologio di sistema. La risoluzione tradizionale data dal
2094 tipo di dato \type{time\_t} è di un secondo, ma nei sistemi più recenti sono
2095 disponibili altri tipi di dati con precisioni maggiori.
2097 Si tenga presente inoltre che a differenza di quanto avviene con altri sistemi
2098 operativi,\footnote{è possibile, ancorché assolutamente sconsigliabile,
2099 forzare l'orologio di sistema all'ora locale per compatibilità con quei
2100 sistemi operativi che han fatto questa deprecabile scelta.} l'orologio di
2101 sistema viene mantenuto sempre in UTC e che la conversione all'ora locale del
2102 proprio fuso orario viene effettuata dalle funzioni di libreria utilizzando le
2103 opportune informazioni di localizzazione (specificate in
2104 \conffiled{/etc/timezone}). In questo modo si ha l'assicurazione che l'orologio
2105 di sistema misuri sempre un tempo monotono crescente come nella realtà, anche
2106 in presenza di cambi di fusi orari.
2108 \itindend{calendar~time}
2110 Il \textit{process time} invece indica sempre una misura di un lasso di tempo
2111 e viene usato per tenere conto dei tempi di esecuzione dei processi. Esso
2112 viene sempre diviso in \textit{user time} e \textit{system time}, per misurare
2113 la durata di ciascun processo il kernel infatti calcola tre tempi:
2114 \begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
2115 \item[\textit{clock time}] il tempo \textsl{reale}, viene chiamato anche
2116 \textit{wall clock time} o \textit{elapsed time}, passato dall'avvio del
2117 processo. Questo tempo fa riferimento al
2118 \textit{calendar time} e dice la durata effettiva dell'esecuzione del
2119 processo, ma chiaramente dipende dal carico del sistema e da quanti altri
2120 processi stanno girando nello stesso momento.
2122 \item[\textit{user time}] il tempo effettivo che il processore ha impiegato
2123 nell'esecuzione delle istruzioni del programma in \textit{user space}. È
2124 anche quello riportato nella risorsa \var{ru\_utime} di \struct{rusage}
2125 vista in sez.~\ref{sec:sys_resource_use}.
2127 \item[\textit{system time}] il tempo effettivo che il processore ha impiegato
2128 per eseguire codice delle \textit{system call} nel kernel per conto del
2129 processo. È anche quello riportato nella risorsa \var{ru\_stime} di
2130 \struct{rusage} vista in sez.~\ref{sec:sys_resource_use}.
2133 La somma di \textit{user time} e \textit{system time} indica il
2134 \textit{process time}, vale a dire il tempo di processore totale che il
2135 sistema ha effettivamente utilizzato per eseguire il programma di un certo
2136 processo. Si può ottenere un riassunto dei valori di questi tempi quando si
2137 esegue un qualsiasi programma lanciando quest'ultimo come argomento del
2140 \itindend{process~time}
2141 \itindbeg{clock~tick}
2143 Come accennato il \textit{process time} viene misurato nei cosiddetti
2144 \textit{clock tick}. Un tempo questo corrispondeva al numero di interruzioni
2145 effettuate dal timer di sistema, oggi lo standard POSIX richiede che esso sia
2146 espresso come multiplo della costante \constd{CLOCKS\_PER\_SEC} che deve
2147 essere definita come 1000000, qualunque sia la risoluzione reale dell'orologio
2148 di sistema e la frequenza delle interruzioni del timer che, come accennato in
2149 sez.~\ref{sec:proc_hierarchy} e come vedremo a breve, è invece data dalla
2150 costante \const{HZ}.
2152 Il tipo di dato usato per questo tempo, \type{clock\_t}, con questa
2153 convenzione ha una risoluzione del microsecondo. Ma non tutte le funzioni di
2154 sistema come vedremo seguono questa convenzione, in tal caso il numero di
2155 \textit{clock tick} al secondo può essere ricavato anche attraverso
2156 \func{sysconf} richiedendo il valore della costante \const{\_SC\_CLK\_TCK}
2157 (vedi sez.~\ref{sec:sys_limits}). Il vecchio simbolo \const{CLK\_TCK}
2158 definito in \headfile{time.h} è ormai considerato obsoleto e non deve essere
2163 In realtà tutti calcoli dei tempi vengono effettuati dal kernel per il
2164 cosiddetto \textit{software clock}, utilizzando il \textit{timer di sistema} e
2165 facendo i conti in base al numero delle interruzioni generate dello stesso, i
2166 cosiddetti \itindex{jiffies} ``\textit{jiffies}''. La durata di un
2167 ``\textit{jiffy}'' è determinata dalla frequenza di interruzione del timer,
2168 indicata in Hertz, come accennato in sez.~\ref{sec:proc_hierarchy}, dal valore
2169 della costante \const{HZ} del kernel, definita in \file{asm/param.h}.
2171 Fino al kernel 2.4 il valore di \const{HZ} era 100 su tutte le architetture
2172 tranne l'alpha, per cui era 1000. Con il 2.6.0 è stato portato a 1000 su tutte
2173 le architetture, ma dal 2.6.13 il valore è diventato una opzione di
2174 compilazione del kernel, con un default di 250 e valori possibili di 100, 250,
2175 1000. Dal 2.6.20 è stato aggiunto anche il valore 300 che è divisibile per le
2176 frequenze di refresh della televisione (50 o 60 Hz). Si può pensare che questi
2177 valori determinino anche la corrispondente durata dei \textit{clock tick}, ma
2178 in realtà questa granularità viene calcolata in maniera indipendente usando la
2179 costante del kernel \const{USER\_HZ}.
2183 Fino al kernel 2.6.21 la durata di un \textit{jiffy} costituiva la risoluzione
2184 massima ottenibile nella misura dei tempi impiegabile in una \textit{system
2185 call} (ad esempio per i timeout). Con il 2.6.21 e l'introduzione degli
2186 \textit{high-resolution timers} (HRT) è divenuto possibile ottenere, per le
2187 funzioni di attesa ed i timer, la massima risoluzione possibile fornita
2188 dall'hardware. Torneremo su questo in sez.~\ref{sec:sig_timer_adv}.
2190 \itindend{clock~tick}
2193 \subsection{La gestione del \textit{process time}}
2194 \label{sec:sys_cpu_times}
2196 Di norma tutte le operazioni del sistema fanno sempre riferimento al
2197 \textit{calendar time}, l'uso del \textit{process time} è riservato a
2198 quei casi in cui serve conoscere i tempi di esecuzione di un processo
2199 (ad esempio per valutarne l'efficienza). In tal caso infatti fare
2200 ricorso al \textit{calendar time} è inutile in quanto il tempo può
2201 essere trascorso mentre un altro processo era in esecuzione o in
2202 attesa del risultato di una operazione di I/O.
2204 La funzione più semplice per leggere il \textit{process time} di un processo è
2205 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
2206 utilizzato dallo stesso; il suo prototipo è:
2210 \fdecl{clock\_t clock(void)}
2211 \fdesc{Legge il valore corrente del tempo di CPU.}
2214 {La funzione ritorna il tempo di CPU in caso di successo e $-1$ se questo non
2215 è ottenibile o rappresentabile in un valore di tipo \type{clock\_t},
2216 \var{errno} non viene usata.}
2219 La funzione restituisce il tempo in \textit{clock tick} ma la \acr{glibc}
2220 segue lo standard POSIX e quindi se si vuole il tempo in secondi occorre
2221 dividere il risultato per la costante \const{CLOCKS\_PER\_SEC}. In genere
2222 \type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
2223 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
2224 riprenderà lo stesso valore iniziale.
2226 La funzione è presente anche nello standard ANSI C, ma in tal caso non è
2227 previsto che il valore ritornato indichi un intervallo di tempo ma solo un
2228 valore assoluto, per questo se si vuole la massima portabilità anche al di
2229 fuori di kernel unix-like, può essere opportuno chiamare la funzione
2230 all'inizio del programma ed ottenere il valore del tempo con una differenza.
2232 Si tenga presente inoltre che con altri kernel unix-like il valore riportato
2233 dalla funzione può includere anche il tempo di processore usato dai processi
2234 figli di cui si è ricevuto lo stato di terminazione con \func{wait} e
2235 affini. Questo non vale per Linux, in cui questa informazione deve essere
2236 ottenuta separatamente.
2238 Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di processore è la
2239 somma di altri due tempi, l'\textit{user time} ed il \textit{system time}, che
2240 sono quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
2241 possono essere letti separatamente attraverso la funzione \funcd{times}, il
2246 \fdecl{clock\_t times(struct tms *buf)}
2247 \fdesc{Legge il valore corrente dei tempi di processore.}
2250 {La funzione ritorna un numero di \textit{clock tick} in caso di successo e
2251 $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il valore
2252 \errval{EFAULT} nel suo significato generico.}
2255 La funzione restituisce i valori di \textit{process time} del processo
2256 corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
2257 in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
2258 due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
2259 \textit{system time} del processo, così come definiti in
2260 sez.~\ref{sec:sys_unix_time}. Gli altri due campi, \var{tms\_cutime} e
2261 \var{tms\_cstime}, riportano la somma dell'\textit{user time} e del
2262 \textit{system time} di tutti processi figli di cui si è ricevuto lo stato di
2265 \begin{figure}[!htb]
2268 \begin{minipage}[c]{0.8\textwidth}
2269 \includestruct{listati/tms.h}
2272 \caption{La struttura \structd{tms} dei tempi di processore associati a un
2274 \label{fig:sys_tms_struct}
2278 Si tenga presente che i tempi di processore dei processi figli di un processo
2279 vengono sempre sommati al valore corrente ogni volta che se ne riceve lo stato
2280 di terminazione, e detto valore è quello che viene a sua volta ottenuto dal
2281 processo padre. Pertanto nei campi \var{tms\_cutime} e \var{tms\_cstime} si
2282 sommano anche i tempi di ulteriori discendenti di cui i rispettivi genitori
2283 abbiano ricevuto lo stato di terminazione.
2285 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
2286 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
2287 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
2288 lo stato di terminazione di tutti i suoi figli, questi processi
2289 ``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi e
2290 così via per i relativi ``\textsl{discendenti}''.
2292 Come accennato in sez.~\ref{sec:sys_resource_use} per i kernel precedenti la
2293 versione 2.6.9 il tempo di processore dei processi figli veniva sommato
2294 comunque chiedendo di ignorare \signal{SIGCHLD} anche se lo standard POSIX
2295 richiede esplicitamente che questo avvenga solo quando si riceve lo stato di
2296 uscita con una funzione della famiglia delle \func{wait}, anche in questo caso
2297 il comportamento è stato adeguato allo standard a partire dalla versione
2300 A differenza di quanto avviene per \func{clock} i valori restituiti nei campi
2301 di una struttura \struct{tms} sono misurati in numero di \textit{clock tick}
2302 effettivi e non in multipli di \const{CLOCKS\_PER\_SEC}, pertanto per ottenere
2303 il valore effettivo del tempo in secondi occorrerà dividere per il risultato
2304 di \code{sysconf(\_SC\_CLK\_TCK)}.
2306 Lo stesso vale per il valore di ritorno della funzione, il cui significato fa
2307 riferimento ad un tempo relativo ad un certo punto nel passato la cui
2308 definizione dipende dalle diverse implementazioni, e varia anche fra diverse
2309 versioni del kernel. Fino al kernel 2.4 si faceva infatti riferimento al
2310 momento dell'avvio del kernel. Con il kernel 2.6 si fa riferimento a
2311 $2^{32}/\mathtt{HZ}-300$ secondi prima dell'avvio.
2313 Considerato che il numero dei \textit{clock tick} per un kernel che è attivo
2314 da molto tempo può eccedere le dimensioni per il tipo \type{clock\_t} il
2315 comportamento più opportuno per i programmi è di ignorare comunque il valore
2316 di ritorno della funzione e ricorrere alle funzioni per il tempo di calendario
2317 del prossimo paragrafo qualora si voglia calcolare il tempo effettivamente
2318 trascorso dall'inizio del programma.
2320 Infine si tenga presente che per dei limiti nelle convenzioni per il ritorno
2321 dei valori delle \textit{system call} su alcune architetture hardware (ed in
2322 particolare la \texttt{i386} dei PC a 32 bit) nel kernel della serie 2.6 il
2323 valore di ritorno della funzione può risultare erroneamente uguale a $-1$,
2324 indicando un errore, nei primi secondi dopo il boot (per la precisione nei
2325 primi 41 secondi) e se il valore del contatore eccede le dimensione del tipo
2329 \subsection{Le funzioni per il \textit{calendar time}}
2330 \label{sec:sys_time_base}
2332 \itindbeg{calendar~time}
2334 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time}
2335 viene espresso normalmente con una variabile di tipo \type{time\_t}, che
2336 usualmente corrisponde ad un tipo elementare; in Linux è definito come
2337 \ctyp{long int}, che di norma corrisponde a 32 bit, cosa che pone un limite al
2338 valore massimo esprimibile al 19 gennaio 2038, per ovviare alla cosa nelle
2339 versioni più recenti viene usato un valore di dimensioni maggiori. Il valore
2340 corrente del \textit{calendar time}, che indicheremo come \textsl{tempo di
2341 sistema}, può essere ottenuto con la funzione \funcd{time} che lo
2342 restituisce nel suddetto formato, il suo prototipo è:
2346 \fdecl{time\_t time(time\_t *t)}
2347 \fdesc{Legge il valore corrente del \textit{calendar time}.}
2350 {La funzione ritorna il valore del \textit{calendar time} in caso di successo
2351 e $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il
2352 valore \errval{EFAULT} nel suo significato generico.}
2355 L'argomento \param{t}, se non nullo, deve essere l'indirizzo di una variabile
2356 su cui duplicare il valore di ritorno, ma il suo uso è considerato obsoleto e
2357 deve essere sempre specificato come \val{NULL}, nel qual caso la funzione non
2360 Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
2361 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
2362 sia necessario; il suo prototipo è:
2366 \fdecl{int stime(time\_t *t)}
2367 \fdesc{Imposta il valore corrente del \textit{calendar time}.}
2370 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
2371 caso \var{errno} assumerà uno dei valori:
2373 \item[\errcode{EPERM}] non si hanno i permessi di amministrazione.
2375 ed inoltre \errval{EFAULT} nel suo significato generico.}
2379 Dato che modificare l'ora ha un impatto su tutto il sistema il cambiamento
2380 dell'orologio è una operazione privilegiata e questa funzione può essere usata
2381 solo da un processo con i privilegi di amministratore (per la precisione la
2382 \textit{capability} \const{CAP\_SYS\_TIME}, vedi
2383 sez.~\ref{sec:proc_capabilities}), altrimenti la chiamata fallirà con un
2384 errore di \errcode{EPERM}.
2386 Data la scarsa precisione nell'uso di \type{time\_t}, che ha una risoluzione
2387 di un secondo, quando si devono effettuare operazioni sui tempi l'uso delle
2388 due funzioni precedenti è sconsigliato, ed esse sono di solito sostituite da
2389 \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le due funzioni
2390 \func{time} e \func{stime} sono più antiche e derivano da SVr4,
2391 \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
2392 in BSD4.3 sono indicate come sostitute delle precedenti, \func{gettimeofday}
2393 viene descritta anche in POSIX.1-2001.} i cui prototipi sono:
2398 \fdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
2399 \fdesc{Legge il tempo corrente del sistema.}
2400 \fdecl{int settimeofday(const struct timeval *tv, const struct timezone *tz)}
2401 \fdesc{Imposta il tempo di sistema.}
2404 {La funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
2405 caso \var{errno} assumerà i valori \errval{EINVAL}, \errval{EFAULT} e per
2406 \func{settimeofday} anche \errval{EPERM}, nel loro significato generico.}
2410 Si noti come queste funzioni utilizzino per indicare il tempo una struttura di
2411 tipo \struct{timeval}, la cui definizione si è già vista in
2412 fig.~\ref{fig:sys_timeval_struct}, questa infatti permette una espressione
2413 alternativa dei valori del \textit{calendar time}, con una precisione,
2414 rispetto a \type{time\_t}, fino al microsecondo, ma la precisione è solo
2415 teorica, e la precisione reale della misura del tempo dell'orologio di sistema
2416 non dipende dall'uso di queste strutture.
2418 Come nel caso di \func{stime} anche \func{settimeofday} può essere utilizzata
2419 solo da un processo coi privilegi di amministratore e più precisamente con la
2420 capacità \const{CAP\_SYS\_TIME}. Si tratta comunque di una condizione generale
2421 che continua a valere per qualunque funzione che vada a modificare l'orologio
2422 di sistema, comprese tutte quelle che tratteremo in seguito.
2426 Il secondo argomento di entrambe le funzioni è una struttura
2427 \struct{timezone}, che storicamente veniva utilizzata per specificare appunto
2428 la cosiddetta \textit{timezone}, cioè l'insieme del fuso orario e delle
2429 convenzioni per l'ora legale che permettevano il passaggio dal tempo
2430 universale all'ora locale. Questo argomento oggi è obsoleto ed in Linux non è
2431 mai stato utilizzato; esso non è supportato né dalla vecchia \textsl{libc5},
2432 né dalla \textsl{glibc}: pertanto quando si chiama questa funzione deve essere
2433 sempre impostato a \val{NULL}.
2437 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
2438 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
2439 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
2440 conseguenze indesiderate. Ad esempio se si porta avanti l'orologio si possono
2441 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
2442 saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
2443 delle operazioni previste nell'intervallo di tempo che viene ripetuto.
2445 Per questo motivo la modalità più corretta per impostare l'ora è quella di
2446 usare la funzione \funcd{adjtime}, il cui prototipo è:
2450 \fdecl{int adjtime(const struct timeval *delta, struct timeval *olddelta)}
2451 \fdesc{Aggiusta l'orologio di sistema.}
2454 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
2455 caso \var{errno} assumerà uno dei valori:
2457 \item[\errcode{EINVAL}] il valore di \param{delta} eccede il massimo
2459 \item[\errcode{EPERM}] il processo non i privilegi di amministratore.
2464 Questa funzione permette di avere un aggiustamento graduale del tempo di
2465 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
2466 indicato nella struttura \struct{timeval} puntata da \param{delta} esprime il
2467 valore di cui si vuole spostare l'orologio. Se è positivo l'orologio sarà
2468 accelerato per un certo tempo in modo da guadagnare il tempo richiesto,
2469 altrimenti sarà rallentato.
2471 La funzione è intesa per piccoli spostamenti del tempo di sistema, ed esistono
2472 pertanto dei limiti massimi per i valori che si possono specificare
2473 per \param{delta}. La \acr{glibc} impone un intervallo compreso fra
2474 \code{INT\_MIN/1000000 + 2} e \code{INT\_MAX/1000000 - 2}, corrispondente, su
2475 una architettura PC ordinaria a 32 bit, ad un valore compreso fra $-2145$ e
2478 Inoltre se si invoca la funzione prima che una precedente richiesta di
2479 aggiustamento sia stata completata, specificando un altro valore, il
2480 precedente aggiustamento viene interrotto, ma la parte dello stesso che è già
2481 stata completata non viene rimossa. Però è possibile in questo caso farsi
2482 restituire nella struttura puntata da \param{olddelta} il tempo restante della
2483 precedente richiesta. Fino al kernel 2.6.26 ed alla \acr{glibc} 2.8 questo
2484 però era possibile soltanto specificando un diverso aggiustamento
2485 per \param{delta}, il bug è stato corretto a partire dalle versioni citate e
2486 si può ottenere l'informazione relativa alla frazione di aggiustamento
2487 mancante usando il valore \val{NULL} per \param{delta}.
2489 Linux poi prevede una specifica funzione di sistema che consente un
2490 aggiustamento molto più dettagliato del tempo, permettendo ad esempio anche di
2491 regolare anche la velocità e le derive dell'orologio di sistema. La funzione
2492 è \funcd{adjtimex} ed il suo prototipo è:
2496 \fdecl{int adjtimex(struct timex *buf)}
2497 \fdesc{Regola l'orologio di sistema.}
2500 {La funzione ritorna lo stato dell'orologio (un valore $\ge 0$) in caso di
2501 successo e $-1$ per un errore, nel qual caso \var{errno} assumerà uno dei
2504 \item[\errcode{EINVAL}] si sono indicati valori fuori dall'intervallo
2505 consentito per qualcuno dei campi di \param{buf}.
2506 \item[\errcode{EPERM}] si è richiesta una modifica dei parametri ed il
2507 processo non ha i privilegi di amministratore.
2509 ed inoltre \errval{EFAULT} nel suo significato generico.}
2512 In caso di successo la funzione restituisce un valore numerico non negativo
2513 che indica lo stato dell'orologio, che può essere controllato con i valori
2514 delle costanti elencate in tab.~\ref{tab:adjtimex_return}.
2519 \begin{tabular}[c]{|l|c|l|}
2521 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2524 \constd{TIME\_OK} & 0 & Orologio sincronizzato.\\
2525 \constd{TIME\_INS} & 1 & Inserimento di un \textit{leap second}.\\
2526 \constd{TIME\_DEL} & 2 & Cancellazione di un \textit{leap second}.\\
2527 \constd{TIME\_OOP} & 3 & \textit{leap second} in corso.\\
2528 \constd{TIME\_WAIT} & 4 & \textit{leap second} avvenuto.\\
2529 \constd{TIME\_BAD} & 5 & Orologio non sincronizzato.\\
2532 \caption{Possibili valori ritornati da \func{adjtimex} in caso di successo.}
2533 \label{tab:adjtimex_return}
2536 La funzione richiede come argomento il puntatore ad una struttura di tipo
2537 \struct{timex}, la cui definizione, effettuata in \headfiled{sys/timex.h}, è
2538 riportata in fig.~\ref{fig:sys_timex_struct} per i campi che interessano la
2539 possibilità di essere modificati. In realtà la struttura è stata estesa con
2540 ulteriori campi, i cui valori sono utilizzabili solo in lettura, non riportati
2541 in fig.~\ref{fig:sys_timex_struct}, i dettagli di questi campi si possono
2542 recuperare dalla pagina di manuale di \func{adjtimex}.
2544 \begin{figure}[!htb]
2545 \footnotesize \centering
2546 \begin{minipage}[c]{\textwidth}
2547 \includestruct{listati/timex.h}
2550 \caption{La struttura \structd{timex} per il controllo dell'orologio di
2552 \label{fig:sys_timex_struct}
2555 L'azione della funzione dipende dal valore del campo \var{mode}
2556 di \param{buf}, che specifica quale parametro dell'orologio di sistema,
2557 specificato nel corrispondente campo di \struct{timex}, deve essere
2558 impostato. Un valore nullo serve per leggere i parametri correnti, i valori
2559 diversi da zero devono essere specificati come OR binario delle costanti
2560 riportate in tab.~\ref{tab:sys_timex_mode}.
2565 \begin{tabular}[c]{|l|p{8cm}|}
2567 \textbf{Nome} & \textbf{Significato}\\
2570 \constd{ADJ\_OFFSET} & Imposta la differenza fra il tempo
2571 reale e l'orologio di sistema:
2572 deve essere indicata in microsecondi
2573 nel campo \var{offset} di
2575 \constd{ADJ\_FREQUENCY} & Imposta la differenza in frequenza
2576 fra il tempo reale e l'orologio di
2577 sistema: deve essere indicata
2578 in parti per milione nel campo
2579 \var{frequency} di \struct{timex}.\\
2580 \constd{ADJ\_MAXERROR} & Imposta il valore massimo
2581 dell'errore sul tempo, espresso in
2582 microsecondi nel campo
2583 \var{maxerror} di \struct{timex}.\\
2584 \constd{ADJ\_ESTERROR} & Imposta la stima dell'errore
2585 sul tempo, espresso in microsecondi
2586 nel campo \var{esterror} di
2588 \constd{ADJ\_STATUS} & Imposta alcuni valori di stato
2590 sistema nella gestione
2591 dell'orologio specificati nel campo
2592 \var{status} di \struct{timex}.\\
2593 \constd{ADJ\_TIMECONST} & Imposta la larghezza di banda del
2594 PLL implementato dal kernel,
2595 specificato nel campo
2596 \var{constant} di \struct{timex}.\\
2597 \constd{ADJ\_TICK} & Imposta il valore dei \textit{tick}
2599 microsecondi, espresso nel campo
2600 \var{tick} di \struct{timex}.\\
2601 \constd{ADJ\_OFFSET\_SINGLESHOT}&Chiede uno spostamento una tantum
2602 dell'orologio secondo il valore del
2603 campo \var{offset} simulando il
2604 comportamento di \func{adjtime}.\\
2607 \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
2608 struttura \struct{timex}.}
2609 \label{tab:sys_timex_mode}
2612 La funzione utilizza il meccanismo di David L. Mills, descritto
2613 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
2614 protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
2615 portabilità è un requisito, la \acr{glibc} provvede anche un suo omonimo
2616 \func{ntp\_adjtime}. La trattazione completa di questa funzione necessita di
2617 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
2618 a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
2619 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
2620 campi della struttura \struct{timex} può essere ritrovato in \cite{GlibcMan}.
2622 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
2623 sintassi specificata per la forma equivalente di questa funzione definita come
2624 \func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
2627 Si tenga presente infine che con l'introduzione a partire dal kernel 2.6.21
2628 degli \textit{high-resolution timer} ed il supporto per i cosiddetti POSIX
2629 \textit{real-time clock}, si può ottenere il \textit{calendar time}
2630 direttamente da questi, come vedremo in sez.~\ref{sec:sig_timer_adv}, con la
2631 massima risoluzione possibile per l'hardware della macchina.
2635 \subsection{La gestione delle date.}
2636 \label{sec:sys_date}
2638 \itindbeg{broken-down~time}
2640 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
2641 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
2642 illustrate, se han senso per specificare un intervallo, non sono molto
2643 intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
2644 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2645 time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2646 time} usuale in ore, minuti, secondi, ecc. e viene usata tenendo conto
2647 anche dell'eventuale utilizzo di un fuso orario.
2649 \begin{figure}[!htb]
2650 \footnotesize \centering
2651 \begin{minipage}[c]{.8\textwidth}
2652 \includestruct{listati/tm.h}
2655 \caption{La struttura \structd{tm} per una rappresentazione del tempo in
2656 termini di ora, minuti, secondi, ecc.}
2657 \label{fig:sys_tm_struct}
2660 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
2661 definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
2662 struttura che si utilizza quando si deve specificare un tempo a partire dai
2663 dati naturali (ora e data), dato che essa consente anche di tenere conto della
2664 gestione del fuso orario e dell'ora legale. In particolare gli ultimi due
2665 campi, \var{tm\_gmtoff} e \var{tm\_zone}, sono estensioni previste da BSD e
2666 supportate dalla \acr{glibc} quando è definita la macro \macro{\_BSD\_SOURCE}.
2668 Ciascuno dei campi di \struct{tm} ha dei precisi intervalli di valori
2669 possibili, con convenzioni purtroppo non troppo coerenti. Ad esempio
2670 \var{tm\_sec} che indica i secondi deve essere nell'intervallo da 0 a 59, ma è
2671 possibile avere anche il valore 60 per un cosiddetto \textit{leap second} (o
2672 \textsl{secondo intercalare}), cioè uno di quei secondi aggiunti al calcolo
2673 dell'orologio per effettuare gli aggiustamenti del calendario per tenere conto
2674 del disallineamento con il tempo solare.\footnote{per dettagli si consulti
2675 \url{http://it.wikipedia.org/wiki/Leap_second}.}
2677 I campi \var{tm\_min} e \var{tm\_hour} che indicano rispettivamente minuti ed
2678 ore hanno valori compresi rispettivamente fra 0 e 59 e fra 0 e 23. Il campo
2679 \var{tm\_mday} che indica il giorno del mese prevede invece un valore compreso
2680 fra 1 e 31, ma la \acr{glibc} supporta pure il valore 0 come indicazione
2681 dell'ultimo giorno del mese precedente. Il campo \var{tm\_mon} indica il mese
2682 dell'anno a partire da gennaio con valori compresi fra 0 e 11.
2684 I campi \var{tm\_wday} e \var{tm\_yday} indicano invece rispettivamente il
2685 giorno della settimana, a partire dalla Domenica, ed il giorno dell'anno, a
2686 partire del primo gennaio, ed hanno rispettivamente valori compresi fra 0 e 6
2687 e fra 0 e 365. L'anno espresso da \var{tm\_year} viene contato come numero di
2688 anni a partire dal 1900. Infine \var{tm\_isdst} è un valore che indica se per
2689 gli altri campi si intende come attiva l'ora legale ed influenza il
2690 comportamento di \func{mktime}.
2693 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2694 da quelle usate per convertire gli altri formati in questo, usando o meno
2695 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2696 tempo in una stringa contenente data ed ora. Le prime due funzioni,
2697 \funcd{asctime} e \funcd{ctime} servono per poter stampare in forma leggibile
2698 un tempo, i loro prototipi sono:
2702 \fdecl{char * asctime(const struct tm *tm)}
2703 \fdesc{Converte un \textit{broken-down time} in una stringa.}
2704 \fdecl{char * ctime(const time\_t *timep)}
2705 \fdesc{Converte un \textit{calendar time} in una stringa.}
2708 {Le funzioni ritornano un puntatore al risultato in caso di successo e
2709 \val{NULL} per un errore, \var{errno} non viene modificata.}
2712 Le funzioni prendono rispettivamente come argomenti i puntatori ad una
2713 struttura \struct{tm} contenente un \textit{broken-down time} o ad una
2714 variabile di tipo \type{time\_t} che esprime il \textit{calendar time},
2715 restituendo il puntatore ad una stringa che esprime la data, usando le
2716 abbreviazioni standard di giorni e mesi in inglese, nella forma:
2718 Sun Apr 29 19:47:44 2012\n"
2721 Nel caso di \func{ctime} la funzione tiene conto della eventuale impostazione
2722 di una \textit{timezone} e effettua una chiamata preventiva a \func{tzset}
2723 (che vedremo a breve), in modo che la data espressa tenga conto del fuso
2724 orario. In realtà \func{ctime} è banalmente definita in termini di
2725 \func{asctime} come \code{asctime(localtime(t))}.
2727 Dato che l'uso di una stringa statica rende le funzioni non rientranti
2728 POSIX.1c e SUSv2 prevedono due sostitute rientranti, il cui nome è al solito
2729 ottenuto aggiungendo un \code{\_r}, che prendono un secondo argomento
2730 \code{char *buf}, in cui l'utente deve specificare il buffer su cui la stringa
2731 deve essere copiata (deve essere di almeno 26 caratteri).
2733 Per la conversione fra \textit{broken-down time} e \textit{calendar time} sono
2734 invece disponibili altre tre funzioni, \funcd{gmtime}, \funcd{localtime} e
2735 \funcd{mktime} i cui prototipi sono:
2738 \fdecl{struct tm * gmtime(const time\_t *timep)}
2739 \fdesc{Converte un \textit{calendar time} in un \textit{broken-down time} in
2741 \fdecl{struct tm * localtime(const time\_t *timep)}
2742 \fdesc{Converte un \textit{calendar time} in un \textit{broken-down time}
2744 \fdecl{time\_t mktime(struct tm *tm)}
2745 \fdesc{Converte un \textit{broken-down time} in un \textit{calendar time}.}
2749 {Le funzioni ritornano un puntatore al risultato in caso di successo e
2750 \val{NULL} per un errore, tranne che \func{mktime} che restituisce
2751 direttamente il valore o $-1$ in caso di errore, \var{errno} non viene
2755 Le le prime funzioni, \func{gmtime}, \func{localtime} servono per convertire
2756 il tempo in \textit{calendar time} specificato da un argomento di tipo
2757 \type{time\_t} restituendo un \textit{broken-down time} con il puntatore ad
2758 una struttura \struct{tm}. La prima effettua la conversione senza tenere conto
2759 del fuso orario, esprimendo la data in tempo coordinato universale (UTC), cioè
2760 l'ora di Greenwich, mentre \func{localtime} usa l'ora locale e per questo
2761 effettua una chiamata preventiva a \func{tzset}.
2763 Anche in questo caso le due funzioni restituiscono l'indirizzo di una
2764 struttura allocata staticamente, per questo sono state definite anche altre
2765 due versioni rientranti (con la solita estensione \code{\_r}), che prevedono
2766 un secondo argomento \code{struct tm *result}, fornito dal chiamante, che deve
2767 preallocare la struttura su cui sarà restituita la conversione. La versione
2768 rientrante di \func{localtime} però non effettua la chiamata preventiva a
2769 \func{tzset} che deve essere eseguita a cura dell'utente.
2771 La funzione \func{mktime} esegue invece la conversione di un
2772 \textit{broken-down time} a partire da una struttura \struct{tm} restituendo
2773 direttamente un valore di tipo \type{time\_t} con il \textit{calendar
2774 time}. La funzione ignora i campi \var{tm\_wday} e \var{tm\_yday} e per gli
2775 altri campi normalizza eventuali valori fuori degli intervalli specificati in
2776 precedenza: se cioè si indica un 12 per \var{tm\_mon} si prenderà il gennaio
2777 dell'anno successivo.
2779 Inoltre la funzione tiene conto del valore di \var{tm\_isdst} per effettuare
2780 le correzioni relative al fuso orario: un valore positivo indica che deve
2781 essere tenuta in conto l'ora legale, un valore nullo che non deve essere
2782 applicata nessuna correzione, un valore negativo che si deve far ricorso alle
2783 informazioni relative al proprio fuso orario per determinare lo stato dell'ora
2786 La funzione infine modifica i valori della struttura \struct{tm} in forma di
2787 \textit{value result argument}, normalizzando i valori dei vari campi,
2788 impostando i valori risultanti per \var{tm\_wday} e \var{tm\_yday} e
2789 assegnando a \var{tm\_isdst} il valore (positivo o nullo) corrispondente allo
2790 stato dell'ora legale. La funzione provvede anche ad impostare il valore della
2791 variabile globale \var{tzname}.
2793 \itindend{calendar~time}
2795 Come accennato l'uso del \textit{broken-down time} permette di tenere conto
2796 anche della differenza fra tempo universale e ora locale, compresa l'eventuale
2797 ora legale. Questo viene fatto dalle funzioni di conversione grazie alle
2798 informazioni riguardo la propria \textit{timezone} mantenute nelle tre
2799 variabili globali mostrate in fig.~\ref{fig:sys_tzname}, cui si può accedere
2800 direttamente includendo \headfile{time.h}. Come illustrato queste variabili
2801 vengono impostate internamente da alcune delle precedenti funzioni di
2802 conversione, ma lo si può fare esplicitamente chiamando direttamente la
2803 funzione \funcd{tzset}, il cui prototipo è:
2807 \fdecl{void tzset(void)}
2808 \fdesc{Imposta le variabili globali della \textit{timezone}.}
2811 {La funzione non ritorna niente e non dà errori.}
2814 La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire
2815 dal valore della variabile di ambiente \envvar{TZ}, se quest'ultima non è
2816 definita verrà usato il file \conffiled{/etc/localtime}. La variabile
2817 \var{tzname} contiene due stringhe, che indicano i due nomi standard della
2818 \textit{timezone} corrente. La prima è il nome per l'ora solare, la seconda
2819 per l'ora legale. Anche se in fig.~\ref{fig:sys_tzname} sono indicate come
2820 \code{char *} non è il caso di modificare queste stringhe. La variabile
2821 \var{timezone} indica la differenza di fuso orario in secondi, mentre
2822 \var{daylight} indica se è attiva o meno l'ora legale.
2824 \begin{figure}[!htb]
2827 \begin{minipage}[c]{.75\textwidth}
2828 \includestruct{listati/time_zone_var.c}
2831 \caption{Le variabili globali usate per la gestione delle
2833 \label{fig:sys_tzname}
2836 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2837 stampare un tempo o una data, la flessibilità non fa parte delle sue
2838 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2839 giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
2844 \fdecl{size\_t strftime(char *s, size\_t max, const char *format,
2845 const struct tm *tm)}
2846 \fdesc{Crea una stringa con una data secondo il formato indicato.}
2849 {La funzione ritorna il numero di caratteri inseriti nella stringa \param{s}
2850 oppure $0$, \var{errno} non viene modificata.}
2854 La funzione converte il \textit{broken-down time} indicato nella struttura
2855 puntata dall'argomento \param{tm} in una stringa di testo da salvare
2856 all'indirizzo puntato dall'argomento \param{s}, purché essa sia di dimensione
2857 inferiore al massimo indicato dall'argomento \param{max}. Il numero di
2858 caratteri generati dalla funzione viene restituito come valore di ritorno,
2859 senza tener però conto del terminatore finale, che invece viene considerato
2860 nel computo della dimensione. Se quest'ultima è eccessiva viene restituito 0 e
2861 lo stato di \param{s} è indefinito.
2866 \begin{tabular}[c]{|c|l|p{6cm}|}
2868 \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2871 \var{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
2872 \var{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
2873 \var{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
2874 \var{\%B}&\texttt{April} & Nome del mese, completo.\\
2875 \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
2876 \var{\%d}&\texttt{24} & Giorno del mese.\\
2877 \var{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
2878 \var{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
2879 \var{\%j}&\texttt{114} & Giorno dell'anno.\\
2880 \var{\%m}&\texttt{04} & Mese dell'anno.\\
2881 \var{\%M}&\texttt{40} & Minuto.\\
2882 \var{\%p}&\texttt{PM} & AM/PM.\\
2883 \var{\%S}&\texttt{50} & Secondo.\\
2884 \var{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
2886 \var{\%w}&\texttt{3} & Giorno della settimana.\\
2887 \var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
2889 \var{\%x}&\texttt{04/24/02} & La data.\\
2890 \var{\%X}&\texttt{18:40:50} & L'ora.\\
2891 \var{\%y}&\texttt{02} & Anno nel secolo.\\
2892 \var{\%Y}&\texttt{2002} & Anno.\\
2893 \var{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
2894 \var{\%\%}&\texttt{\%} & Il carattere \%.\\
2897 \caption{Valori previsti dallo standard ANSI C per modificatore della
2898 stringa di formato di \func{strftime}.}
2899 \label{tab:sys_strftime_format}
2902 Il risultato della funzione è controllato dalla stringa di formato
2903 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2904 viene utilizzato come modificatore. Alcuni dei possibili valori che esso può
2905 assumere sono riportati in tab.~\ref{tab:sys_strftime_format}.\footnote{per la
2906 precisione si sono riportati quelli definiti dallo standard ANSI C che sono
2907 anche quelli ripresi in POSIX.1; la \acr{glibc} fornisce anche le estensioni
2908 introdotte da POSIX.2 per il comando \cmd{date}, i valori introdotti da
2909 SVID3 e ulteriori estensioni GNU; l'elenco completo dei possibili valori è
2910 riportato nella pagina di manuale della funzione.} La funzione tiene conto
2911 anche delle eventuali impostazioni di localizzazione per stampare i vari nomi
2912 in maniera adeguata alla lingua scelta, e con le convenzioni nazionali per i
2913 formati di data ed ora.
2915 Infine per effettuare l'operazione di conversione inversa, da una stringa ad
2916 un \textit{broken-down time}, si può utilizzare la funzione \funcd{strptime},
2921 \fdecl{char *strptime(const char *s, const char *format, struct tm *tm)}
2922 \fdesc{Converte una stringa con in un \textit{broken-down time} secondo un
2926 {La funzione ritorna il puntatore al primo carattere non processato della
2927 stringa o al terminatore finale qualora questa sia processata interamente,
2928 \var{errno} non viene modificata.}
2931 La funzione processa la stringa puntata dall'argomento \param{s} da sinistra a
2932 destra, utilizzando il formato contenuto nella stringa puntata
2933 dall'argomento \param{format}, avvalorando volta volta i corrispondenti campi
2934 della struttura puntata dall'argomento \param{tm}. La scansione si interrompe
2935 immediatamente in caso di mancata corrispondenza a quanto indicato nella
2936 stringa di formato, che usa una sintassi analoga a quella già vista per
2937 \func{strftime}. La funzione supporta i modificatori di
2938 tab.~\ref{tab:sys_strftime_format} più altre estensioni, ma per i dettagli a
2939 questo riguardo si rimanda alla lettura della pagina di manuale.
2941 Si tenga presente comunque che anche in caso di scansione completamente
2942 riuscita la funzione sovrascrive soltanto i campi di \param{tm} indicati dal
2943 formato, la struttura originaria infatti non viene inizializzata e gli altri
2944 campi restano ai valori che avevano in precedenza.
2947 \itindend{broken-down~time}
2949 \section{La gestione degli errori}
2950 \label{sec:sys_errors}
2952 In questa sezione esamineremo le caratteristiche principali della gestione
2953 degli errori in un sistema unix-like. Infatti a parte il caso particolare di
2954 alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
2955 unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
2956 un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
2957 semplicemente usando un opportuno valore di ritorno della funzione invocata.
2958 Inoltre il sistema di classificazione degli errori è stato progettato
2959 sull'architettura a processi, e presenta una serie di problemi nel caso lo si
2960 debba usare con i \textit{thread}.
2963 \subsection{La variabile \var{errno}}
2964 \label{sec:sys_errno}
2966 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2967 riportare condizioni di errore, ed è una norma fondamentale di buona
2968 programmazione controllare \textsl{sempre} che le funzioni chiamate si siano
2969 concluse correttamente.
2971 In genere le funzioni di libreria usano un valore speciale per indicare che
2972 c'è stato un errore. Di solito questo valore, a seconda della funzione, è $-1$
2973 o un puntatore nullo o la costante \val{EOF}; ma questo valore segnala solo
2974 che c'è stato un errore, e non il tipo di errore.
2976 Per riportare il tipo di errore il sistema usa la variabile globale
2977 \var{errno}, definita nell'header \headfile{errno.h}. Come accennato l'uso di
2978 una variabile globale può comportare problemi nel caso dei \textit{thread}, ma
2979 lo standard ISO C consente anche di definire \var{errno} come un cosiddetto
2980 ``\textit{modifiable lvalue}'', cosa che consente di usare anche una macro, e
2981 questo è infatti il metodo usato da Linux per renderla locale ai singoli
2984 La variabile è in genere definita come \dirct{volatile} dato che può essere
2985 cambiata in modo asincrono da un segnale; per un esempio si veda
2986 sez.~\ref{sec:sig_sigchld} ricordando quanto trattato in
2987 sez.~\ref{sec:proc_race_cond}. Dato che un gestore di segnale scritto bene si
2988 cura di salvare e ripristinare il valore della variabile all'uscita, nella
2989 programmazione normale, quando si può fare l'assunzione che i gestori di
2990 segnali siano ben scritti, di questo non è necessario preoccuparsi.
2992 I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
2993 nell'header \headfile{errno.h} sono anche definiti i nomi simbolici per le
2994 costanti numeriche che identificano i vari errori che abbiamo citato fin
2995 dall'inizio nelle descrizioni delle funzioni. Essi iniziano tutti per \val{E}
2996 e si possono considerare come nomi riservati, per questo abbiamo sempre fatto
2997 riferimento a questi nomi, e lo faremo più avanti quando descriveremo i
2998 possibili errori restituiti dalle funzioni. Il programma di esempio
2999 \cmd{errcode} stampa il codice relativo ad un valore numerico con l'opzione
3002 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
3003 programma, e la gran parte delle funzioni di libreria impostano \var{errno} ad
3004 un valore diverso da zero in caso di errore. Il valore è invece indefinito in
3005 caso di successo, perché anche se una funzione di libreria ha successo,
3006 potrebbe averne chiamate altre al suo interno che potrebbero essere fallite
3007 anche senza compromettere il risultato finale, modificando però \var{errno}.
3009 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
3010 essere il risultato di un errore precedente) e non lo si può usare per
3011 determinare quando o se una chiamata a funzione è fallita. La procedura
3012 corretta da seguire per identificare un errore è sempre quella di controllare
3013 \var{errno} immediatamente dopo aver verificato il fallimento della funzione
3014 attraverso il suo codice di ritorno.
3017 \subsection{Le funzioni \func{strerror} e \func{perror}}
3018 \label{sec:sys_strerror}
3020 Benché gli errori siano identificati univocamente dal valore numerico di
3021 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
3022 riportare in opportuni messaggi le condizioni di errore verificatesi. La
3023 prima funzione che si può usare per ricavare i messaggi di errore è
3024 \funcd{strerror}, il cui prototipo è:
3028 \fdecl{char *strerror(int errnum)}
3029 \fdesc{Restituisce una stringa con un messaggio di errore.}
3032 {La funzione ritorna il puntatore alla stringa con il messaggio di errore,
3033 \var{errno} non viene modificato.}
3036 La funzione ritorna il puntatore alla stringa contenente il messaggio di
3037 errore corrispondente al valore di \param{errnum}, se questo non è un valore
3038 valido verrà comunque restituita una stringa valida contenente un messaggio
3039 che dice che l'errore è sconosciuto nella forma. La versione della \acr{glibc}
3040 non modifica il valore di \var{errno} in caso di errore, ma questo non è detto
3041 valga per altri sistemi in quanto lo standard POSIX.1-2001 permette che ciò
3042 avvenga. Non si faccia affidamento su questa caratteristica se si vogliono
3043 scrivere programmi portabili.
3045 In generale \func{strerror} viene usata passando direttamente \var{errno} come
3046 argomento, ed il valore di quest'ultima non verrà modificato. La funzione
3047 inoltre tiene conto del valore della variabile di ambiente
3048 \envvar{LC\_MESSAGES} per usare le appropriate traduzioni dei messaggi
3049 d'errore nella localizzazione presente.
3051 La funzione \func{strerror} utilizza una stringa statica che non deve essere
3052 modificata dal programma; essa è utilizzabile solo fino ad una chiamata
3053 successiva a \func{strerror} o \func{perror} e nessun'altra funzione di
3054 libreria tocca questa stringa. In ogni caso l'uso di una stringa statica rende
3055 la funzione non rientrante, per cui nel caso si usino i \textit{thread} la
3056 \acr{glibc} fornisce una apposita versione rientrante \funcd{strerror\_r}, il
3061 \fdecl{char * strerror\_r(int errnum, char *buf, size\_t size)}
3062 \fdesc{Restituisce una stringa con un messaggio di errore.}
3065 {La funzione ritorna l'indirizzo del messaggio in caso di successo e
3066 \val{NULL} per un errore, nel qual caso \var{errno} assumerà uno dei valori:
3068 \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
3070 \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
3071 contenere la stringa di errore.
3076 Si tenga presente che questa è la versione prevista normalmente nella
3077 \acr{glibc}, ed effettivamente definita in \headfile{string.h}, ne esiste una
3078 analoga nello standard SUSv3 (riportata anche nella pagina di manuale), che
3079 restituisce \code{int} al posto di \code{char *}, e che tronca la stringa
3080 restituita a \param{size}, a cui si accede definendo le opportune macro (per
3081 le quali si rimanda alla lettura della pagina di manuale).
3083 La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
3084 nel buffer \param{buf} che il singolo \textit{thread} deve allocare
3085 autonomamente per evitare i problemi connessi alla condivisione del buffer
3086 statico. Il messaggio è copiato fino alla dimensione massima del buffer,
3087 specificata dall'argomento \param{size}, che deve comprendere pure il
3088 carattere di terminazione; altrimenti la stringa risulterà troncata.
3090 Una seconda funzione usata per riportare i codici di errore in maniera
3091 automatizzata sullo standard error è \funcd{perror}, il cui prototipo è:
3095 \fdecl{void perror(const char *message)}
3096 \fdesc{Stampa un messaggio di errore personalizzato.}
3099 {La funzione non ritorna nulla e non modifica \var{errno}.}
3103 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
3104 in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
3105 riferiscono all'ultimo errore avvenuto. La stringa specificata con
3106 \param{message} viene stampata prima del messaggio d'errore, consentono una
3107 personalizzazione (ad esempio l'indicazione del contesto in cui si è
3108 verificato), seguita dai due punti e da uno spazio, il messaggio è terminato
3109 con un a capo. Il messaggio può essere riportato anche usando le due
3111 \includecodesnip{listati/errlist.c}
3112 dichiarate in \headfile{errno.h}. La prima contiene i puntatori alle stringhe
3113 di errore indicizzati da \var{errno}; la seconda esprime il valore più alto
3114 per un codice di errore, l'utilizzo di una di queste stringhe è
3115 sostanzialmente equivalente a quello di \func{strerror}, ma dato che non è
3116 detto che \var{sys\_errlist} sia stato aggiornato in caso di aggiunta di nuovi
3117 errori, il suo uso è deprecato e si deve sempre usare \func{perror}.
3119 \begin{figure}[!htbp]
3120 \footnotesize \centering
3121 \begin{minipage}[c]{\codesamplewidth}
3122 \includecodesample{listati/errcode_mess.c}
3125 \caption{Codice per la stampa del messaggio di errore standard.}
3126 \label{fig:sys_err_mess}
3129 In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
3130 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
3131 errore e le costanti usate per identificare i singoli errori. Il sorgente
3132 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
3133 gestione delle opzioni e tutte le definizioni necessarie ad associare il
3134 valore numerico alla costante simbolica. In particolare si è riportata la
3135 sezione che converte la stringa passata come argomento in un intero
3136 (\texttt{\small 1-2}), controllando con i valori di ritorno di \funcm{strtol}
3137 che la conversione sia avvenuta correttamente (\texttt{\small 4-10}), e poi
3138 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
3139 11-14}) o la macro (\texttt{\small 15-17}) associate a quel codice.
3143 \subsection{Alcune estensioni GNU}
3144 \label{sec:sys_err_GNU}
3146 Le precedenti funzioni sono quelle definite ed usate nei vari standard; la
3147 \acr{glibc} ha però introdotto una serie di estensioni ``GNU'' che
3148 forniscono alcune funzionalità aggiuntive per una gestione degli errori
3149 semplificata e più efficiente.
3151 La prima estensione consiste in due variabili, \code{char *
3152 program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
3153 che consentono di ricavare il nome del proprio programma. Queste sono utili
3154 quando si deve aggiungere il nome del programma al messaggio d'errore, cosa
3155 comune quando si ha un programma che non viene lanciato da linea di comando e
3156 salva gli errori in un file di log. La prima contiene il nome usato per
3157 lanciare il programma dalla shell ed in sostanza è equivalente ad
3158 \code{argv[0]}; la seconda mantiene solo il nome del programma eliminando
3159 eventuali directory qualora questo sia stato lanciato con un
3162 Una seconda estensione cerca di risolvere uno dei problemi che si hanno con
3163 l'uso di \func{perror}, dovuto al fatto che non c'è flessibilità su quello che
3164 si può aggiungere al messaggio di errore, che può essere solo una stringa. In
3165 molte occasioni invece serve poter scrivere dei messaggi con maggiori
3166 informazioni. Ad esempio negli standard di programmazione GNU si richiede che
3167 ogni messaggio di errore sia preceduto dal nome del programma, ed in generale
3168 si può voler stampare il contenuto di qualche variabile per facilitare la
3169 comprensione di un eventuale problema. Per questo la \acr{glibc} definisce
3170 la funzione \funcd{error}, il cui prototipo è:
3174 \fdecl{void error(int status, int errnum, const char *format, ...)}
3175 \fdesc{Stampa un messaggio di errore formattato.}
3178 {La funzione non ritorna nulla e non riporta errori.}
3181 La funzione fa parte delle estensioni GNU per la gestione degli errori,
3182 l'argomento \param{format} segue la stessa sintassi di \func{printf} (vedi
3183 sez.~\ref{sec:file_formatted_io}), ed i relativi argomenti devono essere
3184 forniti allo stesso modo, mentre \param{errnum} indica l'errore che si vuole
3185 segnalare (non viene quindi usato il valore corrente di \var{errno}).
3187 La funzione stampa sullo \textit{standard error} il nome del programma, come
3188 indicato dalla variabile globale \var{program\_name}, seguito da due punti ed
3189 uno spazio, poi dalla stringa generata da \param{format} e dagli argomenti
3190 seguenti, seguita da due punti ed uno spazio infine il messaggio di errore
3191 relativo ad \param{errnum}, il tutto è terminato da un a capo.
3193 Il comportamento della funzione può essere ulteriormente controllato se si
3194 definisce una variabile \var{error\_print\_progname} come puntatore ad una
3195 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
3196 il nome del programma.
3198 L'argomento \param{status} può essere usato per terminare direttamente il
3199 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
3200 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
3201 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
3202 un'altra variabile globale, \var{error\_message\_count}, che tiene conto di
3203 quanti errori ci sono stati.
3205 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
3206 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
3207 l'errore è \funcd{error\_at\_line}; il suo prototipo è:
3211 \fdecl{void error\_at\_line(int status, int errnum, const char *fname,
3212 unsigned int lineno, \\
3213 \phantom{void error\_at\_line(}const char *format, ...)}
3214 \fdesc{Stampa un messaggio di errore formattato.}
3217 {La funzione non ritorna nulla e non riporta errori.}
3220 \noindent ed il suo comportamento è identico a quello di \func{error} se non
3221 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
3222 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
3223 stampa del nome del programma. Inoltre essa usa un'altra variabile globale,
3224 \var{error\_one\_per\_line}, che impostata ad un valore diverso da zero fa sì
3225 che errori relativi alla stessa linea non vengano ripetuti.
3228 % LocalWords: filesystem like kernel saved header limits sysconf sez tab float
3229 % LocalWords: FOPEN stdio MB LEN CHAR char UCHAR unsigned SCHAR MIN signed INT
3230 % LocalWords: SHRT short USHRT int UINT LONG long ULONG LLONG ULLONG POSIX ARG
3231 % LocalWords: Stevens exec CHILD STREAM stream TZNAME timezone NGROUPS SSIZE
3232 % LocalWords: ssize LISTIO JOB CONTROL job control IDS VERSION YYYYMML bits bc
3233 % LocalWords: dall'header posix lim nell'header glibc run unistd name errno SC
3234 % LocalWords: NGROUP CLK TCK clock tick process PATH pathname BUF CANON path
3235 % LocalWords: pathconf fpathconf descriptor fd uname sys struct utsname info
3236 % LocalWords: EFAULT fig SOURCE NUL LENGTH DOMAIN NMLN UTSLEN system call proc
3237 % LocalWords: domainname sysctl BSD nlen void oldval size oldlenp newval EPERM
3238 % LocalWords: newlen ENOTDIR EINVAL ENOMEM linux array oldvalue paging stack
3239 % LocalWords: TCP shell Documentation ostype hostname osrelease version mount
3240 % LocalWords: const source filesystemtype mountflags ENODEV ENOTBLK block read
3241 % LocalWords: device EBUSY only EACCES NODEV ENXIO major RTSIG syscall PID
3242 % LocalWords: number EMFILE dummy ENAMETOOLONG ENOENT ELOOP virtual devfs MGC
3243 % LocalWords: magic MSK RDONLY NOSUID suid sgid NOEXEC SYNCHRONOUS REMOUNT MNT
3244 % LocalWords: MANDLOCK mandatory locking WRITE APPEND append IMMUTABLE NOATIME
3245 % LocalWords: access NODIRATIME BIND MOVE umount flags FORCE statfs fstatfs ut
3246 % LocalWords: buf ENOSYS EIO EBADF type fstab mntent home shadow username uid
3247 % LocalWords: passwd PAM Pluggable Authentication Method Service Switch pwd ru
3248 % LocalWords: getpwuid getpwnam NULL buflen result ERANGE getgrnam getgrgid AS
3249 % LocalWords: grp group gid SVID fgetpwent putpwent getpwent setpwent endpwent
3250 % LocalWords: fgetgrent putgrent getgrent setgrent endgrent accounting init HZ
3251 % LocalWords: runlevel Hierarchy logout setutent endutent utmpname utmp paths
3252 % LocalWords: WTMP getutent getutid getutline pututline LVL OLD DEAD EMPTY dev
3253 % LocalWords: line libc XPG utmpx getutxent getutxid getutxline pututxline who
3254 % LocalWords: setutxent endutxent wmtp updwtmp logwtmp wtmp host rusage utime
3255 % LocalWords: minflt majflt nswap fault swap timeval wait getrusage usage SELF
3256 % LocalWords: CHILDREN current limit soft RLIMIT address brk mremap mmap dump
3257 % LocalWords: SIGSEGV SIGXCPU SIGKILL sbrk FSIZE SIGXFSZ EFBIG LOCKS lock dup
3258 % LocalWords: MEMLOCK NOFILE NPROC fork EAGAIN SIGPENDING sigqueue kill RSS tv
3259 % LocalWords: resource getrlimit setrlimit rlimit rlim INFINITY capabilities
3260 % LocalWords: capability CAP Sun Sparc PAGESIZE getpagesize SVr SUSv get IGN
3261 % LocalWords: phys pages avphys NPROCESSORS CONF ONLN getloadavg stdlib double
3262 % LocalWords: loadavg nelem scheduler CONFIG ACCT acct filename EUSER sizeof
3263 % LocalWords: ENFILE EROFS PACCT AcctCtrl cap calendar UTC Jan the Epoch GMT
3264 % LocalWords: Greenwich Mean l'UTC timer CLOCKS SEC cron wall elapsed times tz
3265 % LocalWords: tms cutime cstime waitpid gettimeofday settimeofday timex NetBSD
3266 % LocalWords: timespec adjtime olddelta adjtimex David Mills RFC NTP ntp cmd
3267 % LocalWords: nell'RFC ADJ FREQUENCY frequency MAXERROR maxerror ESTERROR PLL
3268 % LocalWords: esterror TIMECONST constant SINGLESHOT MOD INS insert leap OOP
3269 % LocalWords: second delete progress has occurred BAD broken tm gmtoff asctime
3270 % LocalWords: ctime timep gmtime localtime mktime tzname tzset daylight format
3271 % LocalWords: strftime thread EOF modifiable lvalue app errcode strerror LC at
3272 % LocalWords: perror string errnum MESSAGES error message strtol log jiffy asm
3273 % LocalWords: program invocation argv printf print progname exit count fname
3274 % LocalWords: lineno one standardese Di page Wed Wednesday Apr April PM AM CAD
3275 % LocalWords: CEST utmpxname Solaris updwtmpx reboot RESTART Ctrl OFF SIGINT
3276 % LocalWords: HALT halted sync KEXEC kexec load bootloader POWER Power with nr
3277 % LocalWords: Restarting command arg entry segments segment ARCH CRASH CONTEXT
3278 % LocalWords: PRESERVE PPC IA ARM SH MIPS nvcsw nivcsw inblock oublock maxrss
3279 % LocalWords: context switch slice Resident SIG SIGCHLD cur Gb lease mlock Hz
3280 % LocalWords: memory mlockall MAP LOCKED shmctl MSGQUEUE attr NICE nice MADV
3281 % LocalWords: madvise WILLNEED RTPRIO sched setscheduler setparam scheduling
3282 % LocalWords: RTTIME execve kb prlimit pid new old ESRCH EUSERS refresh high
3283 % LocalWords: resolution HRT jiffies strptime pre l'I value argument
3285 %%% Local Variables:
3287 %%% TeX-master: "gapil"