3 %% Copyright (C) 2000-2015 Simone Piccardi. Permission is granted to
4 %% copy, distribute and/or modify this document under the terms of the GNU Free
5 %% Documentation License, Version 1.1 or any later version published by the
6 %% Free Software Foundation; with the Invariant Sections being "Un preambolo",
7 %% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the
8 %% license is included in the section entitled "GNU Free Documentation
12 \chapter{La gestione del sistema, del tempo e degli errori}
15 In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
16 generali del sistema, come quelle per la gestione dei parametri e della
17 configurazione dello stesso, quelle per la lettura dei limiti e delle
18 caratteristiche, quelle per il controllo dell'uso delle risorse dei processi,
19 quelle per la gestione ed il controllo dei filesystem, degli utenti, dei tempi
23 \section{La gestione di caratteristiche e parametri del sistema}
24 \label{sec:sys_characteristics}
26 In questa sezione tratteremo le varie modalità con cui un programma può
27 ottenere informazioni riguardo alle capacità del sistema, e, per quelle per
28 cui è possibile, sul come modificarle. Ogni sistema unix-like infatti è
29 contraddistinto da un gran numero di limiti e costanti che lo caratterizzano,
30 e che possono dipendere da fattori molteplici, come l'architettura hardware,
31 l'implementazione del kernel e delle librerie, le opzioni di
32 configurazione. Il kernel inoltre mette a disposizione l'accesso ad alcuni
33 parametri che possono modificarne il comportamento.
35 La definizione di queste caratteristiche ed il tentativo di provvedere dei
36 meccanismi generali che i programmi possono usare per ricavarle è uno degli
37 aspetti più complessi e controversi con cui le diverse standardizzazioni si
38 sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
39 Daremo comunque una descrizione dei principali metodi previsti dai vari
40 standard per ricavare sia le caratteristiche specifiche del sistema, che
41 quelle della gestione dei file e prenderemo in esame le modalità con cui è
42 possibile intervenire sui parametri del kernel.
44 \subsection{Limiti e caratteristiche del sistema}
45 \label{sec:sys_limits}
47 Quando si devono determinare le caratteristiche generali del sistema ci si
48 trova di fronte a diverse possibilità; alcune di queste infatti possono
49 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
50 interi), o dal sistema operativo (come la presenza o meno del gruppo degli
51 identificatori \textit{saved}), altre invece possono dipendere dalle opzioni
52 con cui si è costruito il sistema (ad esempio da come si è compilato il
53 kernel), o dalla configurazione del medesimo; per questo motivo in generale
54 sono necessari due tipi diversi di funzionalità:
56 \item la possibilità di determinare limiti ed opzioni al momento della
58 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
61 La prima funzionalità si può ottenere includendo gli opportuni header file che
62 contengono le costanti necessarie definite come macro di preprocessore, per la
63 seconda invece sono ovviamente necessarie delle funzioni. La situazione è
64 complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
65 sono fissi in un'implementazione mentre possono variare in un altra: tutto
66 questo crea una ambiguità che non è sempre possibile risolvere in maniera
67 chiara. In generale quello che succede è che quando i limiti del sistema sono
68 fissi essi vengono definiti come macro di preprocessore nel file
69 \headfile{limits.h}, se invece possono variare, il loro valore sarà ottenibile
70 tramite la funzione \func{sysconf} (che esamineremo a breve).
75 \begin{tabular}[c]{|l|r|l|}
77 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
80 \const{MB\_LEN\_MAX}& 16 & Massima dimensione di un
82 \const{CHAR\_BIT} & 8 & Numero di bit di \ctyp{char}.\\
83 \const{UCHAR\_MAX}& 255 & Massimo di \ctyp{unsigned char}.\\
84 \const{SCHAR\_MIN}& -128 & Minimo di \ctyp{signed char}.\\
85 \const{SCHAR\_MAX}& 127 & Massimo di \ctyp{signed char}.\\
86 \const{CHAR\_MIN} & 0 o -128 & Minimo di \ctyp{char}.\footnotemark\\
87 \const{CHAR\_MAX} & 127 o 255 & Massimo di \ctyp{char}.\footnotemark\\
88 \const{SHRT\_MIN} & -32768 & Minimo di \ctyp{short}.\\
89 \const{SHRT\_MAX} & 32767 & Massimo di \ctyp{short}.\\
90 \const{USHRT\_MAX}& 65535 & Massimo di \ctyp{unsigned short}.\\
91 \const{INT\_MAX} & 2147483647 & Minimo di \ctyp{int}.\\
92 \const{INT\_MIN} &-2147483648 & Minimo di \ctyp{int}.\\
93 \const{UINT\_MAX} & 4294967295 & Massimo di \ctyp{unsigned int}.\\
94 \const{LONG\_MAX} & 2147483647 & Massimo di \ctyp{long}.\\
95 \const{LONG\_MIN} &-2147483648 & Minimo di \ctyp{long}.\\
96 \const{ULONG\_MAX}& 4294967295 & Massimo di \ctyp{unsigned long}.\\
99 \caption{Costanti definite in \headfile{limits.h} in conformità allo standard
101 \label{tab:sys_ansic_macro}
104 \footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
105 sistema usi caratteri con segno o meno.}
107 \footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
108 a seconda che il sistema usi caratteri con segno o meno.}
110 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
111 saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
112 da \headfile{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si
113 può vedere per la maggior parte questi limiti attengono alle dimensioni dei
114 dati interi, che sono in genere fissati dall'architettura hardware, le
115 analoghe informazioni per i dati in virgola mobile sono definite a parte, ed
116 accessibili includendo \headfile{float.h}.
121 \begin{tabular}[c]{|l|r|l|}
123 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
126 \const{LLONG\_MAX}& 9223372036854775807& Massimo di \ctyp{long long}.\\
127 \const{LLONG\_MIN}&-9223372036854775808& Minimo di \ctyp{long long}.\\
128 \const{ULLONG\_MAX}&18446744073709551615&
129 Massimo di \ctyp{unsigned long long}.\\
132 \caption{Macro definite in \headfile{limits.h} in conformità allo standard
134 \label{tab:sys_isoc90_macro}
137 Lo standard prevede anche un'altra costante, \const{FOPEN\_MAX}, che può non
138 essere fissa e che pertanto non è definita in \headfile{limits.h}, essa deve
139 essere definita in \headfile{stdio.h} ed avere un valore minimo di 8. A questi
140 valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo \ctyp{long
141 long} introdotto con il nuovo standard, i relativi valori sono in
142 tab.~\ref{tab:sys_isoc90_macro}.
144 Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
145 delle caratteristiche del sistema; mancano completamente tutte quelle che
146 dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
147 sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
148 limiti relativi alle caratteristiche dei file che vedremo in
149 sez.~\ref{sec:sys_file_limits}.
154 \begin{tabular}[c]{|l|r|p{8cm}|}
156 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
159 \const{ARG\_MAX} &131072& Dimensione massima degli argomenti
160 passati ad una funzione della famiglia
162 \const{CHILD\_MAX} & 999& Numero massimo di processi contemporanei
163 che un utente può eseguire.\\
164 \const{OPEN\_MAX} & 256& Numero massimo di file che un processo
165 può mantenere aperti in contemporanea.\\
166 \const{STREAM\_MAX}& 8& Massimo numero di stream aperti per
167 processo in contemporanea.\\
168 \const{TZNAME\_MAX}& 6& Dimensione massima del nome di una
169 \itindex{timezone} \textit{timezone} (vedi
170 sez.~\ref{sec:sys_time_base})).\\
171 \const{NGROUPS\_MAX}& 32& Numero di gruppi supplementari per
172 processo (vedi sez.~\ref{sec:proc_access_id}).\\
173 \const{SSIZE\_MAX}&32767& Valore massimo del tipo \type{ssize\_t}.\\
176 \caption{Costanti per i limiti del sistema.}
177 \label{tab:sys_generic_macro}
180 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
181 meno chiare, tanto che Stevens, in \cite{APUE}, la porta come esempio di
182 ``\textsl{standardese}''. Lo standard prevede che ci siano 13 macro che
183 descrivono le caratteristiche del sistema: 7 per le caratteristiche generiche,
184 riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
185 file, riportate in tab.~\ref{tab:sys_file_macro}.
190 \begin{tabular}[c]{|l|r|p{8cm}|}
192 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
195 \const{\_POSIX\_ARG\_MAX} & 4096& Dimensione massima degli argomenti
196 passati ad una funzione della famiglia
198 \const{\_POSIX\_CHILD\_MAX} & 6& Numero massimo di processi
199 contemporanei che un utente può
201 \const{\_POSIX\_OPEN\_MAX} & 16& Numero massimo di file che un processo
202 può mantenere aperti in
204 \const{\_POSIX\_STREAM\_MAX} & 8& Massimo numero di stream aperti per
205 processo in contemporanea.\\
206 \const{\_POSIX\_TZNAME\_MAX} & 6& Dimensione massima del nome di una
207 \itindex{timezone} \textit{timezone}
208 (vedi sez.~\ref{sec:sys_date}). \\
209 \const{\_POSIX\_RTSIG\_MAX} & 8& Numero massimo di segnali
210 \textit{real-time} (vedi
211 sez.~\ref{sec:sig_real_time}).\\
212 \const{\_POSIX\_NGROUPS\_MAX}& 0& Numero di gruppi supplementari per
214 sez.~\ref{sec:proc_access_id}).\\
215 \const{\_POSIX\_SSIZE\_MAX} &32767& Valore massimo del tipo
217 % \const{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
218 % \const{\_POSIX\_AIO\_MAX} & 1& \\
221 \caption{Macro dei valori minimi di alcune caratteristiche generali del
222 sistema per la conformità allo standard POSIX.1.}
223 \label{tab:sys_posix1_general}
226 Lo standard dice che queste macro devono essere definite in
227 \headfile{limits.h} quando i valori a cui fanno riferimento sono fissi, e
228 altrimenti devono essere lasciate indefinite, ed i loro valori dei limiti
229 devono essere accessibili solo attraverso \func{sysconf}. In realtà queste
230 vengono sempre definite ad un valore generico. Si tenga presente poi che
231 alcuni di questi limiti possono assumere valori molto elevati (come
232 \const{CHILD\_MAX}), e non è pertanto il caso di utilizzarli per allocare
233 staticamente della memoria.
235 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
236 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
237 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
238 implementazione possa dichiararsi conforme allo standard, alcuni dei questi
239 valori sono riportati in tab.~\ref{tab:sys_posix1_general}.
241 In genere questi valori non servono a molto, la loro unica utilità è quella di
242 indicare un limite superiore che assicura la portabilità senza necessità di
243 ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
244 i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
245 valori ottenuti da \func{sysconf}.
250 \begin{tabular}[c]{|l|p{8cm}|}
252 \textbf{Macro}&\textbf{Significato}\\
255 \macro{\_POSIX\_JOB\_CONTROL}& Il sistema supporta il
256 \textit{job control} (vedi
257 sez.~\ref{sec:sess_job_control}).\\
258 \macro{\_POSIX\_SAVED\_IDS} & Il sistema supporta gli identificatori del
259 gruppo \textit{saved} (vedi
260 sez.~\ref{sec:proc_access_id})
261 per il controllo di accesso dei processi.\\
262 \const{\_POSIX\_VERSION} & Fornisce la versione dello standard POSIX.1
263 supportata nel formato YYYYMML (ad esempio
267 \caption{Alcune macro definite in \headfile{limits.h} in conformità allo
269 \label{tab:sys_posix1_other}
272 Oltre ai precedenti valori e a quelli relativi ai file elencati in
273 tab.~\ref{tab:sys_posix1_file},, che devono essere obbligatoriamente definiti,
274 lo standard POSIX.1 ne prevede molti altri. La lista completa si trova
275 dall'header file \file{bits/posix1\_lim.h}, da non usare mai direttamente (è
276 incluso automaticamente all'interno di \headfile{limits.h}). Di questi vale la
277 pena menzionarne alcune macro di uso comune, riportate in
278 tab.~\ref{tab:sys_posix1_other}, che non indicano un valore specifico, ma
279 denotano la presenza di alcune funzionalità nel sistema, come il supporto del
280 \textit{job control} o degli identificatori del gruppo \textit{saved}.
282 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
283 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
284 alle applicazioni di sistema presenti, come quelli su alcuni parametri delle
285 espressioni regolari o del comando \cmd{bc}, non li tratteremo esplicitamente,
286 se ne trova una menzione completa nell'header file \file{bits/posix2\_lim.h},
287 e alcuni di loro sono descritti nella pagina di manuale di \func{sysconf} e
288 nel manuale delle \acr{glibc}.
290 Quando uno dei limiti o delle caratteristiche del sistema può variare, per non
291 dover essere costretti a ricompilare un programma tutte le volte che si
292 cambiano le opzioni con cui è compilato il kernel, o alcuni dei parametri
293 modificabili al momento dell'esecuzione, è necessario ottenerne il valore
294 attraverso la funzione \funcd{sysconf}, cui prototipo è:
298 \fdecl{long sysconf(int name)}
299 \fdesc{Restituisce il valore di un parametro di sistema.}
302 {La funzione ritorna in caso di successo il valore del parametro richiesto, o
303 1 se si tratta di un'opzione disponibile, 0 se l'opzione non è disponibile e
304 $-1$ per un errore, nel qual caso però \var{errno} non viene impostata.}
307 La funzione prende come argomento un intero che specifica quale dei limiti si
308 vuole conoscere. Uno specchietto contenente i principali valori disponibili in
309 Linux è riportato in tab.~\ref{tab:sys_sysconf_par}, l'elenco completo è
310 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
311 relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
316 \begin{tabular}[c]{|l|l|p{8cm}|}
318 \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
321 \texttt{\_SC\_ARG\_MAX} & \const{ARG\_MAX}&
322 La dimensione massima degli argomenti passati
323 ad una funzione della famiglia \func{exec}.\\
324 \texttt{\_SC\_CHILD\_MAX} & \const{CHILD\_MAX}&
325 Il numero massimo di processi contemporanei
326 che un utente può eseguire.\\
327 \texttt{\_SC\_OPEN\_MAX} & \const{OPEN\_MAX}&
328 Il numero massimo di file che un processo può
329 mantenere aperti in contemporanea.\\
330 \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
331 Il massimo numero di stream che un processo
332 può mantenere aperti in contemporanea. Questo
333 limite previsto anche dallo standard ANSI C,
334 che specifica la macro {FOPEN\_MAX}.\\
335 \texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
336 La dimensione massima di un nome di una
337 \itindex{timezone} \texttt{timezone} (vedi
338 sez.~\ref{sec:sys_date}).\\
339 \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
340 Massimo numero di gruppi supplementari che
341 può avere un processo (vedi
342 sez.~\ref{sec:proc_access_id}).\\
343 \texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}&
344 Valore massimo del tipo di dato
346 \texttt{\_SC\_CLK\_TCK} & \const{CLK\_TCK} &
347 Il numero di \itindex{clock~tick}
348 \textit{clock tick} al secondo,
349 cioè l'unità di misura del
350 \itindex{process~time} \textit{process
352 sez.~\ref{sec:sys_unix_time}).\\
353 \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
354 Indica se è supportato il \textit{job
356 sez.~\ref{sec:sess_job_control}) in stile
358 \texttt{\_SC\_SAVED\_IDS} & \macro{\_POSIX\_SAVED\_IDS}&
359 Indica se il sistema supporta i
360 \textit{saved id} (vedi
361 sez.~\ref{sec:proc_access_id}).\\
362 \texttt{\_SC\_VERSION} & \const{\_POSIX\_VERSION} &
363 Indica il mese e l'anno di approvazione
364 della revisione dello standard POSIX.1 a cui
365 il sistema fa riferimento, nel formato
366 YYYYMML, la revisione più recente è 199009L,
367 che indica il Settembre 1990.\\
370 \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
371 \label{tab:sys_sysconf_par}
374 In generale ogni limite o caratteristica del sistema per cui è definita una
375 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
376 essere ottenuto attraverso una chiamata a \func{sysconf}. Il nome della
377 costante da utilizzare come valore dell'argomento \param{name} si otterrà
378 aggiungendo \code{\_SC\_} ai nomi delle costanti definite dai primi due
379 standard (quelle di tab.~\ref{tab:sys_generic_macro}), o sostituendolo a
380 \code{\_POSIX\_} per le costanti definite dagli altri due standard (quelle di
381 tab.~\ref{tab:sys_posix1_general}).
383 In linea teorica si dovrebbe fare uso di \func{sysconf} solo quando la
384 relativa costante di sistema non è definita, quindi con un codice analogo al
386 \includecodesnip{listati/get_child_max.c}
387 ma in realtà con Linux queste costanti sono comunque definite, indicando però
388 un limite generico che non è detto sia corretto; per questo motivo è sempre
389 meglio usare i valori restituiti da \func{sysconf}.
392 \subsection{Limiti e caratteristiche dei file}
393 \label{sec:sys_file_limits}
395 Come per le caratteristiche generali del sistema anche per i file esistono una
396 serie di limiti (come la lunghezza del nome del file o il numero massimo di
397 link) che dipendono sia dall'implementazione che dal filesystem in uso. Anche
398 in questo caso lo standard prevede alcune macro che ne specificano il valore,
399 riportate in tab.~\ref{tab:sys_file_macro}.
404 \begin{tabular}[c]{|l|r|l|}
406 \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
409 \const{LINK\_MAX} &8 & Numero massimo di link a un file.\\
410 \const{NAME\_MAX}& 14 & Lunghezza in byte di un nome di file. \\
411 \const{PATH\_MAX}& 256 & Lunghezza in byte di un \textit{pathname}.\\
412 \const{PIPE\_BUF}&4096 & Byte scrivibili atomicamente in una pipe
413 (vedi sez.~\ref{sec:ipc_pipes}).\\
414 \const{MAX\_CANON}&255 & Dimensione di una riga di terminale in modo
415 canonico (vedi sez.~\ref{sec:term_io_design}).\\
416 \const{MAX\_INPUT}&255 & Spazio disponibile nella coda di input
418 sez.~\ref{sec:term_io_design}).\\
421 \caption{Costanti per i limiti sulle caratteristiche dei file.}
422 \label{tab:sys_file_macro}
425 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
426 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
427 conforme deve rispettare. Le relative macro sono riportate in
428 tab.~\ref{tab:sys_posix1_file} e per esse vale lo stesso discorso fatto per le
429 analoghe di tab.~\ref{tab:sys_posix1_general}.
434 \begin{tabular}[c]{|l|r|l|}
436 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
439 \const{\_POSIX\_LINK\_MAX} &8 & Numero massimo di link a un file.\\
440 \const{\_POSIX\_NAME\_MAX}& 14 & Lunghezza in byte di un nome di file.\\
441 \const{\_POSIX\_PATH\_MAX}& 256 & Lunghezza in byte di un
443 \const{\_POSIX\_PIPE\_BUF}& 512 & Byte scrivibili atomicamente in una
445 \const{\_POSIX\_MAX\_CANON}&255 & Dimensione di una riga di
446 terminale in modo canonico.\\
447 \const{\_POSIX\_MAX\_INPUT}&255 & Spazio disponibile nella coda di input
449 % \const{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
450 % \const{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
451 % \const{\_POSIX\_FD\_SETSIZE}& 16 & \\
452 % \const{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
455 \caption{Costanti dei valori minimi delle caratteristiche dei file per la
456 conformità allo standard POSIX.1.}
457 \label{tab:sys_posix1_file}
460 Tutti questi limiti sono definiti in \headfile{limits.h}; come nel caso
461 precedente il loro uso è di scarsa utilità in quanto ampiamente superati in
462 tutte le implementazioni moderne. In generale i limiti per i file sono molto
463 più soggetti ad essere variabili rispetto ai limiti generali del sistema; ad
464 esempio parametri come la lunghezza del nome del file o il numero di link
465 possono variare da filesystem a filesystem.
467 Per questo motivo quando si ha a che fare con limiti relativi ai file questi
468 devono essere sempre controllati con la funzione \funcd{pathconf}, il cui
473 \fdecl{long pathconf(char *path, int name)}
474 \fdesc{Restituisce il valore di un parametro dei file.}
477 {La funzione ritorna il valore del parametro richiesto in caso di successo e
478 $-1$ per un errore, nel qual caso \var{errno} viene impostata ad uno degli
479 errori possibili relativi all'accesso a \param{path}.}
482 La funzione richiede che si specifichi il limite che si vuole controllare con
483 l'argomento \param{name}, per il quale si deve usare la relativa costante
484 identificativa, il cui nome si ottiene da quelle descritte in
485 tab.~\ref{tab:sys_file_macro} e tab.~\ref{tab:sys_posix1_file} con la stessa
486 convenzione già vista con \func{sysconf}, ma un questo caso con l'uso del
487 suffisso ``\texttt{\_PC\_}''.
489 In questo caso la funzione richiede anche un secondo argomento \param{path}
490 che specifichi a quale file si fa riferimento, dato che il valore del limite
491 cercato può variare a seconda del filesystem su cui si trova il file. Una
492 seconda versione della funzione, \funcd{fpathconf}, opera su un file
493 descriptor invece che su un \textit{pathname}, il suo prototipo è:
497 \fdecl{long fpathconf(int fd, int name)}
498 \fdesc{Restituisce il valore di un parametro dei file.}
501 {È identica a \func{pathconf} solo che utilizza un file descriptor invece di
502 un \textit{pathname}; pertanto gli errori restituiti in \var{errno} cambiano
505 \noindent ed il suo comportamento è identico a quello di \func{pathconf} a
506 parte quello di richiedere l'indicazione di un file descriptor
507 nell'argomento \param{fd}.
511 \subsection{I parametri del kernel ed il filesystem \texttt{/proc}}
512 \label{sec:sys_sysctl}
514 Tradizionalmente la funzione che permette la lettura ed l'impostazione dei
515 parametri del sistema è \funcm{sysctl}. Si tratta di una funzione derivata da
516 BSD4.4 ed introdotta su Linux a partire dal kernel 1.3.57, ma oggi il suo uso
517 è totalmente deprecato. Una \textit{system call} \funcm{\_sysctl} continua ad
518 esistere, ma non dispone più di una interfaccia nella \acr{glibc} ed il suo
519 utilizzo può essere effettuato solo tramite \func{syscall}, ma di nuovo questo
520 viene sconsigliato in quanto la funzionalità non è più mantenuta e molto
521 probabilmente sarà rimossa nel prossimo futuro. Per questo motivo eviteremo di
522 trattarne i particolari.
524 Lo scopo di \funcm{sysctl} era quello di fornire ai programmi una modalità per
525 modificare i parametri di sistema. Questi erano organizzati in maniera
526 gerarchica all'interno di un albero e per accedere a ciascuno di essi
527 occorreva specificare un percorso attraverso i vari nodi dell'albero, in
528 maniera analoga a come avviene per la risoluzione di un \textit{pathname}.
530 I parametri accessibili e modificabili attraverso questa funzione sono
531 moltissimi, dipendendo anche dallo stato corrente del kernel, ad esempio dai
532 moduli che sono stati caricati nel sistema. Inoltre non essendo standardizzati
533 i loro nomi possono variare da una versione di kernel all'altra, alcuni esempi
534 di questi parametri sono:
536 \item il nome di dominio
537 \item i parametri del meccanismo di \textit{paging}.
538 \item il filesystem montato come radice
539 \item la data di compilazione del kernel
540 \item i parametri dello stack TCP
541 \item il numero massimo di file aperti
546 \index{file!filesystem~\texttt {/proc}!definizione|(}
548 Dato che fin dall'inizio i parametri erano organizzati in una struttura
549 albero, è parso naturale rimappare questa organizzazione utilizzando il
550 filesystem \file{/proc}. Questo è un filesystem completamente virtuale, il cui
551 contenuto è generato direttamente dal kernel, che non fa riferimento a nessun
552 dispositivo fisico, ma presenta in forma di file e directory i dati di alcune
553 delle strutture interne del kernel stesso. Il suo utilizzo principale, come
554 denuncia il nome stesso, è quello di fornire una interfaccia per ottenere i
555 dati relativi ai processi (venne introdotto a questo scopo su BSD), ma nel
556 corso del tempo il suo uso è stato ampliato.
558 All'interno di questo filesystem sono pertanto presenti una serie di file che
559 riflettono il contenuto dei parametri del kernel (molti dei quali accessibili
560 in sola lettura) e in altrettante directory, nominate secondo il relativo
561 \ids{PID}, vengono mantenute le informazioni relative a ciascun processo
564 In particolare l'albero dei valori dei parametri di sistema impostabili con
565 \func{sysctl} viene presentato in forma di una gerarchia di file e directory a
566 partire dalla directory \file{/proc/sys}, cosicché è possibile accedere al
567 valore di un parametro del kernel tramite il \textit{pathname} ad un file
568 sotto \file{/proc/sys} semplicemente leggendone il contenuto, così come si può
569 modificare un parametro scrivendo sul file ad esso corrispondente.
571 Il kernel si occupa di generare al volo il contenuto ed i nomi dei file
572 corrispondenti ai vari parametri che sono presenti, e questo ha il grande
573 vantaggio di rendere accessibili gli stessi ad un qualunque comando di shell e
574 di permettere la navigazione dell'albero in modo da riconoscere quali
575 parametri sono presenti senza dover cercare un valore all'interno di una
578 Inizialmente l'uso del filesystem \file{/proc} serviva soltanto a replicare
579 l'accesso, con altrettante corrispondenze ai file presenti in
580 \file{/proc/sys}, ai parametri impostabili tradizionalmente con \func{sysctl},
581 ma vista la assoluta naturalità dell'interfaccia, e la sua maggiore
582 efficienza, nelle versioni più recenti del kernel questa è diventata la
583 modalità canonica per modificare i parametri del kernel, evitando di dover
584 ricorrere all'uso di una \textit{system call} specifica che pur essendo ancora
585 presente, prima o poi verrà eliminata.
587 Nonostante la semplificazione nella gestione ottenuta con l'uso di
588 \file{/proc/sys} resta il problema generale di conoscere il significato di
589 ciascuno degli innumerevoli parametri che vi si trovano. Purtroppo la
590 documentazione degli stessi spesso risulta incompleta e non aggiornata, ma
591 buona parte di quelli può importanti sono descritti dalla documentazione
592 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
594 Ma oltre alle informazioni che sostituiscono quelle ottenibili dalla ormai
595 deprecata \func{sysctl} dentro \file{/proc} sono disponibili moltissime altre
596 informazioni, fra cui ad esempio anche quelle fornite dalla funzione di
597 sistema \funcd{uname},\footnote{con Linux ci sono in realtà 3 \textit{system
598 call} diverse per le dimensioni delle stringhe restituite, le prime due
599 usano rispettivamente delle lunghezze di 9 e 65 byte, la terza usa anch'essa
600 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con una
601 lunghezza di 257 byte, la \acr{glibc} provvede a mascherare questi dettagli
602 usando la versione più recente disponibile.} il cui prototipo è:
605 \fhead{sys/utsname.h}
606 \fdecl{int uname(struct utsname *info)}
607 \fdesc{Restituisce informazioni generali sul sistema.}
610 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
611 caso \var{errno} può assumere solo il valore \errval{EFAULT}.}
614 La funzione, che viene usata dal comando \cmd{uname}, restituisce una serie di
615 informazioni relative al sistema nelle stringhe che costituiscono i campi
616 della struttura \struct{utsname} (la cui definizione è riportata in
617 fig.~\ref{fig:sys_utsname}) che viene scritta nel buffer puntato
618 dall'argomento \param{info}.
620 \begin{figure}[!ht!b]
621 \footnotesize \centering
622 \begin{minipage}[c]{0.8\textwidth}
623 \includestruct{listati/ustname.h}
626 \caption{La struttura \structd{utsname}.}
627 \label{fig:sys_utsname}
630 Si noti come in fig.~\ref{fig:sys_utsname} le dimensioni delle stringhe di
631 \struct{utsname} non sono specificate. Il manuale delle \acr{glibc} indica
632 due costanti per queste dimensioni, \const{\_UTSNAME\_LENGTH} per i campi
633 standard e \const{\_UTSNAME\_DOMAIN\_LENGTH} per quello relativo al nome di
634 dominio, altri sistemi usano nomi diversi come \const{SYS\_NMLN} o
635 \const{\_SYS\_NMLN} o \const{UTSLEN} che possono avere valori diversi. Dato
636 che il buffer per \struct{utsname} deve essere preallocato l'unico modo per
637 farlo in maniera sicura è allora usare come dimensione il valore ottenuto con
638 \code{sizeof(utsname)}.
640 Le informazioni vengono restituite in ciascuno dei singoli campi di
641 \struct{utsname} in forma di stringhe terminate dal carattere NUL. In
642 particolare dette informazioni sono:
644 \item il nome del sistema operativo;
645 \item il nome della macchine (l'\textit{hostname});
646 \item il nome della release del kernel;
647 \item il nome della versione del kernel;
648 \item il tipo di hardware della macchina;
649 \item il nome del domino (il \textit{domainname});
651 ma l'ultima di queste informazioni è stata aggiunta di recente e non è
652 prevista dallo standard POSIX, per questo essa è accessibile, come mostrato in
653 fig.~\ref{fig:sys_utsname}, solo se si è definita la macro
654 \macro{\_GNU\_SOURCE}.
656 Come accennato queste stesse informazioni, anche se a differenza di
657 \func{sysctl} la funzione continua ad essere mantenuta, si possono ottenere
658 direttamente tramite il filesystem \file{/proc}, esse infatti sono mantenute
659 rispettivamente nei file \sysctlrelfile{kernel}{ostype},
660 \sysctlrelfile{kernel}{hostname}, \sysctlrelfile{kernel}{osrelease},
661 \sysctlrelfile{kernel}{version} e \sysctlrelfile{kernel}{domainname} che si
662 trovano sotto la directory \file{/proc/sys/kernel/}.
664 \index{file!filesystem~\texttt {/proc}!definizione|)}
668 \section{La gestione del sistema}
669 \label{sec:sys_management}
671 In questa sezione prenderemo in esame le interfacce di programmazione messe a
672 disposizione per affrontare una serie di tematiche attinenti la gestione
673 generale del sistema come quelle relative alla gestione di utenti e gruppi, al
674 trattamento delle informazioni relative ai collegamenti al sistema, alle
675 modalità per effettuare lo spegnimento o il riavvio di una macchina.
678 \subsection{La gestione delle informazioni su utenti e gruppi}
679 \label{sec:sys_user_group}
681 Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
682 (password, corrispondenze fra nomi simbolici e \ids{UID} numerici, home
683 directory, ecc.) venivano registrate all'interno dei due file di testo
684 \conffile{/etc/passwd} ed \conffile{/etc/group}, il cui formato è descritto
685 dalle relative pagine del manuale\footnote{nella quinta sezione, quella dei
686 file di configurazione (esistono comandi corrispondenti), una trattazione
687 sistemistica dell'intero argomento coperto in questa sezione si consulti
688 sez.~4.3 di \cite{AGL}.} e tutte le funzioni che richiedevano l'accesso a
689 queste informazione andavano a leggere direttamente il contenuto di questi
692 In realtà oltre a questi due file da molto tempo gran parte dei sistemi
693 unix-like usano il cosiddetto sistema delle \textit{shadow password} che
694 prevede anche i due file \conffile{/etc/shadow} e \conffile{/etc/gshadow}, in
695 cui sono state spostate le informazioni di autenticazione (ed inserite alcune
696 estensioni di gestione avanzata) per toglierle dagli altri file che devono
697 poter essere letti da qualunque processo per poter effettuare l'associazione
698 fra username e \ids{UID}.
700 Col tempo però questa impostazione ha incominciato a mostrare dei limiti. Da
701 una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
702 la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
703 che sta per \textit{Pluggable Authentication Method}) che fornisce una
704 interfaccia comune per i processi di autenticazione, svincolando completamente
705 le singole applicazioni dai dettagli del come questa viene eseguita e di dove
706 vengono mantenuti i dati relativi. Si tratta di un sistema modulare, in cui è
707 possibile utilizzare anche più meccanismi insieme, diventa così possibile
708 avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
709 diversi formati per le password e diversi supporti per le informazioni. Il
710 tutto avviene in maniera trasparente per le applicazioni purché per ciascun
711 meccanismo si disponga della opportuna libreria che implementa l'interfaccia
714 Dall'altra parte, il diffondersi delle reti e la necessità di centralizzare le
715 informazioni degli utenti e dei gruppi per insiemi di macchine e servizi
716 all'interno di una stessa organizzazione, in modo da mantenere coerenti i
717 dati, ha portato anche alla necessità di poter recuperare e memorizzare dette
718 informazioni su supporti diversi dai file citati, introducendo il sistema del
719 \itindex{Name~Service~Switch~(NSS)} \textit{Name Service Switch} (che
720 tratteremo brevemente in sez.~\ref{sec:sock_resolver}) dato che la sua
721 applicazione è cruciale nella procedura di risoluzione di nomi di rete.
723 In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
724 per la lettura delle informazioni relative a utenti e gruppi tralasciando
725 completamente quelle relative all'autenticazione.
726 % Per questo non tratteremo
727 % affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
728 % \textit{Name Service Switch}, un meccanismo messo a disposizione dalle
729 % \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
730 % necessario trovare una corrispondenza fra un nome ed un numero (od altra
731 % informazione) ad esso associato, come appunto, quella fra uno username ed un
732 % \ids{UID} o fra un \ids{GID} ed il nome del gruppo corrispondente.
733 Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
734 queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
735 Service Switch}, per cui sono in grado di ricevere informazioni qualunque
736 sia il supporto su cui esse vengono mantenute. Per leggere le informazioni
737 relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
738 \funcd{getpwnam}, i cui prototipi sono:
743 \fdecl{struct passwd *getpwuid(uid\_t uid)}
744 \fdecl{struct passwd *getpwnam(const char *name)}
745 \fdesc{Restituiscono le informazioni relative all'utente specificato.}
748 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
749 in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
750 utente corrispondente a quanto specificato, nel qual caso \var{errno}
751 assumerà il valore riportato dalle funzioni di sistema sottostanti.}
754 Le due funzioni forniscono le informazioni memorizzate nel registro degli
755 utenti (che nelle versioni più recenti per la parte di credenziali di
756 autenticazione vengono ottenute attraverso PAM) relative all'utente
757 specificato attraverso il suo \ids{UID} o il nome di login. Entrambe le
758 funzioni restituiscono un puntatore ad una struttura di tipo \struct{passwd}
759 la cui definizione (anch'essa eseguita in \headfile{pwd.h}) è riportata in
760 fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente illustrato il
761 significato dei vari campi.
766 \begin{minipage}[c]{0.8\textwidth}
767 \includestruct{listati/passwd.h}
770 \caption{La struttura \structd{passwd} contenente le informazioni relative
771 ad un utente del sistema.}
772 \label{fig:sys_passwd_struct}
775 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
776 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
777 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
778 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
779 essere \index{funzioni!rientranti} rientranti; per questo motivo ne esistono
780 anche due versioni alternative (denotate dalla solita estensione \code{\_r}),
781 i cui prototipi sono:
786 \fdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
788 \phantom{struct passwd *getpwuid\_r(}size\_t buflen, struct passwd **result)}
789 \fdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
790 *password, char *buffer,\\
791 \phantom{struct passwd *getpwnam\_r(}size\_t buflen, struct passwd **result)}
792 \fdesc{Restituiscono le informazioni relative all'utente specificato.}
795 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
796 caso \var{errno} assumerà il valore riportato dalle di sistema funzioni
800 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
801 la memoria necessaria a contenere le informazioni. In particolare i valori
802 della struttura \struct{passwd} saranno restituiti all'indirizzo
803 \param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
804 un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
805 puntate dai campi di \param{password}. Infine all'indirizzo puntato da
806 \param{result} viene restituito il puntatore ai dati ottenuti, cioè
807 \param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti. Qualora i
808 dati non possano essere contenuti nei byte specificati da \param{buflen}, la
809 funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
810 impostato a \val{NULL}).
812 Sia queste versioni rientranti che precedenti gli errori eventualmente
813 riportati in \var{errno} in caso di fallimento dipendono dalla sottostanti
814 funzioni di sistema usate per ricavare le informazioni (si veda quanto
815 illustrato in sez.~\ref{sec:sys_errno}) per cui se lo si vuole utilizzare è
816 opportuno inizializzarlo a zero prima di invocare le funzioni per essere
817 sicuri di non avere un residuo di errore da una chiamata precedente. Il non
818 aver trovato l'utente richiesto infatti può essere dovuto a diversi motivi (a
819 partire dal fatto che non esista) per cui si possono ottenere i valori di
820 errore più vari a seconda dei casi.
822 Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
823 \funcd{getgrgid} che permettono di leggere le informazioni relative ai gruppi,
824 i loro prototipi sono:
829 \fdecl{struct group *getgrgid(gid\_t gid)}
830 \fdecl{struct group *getgrnam(const char *name)}
831 \fdesc{Restituiscono le informazioni relative al gruppo specificato.}
834 {Le funzioni ritornano il puntatore alla struttura contenente le informazioni
835 in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
836 utente corrispondente a quanto specificato, nel qual caso \var{errno}
837 assumerà il valore riportato dalle funzioni di sistema sottostanti.}
840 Come per le precedenti per gli utenti esistono anche le analoghe versioni
841 \index{funzioni!rientranti} rientranti che di nuovo utilizzano la stessa
842 estensione \code{\_r}; i loro prototipi sono:
847 \fdecl{int getgrgid\_r(gid\_t gid, struct group *grp, char *buf,
849 \phantom{int getgrgid\_r(}struct group **result)}
850 \fdecl{int getgrnam\_r(const char *name, struct group *grp, char *buf,
852 \phantom{int getgrnam\_r(}struct group **result)}
853 \fdesc{Restituiscono le informazioni relative al gruppo specificato.}
856 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
857 caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
862 Il comportamento di tutte queste funzioni è assolutamente identico alle
863 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
864 in questo caso le informazioni vengono restituite in una struttura di tipo
865 \struct{group}, la cui definizione è riportata in
866 fig.~\ref{fig:sys_group_struct}.
871 \begin{minipage}[c]{0.8\textwidth}
872 \includestruct{listati/group.h}
875 \caption{La struttura \structd{group} contenente le informazioni relative ad
876 un gruppo del sistema.}
877 \label{fig:sys_group_struct}
880 Le funzioni viste finora sono in grado di leggere le informazioni sia
881 direttamente dal file delle password in \conffile{/etc/passwd} che tramite il
882 sistema del \textit{Name Service Switch} e sono completamente generiche. Si
883 noti però che non c'è una funzione che permetta di impostare direttamente una
884 password.\footnote{in realtà questo può essere fatto ricorrendo alle funzioni
885 della libreria PAM, ma questo non è un argomento che tratteremo qui.} Dato
886 che POSIX non prevede questa possibilità esiste un'altra interfaccia che lo
887 fa, derivata da SVID le cui funzioni sono riportate in
888 tab.~\ref{tab:sys_passwd_func}. Questa interfaccia però funziona soltanto
889 quando le informazioni sono mantenute su un apposito file di \textsl{registro}
890 di utenti e gruppi, con il formato classico di \conffile{/etc/passwd} e
891 \conffile{/etc/group}.
896 \begin{tabular}[c]{|l|p{8cm}|}
898 \textbf{Funzione} & \textbf{Significato}\\
901 \funcm{fgetpwent} & Legge una voce dal file di registro degli utenti
903 \funcm{fgetpwent\_r}& Come la precedente, ma \index{funzioni!rientranti}
905 \funcm{putpwent} & Immette una voce in un file di registro degli
907 \funcm{getpwent} & Legge una voce da \conffile{/etc/passwd}.\\
908 \funcm{getpwent\_r} & Come la precedente, ma \index{funzioni!rientranti}
910 \funcm{setpwent} & Ritorna all'inizio di \conffile{/etc/passwd}.\\
911 \funcm{endpwent} & Chiude \conffile{/etc/passwd}.\\
912 \funcm{fgetgrent} & Legge una voce dal file di registro dei gruppi
914 \funcm{fgetgrent\_r}& Come la precedente, ma \index{funzioni!rientranti}
916 \funcm{putgrent} & Immette una voce in un file di registro dei gruppi.\\
917 \funcm{getgrent} & Legge una voce da \conffile{/etc/group}.\\
918 \funcm{getgrent\_r} & Come la precedente, ma \index{funzioni!rientranti}
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 delle \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 delle \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 (vedi
981 tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
982 solo che in questo caso la struttura del registro della \textsl{contabilità} è
983 molto più 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 \headfile{paths.h}, in particolare quelle che ci interessano sono:
1013 \begin{basedescript}{\desclabelwidth{2.0cm}}
1014 \item[\const{\_PATH\_UTMP}] specifica il file che contiene il registro per gli
1015 utenti correntemente collegati, questo è il valore che viene usato se non si
1016 è utilizzato \func{utmpname} per modificarlo;
1017 \item[\const{\_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 \const{EMPTY} & Non contiene informazioni valide.\\
1086 \const{RUN\_LVL} & Identica il runlevel del sistema.\\
1087 \const{BOOT\_TIME} & Identifica il tempo di avvio del sistema.\\
1088 \const{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
1090 \const{NEW\_TIME} & Identifica da quanto è stato modificato il
1092 \const{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
1093 \const{LOGIN\_PROCESS}& Identifica un processo di login.\\
1094 \const{USER\_PROCESS} & Identifica un processo utente.\\
1095 \const{DEAD\_PROCESS} & Identifica un processo terminato.\\
1096 % \const{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
1105 \var{ut\_type} uguale a \const{LOGIN\_PROCESS} o \const{USER\_PROCESS},
1106 restituendo la prima che corrisponde al valore di \var{ut\_line}, che
1107 specifica il dispositivo di terminale che interessa, da indicare senza il
1108 \file{/dev/} iniziale. Lo stesso criterio di ricerca è usato da
1109 \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 dalle \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 Le \acr{glibc} utilizzavano 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 \index{funzioni!rientranti} rientranti. Per questo motivo le \acr{glibc}
1138 forniscono anche delle versioni \index{funzioni!rientranti} rientranti:
1139 \func{getutent\_r}, \func{getutid\_r}, \func{getutline\_r}, che invece di
1140 restituire un puntatore restituiscono un intero e prendono due argomenti
1141 aggiuntivi, i rispettivi prototipi sono:
1145 \fdecl{int *getutent\_r(struct utmp *buffer, struct utmp **result)}
1146 \fdesc{Legge una voce dalla posizione corrente nel registro.}
1147 \fdecl{int *getutid\_r(struct utmp *buffer, struct utmp **result, struct utmp
1149 \fdesc{Ricerca una voce sul registro.}
1150 \fdecl{int *getutline\_r(struct utmp *buffer, struct utmp **result, struct utmp
1152 \fdesc{Ricerca una voce sul registro attinente a un terminale.}
1155 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
1156 caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
1160 Le funzioni si comportano esattamente come le precedenti analoghe non
1161 \index{funzioni!rientranti} rientranti, solo che restituiscono il risultato
1162 all'indirizzo specificato dal primo argomento aggiuntivo \param{buffer} mentre
1163 il secondo, \param{result)} viene usato per restituire il puntatore al buffer
1166 Infine le \acr{glibc} forniscono altre due funzioni, \funcd{updwtmp} e
1167 \funcd{logwtmp}, come estensione per scrivere direttamente delle voci nel file
1168 sul registro storico \sysfile{/var/log/wtmp}; i rispettivi prototipi sono:
1172 \fdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
1173 \fdesc{Aggiunge una voce in coda al registro.}
1174 \fdecl{void logwtmp(const char *line, const char *name, const char *host)}
1175 \fdesc{Aggiunge nel registro una voce con i valori specificati.}
1178 {Le funzioni non restituiscono nulla.}
1181 La prima funzione permette l'aggiunta di una voce in coda al file del registro
1182 storico, indicato dal primo argomento, specificando direttamente una struttura
1183 \struct{utmp}. La seconda invece utilizza gli argomenti \param{line},
1184 \param{name} e \param{host} per costruire la voce che poi aggiunge chiamando
1187 Queste funzioni non sono previste da POSIX.1-2001, anche se sono presenti in
1188 altri sistemi (ad esempio Solaris e NetBSD), per mantenere una coerenza con le
1189 altre funzioni definite nello standard che usano la struttura \struct{utmpx}
1190 la \acr{glibc} definisce anche una funzione \funcm{updwtmpx}, che come in
1191 precedenza è identica a \func{updwtmp} con la sola differenza di richiedere
1192 l'uso di \headfile{utmpx.h} e di una struttura \struct{utmpx} come secondo
1196 \subsection{La gestione dello spegnimento e del riavvio}
1197 \label{sec:sys_reboot}
1199 Una delle operazioni di gestione generale del sistema è quella che attiene
1200 alle modalità con cui se ne può gestire lo spegnimento ed il riavvio. Perché
1201 questo avvenga in maniera corretta, in particolare per le parti che comportano
1202 lo spegnimento effettivo della macchina, occorre che il kernel effettui le
1203 opportune operazioni interagendo con il BIOS ed i dispositivi che controllano
1204 l'erogazione della potenza.
1206 La funzione di sistema che controlla lo spegnimento ed il riavvio (ed altri
1207 aspetti della relativa procedura) è \funcd{reboot},\footnote{la funzione
1208 illustrata è quella fornita dalla \acr{glibc} che maschera i dettagli di
1209 basso livello della \textit{system call} la quale richiede attualmente tre
1210 argomenti; fino al kernel 2.1.30 la \textit{system call} richiedeva un
1211 ulteriore quarto argomento, i primi due indicano dei \textit{magic number}
1212 interi che possono assumere solo alcuni valori predefiniti, il terzo un
1213 comando, corrispondente all'unico argomento della funzione della \acr{glibc}
1214 ed il quarto argomento aggiuntivo, ora ignorato, un puntatore generico ad
1215 ulteriori dati.} il cui prototipo è:
1219 \fhead{sys/reboot.h}
1220 \fdecl{int reboot(int cmd)}
1221 \fdesc{Controlla il riavvio o l'arresto della macchina.}
1224 {La funzione non ritorna o ritorna $0$ in caso di successo e $-1$ per un
1225 errore, nel qual caso \var{errno} assumerà uno dei valori:
1227 \item[\errcode{EFAULT}] c'è un indirizzo non valido nel passaggio degli
1228 argomenti con il comando \const{LINUX\_REBOOT\_CMD\_RESTART2} (obsoleto).
1229 \item[\errcode{EINVAL}] si sono specificati valori non validi per gli
1231 \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
1232 \textit{capability} \const{CAP\_SYS\_BOOT}).
1237 La funzione, oltre al riavvio ed allo spegnimento, consente anche di
1238 controllare l'uso della combinazione di tasti tradizionalmente usata come
1239 scorciatoia da tastiera per richiedere il riavvio (\texttt{Ctrl-Alt-Del},
1240 denominata in breve nella documentazione CAD) ed i suoi effetti specifici
1241 dipendono dalla architettura hardware. Se si è richiesto un riavvio o uno
1242 spegnimento in caso di successo la funzione, non esistendo più il programma,
1243 ovviamente non ritorna, pertanto bisogna avere cura di aver effettuato tutte
1244 le operazioni preliminari allo spegnimento prima di eseguirla.
1246 Il comportamento della funzione viene controllato dall'argomento \param{cmd}
1247 e deve assumere indicato con una delle costanti seguente elenco, che
1248 illustra i comandi attualmente disponibili:
1250 \begin{basedescript}{\desclabelwidth{2.cm}\desclabelstyle{\nextlinelabel}}
1251 \item[\const{LINUX\_REBOOT\_CMD\_CAD\_OFF}] Disabilita l'uso diretto della
1252 combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce nell'invio
1253 del segnale \const{SIGINT} a \texttt{init} (o più in generale al processo
1254 con \ids{PID} 1) il cui effetto dipende dalla configurazione di
1256 \item[\const{LINUX\_REBOOT\_CMD\_CAD\_ON}] Attiva l'uso diretto della
1257 combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce
1258 nell'esecuzione dell'azione che si avrebbe avuto chiamando \func{reboot} con
1259 il comando \const{LINUX\_REBOOT\_CMD\_RESTART}.
1260 \item[\const{LINUX\_REBOOT\_CMD\_HALT}] Viene inviato sulla console il
1261 messaggio ``\textit{System halted.}'' l'esecuzione viene bloccata
1262 immediatamente ed il controllo passato al monitor nella ROM (se esiste e
1263 l'architettura lo consente). Se non si è eseguita una sincronizzazione dei
1264 dati su disco con \func{sync} questi saranno perduti.
1265 \item[\const{LINUX\_REBOOT\_CMD\_KEXEC}] viene eseguito direttamente il nuovo
1266 kernel che è stato opportunamente caricato in memoria da una
1267 \func{kexec\_load} (che tratteremo a breve) eseguita in precedenza. La
1268 funzionalità è disponibile solo a partire dal kernel 2.6.13 e se il kernel
1269 corrente è stato compilato includendo il relativo supporto.\footnote{deve
1270 essere stata abilitata l'opzione di compilazione \texttt{CONFIG\_KEXEC}.}
1271 Questo meccanismo consente di eseguire una sorta di riavvio rapido che evita
1272 di dover ripassare dalla inizializzazione da parte del BIOS ed il lancio del
1273 kernel attraverso un bootloader. Se non si è eseguita una sincronizzazione
1274 dei dati su disco con \func{sync} questi saranno perduti.
1275 \item[\const{LINUX\_REBOOT\_CMD\_POWER\_OFF}] Viene inviato sulla console il
1276 messaggio ``\textit{Power down.}'' l'esecuzione viene bloccata
1277 immediatamente e la macchina, se possibile, viene spenta. Se non si è
1278 eseguita una sincronizzazione dei dati su disco con \func{sync} questi
1280 \item[\const{LINUX\_REBOOT\_CMD\_RESTART}] Viene inviato sulla console il
1281 messaggio ``\textit{Restarting system.}'' ed avviata immediatamente la
1282 procedura di riavvio ordinaria. Se non si è eseguita una sincronizzazione
1283 dei dati su disco con \func{sync} questi saranno perduti.
1284 \item[\const{LINUX\_REBOOT\_CMD\_RESTART2}] Viene inviato sulla console il
1285 messaggio ``\textit{Restarting system with command '\%s'.}'' ed avviata
1286 immediatamente la procedura di riavvio usando il comando fornito
1287 nell'argomento \param{arg} che viene stampato al posto di \textit{'\%s'}
1288 (veniva usato per lanciare un altro programma al posto di \cmd{init}). Nelle
1289 versioni recenti questo argomento viene ignorato ed il riavvio può essere
1290 controllato dall'argomento di avvio del kernel \texttt{reboot=...} Se non
1291 si è eseguita una sincronizzazione dei dati su disco con \func{sync} questi
1296 Come appena illustrato usando il comando \const{LINUX\_REBOOT\_CMD\_KEXEC} si
1297 può eseguire un riavvio immediato pre-caricando una immagine del kernel, che
1298 verrà eseguita direttamente. Questo meccanismo consente di evitare la
1299 reinizializzazione della macchina da parte del BIOS, ed oltre a velocizzare un
1300 eventuale riavvio, ha il vantaggio poter accedere allo stato corrente della
1301 macchina e della memoria, per cui viene usato spesso per installare un kernel
1302 di emergenza da eseguire in caso di crollo del sistema per recuperare il
1303 maggior numero di informazioni possibili.
1305 La funzione di sistema che consente di caricare questa immagine del kernel è
1306 \funcd{kexec\_load}, la funzione non viene definita nella \acr{glibc} e deve
1307 pertanto essere invocata con \func{syscall}, il suo prototipo è:
1310 \fhead{linux/kexec.h}
1311 \fdecl{long kexec\_load(unsigned long entry, unsigned long nr\_segments,
1312 struct kexec\_segment\\
1313 \phantom{long kexec\_load(}*segments, unsigned long flags)}
1315 \fdesc{Carica un kernel per un riavvio immediato.}
1318 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1319 caso \var{errno} assumerà uno dei valori:
1321 \item[\errcode{EBUSY}] c'è già un caricamento in corso, o un altro kernel è
1323 \item[\errcode{EINVAL}] il valore di \param{flags} non è valido o si è
1324 indicato un valore eccessivo per \param{nr\_segments}.
1325 \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
1326 \textit{capability} \const{CAP\_SYS\_BOOT}).
1331 Il primo argomento indica l'indirizzo fisico di esecuzione del nuovo kernel
1332 questo viene caricato usando un vettore di strutture \struct{kexec\_segment}
1333 (la cui definizione è riportata in fig.~\ref{fig:kexec_segment}) che
1334 contengono i singoli segmenti dell'immagine. I primi due campi indicano
1335 indirizzo e dimensione del segmento di memoria in \textit{user space}, i
1336 secondi indirizzo e dimensione in \textit{kernel space}.
1339 \begin{figure}[!htb]
1342 \begin{minipage}[c]{0.8\textwidth}
1343 \includestruct{listati/kexec_segment.h}
1346 \caption{La struttura \structd{kexec\_segment} per il caricamento di un
1347 segmento di immagine del kernel.}
1348 \label{fig:kexec_segment}
1351 L'argomento \param{flags} è una maschera binaria contenente i flag che
1352 consentono di indicare le modalità con cui dovrà essere eseguito il nuovo
1353 kernel. La parte meno significativa viene usata per impostare l'architettura
1354 di esecuzione. Il valore \const{KEXEC\_ARCH\_DEFAULT} indica l'architettura
1355 corrente, ma se ne può specificare anche una diversa, con i valori della
1356 seconda parte di tab.~\ref{tab:kexec_load_flags}, e questa verrà usato posto
1357 che sia effettivamente eseguibile sul proprio processore.
1362 \begin{tabular}[c]{|l|p{8cm}|}
1364 \textbf{Valore} & \textbf{Significato}\\
1367 \const{KEXEC\_ON\_CRASH} & Il kernel caricato sarà eseguito
1368 automaticamente in caso di crollo del
1370 \const{KEXEC\_PRESERVE\_CONTEXT}& Viene preservato lo stato dei programmi
1371 e dei dispositivi prima dell'esecuzione
1372 del nuovo kernel. Viene usato
1373 principalmente per l'ibernazione del
1374 sistema ed ha senso solo se si è
1375 indicato un numero di segmento maggiore
1378 \const{KEXEC\_ARCH\_DEFAULT} & Il kernel caricato verrà eseguito nella
1379 architettura corrente. \\
1380 \texttt{KEXEC\_ARCH\_XXX} & Il kernel caricato verrà eseguito nella
1381 architettura indicata (con \texttt{XXX}
1382 che può essere: \texttt{386},
1383 \texttt{X86\_64}, \texttt{PPC},
1384 \texttt{PPC64}, \texttt{IA\_64},
1385 \texttt{ARM}, \texttt{S390},
1386 \texttt{SH}\texttt{MIPS}
1387 e \texttt{MIPS\_LE}).\\
1391 \caption{Valori per l'argomento \param{flags} di \func{kexec\_load}.}
1392 \label{tab:kexec_load_flags}
1395 I due valori più importanti sono però quelli della parte più significativa
1396 (riportati nella prima sezione di tab.~\ref{tab:kexec_load_flags}). Il primo,
1397 \const{KEXEC\_ON\_CRASH}, consente di impostare l'esecuzione automatica del
1398 nuovo kernel caricato in caso di crollo del sistema, e viene usato quando si
1399 carica un kernel di emergenza da utilizzare per poter raccogliere informazioni
1400 diagnostiche che altrimenti verrebbero perdute non essendo il kernel ordinario
1401 più in grado di essere eseguito in maniera coerente. Il secondo valore,
1402 \const{KEXEC\_PRESERVE\_CONTEXT}, indica invece di preservare lo stato dei
1403 programmi e dei dispositivi, e viene in genere usato per realizzare la
1404 cosiddetta ibernazione in RAM.
1406 % TODO: introdotta con il kernel 3.17 è stata introdotta
1407 % kexec_file_load, per caricare immagine firmate per il secure boot,
1408 % vedi anche http://lwn.net/Articles/603116/
1410 % TODO documentare keyctl ????
1411 % (fare sezione dedicata ????)
1413 % TODO documentare la Crypto API del kernel
1415 % TODO documentare la syscall getrandom, introdotta con il kernel 3.17, vedi
1416 % http://lwn.net/Articles/606141/
1418 %\subsection{La gestione delle chiavi crittografiche}
1419 %\label{sec:keyctl_management}
1421 %TODO non è chiaro se farlo qui, ma documentare la syscall bpf aggiunta con il
1422 %kernel 3.18, vedi http://lwn.net/Articles/612878/
1424 \section{Il controllo dell'uso delle risorse}
1425 \label{sec:sys_res_limits}
1428 Dopo aver esaminato in sez.~\ref{sec:sys_management} le funzioni che
1429 permettono di controllare le varie caratteristiche, capacità e limiti del
1430 sistema a livello globale, in questa sezione tratteremo le varie funzioni che
1431 vengono usate per quantificare le risorse (CPU, memoria, ecc.) utilizzate da
1432 ogni singolo processo e quelle che permettono di imporre a ciascuno di essi
1433 vincoli e limiti di utilizzo.
1436 \subsection{L'uso delle risorse}
1437 \label{sec:sys_resource_use}
1439 Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
1440 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
1441 di tipo \struct{rusage}, la cui definizione (che si trova in
1442 \headfile{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}. Si
1443 ricordi che questa è una delle informazioni preservate attraverso una
1446 \begin{figure}[!htb]
1449 \begin{minipage}[c]{0.8\textwidth}
1450 \includestruct{listati/rusage.h}
1453 \caption{La struttura \structd{rusage} per la lettura delle informazioni dei
1454 delle risorse usate da un processo.}
1455 \label{fig:sys_rusage_struct}
1458 La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
1459 da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
1460 \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si
1461 trova nelle opzioni di compilazione del kernel (e di norma è disabilitato)
1462 che serve per mantenere una contabilità delle risorse usate da ciascun
1463 processo in maniera molto più dettagliata.} ma attualmente solo alcuni dei
1464 campi definiti sono effettivamente mantenuti. Con i kernel della serie 2.4 i
1465 soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
1466 \var{ru\_minflt} e \var{ru\_majflt}. Con i kernel della serie 2.6 si
1467 aggiungono anche \var{ru\_nvcsw} e \var{ru\_nivcsw}, a partire dal 2.6.22
1468 anche \var{ru\_inblock} e \var{ru\_oublock} e dal 2.6.32 anche
1471 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
1472 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
1473 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
1474 ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
1475 \struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
1477 La struttura \struct{rusage} è la struttura utilizzata da \func{wait4} (si
1478 ricordi quando visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di
1479 risorse impiegate dal processo di cui si è letto lo stato di terminazione, ma
1480 essa può anche essere letta direttamente utilizzando la funzione di sistema
1481 \funcd{getrusage}, il cui prototipo è:
1485 \fhead{sys/resource.h}
1487 \fdecl{int getrusage(int who, struct rusage *usage)}
1489 \fdesc{Legge la quantità di risorse usate da un processo.}
1492 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1493 caso \var{errno} assumerà uno dei valori:
1495 \item[\errcode{EINVAL}] l'argomento \param{who} non è valido
1497 ed inoltre \errval{EFAULT} nel suo significato generico.
1501 La funzione ritorna i valori per l'uso delle risorse nella struttura
1502 \struct{rusage} puntata dall'argomento \param{usage}. L'argomento \param{who}
1503 permette di specificare il soggetto di cui si vuole leggere l'uso delle
1504 risorse; esso può assumere solo i valori illustrati in
1505 tab.~\ref{tab:getrusage_who}, di questi \const{RUSAGE\_THREAD} è specifico di
1506 Linux ed è disponibile solo a partire dal kernel 2.6.26. La funzione è stata
1507 recepita nello standard POSIX.1-2001, che però indica come campi di
1508 \struct{rusage} soltanto \var{ru\_utime} e \var{ru\_stime}.
1513 \begin{tabular}[c]{|l|p{8cm}|}
1515 \textbf{Valore} & \textbf{Significato}\\
1518 \const{RUSAGE\_SELF} & Ritorna l'uso delle risorse del processo
1519 corrente, che in caso di uso dei
1520 \textit{thread} ammonta alla somma delle
1521 risorse utilizzate da tutti i \textit{thread}
1523 \const{RUSAGE\_CHILDREN} & Ritorna l'uso delle risorse dell'insieme dei
1524 processi figli di cui è ricevuto lo stato di
1525 terminazione, che a loro volta comprendono
1526 quelle dei loro figli e così via.\\
1527 \const{RUSAGE\_THREAD} & Ritorna l'uso delle risorse del \textit{thread}
1531 \caption{Valori per l'argomento \param{who} di \func{getrusage}.}
1532 \label{tab:getrusage_who}
1535 I campi più utilizzati sono comunque \var{ru\_utime} e \var{ru\_stime} che
1536 indicano rispettivamente il tempo impiegato dal processo nell'eseguire le
1537 istruzioni in \textit{user space}, e quello impiegato dal kernel nelle
1538 \textit{system call} eseguite per conto del processo (vedi
1539 sez.~\ref{sec:sys_unix_time}). I campi \var{ru\_minflt} e \var{ru\_majflt}
1540 servono a quantificare l'uso della memoria virtuale e corrispondono
1541 rispettivamente al numero di \textit{page fault} (vedi
1542 sez.~\ref{sec:proc_mem_gen}) avvenuti senza richiedere I/O su disco (i
1543 cosiddetti \textit{minor page fault}), a quelli che invece han richiesto I/O
1544 su disco (detti invece \textit{major page
1545 fault}).% mentre \var{ru\_nswap} ed al numero di volte che
1546 % il processo è stato completamente tolto dalla memoria per essere inserito
1548 % TODO verificare \var{ru\_nswap} non citato nelle pagine di manuali recenti e
1549 % dato per non utilizzato.
1551 I campi \var{ru\_nvcsw} e \var{ru\_nivcsw} indicano il numero di volte che un
1552 processo ha subito un \textit{context switch} da parte dello
1553 \textit{scheduler} rispettivamente nel caso un cui questo avviene prima
1554 dell'esaurimento della propria \textit{time-slice} (in genere a causa di una
1555 \textit{system call} bloccante), o per averla esaurita o essere stato
1556 interrotto da un processo a priorità maggiore. I campi \var{ru\_inblock} e
1557 \var{ru\_oublock} indicano invece il numero di volte che è stata eseguita una
1558 attività di I/O su un filesystem (rispettivamente in lettura e scrittura) ed
1559 infine \var{ru\_maxrss} indica il valore più alto della
1560 \itindex{Resident~Set~Size~(RSS)} \textit{Resident Set Size} raggiunto dal
1561 processo stesso o, nel caso sia stato usato \const{RUSAGE\_CHILDREN}, da uno
1564 Si tenga conto che per un errore di implementazione nei i kernel precedenti il
1565 2.6.9, nonostante questo fosse esplicitamente proibito dallo standard POSIX.1,
1566 l'uso di \const{RUSAGE\_CHILDREN} comportava l'inserimento dell'ammontare
1567 delle risorse usate dai processi figli anche quando si era impostata una
1568 azione di \const{SIG\_IGN} per il segnale \const{SIGCHLD} (per i segnali si
1569 veda cap.~\ref{cha:signals}). Il comportamento è stato corretto per aderire
1570 allo standard a partire dal kernel 2.6.9.
1573 \subsection{Limiti sulle risorse}
1574 \label{sec:sys_resource_limit}
1576 Come accennato nell'introduzione il kernel mette a disposizione delle
1577 funzionalità che permettono non solo di mantenere dati statistici relativi
1578 all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
1579 utilizzo da parte sia dei singoli processi che degli utenti.
1581 Per far questo sono definite una serie di risorse e ad ogni processo vengono
1582 associati due diversi limiti per ciascuna di esse; questi sono il
1583 \textsl{limite corrente} (o \textit{current limit}) che esprime un valore
1584 massimo che il processo non può superare ad un certo momento, ed il
1585 \textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
1586 valore massimo che può assumere il \textsl{limite corrente}. In generale il
1587 primo viene chiamato anche \textit{soft limit} dato che il suo valore può
1588 essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
1589 fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
1592 In generale il superamento di un limite corrente comporta o l'emissione di uno
1593 specifico segnale o il fallimento della \textit{system call} che lo ha
1594 provocato. A questo comportamento generico fanno eccezione \const{RLIMIT\_CPU}
1595 in cui si ha in comportamento diverso per il superamento dei due limiti e
1596 \const{RLIMIT\_CORE} che influenza soltanto la dimensione o l'eventuale
1597 creazione dei file di \itindex{core~dump} \textit{core dump} (vedi
1598 sez.~\ref{sec:sig_standard}).
1600 Per permettere di leggere e di impostare i limiti di utilizzo delle risorse da
1601 parte di un processo sono previste due funzioni di sistema, \funcd{getrlimit}
1602 e \funcd{setrlimit}, i cui prototipi sono:
1606 \fhead{sys/resource.h}
1608 \fdecl{int getrlimit(int resource, struct rlimit *rlim)}
1609 \fdesc{Legge i limiti di una risorsa.}
1610 \fdecl{int setrlimit(int resource, const struct rlimit *rlim)}
1611 \fdesc{Imposta i limiti di una risorsa.}
1614 {Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
1615 caso \var{errno} assumerà uno dei valori:
1617 \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
1618 nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
1619 \var{rlim->rlim\_max}.
1620 \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1621 cercato di innalzare i propri limiti.
1623 ed inoltre \errval{EFAULT} nel suo significato generico.
1627 Entrambe le funzioni permettono di specificare attraverso l'argomento
1628 \param{resource} su quale risorsa si vuole operare. L'accesso (rispettivamente
1629 in lettura e scrittura) ai valori effettivi dei limiti viene poi effettuato
1630 attraverso la struttura \struct{rlimit} puntata da
1631 \param{rlim}, la cui definizione è riportata in
1632 fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
1633 limite corrente e limite massimo.
1635 \begin{figure}[!htb]
1638 \begin{minipage}[c]{0.8\textwidth}
1639 \includestruct{listati/rlimit.h}
1642 \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
1643 delle risorse usate da un processo.}
1644 \label{fig:sys_rlimit_struct}
1647 Come accennato processo ordinario può alzare il proprio limite corrente fino
1648 al valore del limite massimo, può anche ridurre, irreversibilmente, il valore
1649 di quest'ultimo. Nello specificare un limite, oltre a fornire dei valori
1650 specifici, si può anche usare la costante \const{RLIM\_INFINITY} che permette
1651 di sbloccare completamente l'uso di una risorsa. Si ricordi però che solo un
1652 processo con i privilegi di amministratore\footnote{per essere precisi in
1653 questo caso quello che serve è la \itindex{capabilities} \textit{capability}
1654 \const{CAP\_SYS\_RESOURCE} (vedi sez.~\ref{sec:proc_capabilities}).} può
1655 innalzare un limite al di sopra del valore corrente del limite massimo ed
1656 usare un valore qualsiasi per entrambi i limiti.
1658 Ciascuna risorsa su cui si possono applicare dei limiti è identificata da uno
1659 specifico valore dell'argomento \param{resource}, i valori possibili per
1660 questo argomento, ed il significato della risorsa corrispondente, dei
1661 rispettivi limiti e gli effetti causati dal superamento degli stessi sono
1662 riportati nel seguente elenco:
1664 \begin{basedescript}{\desclabelwidth{2.2cm}}%\desclabelstyle{\nextlinelabel}}
1665 \item[\const{RLIMIT\_AS}] Questa risorsa indica, in byte, la dimensione
1666 massima consentita per la memoria virtuale di un processo, il cosiddetto
1667 \textit{Address Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se il limite
1668 viene superato dall'uso di funzioni come \func{brk}, \func{mremap} o
1669 \func{mmap} esse falliranno con un errore di \errcode{ENOMEM}, mentre se il
1670 superamento viene causato dalla crescita dello \itindex{stack}
1671 \textit{stack} il processo riceverà un segnale di \signal{SIGSEGV}. Dato che
1672 il valore usato è un intero di tipo \ctyp{long} nelle macchine a 32 bit
1673 questo può assumere un valore massimo di 2Gb (anche se la memoria
1674 disponibile può essere maggiore), in tal caso il limite massimo indicabile
1675 resta 2Gb, altrimenti la risorsa si dà per non limitata.
1677 \item[\const{RLIMIT\_CORE}] Questa risorsa indica, in byte, la massima
1678 dimensione per un file di \itindex{core~dump} \textit{core dump} (vedi
1679 sez.~\ref{sec:sig_standard}) creato nella terminazione di un processo. File
1680 di dimensioni maggiori verranno troncati a questo valore, mentre con un
1681 valore nullo si bloccherà la creazione dei \itindex{core~dump} \textit{core
1684 \item[\const{RLIMIT\_CPU}] Questa risorsa indica, in secondi, il massimo tempo
1685 di CPU (vedi sez.~\ref{sec:sys_cpu_times}) che il processo può usare. Il
1686 superamento del limite corrente comporta l'emissione di un segnale di
1687 \signal{SIGXCPU}, la cui azione predefinita (vedi
1688 sez.~\ref{sec:sig_classification}) è terminare il processo. Il segnale però
1689 può essere intercettato e ignorato, in tal caso esso verrà riemesso una
1690 volta al secondo fino al raggiungimento del limite massimo. Il superamento
1691 del limite massimo comporta comunque l'emissione di un segnale di
1692 \signal{SIGKILL}. Si tenga presente che questo è il comportamento presente
1693 su Linux dai kernel della serie 2.2 ad oggi, altri kernel possono avere
1694 comportamenti diversi per quanto avviene quando viene superato il
1695 \textit{soft limit}, pertanto per avere operazioni portabili è suggerito di
1696 intercettare sempre \signal{SIGXCPU} e terminare in maniera ordinata il
1697 processo con la prima ricezione.
1699 \item[\const{RLIMIT\_DATA}] Questa risorsa indica, in byte, la massima
1700 dimensione del \index{segmento!dati} segmento dati di un processo (vedi
1701 sez.~\ref{sec:proc_mem_layout}). Il tentativo di allocare più memoria di
1702 quanto indicato dal limite corrente causa il fallimento della funzione di
1703 allocazione eseguita (\func{brk} o \func{sbrk}) con un errore di
1706 \item[\const{RLIMIT\_FSIZE}] Questa risorsa indica, in byte, la massima
1707 dimensione di un file che un processo può usare. Se il processo cerca di
1708 scrivere o di estendere il file oltre questa dimensione riceverà un segnale
1709 di \signal{SIGXFSZ}, che di norma termina il processo. Se questo segnale
1710 viene intercettato la \textit{system call} che ha causato l'errore fallirà
1711 con un errore di \errcode{EFBIG}.
1713 \item[\const{RLIMIT\_LOCKS}] Questa risorsa indica il numero massimo di
1714 \itindex{file~locking} \textit{file lock} (vedi sez.~\ref{sec:file_locking})
1715 e di \textit{file lease} (vedi sez.~\ref{sec:file_asyncronous_lease}) che un
1716 processo poteva effettuare. È un limite presente solo nelle prime versioni
1717 del kernel 2.4, pertanto non deve essere più utilizzato.
1719 \item[\const{RLIMIT\_MEMLOCK}] Questa risorsa indica, in byte, l'ammontare
1720 massimo di memoria che può essere bloccata in RAM da un processo (vedi
1721 sez.~\ref{sec:proc_mem_lock}). Dato che il \itindex{memory~locking}
1722 \textit{memory locking} viene effettuato sulle pagine di memoria, il valore
1723 indicato viene automaticamente arrotondato al primo multiplo successivo
1724 della dimensione di una pagina di memoria. Il limite comporta il fallimento
1725 delle \textit{system call} che eseguono il \textit{memory locking}
1726 (\func{mlock}, \func{mlockall} ed anche, vedi
1727 sez.~\ref{sec:file_memory_map}, \func{mmap} con l'operazione
1728 \const{MAP\_LOCKED}).
1730 Dal kernel 2.6.9 questo limite comprende anche la memoria che può essere
1731 bloccata da ciascun utente nell'uso della memoria condivisa (vedi
1732 sez.~\ref{sec:ipc_sysv_shm}) con \func{shmctl}, che viene contabilizzata
1733 separatamente ma sulla quale viene applicato questo stesso limite. In
1734 precedenza invece questo limite veniva applicato sulla memoria condivisa per
1735 processi con privilegi amministrativi, il limite su questi è stato rimosso e
1736 la semantica della risorsa cambiata.
1739 \item[\const{RLIMIT\_MSGQUEUE}] Questa risorsa indica il numero massimo di
1740 byte che possono essere utilizzati da un utente, identificato con
1741 l'\ids{UID} reale del processo chiamante, per le code di messaggi POSIX
1742 (vedi sez.~\ref{sec:ipc_posix_mq}). Per ciascuna coda che viene creata viene
1743 calcolata un'occupazione pari a:
1744 \includecodesnip{listati/mq_occupation.c}
1745 dove \var{attr} è la struttura \struct{mq\_attr} (vedi
1746 fig.~\ref{fig:ipc_mq_attr}) usata nella creazione della coda. Il primo addendo
1747 consente di evitare la creazione di una coda con un numero illimitato di
1748 messaggi vuoti che comunque richiede delle risorse di gestione. Questa risorsa
1749 è stata introdotta con il kernel 2.6.8.
1751 \item[\const{RLIMIT\_NICE}] Questa risorsa indica il numero massimo a cui può
1752 essere il portato il valore di \textit{nice} (vedi
1753 sez.~\ref{sec:proc_sched_stand}). Dato che non possono essere usati numeri
1754 negativi per specificare un limite, il valore di \textit{nice} viene
1755 calcolato come \code{20-rlim\_cur}. Questa risorsa è stata introdotta con il
1758 \item[\const{RLIMIT\_NOFILE}] Questa risorsa indica il numero massimo di file
1759 che un processo può aprire. Il tentativo di creazione di un ulteriore file
1760 descriptor farà fallire la funzione (\func{open}, \func{dup}, \func{pipe},
1761 ecc.) con un errore \errcode{EMFILE}.
1763 \item[\const{RLIMIT\_NPROC}] Questa risorsa indica il numero massimo di
1764 processi che possono essere creati dallo stesso utente, che viene
1765 identificato con l'\ids{UID} reale (vedi sez.~\ref{sec:proc_access_id}) del
1766 processo chiamante. Se il limite viene raggiunto \func{fork} fallirà con un
1769 \item[\const{RLIMIT\_RSS}] Questa risorsa indica, in pagine di memoria, la
1770 dimensione massima della memoria residente (il cosiddetto RSS
1771 \itindex{Resident~Set~Size~(RSS)} \textit{Resident Set Size}) cioè
1772 l'ammontare della memoria associata al processo che risiede effettivamente
1773 in RAM e non a quella eventualmente portata sulla \textit{swap} o non ancora
1774 caricata dal filesystem per il \index{segmento!testo} segmento testo del
1775 programma. Ha effetto solo sulle chiamate a \func{madvise} con
1776 \const{MADV\_WILLNEED} (vedi sez.~\ref{sec:file_memory_map}). Presente solo
1777 sui i kernel precedenti il 2.4.30.
1779 \item[\const{RLIMIT\_RTPRIO}] Questa risorsa indica il valore massimo della
1780 priorità statica che un processo può assegnarsi o assegnare con
1781 \func{sched\_setscheduler} e \func{sched\_setparam} (vedi
1782 sez.~\ref{sec:proc_real_time}). Il limite è stato introdotto a partire dal
1783 kernel 2.6.12 (ma per un bug è effettivo solo a partire dal 2.6.13). In
1784 precedenza solo i processi con privilegi amministrativi potevano avere una
1785 priorità statica ed utilizzare una politica di \textit{scheduling} di tipo
1788 \item[\const{RLIMIT\_RTTIME}] Questa risorsa indica, in microsecondi, il tempo
1789 massimo di CPU che un processo eseguito con una priorità statica può
1790 consumare. Il superamento del limite corrente comporta l'emissione di un
1791 segnale di \signal{SIGXCPU}, e quello del limite massimo di \signal{SIGKILL}
1792 con le stesse regole viste \const{RLIMIT\_CPU}: se \signal{SIGXCPU} viene
1793 intercettato ed ignorato il segnale verrà riemesso ogni secondo fino al
1794 superamento del limite massimo. Questo limite è stato introdotto con il
1795 kernel 2.6.25 per impedire che un processo \textit{real-time} possa bloccare
1798 \item[\const{RLIMIT\_SIGPENDING}] Questa risorsa indica il numero massimo di
1799 segnali che possono essere mantenuti in coda per ciascun utente,
1800 identificato per \ids{UID} reale. Il limite comprende sia i segnali normali
1801 che quelli \textit{real-time} (vedi sez.~\ref{sec:sig_real_time}) ed è
1802 attivo solo per \func{sigqueue}, con \func{kill} si potrà sempre inviare un
1803 segnale che non sia già presente su una coda. Questo limite è stato
1804 introdotto con il kernel 2.6.8.
1806 \item[\const{RLIMIT\_STACK}] Questa risorsa indica, in byte, la massima
1807 dimensione dello \itindex{stack} \textit{stack} del processo. Se il processo
1808 esegue operazioni che estendano lo \textit{stack} oltre questa dimensione
1809 riceverà un segnale di \signal{SIGSEGV}.
1811 A partire dal kernel 2.6.23 questo stesso limite viene applicato per la gran
1812 parte delle architetture anche ai dati che possono essere passati come
1813 argomenti e variabili di ambiente ad un programma posto in esecuzione con
1814 \func{execve}, nella misura di un quarto del valore indicato per lo
1815 \textit{stack}. Questo valore in precedenza era fisso e pari a 32 pagine di
1816 memoria, corrispondenti per la gran parte delle architetture a 128kb di
1817 dati, dal 2.6.25, per evitare problemi di compatibilità quando
1818 \const{RLIMIT\_STACK} è molto basso, viene comunque garantito uno spazio
1819 base di 32 pagine qualunque sia l'architettura.
1823 Si tenga conto infine che tutti i limiti eventualmente presenti su un processo
1824 vengono ereditati dai figli da esso creati attraverso una \func{fork} (vedi
1825 sez.~\ref{sec:proc_fork}) e mantenuti invariati per i programmi messi in
1826 esecuzione attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
1828 Si noti come le due funzioni \func{getrlimit} e \func{setrlimit} consentano di
1829 operare solo sul processo corrente. Per questo motivo a partire dal kernel
1830 2.6.36 (e dalla \acr{glibc} 2.13) è stata introdotta un'altra funzione di
1831 sistema \funcd{prlimit} il cui scopo è quello di estendere e sostituire le
1832 precedenti. Il suo prototipo è:
1835 \fhead{sys/resource.h}
1836 \fdecl{int prlimit(pid\_t pid, int resource, const struct rlimit *new\_limit,\\
1837 \phantom{int prlimit(}struct rlimit *old\_limit}
1838 \fdesc{Legge e imposta i limiti di una risorsa.}
1841 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1842 caso \var{errno} assumerà uno dei valori:
1844 \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
1845 nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
1846 \var{rlim->rlim\_max}.
1847 \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
1848 cercato di innalzare i propri limiti o si è cercato di modificare i limiti
1849 di un processo di un altro utente.
1850 \item [\errcode{ESRCH}] il process \param{pid} non esiste.
1852 ed inoltre \errval{EFAULT} nel suo significato generico.
1856 La funzione è specifica di Linux e non portabile; per essere usata richiede
1857 che sia stata definita la macro \macro{\_GNU\_SOURCE}. Il primo argomento
1858 indica il \ids{PID} del processo di cui si vogliono cambiare i limiti e si può
1859 usare un valore nullo per indicare il processo chiamante. Per modificare i
1860 limiti di un altro processo, a meno di non avere privilegi
1861 amministrativi,\footnote{anche in questo caso la \itindex{capabilities}
1862 \textit{capability} necessaria è \const{CAP\_SYS\_RESOURCE} (vedi
1863 sez.~\ref{sec:proc_capabilities}).} l'\ids{UID} ed il \ids{GID} reale del
1864 chiamante devono coincidere con \ids{UID} e \ids{GID} del processo indicato
1865 per i tre gruppi reale, effettivo e salvato.
1867 Se \param{new\_limit} non è \val{NULL} verrà usato come puntatore alla
1868 struttura \struct{rlimit} contenente i valori dei nuovi limiti da impostare,
1869 mentre se \param{old\_limit} non è \val{NULL} verranno letti i valori correnti
1870 del limiti nella struttura \struct{rlimit} da esso puntata. In questo modo è
1871 possibile sia leggere che scrivere, anche in contemporanea, i valori dei
1872 limiti. Il significato dell'argomento \param{resource} resta identico rispetto
1873 a \func{getrlimit} e \func{setrlimit}, così come i restanti requisiti.
1876 \subsection{Le informazioni sulle risorse di memoria e processore}
1877 \label{sec:sys_memory_res}
1879 La gestione della memoria è già stata affrontata in dettaglio in
1880 sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
1881 meccanismo della memoria virtuale attraverso la divisione della memoria fisica
1882 in pagine. In genere tutto ciò è del tutto trasparente al singolo processo,
1883 ma in certi casi, come per l'I/O mappato in memoria (vedi
1884 sez.~\ref{sec:file_memory_map}) che usa lo stesso meccanismo per accedere ai
1885 file, è necessario conoscere le dimensioni delle pagine usate dal kernel. Lo
1886 stesso vale quando si vuole gestire in maniera ottimale l'interazione della
1887 memoria che si sta allocando con il meccanismo della paginazione.
1889 Un tempo la dimensione delle pagine di memoria era fissata una volta per tutte
1890 dall'architettura hardware, per cui il relativo valore veniva mantenuto in una
1891 costante che bastava utilizzare in fase di compilazione. Oggi invece molte
1892 architetture permettono di variare questa dimensione (ad esempio sui PC
1893 recenti si possono usare pagine di 4kb e di 4 Mb) per cui per non dover
1894 ricompilare i programmi per ogni possibile caso e relativa scelta di
1895 dimensioni, è necessario poter utilizzare una funzione che restituisca questi
1896 valori quando il programma viene eseguito.
1898 Dato che si tratta di una caratteristica generale del sistema come abbiamo
1899 visto in sez.~\ref{sec:sys_characteristics} questa dimensione può essere
1900 ottenuta come tutte le altre attraverso una chiamata a \func{sysconf}, nel
1901 caso specifico si dovrebbe utilizzare il parametro \const{\_SC\_PAGESIZE}. Ma
1902 in BSD 4.2 è stata introdotta una apposita funzione di sistema
1903 \funcd{getpagesize} che restituisce la dimensione delle pagine di memoria. La
1904 funzione è disponibile anche su Linux (ma richiede che sia definita la macro
1905 \macro{\_BSD\_SOURCE}) ed il suo prototipo è:
1909 \fdecl{int getpagesize(void)}
1910 \fdesc{Legge la dimensione delle pagine di memoria.}
1913 {La funzione ritorna la dimensione di una pagina in byte, e non sono previsti
1917 La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
1918 standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
1919 ha eliminata, ed i programmi che intendono essere portabili devono ricorrere
1920 alla chiamata a \func{sysconf}.
1922 In Linux è implementata come una \textit{system call} nelle architetture in
1923 cui essa è necessaria, ed in genere restituisce il valore del simbolo
1924 \const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
1925 se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
1926 implementavano questa funzione restituendo sempre un valore statico.
1928 % TODO verificare meglio la faccenda di const{PAGE\_SIZE}
1930 Le \textsl{glibc} forniscono, come specifica estensione GNU, altre due
1931 funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
1932 di ottenere informazioni riguardo le pagine di memoria; i loro prototipi sono:
1935 \fhead{sys/sysinfo.h}
1936 \fdecl{long int get\_phys\_pages(void)}
1937 \fdesc{Legge il numero totale di pagine di memoria.}
1938 \fdecl{long int get\_avphys\_pages(void)}
1939 \fdesc{Legge il numero di pagine di memoria disponibili nel sistema.}
1942 {La funzioni ritornano il numero di pagine, e non sono previsti
1946 Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
1947 rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
1948 \const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
1949 corrispondenti alla RAM della macchina; la seconda invece la memoria
1950 effettivamente disponibile per i processi.
1952 Le \acr{glibc} supportano inoltre, come estensioni GNU, due funzioni che
1953 restituiscono il numero di processori della macchina (e quello dei processori
1954 attivi); anche queste sono informazioni comunque ottenibili attraverso
1955 \func{sysconf} utilizzando rispettivamente i parametri
1956 \const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
1958 Infine le \acr{glibc} riprendono da BSD la funzione \funcd{getloadavg} che
1959 permette di ottenere il carico di processore della macchina, in questo modo è
1960 possibile prendere decisioni su quando far partire eventuali nuovi processi.
1965 \fdecl{int getloadavg(double loadavg[], int nelem)}
1966 \fdesc{Legge il carico medio della macchina.}
1969 {La funzione ritorna il numero di campionamenti restituiti e $-1$ se non
1970 riesce ad ottenere il carico medio, \var{errno} non viene modificata.}
1973 La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
1974 di processi attivi sulla coda dello \textit{scheduler}, calcolato su diversi
1975 intervalli di tempo. Il numero di intervalli che si vogliono leggere è
1976 specificato da \param{nelem}, dato che nel caso di Linux il carico viene
1977 valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti), questo è
1978 anche il massimo valore che può essere assegnato a questo argomento.
1981 \subsection{La \textsl{contabilità} in stile BSD}
1982 \label{sec:sys_bsd_accounting}
1984 Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
1985 kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
1986 compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
1987 cosiddetto \textit{BSD accounting}, che consente di registrare su file una
1988 serie di informazioni\footnote{contenute nella struttura \texttt{acct}
1989 definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
1990 riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
1991 che viene terminato.
1993 Linux consente di salvare la contabilità delle informazioni relative alle
1994 risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
1999 \fdecl{int acct(const char *filename)}
2000 \fdesc{Abilita il \textit{BSD accounting}.}
2003 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
2004 caso \var{errno} assumerà uno dei valori:
2006 \item[\errcode{EACCES}] non si hanno i permessi per accedere a
2008 \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
2009 \item[\errcode{EPERM}] il processo non ha privilegi sufficienti ad
2010 abilitare il \textit{BSD accounting}.
2011 \item[\errcode{EUSERS}] non sono disponibili nel kernel strutture per il
2012 file o si è finita la memoria.
2014 ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
2015 \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
2016 \errval{ENOTDIR}, \errval{EROFS} nel loro significato generico.}
2019 La funzione attiva il salvataggio dei dati sul file indicato dal
2020 \textit{pathname} contenuti nella stringa puntata da \param{filename}; la
2021 funzione richiede che il processo abbia i privilegi di amministratore (è
2022 necessaria la \itindex{capabilities} capability \const{CAP\_SYS\_PACCT}, vedi
2023 sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \val{NULL} per
2024 \param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
2025 semplice esempio per l'uso di questa funzione è riportato nel programma
2026 \texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
2028 Quando si attiva la contabilità, il file che si indica deve esistere; esso
2029 verrà aperto in sola scrittura e le informazioni verranno registrate in
2030 \itindex{append~mode} \textit{append} in coda al file tutte le volte che un
2031 processo termina. Le informazioni vengono salvate in formato binario, e
2032 corrispondono al contenuto della apposita struttura dati definita all'interno
2035 Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
2036 parametro di sistema, modificabile attraverso \sysctlfile{kernel/acct} (o
2037 tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi, il
2038 primo indica la percentuale di spazio disco libero sopra il quale viene
2039 ripresa una registrazione che era stata sospesa per essere scesi sotto il
2040 minimo indicato dal secondo valore (sempre in percentuale di spazio disco
2041 libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
2042 essere controllata detta percentuale.
2044 % TODO: bassa priorità, trattare la lettura del file di accounting, da
2045 % programma, vedi man 5 acct
2048 \section{La gestione dei tempi del sistema}
2049 \label{sec:sys_time}
2051 In questa sezione, una volta introdotti i concetti base della gestione dei
2052 tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
2053 gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
2054 veri tempi di sistema associati ai processi, a quelle per convertire i vari
2055 tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
2056 gestione di data e ora.
2059 \subsection{La misura del tempo in Unix}
2060 \label{sec:sys_unix_time}
2062 Tradizionalmente nei sistemi unix-like sono sempre stati previsti due tipi
2063 distinti di tempi, caratterizzati da altrettante modalità di misura ed
2064 espressi con diversi tipi di dati, chiamati rispettivamente \textit{calendar
2065 time} e \textit{process time}, secondo le seguenti definizioni:
2066 \begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
2068 \item[\textit{calendar time}] \itindex{calendar~time} detto anche
2069 \textsl{tempo di calendario}, \textsl{tempo d'orologio} o \textit{tempo
2070 reale}. Si tratta di un tempo assoluto o di un intervallo di tempo come lo
2071 intende normalmente per le misure fatte con un orologio. Per esprimere
2072 questo tempo è stato riservato il tipo \type{time\_t}, e viene
2073 tradizionalmente misurato in secondi a partire dalla mezzanotte del primo
2074 gennaio 1970, data che viene chiamata \textit{the Epoch}.
2076 \item[\textit{process time}] \itindex{process~time} detto anche \textsl{tempo
2077 di processore} o \textsl{tempo di CPU}. Si tratta del tempo impiegato da
2078 un processore nell'esecuzione del codice di un programma all'interno di un
2079 processo. Per esprimere questo tempo è stato riservato il tipo
2080 \type{clock\_t}, e viene misurato nei cosiddetti \itindex{clock~tick}
2081 \textit{clock tick}, tradizionalmente corrispondenti al numero di
2082 interruzioni del processore da parte del timer di sistema. A differenza del
2083 precedente indica soltanto un intervallo di durata.
2086 Il \itindex{calendar~time} \textit{calendar time} viene sempre mantenuto
2087 facendo riferimento al cosiddetto \textit{tempo universale coordinato} UTC,
2088 anche se talvolta viene usato il cosiddetto GMT (\textit{Greenwich Mean Time})
2089 dato che l'UTC corrisponde all'ora locale di Greenwich. Si tratta del tempo su
2090 cui viene mantenuto il cosiddetto \textsl{orologio di sistema}, e viene usato
2091 per indicare i tempi dei file (quelli di sez.~\ref{sec:file_file_times}) o le
2092 date di avvio dei processi, ed è il tempo che viene usato dai demoni che
2093 compiono lavori amministrativi ad orari definito, come \cmd{cron}.
2095 Si tenga presente che questo tempo è mantenuto dal kernel e non è detto che
2096 corrisponda al tempo misurato dall'orologio hardware presente su praticamente
2097 tutte le piastre madri dei computer moderni (il cosiddetto \textit{hardware
2098 clock}), il cui valore viene gestito direttamente dall'hardware in maniera
2099 indipendente e viene usato dal kernel soltanto all'avvio per impostare un
2100 valore iniziale dell'orologio di sistema. La risoluzione tradizionale data dal
2101 tipo di dato \type{time\_t} è di un secondo, ma nei sistemi più recenti sono
2102 disponibili altri tipi di dati con precisioni maggiori.
2104 Si tenga presente inoltre che a differenza di quanto avviene con altri sistemi
2105 operativi,\footnote{è possibile, ancorché assolutamente sconsigliabile,
2106 forzare l'orologio di sistema all'ora locale per compatibilità con quei
2107 sistemi operativi che han fatto questa deprecabile scelta.} l'orologio di
2108 sistema viene mantenuto sempre in UTC e che la conversione all'ora locale del
2109 proprio fuso orario viene effettuata dalle funzioni di libreria utilizzando le
2110 opportune informazioni di localizzazione (specificate in
2111 \conffile{/etc/timezone}). In questo modo si ha l'assicurazione che l'orologio
2112 di sistema misuri sempre un tempo monotono crescente come nella realtà, anche
2113 in presenza di cambi di fusi orari.
2115 Il \itindex{process~time} \textit{process time} invece indica sempre una
2116 misura di un lasso di tempo e viene usato per tenere conto dei tempi di
2117 esecuzione dei processi. Esso viene sempre diviso in \textit{user time} e
2118 \textit{system time}, per misurare la durata di ciascun processo il kernel
2119 infatti calcola tre tempi:
2120 \begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
2121 \item[\textit{clock time}] il tempo \textsl{reale}, viene chiamato anche
2122 \textit{wall clock time} o \textit{elapsed time}, passato dall'avvio del
2123 processo. Questo tempo fa riferimento al \itindex{calendar~time}
2124 \textit{calendar time} e dice la durata effettiva dell'esecuzione del
2125 processo, ma chiaramente dipende dal carico del sistema e da quanti altri
2126 processi stanno girando nello stesso momento.
2128 \item[\textit{user time}] il tempo effettivo che il processore ha impiegato
2129 nell'esecuzione delle istruzioni del programma in \textit{user space}. È
2130 anche quello riportato nella risorsa \var{ru\_utime} di \struct{rusage}
2131 vista in sez.~\ref{sec:sys_resource_use}.
2133 \item[\textit{system time}] il tempo effettivo che il processore ha impiegato
2134 per eseguire codice delle \textit{system call} nel kernel per conto del
2135 processo. È anche quello riportato nella risorsa \var{ru\_stime} di
2136 \struct{rusage} vista in sez.~\ref{sec:sys_resource_use}.
2139 La somma di \textit{user time} e \textit{system time} indica il
2140 \itindex{process~time} \textit{process time}, vale a dire il tempo di
2141 processore totale che il sistema ha effettivamente utilizzato per eseguire il
2142 programma di un certo processo. Si può ottenere un riassunto dei valori di
2143 questi tempi quando si esegue un qualsiasi programma lanciando quest'ultimo
2144 come argomento del comando \cmd{time}.
2146 Come accennato il \itindex{process~time} \textit{process time} viene misurato
2147 nei cosiddetti \itindex{clock~tick} \textit{clock tick}. Un tempo questo
2148 corrispondeva al numero di interruzioni effettuate dal timer di sistema, oggi
2149 lo standard POSIX richiede che esso sia espresso come multiplo della costante
2150 \const{CLOCKS\_PER\_SEC} che deve essere definita come 1000000, qualunque sia
2151 la risoluzione reale dell'orologio di sistema e la frequenza delle
2152 interruzioni del timer che, come accennato in sez.~\ref{sec:proc_hierarchy} e
2153 come vedremo a breve, è invece data dalla costante \const{HZ}.
2155 Il tipo di dato usato per questo tempo, \type{clock\_t}, con questa
2156 convenzione ha una risoluzione del microsecondo. Ma non tutte le funzioni di
2157 sistema come vedremo seguono questa convenzione, in tal caso il numero di
2158 \itindex{clock~tick} \textit{clock tick} al secondo può essere ricavato anche
2159 attraverso \func{sysconf} richiedendo il valore della costante
2160 \const{\_SC\_CLK\_TCK} (vedi sez.~\ref{sec:sys_limits}). Il vecchio simbolo
2161 \const{CLK\_TCK} definito in \headfile{time.h} è ormai considerato obsoleto e
2162 non deve essere usato.
2164 In realtà tutti calcoli dei tempi vengono effettuati dal kernel per il
2165 cosiddetto \textit{software clock}, utilizzando il \textit{timer di sistema} e
2166 facendo i conti in base al numero delle interruzioni generate dello stesso, i
2167 cosiddetti \itindex{jiffies} ``\textit{jiffies}''. La durata di un
2168 ``\textit{jiffy}'' è determinata dalla frequenza di interruzione del timer,
2169 indicata in Hertz, come accennato in sez.~\ref{sec:proc_hierarchy}, dal valore
2170 della costante \const{HZ} del kernel, definita in \file{asm/param.h}.
2172 Fino al kernel 2.4 il valore di \const{HZ} era 100 su tutte le architetture
2173 tranne l'alpha, per cui era 1000. Con il 2.6.0 è stato portato a 1000 su tutte
2174 le architetture, ma dal 2.6.13 il valore è diventato una opzione di
2175 compilazione del kernel, con un default di 250 e valori possibili di 100, 250,
2176 1000. Dal 2.6.20 è stato aggiunto anche il valore 300 che è divisibile per le
2177 frequenze di refresh della televisione (50 o 60 Hz). Si può pensare che questi
2178 valori determinino anche la corrispondente durata dei \itindex{clock~tick}
2179 \textit{clock tick}, ma in realtà questa granularità viene calcolata in
2180 maniera indipendente usando la costante del kernel \const{USER\_HZ}.
2182 Fino al kernel 2.6.21 la durata di un \textit{jiffy} costituiva la risoluzione
2183 massima ottenibile nella misura dei tempi impiegabile in una \textit{system
2184 call} (ad esempio per i timeout). Con il 2.6.21 e l'introduzione degli
2185 \itindex{High~Resolution~Timer~(HRT)} \textit{high-resolution timers} (HRT) è
2186 divenuto possibile ottenere, per le funzioni di attesa ed i timer, la massima
2187 risoluzione possibile fornita dall'hardware. Torneremo su questo in
2188 sez.~\ref{sec:sig_timer_adv}.
2192 \subsection{La gestione del \textit{process time}}
2193 \label{sec:sys_cpu_times}
2195 \itindbeg{process~time}
2197 Di norma tutte le operazioni del sistema fanno sempre riferimento al
2198 \itindex{calendar~time} \textit{calendar time}, l'uso del \textit{process
2199 time} è riservato a quei casi in cui serve conoscere i tempi di esecuzione
2200 di un processo (ad esempio per valutarne l'efficienza). In tal caso infatti
2201 fare ricorso al \textit{calendar time} è inutile in quanto il tempo può essere
2202 trascorso mentre un altro processo era in esecuzione o in attesa del risultato
2203 di una operazione di I/O.
2205 La funzione più semplice per leggere il \textit{process time} di un processo è
2206 \funcd{clock}, che da una valutazione approssimativa del tempo di CPU
2207 utilizzato dallo stesso; il suo prototipo è:
2211 \fdecl{clock\_t clock(void)}
2212 \fdesc{Legge il valore corrente del tempo di CPU.}
2215 {La funzione ritorna il tempo di CPU in caso di successo e $-1$ se questo non
2216 è ottenibile o rappresentabile in un valore di tipo \type{clock\_t},
2217 \var{errno} non viene usata.}
2220 La funzione restituisce il tempo in \itindex{clock~tick} \textit{clock tick}
2221 ma la \acr{glibc} segue lo standard POSIX e quindi se si vuole il tempo in
2222 secondi occorre dividere il risultato per la costante
2223 \const{CLOCKS\_PER\_SEC}. In genere \type{clock\_t} viene rappresentato come
2224 intero a 32 bit, il che comporta un valore massimo corrispondente a circa 72
2225 minuti, dopo i quali il contatore riprenderà lo stesso valore iniziale.
2227 La funzione è presente anche nello standard ANSI C, ma in tal caso non è
2228 previsto che il valore ritornato indichi un intervallo di tempo ma solo un
2229 valore assoluto, per questo se si vuole la massima portabilità anche al di
2230 fuori di kernel unix-like, può essere opportuno chiamare la funzione
2231 all'inizio del programma ed ottenere il valore del tempo con una differenza.
2233 Si tenga presente inoltre che con altri kernel unix-like il valore riportato
2234 dalla funzione può includere anche il tempo di processore usato dai processi
2235 figli di cui si è ricevuto lo stato di terminazione con \func{wait} e
2236 affini. Questo non vale per Linux, in cui questa informazione deve essere
2237 ottenuta separatamente.
2239 Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di processore è la
2240 somma di altri due tempi, l'\textit{user time} ed il \textit{system time}, che
2241 sono quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
2242 possono essere letti separatamente attraverso la funzione \funcd{times}, il
2247 \fdecl{clock\_t times(struct tms *buf)}
2248 \fdesc{Legge il valore corrente dei tempi di processore.}
2251 {La funzione ritorna un numero di \textit{clock tick} in caso di successo e
2252 $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il valore
2253 \errval{EFAULT} nel suo significato generico.}
2256 La funzione restituisce i valori di \textit{process time} del processo
2257 corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
2258 in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
2259 due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
2260 \textit{system time} del processo, così come definiti in
2261 sez.~\ref{sec:sys_unix_time}. Gli altri due campi, \var{tms\_cutime} e
2262 \var{tms\_cstime}, riportano la somma dell'\textit{user time} e del
2263 \textit{system time} di tutti processi figli di cui si è ricevuto lo stato di
2266 \begin{figure}[!htb]
2269 \begin{minipage}[c]{0.8\textwidth}
2270 \includestruct{listati/tms.h}
2273 \caption{La struttura \structd{tms} dei tempi di processore associati a un
2275 \label{fig:sys_tms_struct}
2279 Si tenga presente che i tempi di processore dei processi figli di un processo
2280 vengono sempre sommati al valore corrente ogni volta che se ne riceve lo stato
2281 di terminazione, e detto valore è quello che viene a sua volta ottenuto dal
2282 processo padre. Pertanto nei campi \var{tms\_cutime} e \var{tms\_cstime} si
2283 sommano anche i tempi di ulteriori discendenti di cui i rispettivi genitori
2284 abbiano ricevuto lo stato di terminazione.
2286 Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
2287 viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
2288 ritornata. Per questo motivo se un processo figlio termina prima di ricevere
2289 lo stato di terminazione di tutti i suoi figli, questi processi
2290 ``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi e
2291 così via per i relativi ``\textsl{discendenti}''.
2293 Come accennato in sez.~\ref{sec:sys_resource_use} per i kernel precedenti la
2294 versione 2.6.9 il tempo di processore dei processi figli veniva sommato
2295 comunque chiedendo di ignorare \const{SIGCHLD} anche se lo standard POSIX
2296 richiede esplicitamente che questo avvenga solo quando si riceve lo stato di
2297 uscita con una funzione della famiglia delle \func{wait}, anche in questo caso
2298 il comportamento è stato adeguato allo standard a partire dalla versione
2301 A differenza di quanto avviene per \func{clock} i valori restituiti nei campi
2302 di una struttura \struct{tms} sono misurati in numero di \itindex{clock~tick}
2303 \textit{clock tick} effettivi e non in multipli di \const{CLOCKS\_PER\_SEC},
2304 pertanto per ottenere il valore effettivo in secondi occorrerà dividere per il
2305 risultato di \code{sysconf(\_SC\_CLK\_TCK)}.
2307 Lo stesso vale per il valore di ritorno della funzione, il cui significato fa
2308 riferimento ad un tempo relativo ad un certo punto nel passato la cui
2309 definizione dipende dalle diverse implementazioni, e varia anche fra diverse
2310 versioni del kernel. Fino al kernel 2.4 si faceva infatti riferimento al
2311 momento dell'avvio del kernel. Con il kernel 2.6 si fa riferimento a
2312 $2^{32}/\mathtt{HZ}-300$ secondi prima dell'avvio.
2314 Considerato che il numero dei \itindex{clock~tick} \textit{clock tick} per un
2315 kernel che è attivo da molto tempo può eccedere le dimensioni per il tipo
2316 \type{clock\_t} il comportamento più opportuno per i programmi è di ignorare
2317 comunque il valore di ritorno della funzione e ricorrere alle funzioni per il
2318 tempo di calendario del prossimo paragrafo qualora si voglia calcolare il
2319 tempo effettivamente trascorso dall'inizio del programma.
2321 Infine si tenga presente che per dei limiti nelle convenzioni per il ritorno
2322 dei valori delle \textit{system call} su alcune architetture hardware (ed in
2323 particolare la \texttt{i386} dei PC a 32 bit) nel kernel della serie 2.6 il
2324 valore di ritorno della funzione può risultare erroneamente uguale a $-1$,
2325 indicando un errore, nei primi secondi dopo il boot (per la precisione nei
2326 primi 41 secondi) e se il valore del contatore eccede le dimensione del tipo
2329 \itindend{process~time}
2332 \subsection{Le funzioni per il \textit{calendar time}}
2333 \label{sec:sys_time_base}
2335 \itindbeg{calendar~time}
2337 Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time}
2338 viene espresso normalmente con una variabile di tipo \type{time\_t}, che
2339 usualmente corrisponde ad un tipo elementare; in Linux è definito come
2340 \ctyp{long int}, che di norma corrisponde a 32 bit. Il valore corrente del
2341 \textit{calendar time}, che indicheremo come \textsl{tempo di sistema}, può
2342 essere ottenuto con la funzione \funcd{time} che lo restituisce nel suddetto
2343 formato, il suo prototipo è:
2347 \fdecl{time\_t time(time\_t *t)}
2348 \fdesc{Legge il valore corrente del \textit{calendar time}.}
2351 {La funzione ritorna il valore del \textit{calendar time} in caso di successo
2352 e $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il
2353 valore \errval{EFAULT} nel suo significato generico.}
2356 L'argomento \param{t}, se non nullo, deve essere l'indirizzo di una variabile
2357 su cui duplicare il valore di ritorno.
2359 Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
2360 l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
2361 sia necessario; il suo prototipo è:
2365 \fdecl{int stime(time\_t *t)}
2366 \fdesc{Imposta il valore corrente del \textit{calendar time}.}
2369 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
2370 caso \var{errno} assumerà uno dei valori:
2372 \item[\errcode{EPERM}] non si hanno i permessi di amministrazione.
2374 ed inoltre \errval{EFAULT} nel suo significato generico.}
2378 Dato che modificare l'ora ha un impatto su tutto il sistema il cambiamento
2379 dell'orologio è una operazione privilegiata e questa funzione può essere usata
2380 solo da un processo con i privilegi di amministratore (per la precisione la la
2381 \itindex{capabilities} capability \const{CAP\_SYS\_TIME}), altrimenti la
2382 chiamata fallirà con un errore di \errcode{EPERM}.
2384 Data la scarsa precisione nell'uso di \type{time\_t}, che ha una risoluzione
2385 massima di un secondo, quando si devono effettuare operazioni sui tempi di
2386 norma l'uso delle due funzioni precedenti è sconsigliato, ed esse sono di
2387 solito sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le
2388 due funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
2389 \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
2390 in BSD4.3 sono indicate come sostitute delle precedenti, \func{gettimeofday}
2391 viene descritta anche in POSIX.1-2001.} i cui prototipi sono:
2396 \fdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
2397 \fdesc{Legge il tempo corrente del sistema.}
2398 \fdecl{int settimeofday(const struct timeval *tv, const struct timezone *tz)}
2399 \fdesc{Imposta il tempo di sistema.}
2402 {La funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
2403 caso \var{errno} assumerà i valori \errval{EINVAL}, \errval{EFAULT} e per
2404 \func{settimeofday} anche \errval{EPERM}, nel loro significato generico.}
2408 Si noti come queste funzioni utilizzino per indicare il tempo una struttura di
2409 tipo \struct{timeval}, la cui definizione si è già vista in
2410 fig.~\ref{fig:sys_timeval_struct}, questa infatti permette una espressione
2411 alternativa dei valori del \textit{calendar time}, con una precisione,
2412 rispetto a \type{time\_t}, fino al microsecondo, ma la precisione è solo
2413 teorica, e la precisione reale della misura del tempo dell'orologio di sistema
2414 non dipende dall'uso di queste strutture.
2416 Come nel caso di \func{stime} anche \func{settimeofday} può essere utilizzata
2417 solo da un processo coi privilegi di amministratore e più precisamente con la
2418 \itindex{capability} capacità \const{CAP\_SYS\_TIME}. Si tratta comunque di
2419 una condizione generale che continua a valere per qualunque funzione che vada
2420 a modificare l'orologio di sistema, comprese tutte quelle che tratteremo in
2423 Il secondo argomento di entrambe le funzioni è una struttura
2424 \struct{timezone}, che storicamente veniva utilizzata per specificare appunto
2425 la \itindex{timezone} \textit{timezone}, cioè l'insieme del fuso orario e
2426 delle convenzioni per l'ora legale che permettevano il passaggio dal tempo
2427 universale all'ora locale. Questo argomento oggi è obsoleto ed in Linux non è
2428 mai stato utilizzato; esso non è supportato né dalle vecchie \textsl{libc5},
2429 né dalle \textsl{glibc}: pertanto quando si chiama questa funzione deve essere
2430 sempre impostato a \val{NULL}.
2432 Modificare l'orologio di sistema con queste funzioni è comunque problematico,
2433 in quanto esse effettuano un cambiamento immediato. Questo può creare dei
2434 buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
2435 conseguenze indesiderate. Ad esempio se si porta avanti l'orologio si possono
2436 perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
2437 saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
2438 delle operazioni previste nell'intervallo di tempo che viene ripetuto.
2440 Per questo motivo la modalità più corretta per impostare l'ora è quella di
2441 usare la funzione \funcd{adjtime}, il cui prototipo è:
2445 \fdecl{int adjtime(const struct timeval *delta, struct timeval *olddelta)}
2446 \fdesc{Aggiusta l'orologio di sistema.}
2449 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
2450 caso \var{errno} assumerà uno dei valori:
2452 \item[\errcode{EINVAL}] il valore di \param{delta} eccede il massimo
2454 \item[\errcode{EPERM}] il processo non i privilegi di amministratore.
2460 Questa funzione permette di avere un aggiustamento graduale del tempo di
2461 sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
2462 indicato nella struttura \struct{timeval} puntata da \param{delta} esprime il
2463 valore di cui si vuole spostare l'orologio. Se è positivo l'orologio sarà
2464 accelerato per un certo tempo in modo da guadagnare il tempo richiesto,
2465 altrimenti sarà rallentato.
2467 La funzione è intesa per piccoli spostamenti del tempo di sistema, ed esistono
2468 pertanto dei limiti massimi per i valori che si possono specificare
2469 per \param{delta}. La \acr{glibc} impone un intervallo compreso fra
2470 \code{INT\_MIN/1000000 + 2} e \code{INT\_MAX/1000000 - 2}, corrispondente, su
2471 una architettura PC ordinaria a 32 bit, ad un valore compreso fra $-2145$ e
2474 Inoltre se si invoca la funzione prima che una precedente richiesta di
2475 aggiustamento sia stata completata, specificando un altro valore, il
2476 precedente aggiustamento viene interrotto, ma la parte dello stesso che è già
2477 stata completata non viene rimossa. Però è possibile in questo caso farsi
2478 restituire nella struttura puntata da \param{olddelta} il tempo restante della
2479 precedente richiesta. Fino al kernel 2.6.26 ed alla \acr{glibc} 2.8 questo
2480 però era possibile soltanto specificando un diverso aggiustamento
2481 per \param{delta}, il bug è stato corretto a partire dalle versioni citate e
2482 si può ottenere l'informazione relativa alla frazione di aggiustamento
2483 mancante usando il valore \val{NULL} per \param{delta}.
2485 Linux poi prevede una specifica funzione di sistema che consente un
2486 aggiustamento molto più dettagliato del tempo, permettendo ad esempio anche di
2487 regolare anche la velocità e le derive dell'orologio di sistema. La funzione
2488 è \funcd{adjtimex} ed il suo prototipo è:
2492 \fdecl{int adjtimex(struct timex *buf)}
2493 \fdesc{Regola l'orologio di sistema.}
2496 {La funzione ritorna lo stato dell'orologio (un valore $\ge 0$) in caso di
2497 successo e $-1$ per un errore, nel qual caso \var{errno} assumerà uno dei
2500 \item[\errcode{EINVAL}] si sono indicati valori fuori dall'intervallo
2501 consentito per qualcuno dei campi di \param{buf}.
2502 \item[\errcode{EPERM}] si è richiesta una modifica dei parametri ed il
2503 processo non ha i privilegi di amministratore.
2505 ed inoltre \errval{EFAULT} nel suo significato generico.}
2508 In caso di successo la funzione restituisce un valore numerico non negativo
2509 che indica lo stato dell'orologio, che può essere controllato con i valori
2510 delle costanti elencate in tab.~\ref{tab:adjtimex_return}.
2515 \begin{tabular}[c]{|l|c|l|}
2517 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2520 \const{TIME\_OK} & 0 & Orologio sincronizzato.\\
2521 \const{TIME\_INS} & 1 & Inserimento di un \textit{leap second}.\\
2522 \const{TIME\_DEL} & 2 & Cancellazione di un \textit{leap second}.\\
2523 \const{TIME\_OOP} & 3 & \textit{leap second} in corso.\\
2524 \const{TIME\_WAIT} & 4 & \textit{leap second} avvenuto.\\
2525 \const{TIME\_BAD} & 5 & Orologio non sincronizzato.\\
2528 \caption{Possibili valori ritornati da \func{adjtimex} in caso di successo.}
2529 \label{tab:adjtimex_return}
2532 La funzione richiede come argomento il puntatore ad una struttura di tipo
2533 \struct{timex}, la cui definizione, effettuata in \headfile{sys/timex.h}, è
2534 riportata in fig.~\ref{fig:sys_timex_struct} per i campi che interessano la
2535 possibilità di essere modificati documentati anche nella pagina di manuale. In
2536 realtà la struttura è stata estesa con ulteriori campi, i cui valori sono
2537 utilizzabili solo in lettura, la cui definizione si può trovare direttamente
2539 \begin{figure}[!htb]
2540 \footnotesize \centering
2541 \begin{minipage}[c]{\textwidth}
2542 \includestruct{listati/timex.h}
2545 \caption{La struttura \structd{timex} per il controllo dell'orologio di
2547 \label{fig:sys_timex_struct}
2550 L'azione della funzione dipende dal valore del campo \var{mode}
2551 di \param{buf}, che specifica quale parametro dell'orologio di sistema,
2552 specificato nel corrispondente campo di \struct{timex}, deve essere
2553 impostato. Un valore nullo serve per leggere i parametri correnti, i valori
2554 diversi da zero devono essere specificati come OR binario delle costanti
2555 riportate in tab.~\ref{tab:sys_timex_mode}.
2560 \begin{tabular}[c]{|l|c|p{8cm}|}
2562 \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
2565 \const{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
2566 reale e l'orologio di sistema:
2567 deve essere indicata in microsecondi
2568 nel campo \var{offset} di
2570 \const{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenza in frequenza
2571 fra il tempo reale e l'orologio di
2572 sistema: deve essere indicata
2573 in parti per milione nel campo
2574 \var{frequency} di \struct{timex}.\\
2575 \const{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo
2576 dell'errore sul tempo, espresso in
2577 microsecondi nel campo
2578 \var{maxerror} di \struct{timex}.\\
2579 \const{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
2580 sul tempo, espresso in microsecondi
2581 nel campo \var{esterror} di
2583 \const{ADJ\_STATUS} & 0x0010 & Imposta alcuni valori di stato
2585 sistema nella gestione
2586 dell'orologio specificati nel campo
2587 \var{status} di \struct{timex}.\\
2588 \const{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del
2589 PLL implementato dal kernel,
2590 specificato nel campo
2591 \var{constant} di \struct{timex}.\\
2592 \const{ADJ\_TICK} & 0x4000 & Imposta il valore dei \textit{tick}
2593 \itindex{clock~tick} del timer in
2594 microsecondi, espresso nel campo
2595 \var{tick} di \struct{timex}.\\
2596 \const{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Chiede uno spostamento una tantum
2597 dell'orologio secondo il valore del
2598 campo \var{offset} simulando il
2599 comportamento di \func{adjtime}.\\
2602 \caption{Costanti per l'assegnazione del valore del campo \var{mode} della
2603 struttura \struct{timex}.}
2604 \label{tab:sys_timex_mode}
2607 La funzione utilizza il meccanismo di David L. Mills, descritto
2608 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
2609 protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
2610 portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
2611 \func{ntp\_adjtime}. La trattazione completa di questa funzione necessita di
2612 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
2613 a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
2614 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
2615 campi della struttura \struct{timex} può essere ritrovato in \cite{GlibcMan}.
2617 Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
2618 sintassi specificata per la forma equivalente di questa funzione definita come
2619 \func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
2622 Si tenga presente infine che con l'introduzione a partire dal kernel 2.6.21
2623 degli \itindex{High~Resolution~Timer~(HRT)} \textit{high-resolution timer} ed
2624 il supporto per i cosiddetti POSIX \textit{real-time clock}, si può ottenere
2625 il \textit{calendar time} direttamente da questi, come vedremo in
2626 sez.~\ref{sec:sig_timer_adv}, con la massima risoluzione possibile per
2627 l'hardware della macchina.
2631 \subsection{La gestione delle date.}
2632 \label{sec:sys_date}
2634 \itindbeg{broken-down~time}
2636 Le funzioni viste al paragrafo precedente sono molto utili per trattare le
2637 operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
2638 illustrate, se han senso per specificare un intervallo, non sono molto
2639 intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
2640 stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
2641 time}, che permette appunto di \textsl{suddividere} il \textit{calendar
2642 time} usuale in ore, minuti, secondi, ecc. e viene usata tenendo conto
2643 anche dell'eventuale utilizzo di un fuso orario.
2645 \begin{figure}[!htb]
2646 \footnotesize \centering
2647 \begin{minipage}[c]{.8\textwidth}
2648 \includestruct{listati/tm.h}
2651 \caption{La struttura \structd{tm} per una rappresentazione del tempo in
2652 termini di ora, minuti, secondi, ecc.}
2653 \label{fig:sys_tm_struct}
2656 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
2657 definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
2658 struttura che si utilizza quando si deve specificare un tempo a partire dai
2659 dati naturali (ora e data), dato che essa consente anche di tenere conto della
2660 gestione del fuso orario e dell'ora legale. In particolare gli ultimi due
2661 campi, \var{tm\_gmtoff} e \var{tm\_zone}, sono estensioni previste da BSD e
2662 supportate dalla \acr{glibc} quando è definita la macro \macro{\_BSD\_SOURCE}.
2664 Ciascuno dei campi di \struct{tm} ha dei precisi intervalli di valori
2665 possibili, con convenzioni purtroppo non troppo coerenti. Ad esempio
2666 \var{tm\_sec} che indica i secondi deve essere nell'intervallo da 0 a 59, ma è
2667 possibile avere anche il valore 60 per un cosiddetto \textit{leap second} (o
2668 \textsl{secondo intercalare}), cioè uno di quei secondi aggiunti al calcolo
2669 dell'orologio per effettuare gli aggiustamenti del calendario per tenere conto
2670 del disallineamento con il tempo solare.\footnote{per dettagli si consulti
2671 \url{http://it.wikipedia.org/wiki/Leap_second}.}
2673 I campi \var{tm\_min} e\var{tm\_hour} che indicano rispettivamente minuti ed
2674 ore hanno valori compresi rispettivamente fra 0 e 59 e fra 0 e 23. Il campo
2675 \var{tm\_mday} che indica il giorno del mese prevede invece un valore compreso
2676 fra 1 e 31, ma la \acr{glibc} supporta pure il valore 0 come indicazione
2677 dell'ultimo giorno del mese precedente. Il campo \var{tm\_mon} indica il mese
2678 dell'anno a partire da gennaio con valori compresi fra 0 e 11.
2680 I campi \var{tm\_wday} e \var{tm\_yday} indicano invece rispettivamente il
2681 giorno della settimana, a partire dalla Domenica, ed il giorno dell'anno, a
2682 partire del primo gennaio, ed hanno rispettivamente valori compresi fra 0 e 6
2683 e fra 0 e 365. L'anno espresso da \var{tm\_year} viene contato come numero di
2684 anni a partire dal 1900. Infine \var{tm\_isdst} è un valore che indica se per
2685 gli altri campi si intende come attiva l'ora legale ed influenza il
2686 comportamento di \func{mktime}.
2689 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
2690 da quelle usate per convertire gli altri formati in questo, usando o meno
2691 l'ora locale o il tempo universale, a quelle per trasformare il valore di un
2692 tempo in una stringa contenente data ed ora. Le prime due funzioni,
2693 \funcd{asctime} e \funcd{ctime} servono per poter stampare in forma leggibile
2694 un tempo, i loro prototipi sono:
2698 \fdecl{char * asctime(const struct tm *tm)}
2699 \fdesc{Converte un \textit{broken-down time} in una stringa.}
2700 \fdecl{char * ctime(const time\_t *timep)}
2701 \fdesc{Converte un \textit{calendar time} in una stringa.}
2704 {Le funzioni ritornano un puntatore al risultato in caso di successo e
2705 \val{NULL} per un errore, \var{errno} non viene modificata.}
2708 Le funzioni prendono rispettivamente come argomenti i puntatori ad una
2709 struttura \struct{tm} contenente un \textit{broken-down time} o ad una
2710 variabile di tipo \type{time\_t} che esprime il \textit{calendar time},
2711 restituendo il puntatore ad una stringa che esprime la data, usando le
2712 abbreviazioni standard di giorni e mesi in inglese, nella forma:
2714 Sun Apr 29 19:47:44 2012\n"
2717 Nel caso di \func{ctime} la funzione tiene conto della eventuale impostazione
2718 di una \itindex{timezone} \textit{timezone} e effettua una chiamata preventiva
2719 a \func{tzset} (che vedremo a breve), in modo che la data espressa tenga conto
2720 del fuso orario. In realtà \func{ctime} è banalmente definita in termini di
2721 \func{asctime} come \code{asctime(localtime(t)}.
2723 Dato che l'uso di una stringa statica rende le funzioni non
2724 \index{funzioni!rientranti} rientranti POSIX.1c e SUSv2 prevedono due
2725 sostitute \index{funzioni!rientranti} rientranti, il cui nome è al solito
2726 ottenuto aggiungendo un \code{\_r}, che prendono un secondo argomento
2727 \code{char *buf}, in cui l'utente deve specificare il buffer su cui la stringa
2728 deve essere copiata (deve essere di almeno 26 caratteri).
2730 Per la conversione fra \textit{broken-down time} e \textit{calendar time} sono
2731 invece disponibili altre tre funzioni, \funcd{gmtime}, \funcd{localtime} e
2732 \funcd{mktime} i cui prototipi sono:
2735 \fdecl{struct tm * gmtime(const time\_t *timep)}
2736 \fdesc{Converte un \textit{calendar time} in un \textit{broken-down time} in
2738 \fdecl{struct tm * localtime(const time\_t *timep)}
2739 \fdesc{Converte un \textit{calendar time} in un \textit{broken-down time}
2741 \fdecl{time\_t mktime(struct tm *tm)}
2742 \fdesc{Converte un \textit{broken-down time} in un \textit{calendar time}.}
2746 {Le funzioni ritornano un puntatore al risultato in caso di successo e
2747 \val{NULL} per un errore, tranne tranne che \func{mktime} che restituisce
2748 direttamente il valore o $-1$ in caso di errore, \var{errno} non viene
2752 Le le prime funzioni, \func{gmtime}, \func{localtime} servono per convertire
2753 il tempo in \textit{calendar time} specificato da un argomento di tipo
2754 \type{time\_t} restituendo un \textit{broken-down time} con il puntatore ad
2755 una struttura \struct{tm}. La prima effettua la conversione senza tenere conto
2756 del fuso orario, esprimendo la data in tempo coordinato universale (UTC), cioè
2757 l'ora di Greenwich, mentre \func{localtime} usa l'ora locale e per questo
2758 effettua una chiamata preventiva a \func{tzset}.
2760 Anche in questo caso le due funzioni restituiscono l'indirizzo di una
2761 struttura allocata staticamente, per questo sono state definite anche altre
2762 due versioni \index{funzioni!rientranti} rientranti (con la solita estensione
2763 \code{\_r}), che prevedono un secondo argomento \code{struct tm *result},
2764 fornito dal chiamante, che deve preallocare la struttura su cui sarà
2765 restituita la conversione. La versione rientrante di \func{localtime} però non
2766 effettua la chiamata preventiva a \func{tzset} che deve essere eseguita a cura
2769 Infine \func{mktime} esegue la conversione di un \textit{broken-down time} a
2770 partire da una struttura \struct{tm} restituendo direttamente un valore di
2771 tipo \type{time\_t} con il \textit{calendar time}. La funzione ignora i campi
2772 \var{tm\_wday} e \var{tm\_yday} e per gli altri campi normalizza eventuali
2773 valori fuori degli intervalli specificati in precedenza: se cioè si indica un
2774 12 per \var{tm\_mon} si prenderà il gennaio dell'anno successivo. Inoltre la
2775 funzione tiene conto del valore di \var{tm\_isdst} per effettuare le
2776 correzioni relative al fuso orario: un valore positivo indica che deve essere
2777 tenuta in conto l'ora legale, un valore nullo che non deve essere applicata
2778 nessuna correzione, un valore negativo che si deve far ricorso alle
2779 informazioni relative al proprio fuso orario per determinare lo stato dell'ora
2782 La funzione inoltre modifica i valori della struttura \struct{tm} in forma di
2783 \itindex{value~result~argument} \textit{value result argument}, normalizzando
2784 i valori dei vari campi, impostando i valori risultanti per \var{tm\_wday} e
2785 \var{tm\_yday} e assegnando a \var{tm\_isdst} il valore (positivo o nullo)
2786 corrispondente allo stato dell'ora legale. La funzione inoltre provvede ad
2787 impostare il valore della \index{variabili!globali} variabile globale
2790 \itindend{calendar~time}
2792 \begin{figure}[!htb]
2795 \begin{minipage}[c]{.75\textwidth}
2796 \includestruct{listati/time_zone_var.c}
2799 \caption{Le \index{variabili!globali} variabili globali usate per la
2800 gestione delle \itindex{timezone} \textit{timezone}.}
2801 \label{fig:sys_tzname}
2804 Come accennato l'uso del \textit{broken-down time} permette di tenere conto
2805 anche della differenza fra tempo universale e ora locale, compresa l'eventuale
2806 ora legale. Questo viene fatto dalle funzioni di conversione grazie alle
2807 informazioni riguardo la propria \itindex{timezone} \textit{timezone}
2808 mantenute nelle tre \index{variabili!globali} variabili globali mostrate in
2809 fig.~\ref{fig:sys_tzname}, cui si si può accedere direttamente includendo
2810 \headfile{time.h}. Come illustrato queste variabili vengono impostate
2811 internamente da alcune delle delle precedenti funzioni di conversione, ma lo
2812 si può fare esplicitamente chiamando direttamente la funzione \funcd{tzset},
2817 \fdecl{void tzset(void)}
2818 \fdesc{Imposta le variabili globali della \textit{timezone}.}
2821 {La funzione non ritorna niente e non dà errori.}
2824 La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire
2825 dal valore della variabile di ambiente \envvar{TZ}, se quest'ultima non è
2826 definita verrà usato il file \conffile{/etc/localtime}. La variabile
2827 \var{tzname} contiene due stringhe, che indicano i due nomi standard della
2828 \itindex{timezone} \textit{timezone} corrente. La prima è il nome per l'ora
2829 solare, la seconda per l'ora legale. Anche se in fig.~\ref{fig:sys_tzname}
2830 sono indicate come \code{char *} non è il caso di modificare queste
2831 stringhe. La variabile \var{timezone} indica la differenza di fuso orario in
2832 secondi, mentre \var{daylight} indica se è attiva o meno l'ora legale.
2834 Benché la funzione \func{asctime} fornisca la modalità più immediata per
2835 stampare un tempo o una data, la flessibilità non fa parte delle sue
2836 caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
2837 giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
2842 \fdecl{size\_t strftime(char *s, size\_t max, const char *format,
2843 const struct tm *tm)}
2844 \fdesc{Crea una stringa con una data secondo il formato indicato.}
2847 {La funzione ritorna il numero di caratteri inseriti nella stringa \param{s}
2848 oppure $0$, \var{errno} non viene modificata.}
2852 La funzione converte il \textit{broken-down time} indicato nella struttura
2853 puntata dall'argomento \param{tm} in una stringa di testo da salvare
2854 all'indirizzo puntato dall'argomento \param{s}, purché essa sia di dimensione
2855 inferiore al massimo indicato dall'argomento \param{max}. Il numero di
2856 caratteri generati dalla funzione viene restituito come valore di ritorno,
2857 senza tener però conto del terminatore finale, che invece viene considerato
2858 nel computo della dimensione. Se quest'ultima è eccessiva viene restituito 0 e
2859 lo stato di \param{s} è indefinito.
2864 \begin{tabular}[c]{|c|l|p{6cm}|}
2866 \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
2869 \var{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
2870 \var{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
2871 \var{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
2872 \var{\%B}&\texttt{April} & Nome del mese, completo.\\
2873 \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
2874 \var{\%d}&\texttt{24} & Giorno del mese.\\
2875 \var{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
2876 \var{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
2877 \var{\%j}&\texttt{114} & Giorno dell'anno.\\
2878 \var{\%m}&\texttt{04} & Mese dell'anno.\\
2879 \var{\%M}&\texttt{40} & Minuto.\\
2880 \var{\%p}&\texttt{PM} & AM/PM.\\
2881 \var{\%S}&\texttt{50} & Secondo.\\
2882 \var{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
2884 \var{\%w}&\texttt{3} & Giorno della settimana.\\
2885 \var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
2887 \var{\%x}&\texttt{04/24/02} & La data.\\
2888 \var{\%X}&\texttt{18:40:50} & L'ora.\\
2889 \var{\%y}&\texttt{02} & Anno nel secolo.\\
2890 \var{\%Y}&\texttt{2002} & Anno.\\
2891 \var{\%Z}&\texttt{CEST} & Nome della \itindex{timezone}
2892 \textit{timezone}.\\
2893 \var{\%\%}&\texttt{\%} & Il carattere \%.\\
2896 \caption{Valori previsti dallo standard ANSI C per modificatore della
2897 stringa di formato di \func{strftime}.}
2898 \label{tab:sys_strftime_format}
2901 Il risultato della funzione è controllato dalla stringa di formato
2902 \param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
2903 viene utilizzato come modificatore. Alcuni dei possibili valori che esso può
2904 assumere sono riportati in tab.~\ref{tab:sys_strftime_format}.\footnote{per la
2905 precisione si sono riportati definiti dallo standard ANSI C, che sono anche
2906 quelli ripresi in POSIX.1; le \acr{glibc} forniscono anche le estensioni
2907 introdotte da POSIX.2 per il comando \cmd{date}, i valori introdotti da
2908 SVID3 e ulteriori estensioni GNU; l'elenco completo dei possibili valori è
2909 riportato nella pagina di manuale della funzione.} La funzione tiene conto
2910 anche delle eventuali impostazioni di localizzazione per stampare i vari nomi
2911 in maniera adeguata alla lingua scelta, e con le convenzioni nazionali per i
2912 formati di data ed ora.
2914 Infine per effettuare l'operazione di conversione inversa, da una stringa ad
2915 un \textit{broken-down time}, si può utilizzare la funzione \funcd{strptime},
2920 \fdecl{char *strptime(const char *s, const char *format, struct tm *tm)}
2921 \fdesc{Converte una stringa con in un \textit{broken-down time} secondo un
2925 {La funzione ritorna il puntatore al primo carattere non processato della
2926 stringa o al terminatore finale qualora questa sia processata interamente,
2927 \var{errno} non viene modificata.}
2930 La funzione processa la stringa puntata dall'argomento \param{s} da sinistra a
2931 destra, utilizzando il formato contenuto nella stringa puntata
2932 dall'argomento \param{format}, avvalorando volta volta i corrispondenti campi
2933 della struttura puntata dall'argomento \param{tm}. La scansione si interrompe
2934 immediatamente in caso di mancata corrispondenza a quanto indicato nella
2935 stringa di formato, che usa una sintassi analoga a quella già vista per
2936 \func{strftime}. La funzione supporta i modificatori di
2937 tab.~\ref{tab:sys_strftime_format} più altre estensioni, ma per i dettagli a
2938 questo riguardo si rimanda alla lettura della pagina di manuale.
2940 Si tenga presente comunque che anche in caso di scansione completamente
2941 riuscita la funzione sovrascrive soltanto i campi di \param{tm} indicati dal
2942 formato, la struttura originaria infatti non viene inizializzati e gli altri
2943 campi restano ai valori che avevano in precedenza.
2946 \itindend{broken-down~time}
2948 \section{La gestione degli errori}
2949 \label{sec:sys_errors}
2951 In questa sezione esamineremo le caratteristiche principali della gestione
2952 degli errori in un sistema unix-like. Infatti a parte il caso particolare di
2953 alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
2954 unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
2955 un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
2956 semplicemente usando un opportuno valore di ritorno della funzione invocata.
2957 Inoltre il sistema di classificazione degli errori è stato progettato
2958 sull'architettura a processi, e presenta una serie di problemi nel caso lo si
2959 debba usare con i \itindex{thread} \textit{thread}.
2962 \subsection{La variabile \var{errno}}
2963 \label{sec:sys_errno}
2965 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
2966 riportare condizioni di errore, ed è una norma fondamentale di buona
2967 programmazione controllare \textsl{sempre} che le funzioni chiamate si siano
2968 concluse correttamente.
2970 In genere le funzioni di libreria usano un valore speciale per indicare che
2971 c'è stato un errore. Di solito questo valore, a seconda della funzione, è $-1$
2972 o un puntatore nullo o la costante \val{EOF}; ma questo valore segnala solo
2973 che c'è stato un errore, e non il tipo di errore.
2975 Per riportare il tipo di errore il sistema usa \index{variabili!globali} la
2976 variabile globale \var{errno}, definita nell'header \headfile{errno.h}. Come
2977 accennato l'uso di una variabile globale può comportare problemi nel caso dei
2978 \itindex{thread} \textit{thread}, ma lo standard ISO C consente anche di
2979 definire \var{errno} come un cosiddetto ``\textit{modifiable lvalue}'', cosa
2980 che consente di usare anche una macro, e questo è infatti il metodo usato da
2981 Linux per renderla locale ai singoli \itindex{thread} \textit{thread}.
2983 La variabile è in genere definita come \direct{volatile} dato che può essere
2984 cambiata in modo asincrono da un segnale, per un esempio si veda
2985 sez.~\ref{sec:sig_sigchld} ricordando quanto trattato in
2986 sez.~\ref{sec:proc_race_cond}). Dato che un gestore di segnale scritto bene si
2987 cura di salvare e ripristinare il valore della variabile all'uscita, nella
2988 programmazione normale, quando si può fare l'assunzione che i gestori di
2989 segnali siano ben scritti, di questo non è necessario preoccuparsi.
2991 I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
2992 nell'header \headfile{errno.h} sono anche definiti i nomi simbolici per le
2993 costanti numeriche che identificano i vari errori che abbiamo citato fin
2994 dall'inizio nelle descrizioni delle funzioni. Essi iniziano tutti per \val{E}
2995 e si possono considerare come nomi riservati, per questo abbiamo sempre fatto
2996 riferimento a questi nomi, e lo faremo più avanti quando descriveremo i
2997 possibili errori restituiti dalle funzioni. Il programma di esempio
2998 \cmd{errcode} stampa il codice relativo ad un valore numerico con l'opzione
3001 Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
3002 programma, e la gran parte delle funzioni di libreria impostano \var{errno} ad
3003 un valore diverso da zero in caso di errore. Il valore è invece indefinito in
3004 caso di successo, perché anche se una funzione di libreria ha successo,
3005 potrebbe averne chiamate altre al suo interno che potrebbero essere fallite
3006 anche senza compromettere il risultato finale, modificando però \var{errno}.
3008 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
3009 essere il risultato di un errore precedente) e non lo si può usare per
3010 determinare quando o se una chiamata a funzione è fallita. La procedura
3011 corretta da seguire per identificare un errore è sempre quella di controllare
3012 \var{errno} immediatamente dopo aver verificato il fallimento della funzione
3013 attraverso il suo codice di ritorno.
3016 \subsection{Le funzioni \func{strerror} e \func{perror}}
3017 \label{sec:sys_strerror}
3019 Benché gli errori siano identificati univocamente dal valore numerico di
3020 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
3021 riportare in opportuni messaggi le condizioni di errore verificatesi. La
3022 prima funzione che si può usare per ricavare i messaggi di errore è
3023 \funcd{strerror}, il cui prototipo è:
3027 \fdecl{char *strerror(int errnum)}
3028 \fdesc{Restituisce una stringa con un messaggio di errore.}
3031 {La funzione ritorna il puntatore alla stringa con il messaggio di errore,
3032 \var{errno} non viene modificato.}
3035 La funzione ritorna il puntatore alla stringa contenente il messaggio di
3036 errore corrispondente al valore di \param{errnum}, se questo non è un valore
3037 valido verrà comunque restituita una stringa valida contenente un messaggio
3038 che dice che l'errore è sconosciuto nella forma. La versione della \acr{glibc}
3039 non modifica il valore di \var{errno} in caso di errore, ma questo non è detto
3040 valga per altri sistemi in quanto lo standard POSIX.1-2001 permette che ciò
3041 avvenga. Non si faccia affidamento su questa caratteristica se si vogliono
3042 scrivere programmi portabili.
3044 In generale \func{strerror} viene usata passando direttamente \var{errno} come
3045 argomento, ed il valore di quest'ultima non verrà modificato. La funzione
3046 inoltre tiene conto del valore della variabile di ambiente
3047 \envvar{LC\_MESSAGES} per usare le appropriate traduzioni dei messaggi
3048 d'errore nella localizzazione presente.
3050 La funzione \func{strerror} utilizza una stringa statica che non deve essere
3051 modificata dal programma; essa è utilizzabile solo fino ad una chiamata
3052 successiva a \func{strerror} o \func{perror} e nessun'altra funzione di
3053 libreria tocca questa stringa. In ogni caso l'uso di una stringa statica rende
3054 la funzione non \index{funzioni!rientranti} rientrante, per cui nel caso si
3055 usino i \itindex{thread} \textit{thread} la \acr{glibc} fornisce una apposita
3056 versione \index{funzioni!rientranti} rientrante \funcd{strerror\_r}, il cui
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 \itindex{thread} \textit{thread} deve
3085 allocare autonomamente per evitare i problemi connessi alla condivisione del
3086 buffer statico. Il messaggio è copiato fino alla dimensione massima del
3087 buffer, 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
3110 \index{variabili!globali} variabili globali:
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}.
3117 \begin{figure}[!htbp]
3118 \footnotesize \centering
3119 \begin{minipage}[c]{\codesamplewidth}
3120 \includecodesample{listati/errcode_mess.c}
3123 \caption{Codice per la stampa del messaggio di errore standard.}
3124 \label{fig:sys_err_mess}
3127 In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
3128 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
3129 errore e le costanti usate per identificare i singoli errori. Il sorgente
3130 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
3131 gestione delle opzioni e tutte le definizioni necessarie ad associare il
3132 valore numerico alla costante simbolica. In particolare si è riportata la
3133 sezione che converte la stringa passata come argomento in un intero
3134 (\texttt{\small 1-2}), controllando con i valori di ritorno di \funcm{strtol}
3135 che la conversione sia avvenuta correttamente (\texttt{\small 4-10}), e poi
3136 stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
3137 11-14}) o la macro (\texttt{\small 15-17}) associate a quel codice.
3141 \subsection{Alcune estensioni GNU}
3142 \label{sec:sys_err_GNU}
3144 Le precedenti funzioni sono quelle definite ed usate nei vari standard; le
3145 \acr{glibc} hanno però introdotto una serie di estensioni ``GNU'' che
3146 forniscono alcune funzionalità aggiuntive per una gestione degli errori
3147 semplificata e più efficiente.
3149 La prima estensione consiste in due variabili, \code{char *
3150 program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
3151 che consentono di ricavare il nome del proprio programma. Queste sono utili
3152 quando si deve aggiungere il nome del programma al messaggio d'errore, cosa
3153 comune quando si ha un programma che non viene lanciato da linea di comando e
3154 salva gli errori in un file di log. La prima contiene il nome usato per
3155 lanciare il programma dalla shell ed in sostanza è equivalente ad
3156 \code{argv[0]}; la seconda mantiene solo il nome del programma eliminando
3157 eventuali directory qualora questo sia stato lanciato con un
3160 Una seconda estensione cerca di risolvere uno dei problemi che si hanno con
3161 l'uso di \func{perror}, dovuto al fatto che non c'è flessibilità su quello che
3162 si può aggiungere al messaggio di errore, che può essere solo una stringa. In
3163 molte occasioni invece serve poter scrivere dei messaggi con maggiori
3164 informazioni. Ad esempio negli standard di programmazione GNU si richiede che
3165 ogni messaggio di errore sia preceduto dal nome del programma, ed in generale
3166 si può voler stampare il contenuto di qualche variabile per facilitare la
3167 comprensione di un eventuale problema. Per questo le \acr{glibc} definiscono
3168 la funzione \funcd{error}, il cui prototipo è:
3172 \fdecl{void error(int status, int errnum, const char *format, ...)}
3173 \fdesc{Stampa un messaggio di errore formattato.}
3176 {La funzione non ritorna nulla e non riporta errori.}
3179 La funzione fa parte delle estensioni GNU per la gestione degli errori,
3180 l'argomento \param{format} segue la stessa sintassi di \func{printf} (vedi
3181 sez.~\ref{sec:file_formatted_io}), ed i relativi argomenti devono essere
3182 forniti allo stesso modo, mentre \param{errnum} indica l'errore che si vuole
3183 segnalare (non viene quindi usato il valore corrente di \var{errno}).
3185 La funzione stampa sullo \itindex{standard~error} \textit{standard error} il
3186 nome del programma, come indicato dalla \index{variabili!globali} variabile
3187 globale \var{program\_name}, seguito da due punti ed uno spazio, poi dalla
3188 stringa generata da \param{format} e dagli argomenti seguenti, seguita da due
3189 punti ed uno spazio infine il messaggio di errore relativo ad \param{errnum},
3190 il tutto è terminato da un a capo.
3192 Il comportamento della funzione può essere ulteriormente controllato se si
3193 definisce una variabile \var{error\_print\_progname} come puntatore ad una
3194 funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
3195 il nome del programma.
3197 L'argomento \param{status} può essere usato per terminare direttamente il
3198 programma in caso di errore, nel qual caso \func{error} dopo la stampa del
3199 messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
3200 il valore è nullo \func{error} ritorna normalmente ma viene incrementata
3201 un'altra \index{variabili!globali} variabile globale,
3202 \var{error\_message\_count}, che tiene conto di quanti errori ci sono stati.
3204 Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
3205 prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
3206 l'errore è \funcd{error\_at\_line}; il suo prototipo è:
3210 \fdecl{void error\_at\_line(int status, int errnum, const char *fname,
3211 unsigned int lineno, \\
3212 \phantom{void error\_at\_line(}const char *format, ...)}
3213 \fdesc{Stampa un messaggio di errore formattato.}
3216 {La funzione non ritorna nulla e non riporta errori.}
3219 \noindent ed il suo comportamento è identico a quello di \func{error} se non
3220 per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
3221 nome di file indicato da \param{fname} ed un numero di linea subito dopo la
3222 stampa del nome del programma. Inoltre essa usa un'altra
3223 \index{variabili!globali} variabile globale, \var{error\_one\_per\_line}, che
3224 impostata ad un valore diverso da zero fa si che errori relativi alla stessa
3225 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 NSS
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
3285 %%% Local Variables:
3287 %%% TeX-master: "gapil"