1 \chapter{La gestione del sistema, delle risorse, e degli errori}
4 In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
5 generali del sistema, come quelle per la gestione di parametri e
6 configurazione, quelle per la lettura dei limiti e delle caratteristiche dello
7 stesso, quelle per il controllo dell'uso delle risorse da parte dei processi,
8 quelle per la gestione dei tempi e degli errori.
12 \section{La lettura delle caratteristiche del sistema}
13 \label{sec:sys_characteristics}
15 In questa sezione tratteremo le varie modalità con cui un programma può
16 ottenere informazioni riguardo alle capacità del sistema. Ogni sistema infatti
17 è contraddistinto da un gran numero di limiti e costanti che lo
18 caratterizzano, e che possono dipendere da fattori molteplici, come
19 l'architettura hardware, l'implementazione del kernel e delle librerie, le
20 opzioni di configurazione.
22 La definizione di queste caratteristiche ed il tentativo di provvedere dei
23 meccanismi generali che i programmi potessero usare per ricavarle è uno degli
24 aspetti più complessi e controversi coi cui i vari standard si sono dovuti
25 confrontare, spesso con risultati spesso tutt'altro che chiari. Proveremo
26 comunque a dare una descrizione dei principali metodi previsti dai vari
27 standard per ricavare sia le caratteristiche specifiche del sistema, che
31 \subsection{Limiti e parametri di sistema}
32 \label{sec:sys_limits}
34 Quando si devono determinare le le caratteristiche generali del sistema ci si
35 trova di fronte a diverse possibilità; alcune di queste infatti possono
36 dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
37 interi), o dal sistema operativo (come la presenza o meno dei \textit{saved
38 id}), altre invece possono dipendere dalle opzioni con cui si è costruito
39 il sistema (ad esempio da come si è compilato il kernel), o dalla
40 configurazione del medesimo; per questo motivo in generale sono necessari due
41 tipi diversi di funzionalità:
43 \item la possibilità di determinare limiti ed opzioni al momento della
45 \item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
48 La prima funzionalità si può ottenere includendo gli opportuni header file che
49 contengono le costanti necessarie definite come macro di preprocessore, per la
50 seconda invece sono ovviamente necessarie delle funzioni. La situazione è
51 complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
52 sono fissi in un'implementazione mentre possono variare in un altra. Tutto
53 questo crea una ambiguità che non è sempre possibile risolvere in maniera
54 chiara; in generale quello che succede è che quando i limiti del sistema sono
55 fissi essi vengono definiti come macro di preprocessore nel file
56 \file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
57 tramite la funzione \func{sysconf} (che esamineremo in
58 \secref{sec:sys_sysconf}).
60 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
61 saranno sempre disponibili al momento della compilazione; un elenco, ripreso
62 da \file{limits.h}, è riportato in \tabref{tab:sys_ansic_macro}. Come si può
63 vedere per la maggior parte questi limiti attengono alle dimensioni dei dati
64 interi, che sono in genere fissati dall'architettura hardware (le analoghe
65 informazioni per i dati in virgola mobile sono definite a parte, ed
66 accessibili includendo \file{float.h}). Lo standard prevede anche un'altra
67 costante, \macro{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
68 definita in \file{limits.h}; essa deve essere definita in \file{stdio.h} ed
69 avere un valore minimo di 8.
74 \begin{tabular}[c]{|l|r|l|}
76 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
79 \macro{MB\_LEN\_MAX}& 16 & massima dimensione di un
81 \macro{CHAR\_BIT} & 8 & bit di \ctyp{char}\\
82 \macro{UCHAR\_MAX}& 255 & massimo di \ctyp{unsigned char}\\
83 \macro{SCHAR\_MIN}& -128 & minimo di \ctyp{signed char}\\
84 \macro{SCHAR\_MAX}& 127 & massimo di \ctyp{signed char}\\
85 \macro{CHAR\_MIN} &\footnotemark& minimo di \ctyp{char}\\
86 \macro{CHAR\_MAX} &\footnotemark& massimo di \ctyp{char}\\
87 \macro{SHRT\_MIN} & -32768 & minimo di \ctyp{short}\\
88 \macro{SHRT\_MAX} & 32767 & massimo di \ctyp{short}\\
89 \macro{USHRT\_MAX}& 65535 & massimo di \ctyp{unsigned short}\\
90 \macro{INT\_MAX} & 2147483647 & minimo di \ctyp{int}\\
91 \macro{INT\_MIN} &-2147483648 & minimo di \ctyp{int}\\
92 \macro{UINT\_MAX} & 4294967295 & massimo di \ctyp{unsigned int}\\
93 \macro{LONG\_MAX} & 2147483647 & massimo di \ctyp{long}\\
94 \macro{LONG\_MIN} &-2147483648 & minimo di \ctyp{long}\\
95 \macro{ULONG\_MAX}& 4294967295 & massimo di \ctyp{unsigned long}\\
98 \caption{Costanti definite in \file{limits.h} in conformità allo standard
100 \label{tab:sys_ansic_macro}
103 \footnotetext[1]{il valore può essere 0 o \macro{SCHAR\_MIN} a seconda che il
104 sistema usi caratteri con segno o meno.}
106 \footnotetext[2]{il valore può essere \macro{UCHAR\_MAX} o \macro{SCHAR\_MAX}
107 a seconda che il sistema usi caratteri con segno o meno.}
109 A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
110 \ctyp{long long} introdotto con il nuovo standard, i relativi valori sono in
111 \tabref{tab:sys_isoc90_macro}.
116 \begin{tabular}[c]{|l|r|l|}
118 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
121 \macro{LLONG\_MAX}& 9223372036854775807& massimo di \ctyp{long long}\\
122 \macro{LLONG\_MIN}&-9223372036854775808& minimo di \ctyp{long long}\\
123 \macro{ULLONG\_MAX}&18446744073709551615&
124 massimo di \ctyp{unsigned long long}\\
127 \caption{Macro definite in \file{limits.h} in conformità allo standard
129 \label{tab:sys_isoc90_macro}
132 Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
133 delle caratteristiche del sistema; mancano completamente tutte quelle che
134 dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
135 sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
136 limiti relativi alle caratteristiche dei file che vedremo in
137 \secref{sec:sys_file_limits}.
139 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
140 meno chiare\footnote{tanto che Stevens, in \cite{APUE}, la porta come esempio
141 di ``standardese''.}. Lo standard prevede che ci siano 13 macro che
142 descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
143 riportate in \tabref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
144 file, riportate in \tabref{tab:sys_file_macro}).
149 \begin{tabular}[c]{|l|r|p{8cm}|}
151 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
154 \macro{ARG\_MAX} &131072& dimensione massima degli argomenti
155 passati ad una funzione della famiglia
157 \macro{CHILD\_MAX} & 999& numero massimo di processi contemporanei
158 che un utente può eseguire.\\
159 \macro{OPEN\_MAX} & 256& numero massimo di file che un processo
160 può mantenere aperti in contemporanea.\\
161 \macro{STREAM\_MAX}& 8& massimo numero di stream aperti per
162 processo in contemporanea.\\
163 \macro{TZNAME\_MAX}& 6& dimensione massima del nome di una
164 \texttt{timezone} (vedi ).\\
165 \macro{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
166 processo (vedi \secref{sec:proc_access_id}).\\
167 \macro{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
171 \caption{Costanti per i limiti del sistema.}
172 \label{tab:sys_generic_macro}
175 Lo standard dice che queste macro devono essere definite in \file{limits.h}
176 quando i valori a cui fanno riferimento sono fissi, e altrimenti devono essere
177 lasciate indefinite, ed i loro valori dei limiti devono essere accessibili
178 solo attraverso \func{sysconf}. In realtà queste vengono sempre definite ad
179 un valore generico. Si tenga presente poi che alcuni di questi limiti possono
180 assumere valori molto elevati (come \macro{CHILD\_MAX}), e non è pertanto il
181 caso di utilizzarli per allocare staticamente della memoria.
183 A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
184 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
185 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
186 implementazione possa dichiararsi conforme allo standard; detti valori sono
187 riportati in \tabref{tab:sys_posix1_general}.
192 \begin{tabular}[c]{|l|r|p{8cm}|}
194 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
197 \macro{\_POSIX\_ARG\_MAX} & 4096& dimensione massima degli argomenti
198 passati ad una funzione della famiglia
200 \macro{\_POSIX\_CHILD\_MAX} & 6& numero massimo di processi
201 contemporanei che un utente può
203 \macro{\_POSIX\_OPEN\_MAX} & 16& numero massimo di file che un processo
204 può mantenere aperti in
206 \macro{\_POSIX\_STREAM\_MAX} & 8& massimo numero di stream aperti per
207 processo in contemporanea.\\
208 \macro{\_POSIX\_TZNAME\_MAX} & & dimensione massima del nome di una
209 \texttt{timezone} (vedi ).\\
210 \macro{\_POSIX\_NGROUPS\_MAX}& 0& numero di gruppi supplementari per
212 \secref{sec:proc_access_id}).\\
213 \macro{\_POSIX\_SSIZE\_MAX} &32767& valore massimo del tipo
215 \macro{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
216 \macro{\_POSIX\_AIO\_MAX} & 1& \\
220 \caption{Macro dei valori minimi delle caratteristiche generali del sistema
221 per la conformità allo standard POSIX.1.}
222 \label{tab:sys_posix1_general}
225 In genere questi valori non servono a molto, la loro unica utilità è quella di
226 indicare un limite superiore che assicura la portabilità senza necessità di
227 ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
228 i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
229 valori ottenuti da \func{sysconf}.
234 \begin{tabular}[c]{|l|p{8cm}|}
236 \textbf{Macro}&\textbf{Significato}\\
239 \macro{\_POSIX\_JOB\_CONTROL}& il sistema supporta il
240 \textit{job control} (vedi
241 \secref{sec:sess_xxx}).\\
242 \macro{\_POSIX\_SAVED\_IDS} & il sistema supporta i \textit{saved id}
243 (vedi \secref{sec:proc_access_id}).
244 per il controllo di accesso dei processi\\
245 \macro{\_POSIX\_VERSION} & fornisce la versione dello standard POSIX.1
246 supportata nel formato YYYYMML (ad esempio
250 \caption{Alcune macro definite in \file{limits.h} in conformità allo standard
252 \label{tab:sys_posix1_other}
255 Oltre ai precedenti valori (e a quelli relativi ai file elencati in
256 \tabref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
257 lo standard POSIX.1 ne prevede parecchi altri. La lista completa si trova
258 dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
259 incluso automaticamente all'interno di \file{limits.h}). Di questi vale la
260 pena menzionare alcune macro di uso comune, (riportate in
261 \tabref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
262 denotano la presenza di alcune funzionalità nel sistema (come il supporto del
263 \textit{job control} o dei \textit{saved id}).
265 Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
266 altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
267 alle applicazioni di sistema presenti (come quelli su alcuni parametri delle
268 espressioni regolari o del comando \cmd{bc}), non li tratteremo
269 esplicitamente, se ne trova una menzione completa nell'header file
270 \file{bits/posix2\_lim.h}, e alcuni di loro sono descritti nella man page di
271 \func{sysconf} e nel manuale delle \acr{glibc}.
274 \subsection{La funzione \func{sysconf}}
275 \label{sec:sys_sysconf}
277 Come accennato in \secref{sec:sys_limits} quando uno dei limiti o delle
278 caratteristiche del sistema può variare, è necessario ottenerne il valore
279 attraverso la funzione \func{sysconf}, per non dover essere costretti a
280 ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
281 compilato il kernel, o alcuni dei parametri modificabili a run time. Il
282 prototipo di questa funzione è:
283 \begin{prototype}{unistd.h}{long sysconf(int name)}
284 Restituisce il valore del parametro di sistema \param{name}.
286 \bodydesc{La funzione restituisce indietro il valore del parametro
287 richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
288 è disponibile e -1 in caso di errore (ma \var{errno} non viene settata).}
291 La funzione prende come argomento un intero che specifica quale dei limiti si
292 vuole conoscere; uno specchietto contenente i principali valori disponibili in
293 Linux è riportato in \tabref{tab:sys_sysconf_par}; l'elenco completo è
294 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
295 relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
300 \begin{tabular}[c]{|l|l|p{9cm}|}
302 \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
305 \texttt{\_SC\_ARG\_MAX} &\macro{ARG\_MAX}&
306 La dimensione massima degli argomenti passati ad una funzione
307 della famiglia \func{exec}.\\
308 \texttt{\_SC\_CHILD\_MAX}&\macro{\_CHILD\_MAX}&
309 Il numero massimo di processi contemporanei che un utente può
311 \texttt{\_SC\_OPEN\_MAX}&\macro{\_OPEN\_MAX}&
312 Il numero massimo di file che un processo può mantenere aperti in
314 \texttt{\_SC\_STREAM\_MAX}& \macro{STREAM\_MAX}&
315 Il massimo numero di stream che un processo può mantenere aperti in
316 contemporanea. Questo limite previsto anche dallo standard ANSI C, che
317 specifica la macro {FOPEN\_MAX}.\\
318 \texttt{\_SC\_TZNAME\_MAX}&\macro{TZNAME\_MAX}&
319 La dimensione massima di un nome di una \texttt{timezone} (vedi ).\\
320 \texttt{\_SC\_NGROUPS\_MAX}&\macro{NGROUP\_MAX}&
321 Massimo numero di gruppi supplementari che può avere un processo (vedi
322 \secref{sec:proc_access_id}).\\
323 \texttt{\_SC\_SSIZE\_MAX}&\macro{SSIZE\_MAX}&
324 valore massimo del tipo di dato \type{ssize\_t}.\\
325 \texttt{\_SC\_CLK\_TCK}& \macro{CLK\_TCK} &
326 Il numero di \textit{clock tick} al secondo, cioè la frequenza delle
327 interruzioni del timer di sistema (vedi \secref{sec:proc_priority}).\\
328 \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
329 Indica se è supportato il \textit{job control} (vedi
330 \secref{sec:sess_xxx}) in stile POSIX.\\
331 \texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
332 Indica se il sistema supporta i \textit{saved id} (vedi
333 \secref{sec:proc_access_id}).\\
334 \texttt{\_SC\_VERSION}& \macro{\_POSIX\_VERSION} &
335 Indica il mese e l'anno di approvazione della revisione dello standard
336 POSIX.1 a cui il sistema fa riferimento, nel formato YYYYMML, la
337 revisione più recente è 199009L, che indica il Settembre 1990.\\
340 \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
341 \label{tab:sys_sysconf_par}
344 In generale ogni limite o caratteristica del sistema per cui è definita una
345 macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
346 essere ottenuto attraverso una chiamata a \func{sysconf}. Il valore si otterrà
347 specificando come valore del parametro \param{name} il nome ottenuto
348 aggiungendo \code{\_SC\_} ai nomi delle macro definite dai primi due, o
349 sostituendolo a \code{\_POSIX\_} per le macro definite dagli gli altri due.
351 In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
352 macro non è definita, quindi con un codice analogo al seguente:
354 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
360 int val = sysconf(_SC_CHILD_MAX);
362 perror("fatal error");
369 ma in realtà in Linux queste macro sono comunque definite e indicando un
370 limite generico, per cui è sempre meglio usare i valori restituiti da
374 \subsection{I limiti dei file}
375 \label{sec:sys_file_limits}
377 Come per le caratteristiche generali del sistema anche per i file esistono una
378 serie di limiti (come la lunghezza del nome del file o il numero massimo di
379 link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
380 in questo caso lo standard prevede alcune macro che ne specificano il valore,
381 riportate in \tabref{tab:sys_file_macro}.
386 \begin{tabular}[c]{|l|r|p{8cm}|}
388 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
391 \macro{NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
392 \macro{PATH\_MAX}& 256 & lunghezza in byte di pathname.\\
393 \macro{PIPE\_BUF}& 512 & byte scrivibili atomicamente in una pipe\\
394 \macro{LINK\_MAX} &8 & numero massimo di link a un file\\
395 \macro{MAX\_CANON}&255 & spazio disponibile nella coda di input
396 canonica del terminale\\
397 \macro{MAX\_INPUT}&255 & spazio disponibile nella coda di input
401 \caption{Macro per i limiti sulle caratteristiche dei file.}
402 \label{tab:sys_file_macro}
405 Come per i limiti di sistema POSIX.1 detta una serie di valori minimi per
406 queste caratteristiche, che ogni sistema che vuole essere conforme deve
407 rispettare; le relative macro sono riportate in \tabref{tab:sys_posix1_file},
408 e per esse vale lo stesso discorso fatto per le analoghe di
409 \tabref{tab:sys_posix1_general}.
414 \begin{tabular}[c]{|l|r|p{8cm}|}
416 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
419 \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
420 \macro{\_POSIX\_LINK\_MAX} &8 & numero massimo di link a un file\\
421 \macro{\_POSIX\_MAX\_CANON}&255 & spazio disponibile nella coda di input
422 canonica del terminale\\
423 \macro{\_POSIX\_MAX\_INPUT}&255 & spazio disponibile nella coda di input
425 \macro{\_POSIX\_NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
426 \macro{\_POSIX\_PATH\_MAX}& 256 & lunghezza in byte di pathname.\\
427 \macro{\_POSIX\_PIPE\_BUF}& 512 & byte scrivibili atomicamente in una
429 % \macro{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
430 % \macro{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
431 % \macro{\_POSIX\_FD\_SETSIZE}& 16 & \\
432 % \macro{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
435 \caption{Macro dei valori minimi delle caratteristiche dei file per la
436 conformità allo standard POSIX.1.}
437 \label{tab:sys_posix1_file}
440 Tutti questi limiti sono definiti in \file{limits.h}; come nel caso precedente
441 il loro uso è di scarsa utilità in quanto ampiamente superati in tutte le
442 implementazioni moderne.
445 \subsection{La funzione \func{pathconf}}
446 \label{sec:sys_pathconf}
448 In generale i limiti per i file sono molto più soggetti ad essere variabili
449 rispetto ai precedenti limiti generali del sistema; ad esempio parametri come
450 la lunghezza del nome del file o il numero di link possono variare da
451 filesystem a filesystem; per questo motivo questi limiti devono essere sempre
452 controllati con la funzione \func{pathconf}, il cui prototipo è:
453 \begin{prototype}{unistd.h}{long pathconf(char *path, int name)}
454 Restituisce il valore del parametro \param{name} per il file \param{path}.
456 \bodydesc{La funzione restituisce indietro il valore del parametro
457 richiesto, o -1 in caso di errore (ed \var{errno} viene settata ad uno
458 degli errori possibili relativi all'accesso a \param{path}).}
461 E si noti come la funzione in questo caso richieda un parametro che specifichi
462 a quale file si fa riferimento, dato che il valore del limite cercato può
463 variare a seconda del filesystem. Una seconda versione della funzione,
464 \func{fpathconf}, opera su un file descriptor invece che su un pathname, il
466 \begin{prototype}{unistd.h}{long fpathconf(int fd, int name)}
467 Restituisce il valore del parametro \param{name} per il file \param{fd}.
469 \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
470 invece di un pathname; pertanto gli errori restituiti cambiano di
473 \noindent ed il suo comportamento è identico a quello di \func{pathconf}.
476 \subsection{La funzione \func{uname}}
477 \label{sec:sys_uname}
479 Un'altra funzione che si può utilizzare per raccogliere informazioni sia
480 riguardo al sistema che al computer su cui esso sta girando è \func{uname}, il
482 \begin{prototype}{sys/utsname.h}{int uname(struct utsname *info)}
483 Restituisce informazioni sul sistema nella struttura \param{info}.
485 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
486 fallimento, nel qual caso \var{errno} viene settata a \macro{EFAULT}.}
489 La funzione, che viene usata dal comando \cmd{uname}, restituisce le
490 informazioni richieste nella struttura \param{info}; anche questa struttura è
491 definita in \file{sys/utsname.h}, secondo quanto mostrato in
492 \secref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
493 indicano rispettivamente:
495 \item il nome del sistema operativo;
496 \item il nome della release del kernel;
497 \item il nome della versione del kernel;
498 \item il tipo di macchina in uso;
499 \item il nome della stazione;
500 \item il nome del domino.
502 l'ultima informazione è stata aggiunta di recente e non è prevista dallo
503 standard POSIX, essa è accessibile, come mostrato in \figref{fig:sig_stack_t},
504 solo definendo \macro{\_GNU\_SOURCE}.
507 \footnotesize \centering
508 \begin{minipage}[c]{15cm}
509 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
523 \caption{La struttura \var{utsname}.}
524 \label{fig:sys_utsname}
527 In generale si tenga presente che le dimensioni delle stringe di una
528 \var{utsname} non è specificata, e che esse sono sempre terminate con
529 \macro{NULL}; il manuale delle \acr{glibc} indica due diverse dimensioni,
530 \macro{\_UTSNAME\_LENGTH} per i campi standard e
531 \macro{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
532 altri sistemi usano nomi diversi come \macro{SYS\_NMLN} o \macro{\_SYS\_NMLN}
533 or \macro{UTSLEN} che possono avere valori diversi; nel caso di Linux
534 \func{uname} corrisponde in realtà a 3 system call diverse, le prime due usano
535 delle lunghezze delle stringhe di 9 e 65 byte; la terza 65, restituisce anche
536 l'ultimo campo con una lunghezza di 257 byte.
539 \section{Opzioni e configurazione del sistema}
540 \label{sec:sys_config}
542 Come abbiamo accennato nella sezione precedente, non tutti i limiti che
543 caratterizzano il sistema sono fissi, o perlomeno non lo sono in tutte le
544 implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
545 di esaminare il meccanismo che permette, quando questi possono variare durante
546 l'esecuzione del sistema, di modificarli.
548 Inoltre, al di la di quelli che possono essere limiti caratteristici previsti
549 da uno standard, ogni sistema può avere una sua serie di altri parametri di
550 configurazione, che, non essendo mai fissi e variando da sistema a sistema,
551 non sono stati inclusi nella standardizzazione della sezione precedente. Per
552 questi occorre, oltre al meccanismo di settaggio, pure un meccanismo di
555 Affronteremo questi argomenti in questa sezione, insieme alle funzioni che si
556 usano per il controllo di altre caratteristiche generali del sistema, come
557 quelle per la gestione dei filesystem e di utenti e gruppi.
560 \subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
561 \label{sec:sys_sysctl}
563 La funzione che permette la lettura ed il settaggio dei parametri del sistema
564 è \func{sysctl}; è una funzione derivata da BSD4.4, ma l'implementazione è
565 specifica di Linux; il suo prototipo è:
568 \headdecl{linux/unistd.h}
569 \headdecl{linux/sysctl.h}
570 \funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
571 *newval, size\_t newlen)}
573 Legge o scrive uno dei parametri di sistema.
575 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
576 errore, nel qual caso \var{errno} viene settato ai valori:
578 \item[\macro{EPERM}] il processo non ha il permesso di accedere ad uno dei
579 componenti nel cammino specificato per il parametro, o non ha il permesso
580 di accesso al parametro nella modalità scelta.
581 \item[\macro{ENOTDIR}] non esiste un parametro corrispondente al nome
583 \item[\macro{EFAULT}] si è specificato \param{oldlenp} zero quando
584 \param{oldval} è non nullo.
585 \item[\macro{EINVAL}] o si è specificato un valore non valido per il
586 parametro che si vuole settare o lo spazio provvisto per il ritorno di un
587 valore non è delle giuste dimensioni.
588 \item[\macro{ENOMEM}] talvolta viene usato più correttamente questo errore
589 quando non si è specificato sufficiente spazio per ricevere il valore di un
595 I parametri a cui la funzione permettere di accedere sono organizzati in
596 maniera gerarchica all'interno un albero; per accedere ad uno di essi occorre
597 specificare un cammino attraverso i vari nodi dell'albero, in maniera analoga
598 a come avviene per la risoluzione di un pathname (da cui l'uso alternativo del
599 filesystem \file{/proc} che vedremo dopo).
601 Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
602 arriva ad identificare un parametro specifico è passato alla funzione
603 attraverso l'array \param{name}, di lunghezza \param{nlen}, che contiene la
604 sequenza dei vari nodi da attraversare. Ogni parametro ha un valore in un
605 formato specifico che può essere un intero, una stringa o anche una struttura
606 complessa, per questo motivo il valori vengono passati come puntatori
609 L'indirizzo a cui il valore corrente del parametro deve essere letto è
610 specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
611 \param{oldlenp} (passato come puntatore per avere indietro la dimensione
612 effettiva di quanto letto); il valore che si vuole settare nel sistema è
613 passato in \param{newval} e la sua dimensione in \param{newlen}.
615 Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
616 valore letto restituito dalla funzione è quello precedente alla scrittura.
618 I parametri accessibili attraverso questa funzione sono moltissimi, e possono
619 essere trovati in \file{sysctl.h}, essi inoltre dipendono anche dallo stato
620 corrente del kernel (ad esempio dai moduli che sono stati caricati nel
621 sistema) e in genere i loro nomi possono variare da una versione di kernel
622 all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
623 quando esistono modalità alternative per ottenere le stesse informazioni.
624 Alcuni esempi di parametri ottenibili sono:
626 \item il nome di dominio
627 \item i parametri del meccanismo di \textit{paging}.
628 \item il filesystem montato come radice
629 \item la data di compilazione del kernel
630 \item i parametri dello stack TCP
631 \item il numero massimo di file aperti
634 Come accennato in Linux si ha una modalità alternativa per accedere alle
635 stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
636 \file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
637 kernel, che non fa riferimento a nessun dispositivo fisico, ma presenta in
638 forma di file alcune delle strutture interne del kernel stesso.
640 In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
641 di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
642 specificando un pathname e leggendo e scrivendo sul file corrispondente al
643 parametro scelto. Il kernel si occupa di generare al volo il contenuto ed i
644 nomi dei file corrispondenti, e questo ha il grande vantaggio di rendere
645 accessibili i vari parametri a qualunque comando di shell e di permettere la
646 navigazione dell'albero dei valori.
648 Alcune delle corrispondenze dei file presenti in \file{/proc/sys} con i valori
649 di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
650 in \file{linux/sysctl.h},\footnote{indicando un file di definizioni si fa
651 riferimento alla directory standard dei file di include, che in ogni
652 distribuzione che si rispetti è \file{/usr/include}.} la informazione
653 disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
654 inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
656 Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc}
657 sono disponibili moltissime altre informazioni, fra cui ad esempio anche
658 quelle fornite da \func{uname} (vedi \secref{sec:sys_config}) che sono
659 mantenute nei file \file{ostype}, \file{hostname}, \file{osrelease},
660 \file{version} e \file{domainname} di \file{/proc/kernel/}.
664 \subsection{La gestione delle proprietà dei filesystem}
665 \label{sec:sys_file_config}
667 Come accennato in \secref{sec:file_organization} per poter accedere ai file
668 occorre prima rendere disponibile al sistema il filesystem su cui essi sono
669 memorizzati; l'operazione di attivazione del filesystem è chiamata
670 \textsl{montaggio}, per far questo in Linux\footnote{la funzione è specifica
671 di Linux e non è portabile.} si usa la funzione \func{mount} il cui prototipo
673 \begin{prototype}{sys/mount.h}
674 {mount(const char *source, const char *target, const char *filesystemtype,
675 unsigned long mountflags, const void *data)}
677 Monta il filesystem di tipo \param{filesystemtype} contenuto in \param{source}
678 sulla directory \param{target}.
680 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
681 fallimento, nel qual caso gli errori comuni a tutti i filesystem che possono
682 essere restituiti in \var{errno} sono:
684 \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
685 \item[\macro{ENODEV}] \param{filesystemtype} non esiste o non è configurato
687 \item[\macro{ENOTBLK}] non si è usato un \textit{block device} per
688 \param{source} quando era richiesto.
689 \item[\macro{EBUSY}] \param{source} è già montato, o non può essere
690 rimontato in read-only perché ci sono ancora file aperti in scrittura, o
691 \param{target} è ancora in uso.
692 \item[\macro{EINVAL}] il device \param{source} presenta un
693 \textit{superblock} non valido, o si è cercato di rimontare un filesystem
694 non ancora montato, o di montarlo senza che \param{target} sia un
695 \textit{mount point} o di spostarlo quando \param{target} non è un
696 \textit{mount point} o è \file{/}.
697 \item[\macro{EACCES}] non si ha il permesso di accesso su uno dei componenti
698 del pathname, o si è cercato di montare un filesystem disponibile in sola
699 lettura senza averlo specificato o il device \param{source} è su un
700 filesystem montato con l'opzione \macro{MS\_NODEV}.
701 \item[\macro{ENXIO}] il \textit{major number} del device \param{source} è
703 \item[\macro{EMFILE}] la tabella dei device \textit{dummy} è piena.
705 ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
706 \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
709 La funzione monta sulla directory \param{target}, detta \textit{mount point},
710 il filesystem contenuto in \param{source}. In generale un filesystem è
711 contenuto su un disco, e l'operazione di montaggio corrisponde a rendere
712 visibile al sistema il contenuto del suddetto disco, identificato attraverso
713 il file di dispositivo ad esso associato.
715 Ma la struttura del virtual filesystem vista in \secref{sec:file_vfs} è molto
716 più flessibile e può essere usata anche per oggetti diversi da un disco. Ad
717 esempio usando il \textit{loop device} si può montare un file qualunque (come
718 l'immagine di un CD-ROM o di un floppy) che contiene un filesystem, inoltre
719 alcuni filesystem, come \file{proc} o \file{devfs} sono del tutto virtuali, i
720 loro dati sono generati al volo ad ogni lettura, e passati al kernel ad ogni
723 Il tipo di filesystem è specificato da \param{filesystemtype}, che deve essere
724 una delle stringhe riportate in \file{/proc/filesystems}, che contiene
725 l'elenco dei filesystem supportati dal kernel; nel caso si sia indicato uno
726 dei filesystem virtuali, il contenuto di \param{source} viene ignorato.
728 Dopo l'esecuzione della funzione il contenuto del filesystem viene resto
729 disponibile nella directory specificata come \textit{mount point}, il
730 precedente contenuto di detta directory viene mascherato dal contenuto della
731 directory radice del filesystem montato.
733 Dal kernel 2.4.x inoltre è divenuto possibile sia spostare atomicamente un
734 \textit{mount point} da una directory ad un'altra, che montare in diversi
735 \textit{mount point} lo stesso filesystem, che montare più filesystem sullo
736 stesso \textit{mount point} (nel qual caso vale quanto appena detto, e solo il
737 contenuto dell'ultimo filesystem montato sarà visibile).
739 Ciascun filesystem è dotato di caratteristiche specifiche che possono essere
740 attivate o meno, alcune di queste sono generali (anche se non è detto siano
741 disponibili in ogni filesystem), e vengono specificate come opzioni di
742 montaggio con l'argomento \param{mountflags}.
744 In Linux \param{mountflags} deve essere un intero a 32 bit i cui 16 più
745 significativi sono un \textit{magic number}\footnote{cioè un numero speciale
746 usato come identificativo, che nel caso è \code{0xC0ED}; si può usare la
747 costante \macro{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
748 riservata al \textit{magic number}.} mentre i 16 meno significativi sono
749 usati per specificare le opzioni; essi sono usati come maschera binaria e
750 vanno settati con un OR aritmetico della costante \macro{MS\_MGC\_VAL} con i
751 valori riportati in \ntab.
756 \begin{tabular}[c]{|l|r|l|}
758 \textbf{Parametro} & \textbf{Valore}&\textbf{Significato}\\
761 \macro{MS\_RDONLY} & 1 & monta in sola lettura\\
762 \macro{MS\_NOSUID} & 2 & ignora i bit \acr{suid} e \acr{sgid}\\
763 \macro{MS\_NODEV} & 4 & impedisce l'accesso ai file di dispositivo\\
764 \macro{MS\_NOEXEC} & 8 & impedisce di eseguire programmi \\
765 \macro{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
766 \macro{MS\_REMOUNT} & 32 & rimonta il filesystem cambiando i flag\\
767 \macro{MS\_MANDLOCK} & 64 & consente il \textit{mandatory locking} (vedi
768 \secref{sec:file_mand_locking})\\
769 \macro{S\_WRITE} & 128 & scrive normalmente \\
770 \macro{S\_APPEND} & 256 & consente la scrittura solo in \textit{append
771 mode} (vedi \secref{sec:file_sharing})\\
772 \macro{S\_IMMUTABLE} & 512 & impedisce che si possano modificare i file \\
773 \macro{MS\_NOATIME} &1024 & non aggiorna gli \textit{access time} (vedi
774 \secref{sec:file_file_times})\\
775 \macro{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
777 \macro{MS\_BIND} &4096 & monta il filesystem altrove\\
778 \macro{MS\_MOVE} &8192 & sposta atomicamente il punto di montaggio \\
781 \caption{Tabella dei codici dei flag di montaggio di un filesystem.}
782 \label{tab:sys_mount_flags}
785 Per il settaggio delle caratteristiche particolari di ciascun filesystem si
786 usa invece l'argomento \param{data} che serve per passare le ulteriori
787 informazioni necessarie, che ovviamente variano da filesystem a filesystem.
789 La funzione \func{mount} può essere utilizzata anche per effettuare il
790 \textsl{rimontaggio} di un filesystem, cosa che permette di cambiarne al volo
791 alcune delle caratteristiche di funzionamento (ad esempio passare da sola
792 lettura a lettura/scrittura). Questa operazione è attivata attraverso uno dei
793 bit di \param{mountflags}, \macro{MS\_REMOUNT}, che se settato specifica che
794 deve essere effettuato il rimontaggio del filesystem (con le opzioni
795 specificate dagli altri bit), anche in questo caso il valore di \param{source}
798 Una volta che non si voglia più utilizzare un certo filesystem è possibile
799 \textsl{smontarlo} usando la funzione \func{umount}, il cui prototipo è:
800 \begin{prototype}{sys/mount.h}{umount(const char *target)}
802 Smonta il filesystem montato sulla directory \param{target}.
804 \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
805 fallimento, nel qual caso \var{errno} viene settata a:
807 \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
808 \item[\macro{EBUSY}] \param{target} è la directory di lavoro di qualche
809 processo, o contiene dei file aperti, o un altro mount point.
811 ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
812 \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
814 \noindent la funzione prende il nome della directory su cui il filesystem è
815 montato e non il file o il dispositivo che è stato montato,\footnote{questo è
816 vero a partire dal kernel 2.3.99-pre7, prima esistevano due chiamate
817 separate e la funzione poteva essere usata anche specificando il file di
818 dispositivo.} in quanto con il kernel 2.4.x è possibile montare lo stesso
819 dispositivo in più punti. Nel caso più di un filesystem sia stato montato
820 sullo stesso \textit{mount point} viene smontato quello che è stato montato
823 Si tenga presente che la funzione fallisce quando il filesystem è
824 \textsl{occupato}, questo avviene quando ci sono ancora file aperti sul
825 filesystem, se questo contiene la directory di lavoro corrente di un qualunque
826 processo o il mount point di un altro filesystem; in questo caso l'errore
827 restituito è \macro{EBUSY}.
829 Linux provvede inoltre una seconda funzione, \func{umount2}, che in alcuni
830 casi permette di forzare lo smontaggio di un filesystem, anche quando questo
831 risulti occupato; il suo prototipo è:
832 \begin{prototype}{sys/mount.h}{umount2(const char *target, int flags)}
834 La funzione è identica a \func{umount} per comportamento e codici di errore,
835 ma con \param{flags} si può specificare se forzare lo smontaggio.
838 Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
839 definito è il bit \macro{MNT\_FORCE}; gli altri bit devono essere nulli.
840 Specificando \macro{MNT\_FORCE} la funzione cercherà di liberare il filesystem
841 anche se è occupato per via di una delle condizioni descritte in precedenza. A
842 seconda del tipo di filesystem alcune (o tutte) possono essere superate,
843 evitando l'errore di \macro{EBUSY}. In tutti i casi prima dello smontaggio
844 viene eseguita una sincronizzazione dei dati.
846 Altre due funzioni specifiche di Linux,\footnote{esse si trovano anche su BSD,
847 ma con una struttura diversa.} utili per ottenere in maniera diretta
848 informazioni riguardo al filesystem su cui si trova un certo file, sono
849 \func{statfs} e \func{fstatfs}, i cui prototipi sono:
852 \funcdecl{int statfs(const char *path, struct statfs *buf)}
854 \funcdecl{int fstatfs(int fd, struct statfs *buf)}
856 Restituisce in \param{buf} le informazioni relative al filesystem su cui è
857 posto il file specificato.
859 \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
860 errore, nel qual caso \var{errno} viene settato ai valori:
862 \item[\macro{ENOSYS}] il filesystem su cui si trova il file specificato non
863 supporta la funzione.
865 e \macro{EFAULT} ed \macro{EIO} per entrambe, \macro{EBADF} per
866 \func{fstatfs}, \macro{ENOTDIR}, \macro{ENAMETOOLONG}, \macro{ENOENT},
867 \macro{EACCES}, \macro{ELOOP} per \func{statfs}.}
870 Queste funzioni permettono di ottenere una serie di informazioni generali
871 riguardo al filesystem su cui si trova il file specificato; queste vengono
872 restituite una struttura \param{buf} di tipo \type{statfs} definita come in
873 \ref{fig:sys_statfs}, ed i campi che sono indefiniti per il filesystem in
874 esame sono settati a zero. I valori del campo \var{f\_type} sono definiti per
875 i vari filesystem nei relativi file di header dei sorgenti del kernel da
876 costanti del tipo \macro{XXX\_SUPER\_MAGIC}, dove \macro{XXX} in genere è il
877 nome del filesystem stesso.
880 \footnotesize \centering
881 \begin{minipage}[c]{15cm}
882 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
884 long f_type; /* tipo di filesystem */
885 long f_bsize; /* dimensione ottimale dei blocchi di I/O */
886 long f_blocks; /* blocchi totali nel filesystem */
887 long f_bfree; /* blocchi liberi nel filesystem */
888 long f_bavail; /* blocchi liberi agli utenti normali */
889 long f_files; /* inodes totali nel filesystem */
890 long f_ffree; /* inodes liberi nel filesystem */
891 fsid_t f_fsid; /* filesystem id */
892 long f_namelen; /* lunghezza massima dei nomi dei file */
893 long f_spare[6]; /* riservati per uso futuro */
898 \caption{La struttura \var{statfs}.}
899 \label{fig:sys_statfs}
903 Le \acr{glibc} provvedono infine una serie di funzioni per la gestione dei due
904 file standard \file{/etc/fstab} e \file{/etc/mtab}, che convenzionalmente sono
905 usati in quasi tutti i sistemi unix per mantenere rispettivamente le
906 informazioni riguardo ai filesystem da montare e a quelli correntemente
907 montati. Le funzioni servono a leggere il contenuto di questi file in
908 opportune strutture \var{struct fstab} e \var{struct mntent}, e, per
909 \file{/etc/mtab} per inserire e rimuovere le voci presenti nel file.
911 In generale si dovrebbero usare queste funzioni (in particolar modo quelle
912 relative a \file{/etc/mtab}), quando si debba scrivere un programma che
913 effettua il montaggio di un filesystem; in realtà in questi casi è molto più
914 semplice invocare direttamente il programma \cmd{mount}, per cui ne
915 tralasceremo la trattazione, rimandando al manuale delle \acr{glibc}
916 \cite{glibc} per la documentazione completa.
919 \subsection{La gestione di utenti e gruppi}
920 \label{sec:sys_user_group}
922 L'ultimo argomento di questa sezione è quello che riguarda le funzioni
923 utilizzate per gestire utenti e gruppi all'interno del sistema.
924 Tradizionalmente l'informazione per la gestione di utenti e gruppi veniva
925 tenuta tutta nei due file di testo \file{/etc/passwd} ed \file{/etc/group};
926 oggi la maggior parte delle distribuzioni di Linux usa la libreria PAM (sigla
927 che sta \textit{Pluggable Authentication Method}) che permette di separare
928 completamente i meccanismi di gestione degli utenti (autenticazione,
929 riconoscimento, ecc.) dalle modalità in cui i relativi dati vengono mantenuti.
931 In questo paragrafo ci limiteremo comunque alle funzioni classiche per la
932 lettura delle informazioni relative a utenti e gruppi previste dallo standard
933 POSIX.1, che fanno riferimento a quanto memorizzato nei due file appena
934 citati, il cui formato è descritto dalle relative pagine del manuale (cioè
935 \cmd{man 5 passwd} e \cmd{man 5 group}).
937 Per leggere le informazioni relative ad un utente si possono usare due
938 funzioni, \func{getpwuid} e \func{getpwnam}, i cui prototipi sono:
941 \headdecl{sys/types.h}
942 \funcdecl{struct passwd *getpwuid(uid\_t uid)}
944 \funcdecl{struct passwd *getpwnam(const char *name)}
946 Restituiscono le informazioni relative all'utente specificato.
948 \bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
949 informazioni in caso di successo e \macro{NULL} nel caso non sia stato
950 trovato nessun utente corrispondente a quanto specificato.}
953 Le due funzioni forniscono le informazioni memorizzate nel database degli
954 utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
955 relative all'utente specificato attraverso il suo \acr{uid} o il nome di
956 login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
957 tipo \type{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
958 riportata in \figref{fig:sys_passwd_struct}, dove è pure brevemente illustrato
959 il significato dei vari campi.
964 \begin{minipage}[c]{15cm}
965 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
967 char *pw_name; /* user name */
968 char *pw_passwd; /* user password */
969 uid_t pw_uid; /* user id */
970 gid_t pw_gid; /* group id */
971 char *pw_gecos; /* real name */
972 char *pw_dir; /* home directory */
973 char *pw_shell; /* shell program */
978 \caption{La struttura \var{passwd} contenente le informazioni relative ad un
980 \label{fig:sys_passwd_struct}
983 La struttura usata da entrambe le funzioni è allocata staticamente, per questo
984 motivo viene sovrascritta ad ogni nuova invocazione, così come le stringhe a
985 cui essa fa riferimento. Ovviamente queste funzioni non sono rientranti, ne
986 esistono quindi anche due versioni alternative (denotate dalla solita
987 estensione \code{\_r}), i cui prototipi sono:
991 \headdecl{sys/types.h}
993 \funcdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
994 char *buffer, size\_t buflen, struct passwd **result)}
996 \funcdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
997 *password, char *buffer, size\_t buflen, struct passwd **result)}
999 Restituiscono le informazioni relative all'utente specificato.
1001 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1002 altrimenti, nel qual caso \var{errno} sarà settato opportunamente.}
1005 In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
1006 la memoria necessaria a contenere le informazioni. In particolare i valori
1007 della struttura \var{passwd} saranno restituiti all'indirizzo \param{password}
1008 mentre la memoria allocata all'indirizzo \param{buffer}, per un massimo di
1009 \param{buflen} byte, sarà utilizzata per contenere le stringhe puntate dai
1010 campi di \param{password}; infine all'indirizzo puntato da \param{result}
1011 viene restituito il puntatore ai dati ottenuti, cioè \param{buffer} nel caso
1012 l'utente esista, o \macro{NULL} altrimenti. Qualora i dati non possano essere
1013 contenuti in \param{buflen} byte la funzione fallirà restituendo
1014 \macro{ERANGE} (e \param{result} sarà comunque settato a \macro{NULL}).
1016 Del tutto analoghe alle precedenti sono le funzioni \func{getgrnam} e
1017 \func{getgrgid} (e le relative analoghe rientranti con la stessa estensione
1018 \code{\_r}) che permettono di leggere le informazioni relative ai gruppi, i
1019 loro prototipi sono:
1022 \headdecl{sys/types.h}
1024 \funcdecl{struct group *getgrgid(gid\_t gid)}
1026 \funcdecl{struct group *getgrnam(const char *name)}
1028 \funcdecl{struct group *getpwuid\_r(gid\_t gid, struct group *password,
1029 char *buffer, size\_t buflen, struct group **result)}
1031 \funcdecl{struct group *getpwnam\_r(const char *name, struct group
1032 *password, char *buffer, size\_t buflen, struct group **result)}
1034 Restituiscono le informazioni relative al gruppo specificato.
1036 \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
1037 altrimenti, nel qual caso \var{errno} sarà settato opportunamente.}
1040 Il comportamento di tutte queste funzioni è assolutamente identico alle
1041 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
1042 in questo caso le informazioni vengono restituite in una struttura di tipo
1043 \type{group}, la cui definizione è riportata in \figref{fig:sys_group_struct}.
1045 \begin{figure}[!htb]
1048 \begin{minipage}[c]{15cm}
1049 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1051 char *gr_name; /* group name */
1052 char *gr_passwd; /* group password */
1053 gid_t gr_gid; /* group id */
1054 char **gr_mem; /* group members */
1059 \caption{La struttura \var{group} contenente le informazioni relative ad un
1060 gruppo del sistema.}
1061 \label{fig:sys_group_struct}
1064 Le funzioni viste finora sono in grado di leggere le informazioni sia dal file
1065 delle password in \file{/etc/passwd} che con qualunque altro metodo sia stato
1066 utilizzato per mantenere il database degli utenti. Non permettono però di
1067 settare direttamente le password; questo è possibile con un'altra interfaccia
1068 al database degli utenti, derivata da SVID, che però funziona soltanto con un
1069 database che sia tenuto su un file che abbia il formato classico di
1072 Dato che ormai la gran parte delle distribuzioni di Linux utilizzano PAM, che
1073 come minimo usa almeno le \textit{shadow password}, quindi con delle modifiche
1074 rispetto al formato classico di \file{/etc/passwd}, le funzioni che danno la
1075 capacità scrivere delle voci nel database (\func{putpwent} e \func{putgrent})
1076 non permettono di specificarle in maniera completa. Per questo motivo l'uso di
1077 queste funzioni è deprecato in favore dell'uso di PAM, per cui ci limitiamo a
1078 elencarle in \tabref{tab:sys_passwd_func}, rimandando chi fosse interessato
1079 alle man page e al manuale delle \acr{glibc} per i dettagli del funzionamento.
1084 \begin{tabular}[c]{|l|p{8cm}|}
1086 \textbf{Funzione} & \textbf{Significato}\\
1089 \func{fgetpwent} & Legge una voce dal database utenti da un file
1090 specificato aprendolo la prima volta.\\
1091 \func{fgetpwent\_r}& Come la precedente, ma rientrante.\\
1092 \func{getpwent} & Legge una voce dal database utenti (da
1093 \file{/etc/passwd}) aprendolo la prima volta.\\
1094 \func{getpwent\_r} & Come la precedente, ma rientrante.\\
1095 \func{setpwent} & Ritorna all'inizio del database.\\
1096 \func{putpwent} & Immette una voce nel database utenti.\\
1097 \func{endpwent} & Chiude il database degli utenti.\\
1098 \func{fgetgrent} & Legge una voce dal database dei gruppi da un file
1099 specificato aprendolo la prima volta.\\
1100 \func{fgetgrent\_r}& Come la precedente, ma rientrante.\\
1101 \func{getgrent} & Legge una voce dal database dei gruppi (da
1102 \file{/etc/passwd}) aprendolo la prima volta.\\
1103 \func{getgrent\_r} & Come la precedente, ma rientrante.\\
1104 \func{setgrent} & Immette una voce nel database dei gruppi.\\
1105 \func{putgrent} & Immette una voce nel database dei gruppi.\\
1106 \func{endgrent} & Chiude il database dei gruppi.\\
1109 \caption{Funzioni per la manipolazione dei campi di un file usato come
1110 database di utenti e gruppi nel formato di \file{/etc/passwd} e
1111 \file{/etc/groups}.}
1112 \label{tab:sys_passwd_func}
1115 Un altro insieme di funzioni utili è quello che permette di accedere ai dati
1116 del database di \textit{accounting} degli utenti, che mantiene la traccia di
1117 chi si è collegato al sistema e di che è correntemente collegato, insieme alle
1118 informazioni, per ciascun terminale, di chi ci è collegato, da che ora,
1119 dell'\acr{uid} della shell di login, ed una serie di altre informazioni
1120 relativa al sistema come il run-level, l'orario dell'ultimo riavvio, ed altre.
1122 Le informazioni sono tenute nei due file \file{/var/run/utmp} (per chi sta
1123 utilizzando il sistema al momento corrente) e \file{/var/log/wtmp} (per la
1124 storia dei login precedenti). Questi file non devono mai essere letti
1125 direttamente, ma le informazioni che contengono possono essere ricavate
1126 attraverso le opportune funzioni di libreria. Queste sono analoghe alle
1127 precedenti per il database delle password, solo che la struttura del database
1128 è molto più complessa, dato che contiene vari tipi di informazione.
1130 Le prime tre funzioni, \func{utmpname}, \func{setutent} e \func{endutent},
1131 servono a aprire e chiudere il database, e a specificare il file su cui esso è
1132 mantenuto (in caso questo non venga specificato viene usato il valore standard
1133 \macro{\_PATH\_UTMP} che è definito in \file{paths.h}. Il loro prototipi sono:
1137 \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
1138 database di \textit{accounting}.
1140 \funcdecl{void setutent(void)} Apre il file del database di
1141 \textit{accounting}, posizionandosi al suo inizio.
1143 \funcdecl{void endutent(void)} Chiude il file del database di
1144 \textit{accounting}.
1146 \bodydesc{Le funzioni non ritornano codici di errore.}
1149 Una volta aperto il file si può eseguire una scansione leggendo o scrivendo
1150 una voce con le funzioni \func{getutent}, \func{getutid}, \func{getutline} e
1151 \func{pututline}, i cui prototipi sono:
1155 \funcdecl{struct utmp *getutent(void)}
1156 Legge una voce dal dalla posizione corrente nel database.
1158 \funcdecl{struct utmp *getutid(struct utmp *ut)}
1159 Esegue una ricerca dalla posizione corrente sulla base del contenuto di
1162 \funcdecl{struct utmp *getutline(struct utmp *ut)}
1163 Ricerca nel database la prima voce corrispondente ad un processo sulla linea
1164 di terminale specificata tramite \param{ut}.
1166 \funcdecl{struct utmp *pututline(struct utmp *ut)}
1167 Scrive una voce nel database.
1169 \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
1170 caso di successo e \macro{NULL} in caso di errore.}
1173 Tutte queste funzioni fanno riferimento ad una struttura di tipo \var{utmp},
1174 la cui definizione in Linux è riportata in \secref{fig:sys_utmp_struct}. Le
1175 prime tre funzioni servono per leggere una voce dal database; \func{getutent}
1176 legge semplicemente la prima voce disponibile; le altre due permettono di
1177 eseguire una ricerca.
1179 \begin{figure}[!htb]
1182 \begin{minipage}[c]{15cm}
1183 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1186 short int ut_type; /* Type of login. */
1187 pid_t ut_pid; /* Process ID of login process. */
1188 char ut_line[UT_LINESIZE]; /* Devicename. */
1189 char ut_id[4]; /* Inittab ID. */
1190 char ut_user[UT_NAMESIZE]; /* Username. */
1191 char ut_host[UT_HOSTSIZE]; /* Hostname for remote login. */
1192 struct exit_status ut_exit; /* Exit status of a process marked
1194 long int ut_session; /* Session ID, used for windowing. */
1195 struct timeval ut_tv; /* Time entry was made. */
1196 int32_t ut_addr_v6[4]; /* Internet address of remote host. */
1197 char __unused[20]; /* Reserved for future use. */
1202 \caption{La struttura \var{utmp} contenente le informazioni di una voce del
1203 database di \textit{accounting}.}
1204 \label{fig:sys_utmp_struct}
1207 Con \func{getutid} si può cercare la voce relativa ad uno specifico tipo di
1208 login o di runlevel, a seconda del valore del campo \var{ut\_type}
1209 dell'argomento \param{ut}; questo può assumere i valori riportati in
1215 \begin{tabular}[c]{|l|p{8cm}|}
1217 \textbf{Funzione} & \textbf{Significato}\\
1220 \macro{EMPTY} & Non contiene informazioni valide. \\
1221 \macro{RUN_LVL} & Identica il runlevel del sistema. \\
1222 \macro{BOOT_TIME} & Identifica il tempo di avvio del sistema \\
1223 \macro{OLD_TIME} & Identifica quando è stato modificato l'orogio di
1225 \macro{NEW_TIME} & Identifica da qaunto è stato modificato il
1227 \macro{INIT_PROCESS} & Identifica un processo lanciato ad \cmd{init}. \\
1228 \macro{LOGIN_PROCESS}& Identifica un processo di login. \\
1229 \macro{USER_PROCESS} & Identifica un processo utente. \\
1230 \macro{DEAD_PROCESS} & Identifica un processo terminato. \\
1231 \macro{ACCOUNTING} & ??? \\
1234 \caption{Classificazione delle voci del database di accounting a seconda dei
1235 possibili valori del campo \var{ut\_type}.}
1236 \label{tab:sys_ut_type}
1242 \section{Limitazione ed uso delle risorse}
1243 \label{sec:sys_res_limits}
1245 In questa sezione esamineremo le funzioni che permettono di esaminare e
1246 controllare come le varie risorse del sistema (CPU, memoria, ecc.) vengono
1247 utilizzate dai singoli processi, e le modalità con cui è possibile imporre dei
1248 limiti sul loro utilizzo.
1252 \subsection{L'uso delle risorse}
1253 \label{sec:sys_resource_use}
1257 \subsection{Limiti sulle risorse}
1258 \label{sec:sys_resource_limit}
1261 \subsection{Le risorse di memoria}
1262 \label{sec:sys_memory_res}
1265 \subsection{Le risorse di processore}
1266 \label{sec:sys_cpu_load}
1270 \begin{figure}[!htb]
1273 \begin{minipage}[c]{15cm}
1274 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
1276 struct timeval ru_utime; /* user time used */
1277 struct timeval ru_stime; /* system time used */
1278 long ru_maxrss; /* maximum resident set size */
1279 long ru_ixrss; /* integral shared memory size */
1280 long ru_idrss; /* integral unshared data size */
1281 long ru_isrss; /* integral unshared stack size */
1282 long ru_minflt; /* page reclaims */
1283 long ru_majflt; /* page faults */
1284 long ru_nswap; /* swaps */
1285 long ru_inblock; /* block input operations */
1286 long ru_oublock; /* block output operations */
1287 long ru_msgsnd; /* messages sent */
1288 long ru_msgrcv; /* messages received */
1289 long ru_nsignals; ; /* signals received */
1290 long ru_nvcsw; /* voluntary context switches */
1291 long ru_nivcsw; /* involuntary context switches */
1296 \caption{La struttura \var{rusage} per la lettura delle informazioni dei
1297 delle risorse usate da un processo.}
1298 \label{fig:sys_rusage_struct}
1304 \var{tms\_utime}, \var{tms\_stime}, \var{tms\_cutime}, \var{tms\_uetime}
1308 \section{La gestione dei tempi del sistema}
1309 \label{sec:sys_time}
1311 In questa sezione tratteremo le varie funzioni per la gestione delle
1312 date e del tempo in un sistema unix-like, e quelle per convertire i vari
1313 tempi nelle differenti rappresentazioni che vengono utilizzate.
1316 \subsection{La misura del tempo in Unix}
1317 \label{sec:sys_unix_time}
1319 Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
1320 dati per la misure dei tempi all'interno del sistema: essi sono
1321 rispettivamente chiamati \textit{calendar time} e \textit{process time},
1322 secondo le definizioni:
1324 \item \textit{calendar time}: è il numero di secondi dalla mezzanotte del
1325 primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
1326 usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
1327 Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
1328 dato che l'UTC corrisponde all'ora locale di Greenwich. È il tempo su cui
1329 viene mantenuto l'orologio del calcolatore, e viene usato ad esempio per
1330 indicare le date di modifica dei file o quelle di avvio dei processi. Per
1331 memorizzare questo tempo è stato riservato il tipo primitivo \type{time\_t}.
1332 \item \textit{process time}: detto anche tempo di processore. Viene misurato
1333 in \textit{clock tick}, corrispondenti al numero di interruzioni effettuate
1334 dal timer di sistema, e che per Linux avvengono ogni centesimo di
1335 secondo.\footnote{eccetto per la piattaforma alpha dove avvengono ogni
1336 millesimo di secondo.} Il dato primitivo usato per questo tempo è
1337 \type{clock\_t}, inoltre la costante \macro{HZ} restituisce la frequenza di
1338 operazione del timer, e corrisponde dunque al numero di tick al secondo. Lo
1339 standard POSIX definisce allo stesso modo la costante \macro{CLK\_TCK});
1340 questo valore può comunque essere ottenuto con \func{sysconf} (vedi
1341 \secref{sec:sys_limits}).
1344 In genere si usa il \textit{calendar time} per esprimere le date dei file e le
1345 informazioni analoghe che riguardano i cosiddetti \textsl{tempi di orologio},
1346 che vengono usati ad esempio per i demoni che compiono lavori amministrativi
1347 ad ore definite, come \cmd{cron}.
1349 Di solito questo tempo viene convertito automaticamente dal valore in UTC al
1350 tempo locale, utilizzando le opportune informazioni di localizzazione
1351 (specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
1352 mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
1353 dall'orologio hardware del calcolatore.
1355 Anche il \textit{process time} di solito si esprime in secondi, ma provvede una
1356 precisione ovviamente superiore al \textit{calendar time} (la cui granularità
1357 minima è il secondo) e viene usato per tenere conto dei tempi di esecuzione
1358 dei processi. Per ciascun processo il kernel calcola tre tempi diversi:
1359 \begin{description*}
1360 \item[\textit{clock time}]: il tempo \textsl{reale} (viene chiamato anche
1361 \textit{wall clock time}) passato dall'avvio del processo. Chiaramente tale
1362 tempo dipende anche dal carico del sistema e da quanti altri processi
1363 stavano girando nello stesso periodo.
1364 \item[\textit{user time}]: il tempo che la CPU ha impiegato nell'esecuzione
1365 delle istruzioni del processo in user space.
1366 \item[\textit{system time}]: il tempo che la CPU ha impiegato nel kernel per
1367 eseguire delle system call per conto del processo.
1370 In genere la somma di \textit{user time} e \textit{system time} indica il
1371 tempo di processore totale in cui il sistema è stato effettivamente impegnato
1372 nell'eseguire un certo processo e viene chiamato \textit{CPU time}.
1377 \section{La gestione degli errori}
1378 \label{sec:sys_errors}
1380 La gestione degli errori è in genere una materia complessa. Inoltre il modello
1381 utilizzato dai sistema unix-like è basato sull'architettura a processi, e
1382 presenta una serie di problemi nel caso lo si debba usare con i thread.
1383 Esamineremo in questa sezione le sue caratteristiche principali.
1386 \subsection{La variabile \var{errno}}
1387 \label{sec:sys_errno}
1389 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
1390 riportare condizioni di errore, ed è una buona norma di programmazione
1391 controllare sempre che le funzioni chiamate si siano concluse correttamente.
1393 In genere le funzioni di libreria usano un valore speciale per indicare che
1394 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
1395 costante \macro{EOF} (a seconda della funzione); ma questo valore segnala solo
1396 che c'è stato un errore, non il tipo di errore.
1398 Per riportare il tipo di errore il sistema usa la variabile globale
1399 \var{errno},\footnote{L'uso di una variabile globale può comportare alcuni
1400 problemi (ad esempio nel caso dei thread) ma lo standard ISO C consente
1401 anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
1402 può anche usare una macro, e questo è infatti il modo usato da Linux per
1403 renderla locale ai singoli thread.} definita nell'header \file{errno.h}; la
1404 variabile è in genere definita come \ctyp{volatile} dato che può essere
1405 cambiata in modo asincrono da un segnale (si veda \ref{sec:sig_sigchld} per un
1406 esempio, ricordando quanto trattato in \ref{sec:proc_race_cond}), ma dato che
1407 un manipolatore di segnale scritto bene salva e ripristina il valore della
1408 variabile, di questo non è necessario preoccuparsi nella programmazione
1411 I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},
1412 nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
1413 costanti numeriche che identificano i vari errori; essi iniziano tutti per
1414 \macro{E} e si possono considerare come nomi riservati. In seguito faremo
1415 sempre riferimento a tali valori, quando descriveremo i possibili errori
1416 restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
1417 codice relativo ad un valore numerico con l'opzione \cmd{-l}.
1419 Il valore di \var{errno} viene sempre settato a zero all'avvio di un
1420 programma, gran parte delle funzioni di libreria settano \var{errno} ad un
1421 valore diverso da zero in caso di errore. Il valore è invece indefinito in
1422 caso di successo, perché anche se una funzione ha successo, può chiamarne
1423 altre al suo interno che falliscono, modificando così \var{errno}.
1425 Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
1426 essere il risultato di un errore precedente) e non lo si può usare per
1427 determinare quando o se una chiamata a funzione è fallita. La procedura da
1428 seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
1429 verificato il fallimento della funzione attraverso il suo codice di ritorno.
1432 \subsection{Le funzioni \func{strerror} e \func{perror}}
1433 \label{sec:sys_strerror}
1435 Benché gli errori siano identificati univocamente dal valore numerico di
1436 \var{errno} le librerie provvedono alcune funzioni e variabili utili per
1437 riportare in opportuni messaggi le condizioni di errore verificatesi. La
1438 prima funzione che si può usare per ricavare i messaggi di errore è
1439 \func{strerror}, il cui prototipo è:
1440 \begin{prototype}{string.h}{char *strerror(int errnum)}
1441 Ritorna una stringa (statica) che descrive l'errore il cui codice è passato
1445 In generale \func{strerror} viene usata passando \var{errno} come parametro;
1446 nel caso si specifichi un codice sbagliato verrà restituito un messaggio di
1447 errore sconosciuto. La funzione utilizza una stringa statica che non deve
1448 essere modificata dal programma e che è utilizzabile solo fino ad una chiamata
1449 successiva a \func{strerror}; nel caso si usino i thread è
1450 provvista\footnote{questa funzione è una estensione GNU, non fa parte dello
1451 standard POSIX.} una versione apposita:
1452 \begin{prototype}{string.h}
1453 {char *strerror\_r(int errnum, char *buff, size\_t size)}
1454 Analoga a \func{strerror} ma ritorna il messaggio in un buffer
1455 specificato da \param{buff} di lunghezza massima (compreso il terminatore)
1459 che utilizza un buffer che il singolo thread deve allocare, per evitare i
1460 problemi connessi alla condivisione del buffer statico. Infine, per completare
1461 la caratterizzazione dell'errore, si può usare anche la variabile
1462 globale\footnote{anche questa è un'estensione GNU.}
1463 \var{program\_invocation\_short\_name} che riporta il nome del programma
1464 attualmente in esecuzione.
1466 Una seconda funzione usata per riportare i codici di errore in maniera
1467 automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) è
1468 \func{perror}, il cui prototipo è:
1469 \begin{prototype}{stdio.h}{void perror (const char *message)}
1470 Stampa il messaggio di errore relativo al valore corrente di \var{errno}
1471 sullo standard error; preceduto dalla stringa \var{message}.
1473 i messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
1474 in \capref{cha:errors}), e, usando il valore corrente di \var{errno}, si
1475 riferiscono all'ultimo errore avvenuto. La stringa specificata con
1476 \var{message} viene stampato prime del messaggio d'errore, seguita dai due
1477 punti e da uno spazio, il messaggio è terminato con un a capo.
1479 Il messaggio può essere riportato anche usando altre variabili globali
1480 dichiarate in \file{errno.h}:
1482 const char *sys_errlist[];
1485 la prima contiene i puntatori alle stringhe di errore indicizzati da
1486 \var{errno}; la seconda esprime il valore più alto per un codice di errore,
1487 l'utilizzo di questa stringa è sostanzialmente equivalente a quello di
1490 In \nfig\ è riportata la sezione attinente del codice del programma
1491 \cmd{errcode}, che può essere usato per stampare i messaggi di errore e le
1492 costanti usate per identificare i singoli errori; il sorgente completo del
1493 programma è allegato nel file \file{ErrCode.c} e contiene pure la gestione
1494 delle opzioni e tutte le definizioni necessarie ad associare il valore
1495 numerico alla costante simbolica. In particolare si è riportata la sezione che
1496 converte la stringa passata come parametro in un intero (\texttt{\small
1497 1--2}), controllando con i valori di ritorno di \func{strtol} che la
1498 conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi stampa,
1499 a seconda dell'opzione scelta il messaggio di errore (\texttt{\small 11--14})
1500 o la macro (\texttt{\small 15--17}) associate a quel codice.
1502 \begin{figure}[!htb]
1504 \begin{lstlisting}{}
1505 /* convert string to number */
1506 err = strtol(argv[optind], NULL, 10);
1507 /* testing error condition on conversion */
1508 if (err==LONG_MIN) {
1509 perror("Underflow on error code");
1511 } else if (err==LONG_MIN) {
1512 perror("Overflow on error code");
1515 /* conversion is fine */
1517 printf("Error message for %d is %s\n", err, strerror(err));
1520 printf("Error label for %d is %s\n", err, err_code[err]);
1523 \caption{Codice per la stampa del messaggio di errore standard.}
1524 \label{fig:sys_err_mess}
1529 %%% Local Variables:
1531 %%% TeX-master: "gapil"
projects / gapil.git / blob