\chapter{La gestione del sistema, del tempo e degli errori}
\label{cha:system}
-In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
+In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
generali del sistema, come quelle per la gestione dei parametri e della
configurazione dello stesso, quelle per la lettura dei limiti e delle
caratteristiche, quelle per il controllo dell'uso delle risorse dei processi,
-\section{Capacità e caratteristiche del sistema}
+\section{Capacità e caratteristiche del sistema}
\label{sec:sys_characteristics}
-In questa sezione tratteremo le varie modalità con cui un programma può
-ottenere informazioni riguardo alle capacità del sistema. Ogni sistema
-unix-like infatti è contraddistinto da un gran numero di limiti e costanti che
+In questa sezione tratteremo le varie modalità con cui un programma può
+ottenere informazioni riguardo alle capacità del sistema. Ogni sistema
+unix-like infatti è contraddistinto da un gran numero di limiti e costanti che
lo caratterizzano, e che possono dipendere da fattori molteplici, come
l'architettura hardware, l'implementazione del kernel e delle librerie, le
opzioni di configurazione.
La definizione di queste caratteristiche ed il tentativo di provvedere dei
-meccanismi generali che i programmi possono usare per ricavarle è uno degli
-aspetti più complessi e controversi con cui le diverse standardizzazioni si
+meccanismi generali che i programmi possono usare per ricavarle è uno degli
+aspetti più complessi e controversi con cui le diverse standardizzazioni si
sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
Daremo comunque una descrizione dei principali metodi previsti dai vari
standard per ricavare sia le caratteristiche specifiche del sistema, che
\label{sec:sys_limits}
Quando si devono determinare le caratteristiche generali del sistema ci si
-trova di fronte a diverse possibilità; alcune di queste infatti possono
+trova di fronte a diverse possibilità; alcune di queste infatti possono
dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
interi), o dal sistema operativo (come la presenza o meno del gruppo degli
identificatori \textit{saved}), altre invece possono dipendere dalle opzioni
-con cui si è costruito il sistema (ad esempio da come si è compilato il
+con cui si è costruito il sistema (ad esempio da come si è compilato il
kernel), o dalla configurazione del medesimo; per questo motivo in generale
-sono necessari due tipi diversi di funzionalità:
+sono necessari due tipi diversi di funzionalità:
\begin{itemize*}
-\item la possibilità di determinare limiti ed opzioni al momento della
+\item la possibilità di determinare limiti ed opzioni al momento della
compilazione.
-\item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
+\item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
\end{itemize*}
-La prima funzionalità si può ottenere includendo gli opportuni header file che
+La prima funzionalità si può ottenere includendo gli opportuni header file che
contengono le costanti necessarie definite come macro di preprocessore, per la
-seconda invece sono ovviamente necessarie delle funzioni. La situazione è
+seconda invece sono ovviamente necessarie delle funzioni. La situazione è
complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
sono fissi in un'implementazione mentre possono variare in un altra. Tutto
-questo crea una ambiguità che non è sempre possibile risolvere in maniera
-chiara; in generale quello che succede è che quando i limiti del sistema sono
+questo crea una ambiguità che non è sempre possibile risolvere in maniera
+chiara; in generale quello che succede è che quando i limiti del sistema sono
fissi essi vengono definiti come macro di preprocessore nel file
-\file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
+\file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
tramite la funzione \func{sysconf} (che esamineremo in
sez.~\ref{sec:sys_sysconf}).
Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
-da \file{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si può
+da \file{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si può
vedere per la maggior parte questi limiti attengono alle dimensioni dei dati
interi, che sono in genere fissati dall'architettura hardware (le analoghe
informazioni per i dati in virgola mobile sono definite a parte, ed
accessibili includendo \file{float.h}). Lo standard prevede anche un'altra
-costante, \const{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
+costante, \const{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
definita in \file{limits.h}; essa deve essere definita in \file{stdio.h} ed
avere un valore minimo di 8.
\const{ULONG\_MAX}& 4294967295 & Massimo di \ctyp{unsigned long}.\\
\hline
\end{tabular}
- \caption{Costanti definite in \file{limits.h} in conformità allo standard
+ \caption{Costanti definite in \file{limits.h} in conformità allo standard
ANSI C.}
\label{tab:sys_ansic_macro}
\end{table}
-\footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
+\footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
sistema usi caratteri con segno o meno.}
-\footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
+\footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
a seconda che il sistema usi caratteri con segno o meno.}
A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
Massimo di \ctyp{unsigned long long}.\\
\hline
\end{tabular}
- \caption{Macro definite in \file{limits.h} in conformità allo standard
+ \caption{Macro definite in \file{limits.h} in conformità allo standard
ISO C90.}
\label{tab:sys_isoc90_macro}
\end{table}
limiti relativi alle caratteristiche dei file che vedremo in
sez.~\ref{sec:sys_file_limits}.
-Purtroppo la sezione dello standard che tratta questi argomenti è una delle
+Purtroppo la sezione dello standard che tratta questi argomenti è una delle
meno chiare\footnote{tanto che Stevens, in \cite{APUE}, la porta come esempio
di ``\textsl{standardese}''.}. Lo standard prevede che ci siano 13 macro che
descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
passati ad una funzione della famiglia
\func{exec}.\\
\const{CHILD\_MAX} & 999& Numero massimo di processi contemporanei
- che un utente può eseguire.\\
+ che un utente può eseguire.\\
\const{OPEN\_MAX} & 256& Numero massimo di file che un processo
- può mantenere aperti in contemporanea.\\
+ può mantenere aperti in contemporanea.\\
\const{STREAM\_MAX}& 8& Massimo numero di stream aperti per
processo in contemporanea.\\
\const{TZNAME\_MAX}& 6& Dimensione massima del nome di una
Lo standard dice che queste macro devono essere definite in \file{limits.h}
quando i valori a cui fanno riferimento sono fissi, e altrimenti devono essere
lasciate indefinite, ed i loro valori dei limiti devono essere accessibili
-solo attraverso \func{sysconf}. In realtà queste vengono sempre definite ad
+solo attraverso \func{sysconf}. In realtà queste vengono sempre definite ad
un valore generico. Si tenga presente poi che alcuni di questi limiti possono
-assumere valori molto elevati (come \const{CHILD\_MAX}), e non è pertanto il
+assumere valori molto elevati (come \const{CHILD\_MAX}), e non è pertanto il
caso di utilizzarli per allocare staticamente della memoria.
A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
-definiscono i valori minimi le stesse caratteristiche devono avere, perché una
+definiscono i valori minimi le stesse caratteristiche devono avere, perché una
implementazione possa dichiararsi conforme allo standard; detti valori sono
riportati in tab.~\ref{tab:sys_posix1_general}.
passati ad una funzione della famiglia
\func{exec}.\\
\const{\_POSIX\_CHILD\_MAX} & 6& Numero massimo di processi
- contemporanei che un utente può
+ contemporanei che un utente può
eseguire.\\
\const{\_POSIX\_OPEN\_MAX} & 16& Numero massimo di file che un processo
- può mantenere aperti in
+ può mantenere aperti in
contemporanea.\\
\const{\_POSIX\_STREAM\_MAX} & 8& Massimo numero di stream aperti per
processo in contemporanea.\\
\hline
\end{tabular}
\caption{Macro dei valori minimi delle caratteristiche generali del sistema
- per la conformità allo standard POSIX.1.}
+ per la conformità allo standard POSIX.1.}
\label{tab:sys_posix1_general}
\end{table}
-In genere questi valori non servono a molto, la loro unica utilità è quella di
-indicare un limite superiore che assicura la portabilità senza necessità di
+In genere questi valori non servono a molto, la loro unica utilità è quella di
+indicare un limite superiore che assicura la portabilità senza necessità di
ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
-i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
+i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
valori ottenuti da \func{sysconf}.
\begin{table}[htb]
199009L).\\
\hline
\end{tabular}
- \caption{Alcune macro definite in \file{limits.h} in conformità allo standard
+ \caption{Alcune macro definite in \file{limits.h} in conformità allo standard
POSIX.1.}
\label{tab:sys_posix1_other}
\end{table}
Oltre ai precedenti valori (e a quelli relativi ai file elencati in
tab.~\ref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
lo standard POSIX.1 ne prevede parecchi altri. La lista completa si trova
-dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
+dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
incluso automaticamente all'interno di \file{limits.h}). Di questi vale la
pena menzionare alcune macro di uso comune, (riportate in
tab.~\ref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
-denotano la presenza di alcune funzionalità nel sistema (come il supporto del
+denotano la presenza di alcune funzionalità nel sistema (come il supporto del
\textit{job control} o degli identificatori del gruppo \textit{saved}).
Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
\label{sec:sys_sysconf}
Come accennato in sez.~\ref{sec:sys_limits} quando uno dei limiti o delle
-caratteristiche del sistema può variare, per non dover essere costretti a
-ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
-compilato il kernel, o alcuni dei parametri modificabili a run time, è
+caratteristiche del sistema può variare, per non dover essere costretti a
+ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
+compilato il kernel, o alcuni dei parametri modificabili a run time, è
necessario ottenerne il valore attraverso la funzione \funcd{sysconf}. Il
-prototipo di questa funzione è:
+prototipo di questa funzione è:
\begin{prototype}{unistd.h}{long sysconf(int name)}
Restituisce il valore del parametro di sistema \param{name}.
\bodydesc{La funzione restituisce indietro il valore del parametro
richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
- è disponibile e -1 in caso di errore (ma \var{errno} non viene impostata).}
+ è disponibile e -1 in caso di errore (ma \var{errno} non viene impostata).}
\end{prototype}
La funzione prende come argomento un intero che specifica quale dei limiti si
vuole conoscere; uno specchietto contenente i principali valori disponibili in
-Linux è riportato in tab.~\ref{tab:sys_sysconf_par}; l'elenco completo è
-contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
-relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
+Linux è riportato in tab.~\ref{tab:sys_sysconf_par}; l'elenco completo è
+contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
+relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
\begin{table}[htb]
\centering
ad una funzione della famiglia \func{exec}.\\
\texttt{\_SC\_CHILD\_MAX} & \const{\_CHILD\_MAX}&
Il numero massimo di processi contemporanei
- che un utente può eseguire.\\
+ che un utente può eseguire.\\
\texttt{\_SC\_OPEN\_MAX} & \const{\_OPEN\_MAX}&
- Il numero massimo di file che un processo può
+ Il numero massimo di file che un processo può
mantenere aperti in contemporanea.\\
\texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
Il massimo numero di stream che un processo
- può mantenere aperti in contemporanea. Questo
+ può mantenere aperti in contemporanea. Questo
limite previsto anche dallo standard ANSI C,
che specifica la macro {FOPEN\_MAX}.\\
\texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
sez.~\ref{sec:sys_date}).\\
\texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
Massimo numero di gruppi supplementari che
- può avere un processo (vedi
+ può avere un processo (vedi
sez.~\ref{sec:proc_access_id}).\\
\texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}&
Valore massimo del tipo di dato
\texttt{\_SC\_CLK\_TCK} & \const{CLK\_TCK} &
Il numero di \itindex{clock~tick}
\textit{clock tick} al secondo,
- cioè l'unità di misura del
+ cioè l'unità di misura del
\itindex{process~time} \textit{process
time} (vedi
sez.~\ref{sec:sys_unix_time}).\\
\texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
- Indica se è supportato il \textit{job
+ Indica se è supportato il \textit{job
control} (vedi
sez.~\ref{sec:sess_job_control}) in stile
POSIX.\\
Indica il mese e l'anno di approvazione
della revisione dello standard POSIX.1 a cui
il sistema fa riferimento, nel formato
- YYYYMML, la revisione più recente è 199009L,
+ YYYYMML, la revisione più recente è 199009L,
che indica il Settembre 1990.\\
\hline
\end{tabular}
\label{tab:sys_sysconf_par}
\end{table}
-In generale ogni limite o caratteristica del sistema per cui è definita una
-macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
-essere ottenuto attraverso una chiamata a \func{sysconf}. Il valore si otterrà
+In generale ogni limite o caratteristica del sistema per cui è definita una
+macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
+essere ottenuto attraverso una chiamata a \func{sysconf}. Il valore si otterrà
specificando come valore dell'argomento \param{name} il nome ottenuto
aggiungendo \code{\_SC\_} ai nomi delle macro definite dai primi due, o
sostituendolo a \code{\_POSIX\_} per le macro definite dagli gli altri due.
In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
-macro non è definita, quindi con un codice analogo al seguente:
+macro non è definita, quindi con un codice analogo al seguente:
\includecodesnip{listati/get_child_max.c}
-ma in realtà in Linux queste macro sono comunque definite, indicando però un
-limite generico. Per questo motivo è sempre meglio usare i valori restituiti
+ma in realtà in Linux queste macro sono comunque definite, indicando però un
+limite generico. Per questo motivo è sempre meglio usare i valori restituiti
da \func{sysconf}.
\hline
\end{tabular}
\caption{Costanti dei valori minimi delle caratteristiche dei file per la
- conformità allo standard POSIX.1.}
+ conformità allo standard POSIX.1.}
\label{tab:sys_posix1_file}
\end{table}
Tutti questi limiti sono definiti in \file{limits.h}; come nel caso precedente
-il loro uso è di scarsa utilità in quanto ampiamente superati in tutte le
+il loro uso è di scarsa utilità in quanto ampiamente superati in tutte le
implementazioni moderne.
\subsection{La funzione \func{pathconf}}
\label{sec:sys_pathconf}
-In generale i limiti per i file sono molto più soggetti ad essere variabili
+In generale i limiti per i file sono molto più soggetti ad essere variabili
rispetto ai limiti generali del sistema; ad esempio parametri come la
lunghezza del nome del file o il numero di link possono variare da filesystem
a filesystem; per questo motivo questi limiti devono essere sempre controllati
-con la funzione \funcd{pathconf}, il cui prototipo è:
+con la funzione \funcd{pathconf}, il cui prototipo è:
\begin{prototype}{unistd.h}{long pathconf(char *path, int name)}
Restituisce il valore del parametro \param{name} per il file \param{path}.
\end{prototype}
E si noti come la funzione in questo caso richieda un argomento che specifichi
-a quale file si fa riferimento, dato che il valore del limite cercato può
+a quale file si fa riferimento, dato che il valore del limite cercato può
variare a seconda del filesystem. Una seconda versione della funzione,
\funcd{fpathconf}, opera su un file descriptor invece che su un
-\itindex{pathname} \textit{pathname}. Il suo prototipo è:
+\itindex{pathname} \textit{pathname}. Il suo prototipo è:
\begin{prototype}{unistd.h}{long fpathconf(int fd, int name)}
Restituisce il valore del parametro \param{name} per il file \param{fd}.
- \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
+ \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
invece di un \itindex{pathname} \textit{pathname}; pertanto gli errori
restituiti cambiano di conseguenza.}
\end{prototype}
-\noindent ed il suo comportamento è identico a quello di \func{pathconf}.
+\noindent ed il suo comportamento è identico a quello di \func{pathconf}.
\subsection{La funzione \func{uname}}
\label{sec:sys_uname}
-Un'altra funzione che si può utilizzare per raccogliere informazioni sia
-riguardo al sistema che al computer su cui esso sta girando è \funcd{uname};
-il suo prototipo è:
+Un'altra funzione che si può utilizzare per raccogliere informazioni sia
+riguardo al sistema che al computer su cui esso sta girando è \funcd{uname};
+il suo prototipo è:
\begin{prototype}{sys/utsname.h}{int uname(struct utsname *info)}
Restituisce informazioni sul sistema nella struttura \param{info}.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
- fallimento, nel qual caso \var{errno} assumerà il valore \errval{EFAULT}.}
+ fallimento, nel qual caso \var{errno} assumerà il valore \errval{EFAULT}.}
\end{prototype}
La funzione, che viene usata dal comando \cmd{uname}, restituisce le
-informazioni richieste nella struttura \param{info}; anche questa struttura è
+informazioni richieste nella struttura \param{info}; anche questa struttura è
definita in \file{sys/utsname.h}, secondo quanto mostrato in
fig.~\ref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
indicano rispettivamente:
\item il nome della stazione;
\item il nome del domino.
\end{itemize*}
-l'ultima informazione è stata aggiunta di recente e non è prevista dallo
-standard POSIX, essa è accessibile, come mostrato in
+l'ultima informazione è stata aggiunta di recente e non è prevista dallo
+standard POSIX, essa è accessibile, come mostrato in
fig.~\ref{fig:sys_utsname}, solo definendo \macro{\_GNU\_SOURCE}.
\begin{figure}[!htb]
\end{figure}
In generale si tenga presente che le dimensioni delle stringhe di una
-struttura \struct{utsname} non è specificata, e che esse sono sempre terminate
+struttura \struct{utsname} non è specificata, e che esse sono sempre terminate
con NUL; il manuale delle \acr{glibc} indica due diverse dimensioni,
\const{\_UTSNAME\_LENGTH} per i campi standard e
\const{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
altri sistemi usano nomi diversi come \const{SYS\_NMLN} o \const{\_SYS\_NMLN}
o \const{UTSLEN} che possono avere valori diversi.\footnote{nel caso di Linux
- \func{uname} corrisponde in realtà a 3 system call diverse, le prime due
+ \func{uname} corrisponde in realtà a 3 system call diverse, le prime due
usano rispettivamente delle lunghezze delle stringhe di 9 e 65 byte; la
terza usa anch'essa 65 byte, ma restituisce anche l'ultimo campo,
\var{domainname}, con una lunghezza di 257 byte.}
Come abbiamo accennato nella sezione precedente, non tutti i limiti che
caratterizzano il sistema sono fissi, o perlomeno non lo sono in tutte le
-implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
+implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
di esaminare il meccanismo che permette, quando questi possono variare durante
l'esecuzione del sistema, di modificarli.
Inoltre, al di la di quelli che possono essere limiti caratteristici previsti
-da uno standard, ogni sistema può avere una sua serie di altri parametri di
+da uno standard, ogni sistema può avere una sua serie di altri parametri di
configurazione, che, non essendo mai fissi e variando da sistema a sistema,
non sono stati inclusi nella standardizzazione della sezione precedente. Per
questi occorre, oltre al meccanismo di impostazione, pure un meccanismo di
\label{sec:sys_sysctl}
La funzione che permette la lettura ed l'impostazione dei parametri del
-sistema è \funcd{sysctl}; è una funzione derivata da BSD4.4, ma
-l'implementazione è specifica di Linux; il suo prototipo è:
+sistema è \funcd{sysctl}; è una funzione derivata da BSD4.4, ma
+l'implementazione è specifica di Linux; il suo prototipo è:
\begin{functions}
\headdecl{unistd.h}
\funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
Legge o scrive uno dei parametri di sistema.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori:
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{EPERM}] non si ha il permesso di accedere ad uno dei
componenti nel cammino specificato per il parametro, o di accedere al
- parametro nella modalità scelta.
+ parametro nella modalità scelta.
\item[\errcode{ENOTDIR}] non esiste un parametro corrispondente al nome
\param{name}.
-% \item[\errcode{EFAULT}] si è specificato \param{oldlenp} zero quando
-% \param{oldval} è non nullo.
- \item[\errcode{EINVAL}] o si è specificato un valore non valido per il
+% \item[\errcode{EFAULT}] si è specificato \param{oldlenp} zero quando
+% \param{oldval} è non nullo.
+ \item[\errcode{EINVAL}] o si è specificato un valore non valido per il
parametro che si vuole impostare o lo spazio provvisto per il ritorno di un
- valore non è delle giuste dimensioni.
- \item[\errcode{ENOMEM}] talvolta viene usato più correttamente questo errore
- quando non si è specificato sufficiente spazio per ricevere il valore di un
+ valore non è delle giuste dimensioni.
+ \item[\errcode{ENOMEM}] talvolta viene usato più correttamente questo errore
+ quando non si è specificato sufficiente spazio per ricevere il valore di un
parametro.
\end{errlist}
ed inoltre \errval{EFAULT}.
maniera gerarchica all'interno di un albero;\footnote{si tenga presente che
includendo solo \file{unistd.h}, saranno definiti solo i parametri generici;
dato che ce ne sono molti specifici dell'implementazione, nel caso di Linux
- occorrerà includere anche i file \file{linux/unistd.h} e
+ occorrerà includere anche i file \file{linux/unistd.h} e
\file{linux/sysctl.h}.} per accedere ad uno di essi occorre specificare un
cammino attraverso i vari nodi dell'albero, in maniera analoga a come avviene
per la risoluzione di un \itindex{pathname} \textit{pathname} (da cui l'uso
alternativo del filesystem \file{/proc}, che vedremo dopo).
-Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
-arriva ad identificare un parametro specifico è passato alla funzione
+Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
+arriva ad identificare un parametro specifico è passato alla funzione
attraverso l'array \param{name}, di lunghezza \param{nlen}, che contiene la
sequenza dei vari nodi da attraversare. Ogni parametro ha un valore in un
-formato specifico che può essere un intero, una stringa o anche una struttura
+formato specifico che può essere un intero, una stringa o anche una struttura
complessa, per questo motivo i valori vengono passati come puntatori
\ctyp{void}.
-L'indirizzo a cui il valore corrente del parametro deve essere letto è
-specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
+L'indirizzo a cui il valore corrente del parametro deve essere letto è
+specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
\param{oldlenp} (passato come puntatore per avere indietro la dimensione
-effettiva di quanto letto); il valore che si vuole impostare nel sistema è
+effettiva di quanto letto); il valore che si vuole impostare nel sistema è
passato in \param{newval} e la sua dimensione in \param{newlen}.
-Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
-valore letto restituito dalla funzione è quello precedente alla scrittura.
+Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
+valore letto restituito dalla funzione è quello precedente alla scrittura.
I parametri accessibili attraverso questa funzione sono moltissimi, e possono
essere trovati in \file{sysctl.h}, essi inoltre dipendono anche dallo stato
corrente del kernel (ad esempio dai moduli che sono stati caricati nel
sistema) e in genere i loro nomi possono variare da una versione di kernel
-all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
-quando esistono modalità alternative per ottenere le stesse informazioni.
+all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
+quando esistono modalità alternative per ottenere le stesse informazioni.
Alcuni esempi di parametri ottenibili sono:
\begin{itemize}
\item il nome di dominio
\item il numero massimo di file aperti
\end{itemize}
-Come accennato in Linux si ha una modalità alternativa per accedere alle
+Come accennato in Linux si ha una modalità alternativa per accedere alle
stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
-\file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
+\file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
kernel, che non fa riferimento a nessun dispositivo fisico, ma presenta in
forma di file alcune delle strutture interne del kernel stesso.
In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
-di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
+di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
specificando un \itindex{pathname} \textit{pathname} e leggendo e scrivendo sul
file corrispondente al parametro scelto. Il kernel si occupa di generare al
volo il contenuto ed i nomi dei file corrispondenti, e questo ha il grande
e di permettere la navigazione dell'albero dei valori.
Alcune delle corrispondenze dei file presenti in \file{/proc/sys} con i valori
-di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
+di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
in \file{linux/sysctl.h},\footnote{indicando un file di definizioni si fa
riferimento alla directory standard dei file di include, che in ogni
- distribuzione che si rispetti è \file{/usr/include}.} la informazione
-disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
+ distribuzione che si rispetti è \file{/usr/include}.} la informazione
+disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc} sono
-\subsection{La gestione delle proprietà dei filesystem}
+\subsection{La gestione delle proprietà dei filesystem}
\label{sec:sys_file_config}
Come accennato in sez.~\ref{sec:file_organization} per poter accedere ai file
occorre prima rendere disponibile al sistema il filesystem su cui essi sono
-memorizzati; l'operazione di attivazione del filesystem è chiamata
-\textsl{montaggio}, per far questo in Linux\footnote{la funzione è specifica
- di Linux e non è portabile.} si usa la funzione \funcd{mount} il cui
-prototipo è:
+memorizzati; l'operazione di attivazione del filesystem è chiamata
+\textsl{montaggio}, per far questo in Linux\footnote{la funzione è specifica
+ di Linux e non è portabile.} si usa la funzione \funcd{mount} il cui
+prototipo è:
\begin{prototype}{sys/mount.h}
{mount(const char *source, const char *target, const char *filesystemtype,
unsigned long mountflags, const void *data)}
essere restituiti in \var{errno} sono:
\begin{errlist}
\item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
- \item[\errcode{ENODEV}] \param{filesystemtype} non esiste o non è configurato
+ \item[\errcode{ENODEV}] \param{filesystemtype} non esiste o non è configurato
nel kernel.
- \item[\errcode{ENOTBLK}] non si è usato un \textit{block device} per
+ \item[\errcode{ENOTBLK}] non si è usato un \textit{block device} per
\param{source} quando era richiesto.
- \item[\errcode{EBUSY}] \param{source} è già montato, o non può essere
- rimontato in read-only perché ci sono ancora file aperti in scrittura, o
- \param{target} è ancora in uso.
+ \item[\errcode{EBUSY}] \param{source} è già montato, o non può essere
+ rimontato in read-only perché ci sono ancora file aperti in scrittura, o
+ \param{target} è ancora in uso.
\item[\errcode{EINVAL}] il device \param{source} presenta un
- \textit{superblock} non valido, o si è cercato di rimontare un filesystem
+ \textit{superblock} non valido, o si è cercato di rimontare un filesystem
non ancora montato, o di montarlo senza che \param{target} sia un
- \textit{mount point} o di spostarlo quando \param{target} non è un
- \textit{mount point} o è \file{/}.
+ \textit{mount point} o di spostarlo quando \param{target} non è un
+ \textit{mount point} o è \file{/}.
\item[\errcode{EACCES}] non si ha il permesso di accesso su uno dei
- componenti del \itindex{pathname} \textit{pathname}, o si è cercato
+ componenti del \itindex{pathname} \textit{pathname}, o si è cercato
di montare un filesystem disponibile in sola lettura senza averlo
- specificato o il device \param{source} è su un filesystem montato con
+ specificato o il device \param{source} è su un filesystem montato con
l'opzione \const{MS\_NODEV}.
\item[\errcode{ENXIO}] il \itindex{major~number} \textit{major number} del
- device \param{source} è sbagliato.
- \item[\errcode{EMFILE}] la tabella dei device \textit{dummy} è piena.
+ device \param{source} è sbagliato.
+ \item[\errcode{EMFILE}] la tabella dei device \textit{dummy} è piena.
\end{errlist}
ed inoltre \errval{ENOTDIR}, \errval{EFAULT}, \errval{ENOMEM},
\errval{ENAMETOOLONG}, \errval{ENOENT} o \errval{ELOOP}.}
\end{prototype}
La funzione monta sulla directory \param{target}, detta \textit{mount point},
-il filesystem contenuto in \param{source}. In generale un filesystem è
+il filesystem contenuto in \param{source}. In generale un filesystem è
contenuto su un disco, e l'operazione di montaggio corrisponde a rendere
visibile al sistema il contenuto del suddetto disco, identificato attraverso
il file di dispositivo ad esso associato.
-Ma la struttura del virtual filesystem vista in sez.~\ref{sec:file_vfs} è molto
-più flessibile e può essere usata anche per oggetti diversi da un disco. Ad
-esempio usando il \textit{loop device} si può montare un file qualunque (come
+Ma la struttura del virtual filesystem vista in sez.~\ref{sec:file_vfs} è molto
+più flessibile e può essere usata anche per oggetti diversi da un disco. Ad
+esempio usando il \textit{loop device} si può montare un file qualunque (come
l'immagine di un CD-ROM o di un floppy) che contiene un filesystem, inoltre
alcuni filesystem, come \file{proc} o \file{devfs} sono del tutto virtuali, i
loro dati sono generati al volo ad ogni lettura, e passati al kernel ad ogni
scrittura.
-Il tipo di filesystem è specificato da \param{filesystemtype}, che deve essere
+Il tipo di filesystem è specificato da \param{filesystemtype}, che deve essere
una delle stringhe riportate nel file \procfile{/proc/filesystems}, che
contiene l'elenco dei filesystem supportati dal kernel; nel caso si sia
indicato uno dei filesystem virtuali, il contenuto di \param{source} viene
precedente contenuto di detta directory viene mascherato dal contenuto della
directory radice del filesystem montato.
-Dal kernel 2.4.x inoltre è divenuto possibile sia spostare atomicamente un
+Dal kernel 2.4.x inoltre è divenuto possibile sia spostare atomicamente un
\textit{mount point} da una directory ad un'altra, sia montare in diversi
-\textit{mount point} lo stesso filesystem, sia montare più filesystem sullo
+\textit{mount point} lo stesso filesystem, sia montare più filesystem sullo
stesso \textit{mount point} (nel qual caso vale quanto appena detto, e solo il
-contenuto dell'ultimo filesystem montato sarà visibile).
+contenuto dell'ultimo filesystem montato sarà visibile).
-Ciascun filesystem è dotato di caratteristiche specifiche che possono essere
-attivate o meno, alcune di queste sono generali (anche se non è detto siano
+Ciascun filesystem è dotato di caratteristiche specifiche che possono essere
+attivate o meno, alcune di queste sono generali (anche se non è detto siano
disponibili in ogni filesystem), e vengono specificate come opzioni di
montaggio con l'argomento \param{mountflags}.
-In Linux \param{mountflags} deve essere un intero a 32 bit i cui 16 più
-significativi sono un \textit{magic number}\footnote{cioè un numero speciale
- usato come identificativo, che nel caso è \code{0xC0ED}; si può usare la
+In Linux \param{mountflags} deve essere un intero a 32 bit i cui 16 più
+significativi sono un \textit{magic number}\footnote{cioè un numero speciale
+ usato come identificativo, che nel caso è \code{0xC0ED}; si può usare la
costante \const{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
riservata al \textit{magic number}.} mentre i 16 meno significativi sono
usati per specificare le opzioni; essi sono usati come maschera binaria e
\end{table}
% TODO aggiornare con i nuovi flag di man mount
-% gli S_* non esistono più come segnalato da Alessio...
+% gli S_* non esistono più come segnalato da Alessio...
% verificare i readonly mount bind del 2.6.26
Per l'impostazione delle caratteristiche particolari di ciascun filesystem si
usa invece l'argomento \param{data} che serve per passare le ulteriori
informazioni necessarie, che ovviamente variano da filesystem a filesystem.
-La funzione \func{mount} può essere utilizzata anche per effettuare il
+La funzione \func{mount} può essere utilizzata anche per effettuare il
\textsl{rimontaggio} di un filesystem, cosa che permette di cambiarne al volo
alcune delle caratteristiche di funzionamento (ad esempio passare da sola
-lettura a lettura/scrittura). Questa operazione è attivata attraverso uno dei
+lettura a lettura/scrittura). Questa operazione è attivata attraverso uno dei
bit di \param{mountflags}, \const{MS\_REMOUNT}, che se impostato specifica che
deve essere effettuato il rimontaggio del filesystem (con le opzioni
specificate dagli altri bit), anche in questo caso il valore di \param{source}
viene ignorato.
-Una volta che non si voglia più utilizzare un certo filesystem è possibile
-\textsl{smontarlo} usando la funzione \funcd{umount}, il cui prototipo è:
+Una volta che non si voglia più utilizzare un certo filesystem è possibile
+\textsl{smontarlo} usando la funzione \funcd{umount}, il cui prototipo è:
\begin{prototype}{sys/mount.h}{umount(const char *target)}
Smonta il filesystem montato sulla directory \param{target}.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
- fallimento, nel qual caso \var{errno} assumerà uno dei valori:
+ fallimento, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
- \item[\errcode{EBUSY}] \param{target} è la directory di lavoro di qualche
+ \item[\errcode{EBUSY}] \param{target} è la directory di lavoro di qualche
processo, o contiene dei file aperti, o un altro mount point.
\end{errlist}
ed inoltre \errval{ENOTDIR}, \errval{EFAULT}, \errval{ENOMEM},
\errval{ENAMETOOLONG}, \errval{ENOENT} o \errval{ELOOP}.}
\end{prototype}
-\noindent la funzione prende il nome della directory su cui il filesystem è
-montato e non il file o il dispositivo che è stato montato,\footnote{questo è
+\noindent la funzione prende il nome della directory su cui il filesystem è
+montato e non il file o il dispositivo che è stato montato,\footnote{questo è
vero a partire dal kernel 2.3.99-pre7, prima esistevano due chiamate
separate e la funzione poteva essere usata anche specificando il file di
- dispositivo.} in quanto con il kernel 2.4.x è possibile montare lo stesso
-dispositivo in più punti. Nel caso più di un filesystem sia stato montato
-sullo stesso \textit{mount point} viene smontato quello che è stato montato
+ dispositivo.} in quanto con il kernel 2.4.x è possibile montare lo stesso
+dispositivo in più punti. Nel caso più di un filesystem sia stato montato
+sullo stesso \textit{mount point} viene smontato quello che è stato montato
per ultimo.
-Si tenga presente che la funzione fallisce quando il filesystem è
+Si tenga presente che la funzione fallisce quando il filesystem è
\textsl{occupato}, questo avviene quando ci sono ancora file aperti sul
filesystem, se questo contiene la directory di lavoro corrente di un qualunque
processo o il mount point di un altro filesystem; in questo caso l'errore
-restituito è \errcode{EBUSY}.
+restituito è \errcode{EBUSY}.
Linux provvede inoltre una seconda funzione, \funcd{umount2}, che in alcuni
casi permette di forzare lo smontaggio di un filesystem, anche quando questo
-risulti occupato; il suo prototipo è:
+risulti occupato; il suo prototipo è:
\begin{prototype}{sys/mount.h}{umount2(const char *target, int flags)}
- La funzione è identica a \func{umount} per comportamento e codici di errore,
- ma con \param{flags} si può specificare se forzare lo smontaggio.
+ La funzione è identica a \func{umount} per comportamento e codici di errore,
+ ma con \param{flags} si può specificare se forzare lo smontaggio.
\end{prototype}
-Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
-definito è il bit \const{MNT\_FORCE}; gli altri bit devono essere nulli.
-Specificando \const{MNT\_FORCE} la funzione cercherà di liberare il filesystem
-anche se è occupato per via di una delle condizioni descritte in precedenza. A
+Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
+definito è il bit \const{MNT\_FORCE}; gli altri bit devono essere nulli.
+Specificando \const{MNT\_FORCE} la funzione cercherà di liberare il filesystem
+anche se è occupato per via di una delle condizioni descritte in precedenza. A
seconda del tipo di filesystem alcune (o tutte) possono essere superate,
evitando l'errore di \errcode{EBUSY}. In tutti i casi prima dello smontaggio
viene eseguita una sincronizzazione dei dati.
\funcdecl{int fstatfs(int fd, struct statfs *buf)}
- Restituisce in \param{buf} le informazioni relative al filesystem su cui è
+ Restituisce in \param{buf} le informazioni relative al filesystem su cui è
posto il file specificato.
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori:
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{ENOSYS}] il filesystem su cui si trova il file specificato non
supporta la funzione.
filesystem in esame sono impostati a zero. I valori del campo \var{f\_type}
sono definiti per i vari filesystem nei relativi file di header dei sorgenti
del kernel da costanti del tipo \var{XXX\_SUPER\_MAGIC}, dove \var{XXX} in
-genere è il nome del filesystem stesso.
+genere è il nome del filesystem stesso.
\begin{figure}[!htb]
\footnotesize \centering
In generale si dovrebbero usare queste funzioni (in particolare quelle
relative a \conffile{/etc/mtab}), quando si debba scrivere un programma che
-effettua il montaggio di un filesystem; in realtà in questi casi è molto più
+effettua il montaggio di un filesystem; in realtà in questi casi è molto più
semplice invocare direttamente il programma \cmd{mount}, per cui ne
tralasceremo la trattazione, rimandando al manuale delle \acr{glibc}
\cite{glibc} per la documentazione completa.
Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
(password, corrispondenze fra nomi simbolici e user-id, home directory, ecc.)
venivano registrate all'interno dei due file di testo \conffile{/etc/passwd}
-ed \conffile{/etc/group},\footnote{in realtà oltre a questi nelle
- distribuzioni più recenti è stato introdotto il sistema delle \textit{shadow
+ed \conffile{/etc/group},\footnote{in realtà oltre a questi nelle
+ distribuzioni più recenti è stato introdotto il sistema delle \textit{shadow
password} che prevede anche i due file \conffile{/etc/shadow} e
\conffile{/etc/gshadow}, in cui sono state spostate le informazioni di
autenticazione (ed inserite alcune estensioni) per toglierle dagli altri
file che devono poter essere letti per poter effettuare l'associazione fra
- username e \acr{uid}.} il cui formato è descritto dalle relative pagine del
+ username e \acr{uid}.} il cui formato è descritto dalle relative pagine del
manuale\footnote{nella quinta sezione, quella dei file di configurazione,
- occorre cioè usare \cmd{man 5 passwd} dato che altrimenti si avrebbe la
+ occorre cioè usare \cmd{man 5 passwd} dato che altrimenti si avrebbe la
pagina di manuale del comando \cmd{passwd}.} e tutte le funzioni che
richiedevano l'accesso a queste informazione andavano a leggere direttamente
il contenuto di questi file.
-Col tempo però questa impostazione ha incominciato a mostrare dei limiti: da
-una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
+Col tempo però questa impostazione ha incominciato a mostrare dei limiti: da
+una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
che sta per \textit{Pluggable Authentication Method}) che fornisce una
interfaccia comune per i processi di autenticazione,\footnote{il
- \textit{Pluggable Authentication Method} è un sistema modulare, in cui è
- possibile utilizzare anche più meccanismi insieme, diventa così possibile
+ \textit{Pluggable Authentication Method} è un sistema modulare, in cui è
+ possibile utilizzare anche più meccanismi insieme, diventa così possibile
avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
diversi formati per le password e diversi supporti per le informazioni, il
- tutto in maniera trasparente per le applicazioni purché per ciascun
+ tutto in maniera trasparente per le applicazioni purché per ciascun
meccanismo si disponga della opportuna libreria che implementa l'interfaccia
di PAM.} svincolando completamente le singole applicazione dai dettagli del
come questa viene eseguita e di dove vengono mantenuti i dati relativi;
-dall'altra con il diffondersi delle reti la necessità di centralizzare le
+dall'altra con il diffondersi delle reti la necessità di centralizzare le
informazioni degli utenti e dei gruppi per insiemi di macchine, in modo da
-mantenere coerenti i dati, ha portato anche alla necessità di poter recuperare
+mantenere coerenti i dati, ha portato anche alla necessità di poter recuperare
e memorizzare dette informazioni su supporti diversi, introducendo il sistema
del \itindex{Name~Service~Switch} \textit{Name Service Switch} che tratteremo
-brevemente più avanti (in sez.~\ref{sec:sock_resolver}) dato che la maggior
+brevemente più avanti (in sez.~\ref{sec:sock_resolver}) dato che la maggior
parte delle sua applicazioni sono relative alla risoluzioni di nomi di rete.
In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
\end{functions}
Le due funzioni forniscono le informazioni memorizzate nel registro degli
-utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
+utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
relative all'utente specificato attraverso il suo \acr{uid} o il nome di
login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
-tipo \struct{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
-riportata in fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente
+tipo \struct{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
+riportata in fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente
illustrato il significato dei vari campi.
\begin{figure}[!htb]
\label{fig:sys_passwd_struct}
\end{figure}
-La struttura usata da entrambe le funzioni è allocata staticamente, per questo
+La struttura usata da entrambe le funzioni è allocata staticamente, per questo
motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
fanno riferimento. Ovviamente questo implica che dette funzioni non possono
Restituiscono le informazioni relative all'utente specificato.
\bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
- altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
+ altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
\end{functions}
-In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
+In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
la memoria necessaria a contenere le informazioni. In particolare i valori
della struttura \struct{passwd} saranno restituiti all'indirizzo
\param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
-un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
+un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
puntate dai campi di \param{password}. Infine all'indirizzo puntato da
-\param{result} viene restituito il puntatore ai dati ottenuti, cioè
+\param{result} viene restituito il puntatore ai dati ottenuti, cioè
\param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti. Qualora i
dati non possano essere contenuti nei byte specificati da \param{buflen}, la
-funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
+funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
impostato a \val{NULL}).
Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
Restituiscono le informazioni relative al gruppo specificato.
\bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
- altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
+ altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
\end{functions}
-Il comportamento di tutte queste funzioni è assolutamente identico alle
-precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
+Il comportamento di tutte queste funzioni è assolutamente identico alle
+precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
in questo caso le informazioni vengono restituite in una struttura di tipo
-\struct{group}, la cui definizione è riportata in
+\struct{group}, la cui definizione è riportata in
fig.~\ref{fig:sys_group_struct}.
\begin{figure}[!htb]
Le funzioni viste finora sono in grado di leggere le informazioni sia
direttamente dal file delle password in \conffile{/etc/passwd} che tramite il
sistema del \itindex{Name~Service~Switch} \textit{Name Service Switch} e sono
-completamente generiche. Si noti però che non c'è una funzione che permetta di
-impostare direttamente una password.\footnote{in realtà questo può essere
- fatto ricorrendo a PAM, ma questo è un altro discorso.} Dato che POSIX non
-prevede questa possibilità esiste un'altra interfaccia che lo fa, derivata da
+completamente generiche. Si noti però che non c'è una funzione che permetta di
+impostare direttamente una password.\footnote{in realtà questo può essere
+ fatto ricorrendo a PAM, ma questo è un altro discorso.} Dato che POSIX non
+prevede questa possibilità esiste un'altra interfaccia che lo fa, derivata da
SVID le cui funzioni sono riportate in tab.~\ref{tab:sys_passwd_func}. Questa
-però funziona soltanto quando le informazioni sono mantenute su un apposito
+però funziona soltanto quando le informazioni sono mantenute su un apposito
file di \textsl{registro} di utenti e gruppi, con il formato classico di
\conffile{/etc/passwd} e \conffile{/etc/group}.
almeno le \textit{shadow password} (quindi con delle modifiche rispetto al
formato classico del file \conffile{/etc/passwd}), si tenga presente che le
funzioni di questa interfaccia che permettono di scrivere delle voci in un
-\textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
-hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
-questa estensione. Per questo motivo l'uso di queste funzioni è deprecato, in
+\textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
+hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
+questa estensione. Per questo motivo l'uso di queste funzioni è deprecato, in
quanto comunque non funzionale, pertanto ci limiteremo a fornire soltanto
l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
-ulteriore. Chi volesse insistere ad usare questa interfaccia può fare
+ulteriore. Chi volesse insistere ad usare questa interfaccia può fare
riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
delle \acr{glibc} per i dettagli del funzionamento.
-\subsection{Il registro della \textsl{contabilità} degli utenti}
+\subsection{Il registro della \textsl{contabilità} degli utenti}
\label{sec:sys_accounting}
L'ultimo insieme di funzioni relative alla gestione del sistema che
-esamineremo è quello che permette di accedere ai dati del registro della
-cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti. In esso
+esamineremo è quello che permette di accedere ai dati del registro della
+cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti. In esso
vengono mantenute una serie di informazioni storiche relative sia agli utenti
che si sono collegati al sistema, (tanto per quelli correntemente collegati,
che per la registrazione degli accessi precedenti), sia relative all'intero
cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
della macchina.
-I dati vengono usualmente\footnote{questa è la locazione specificata dal
+I dati vengono usualmente\footnote{questa è la locazione specificata dal
\textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
\file{/var/log/wtmp}.\footnote{non si confonda quest'ultimo con il simile
In questo modo il primo file viene utilizzato per registrare chi sta
utilizzando il sistema al momento corrente, mentre il secondo mantiene la
-registrazione delle attività degli utenti. A quest'ultimo vengono anche
+registrazione delle attività degli utenti. A quest'ultimo vengono anche
aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
informazioni sono descritte in dettaglio nel manuale delle \acr{glibc}.
contengono possono essere ricavate attraverso le opportune funzioni di
libreria. Queste sono analoghe alle precedenti funzioni (vedi
tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
-solo che in questo caso la struttura del registro della \textsl{contabilità} è
-molto più complessa, dato che contiene diversi tipi di informazione.
+solo che in questo caso la struttura del registro della \textsl{contabilità} è
+molto più complessa, dato che contiene diversi tipi di informazione.
Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
servono rispettivamente a aprire e a chiudere il file che contiene il
\bodydesc{Le funzioni non ritornano codici di errore.}
\end{functions}
e si tenga presente che le funzioni non restituiscono nessun valore, pertanto
-non è possibile accorgersi di eventuali errori (ad esempio se si è impostato
+non è possibile accorgersi di eventuali errori (ad esempio se si è impostato
un nome di file sbagliato con \func{utmpname}).
Nel caso non si sia utilizzata \func{utmpname} per specificare un file di
registro alternativo, sia \func{setutent} che \func{endutent} operano usando
-il default che è \file{/var/run/utmp}. Il nome di questo file, così come una
-serie di altri valori di default per i \textit{pathname} di uso più comune,
+il default che è \file{/var/run/utmp}. Il nome di questo file, così come una
+serie di altri valori di default per i \textit{pathname} di uso più comune,
viene mantenuto nei valori di una serie di costanti definite includendo
\file{paths.h}, in particolare quelle che ci interessano sono:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\const{\_PATH\_UTMP}] specifica il file che contiene il registro per gli
- utenti correntemente collegati; questo è il valore che viene usato se non si
- è utilizzato \func{utmpname} per modificarlo.
+ utenti correntemente collegati; questo è il valore che viene usato se non si
+ è utilizzato \func{utmpname} per modificarlo.
\item[\const{\_PATH\_WTMP}] specifica il file che contiene il registro per
l'archivio storico degli utenti collegati.
\end{basedescript}
che nel caso di Linux hanno un valore corrispondente ai file
\file{/var/run/utmp} e \file{/var/log/wtmp} citati in precedenza.
-Una volta aperto il file del registro degli utenti si può eseguire una
+Una volta aperto il file del registro degli utenti si può eseguire una
scansione leggendo o scrivendo una voce con le funzioni \funcd{getutent},
\funcd{getutid}, \funcd{getutline} e \funcd{pututline}, i cui prototipi sono:
\begin{functions}
\end{functions}
Tutte queste funzioni fanno riferimento ad una struttura di tipo
-\struct{utmp}, la cui definizione in Linux è riportata in
+\struct{utmp}, la cui definizione in Linux è riportata in
fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
voce dal registro; \func{getutent} legge semplicemente la prima voce
disponibile; le altre due permettono di eseguire una ricerca.
\end{minipage}
\normalsize
\caption{La struttura \structd{utmp} contenente le informazioni di una voce
- del registro di \textsl{contabilità}.}
+ del registro di \textsl{contabilità}.}
\label{fig:sys_utmp_struct}
\end{figure}
-Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
-campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
+Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
+campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
\const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
-verrà restituito la prima voce che corrisponde al tipo determinato; quando
+verrà restituito la prima voce che corrisponde al tipo determinato; quando
invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
-\const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
+\const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
\begin{table}[htb]
\const{EMPTY} & Non contiene informazioni valide.\\
\const{RUN\_LVL} & Identica il runlevel del sistema.\\
\const{BOOT\_TIME} & Identifica il tempo di avvio del sistema.\\
- \const{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
+ \const{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
sistema.\\
- \const{NEW\_TIME} & Identifica da quanto è stato modificato il
+ \const{NEW\_TIME} & Identifica da quanto è stato modificato il
sistema.\\
\const{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
\const{LOGIN\_PROCESS}& Identifica un processo di login.\\
\var{ut\_type} uguale a \const{LOGIN\_PROCESS} o \const{USER\_PROCESS},
restituendo la prima che corrisponde al valore di \var{ut\_line}, che
specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
-terminale che interessa. Lo stesso criterio di ricerca è usato da
+terminale che interessa. Lo stesso criterio di ricerca è usato da
\func{pututline} per trovare uno spazio dove inserire la voce specificata,
qualora non sia trovata la voce viene aggiunta in coda al registro.
-In generale occorre però tenere conto che queste funzioni non sono
+In generale occorre però tenere conto che queste funzioni non sono
completamente standardizzate, e che in sistemi diversi possono esserci
differenze; ad esempio \func{pututline} restituisce \code{void} in vari
sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
sono un sovrainsieme di \code{utmp}.
-Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
+Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
inutili queste nuove strutture; pertanto esse e le relative funzioni di
gestione (\func{getutxent}, \func{getutxid}, \func{getutxline},
\func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
Dopo aver esaminato le funzioni che permettono di controllare le varie
-caratteristiche, capacità e limiti del sistema a livello globale, in questa
+caratteristiche, capacità e limiti del sistema a livello globale, in questa
sezione tratteremo le varie funzioni che vengono usate per quantificare le
risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
permettono di imporre a ciascuno di essi vincoli e limiti di
\label{sec:sys_resource_use}
Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
-l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
+l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
di tipo \struct{rusage}, la cui definizione (che si trova in
-\file{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
+\file{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
\begin{figure}[!htb]
\footnotesize
\label{fig:sys_rusage_struct}
\end{figure}
-La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
+La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
\textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si trova
- nelle opzioni di compilazione del kernel (e di norma è disabilitato) che
- serve per mantenere una contabilità delle risorse usate da ciascun processo
- in maniera molto più dettagliata.} ma attualmente (con i kernel della serie
+ nelle opzioni di compilazione del kernel (e di norma è disabilitato) che
+ serve per mantenere una contabilità delle risorse usate da ciascun processo
+ in maniera molto più dettagliata.} ma attualmente (con i kernel della serie
2.4.x e 2.6.x) i soli campi che sono mantenuti sono: \var{ru\_utime},
\var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I
primi due indicano rispettivamente il tempo impiegato dal processo
\itindex{page~fault} \textit{page fault} (vedi sez.~\ref{sec:proc_mem_gen})
avvenuti senza richiedere I/O su disco (i cosiddetti \textit{minor page
fault}), a quelli che invece han richiesto I/O su disco (detti invece
-\textit{major page fault}) ed al numero di volte che il processo è stato
+\textit{major page fault}) ed al numero di volte che il processo è stato
completamente tolto dalla memoria per essere inserito nello swap.
-In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
-necessario, ma aumenta la portabilità, e serve comunque quando, come nella
+In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
+necessario, ma aumenta la portabilità, e serve comunque quando, come nella
maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
\struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
-Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
-visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di risorse
-impiegate dal processo di cui si è letto lo stato di terminazione, ma essa può
+Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
+visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di risorse
+impiegate dal processo di cui si è letto lo stato di terminazione, ma essa può
anche essere letta direttamente utilizzando la funzione \funcd{getrusage}, il
-cui prototipo è:
+cui prototipo è:
\begin{functions}
\headdecl{sys/time.h}
\headdecl{sys/resource.h}
\headdecl{unistd.h}
\funcdecl{int getrusage(int who, struct rusage *usage)}
- Legge la quantità di risorse usate da un processo.
+ Legge la quantità di risorse usate da un processo.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
- nel qual caso \var{errno} può essere \errval{EINVAL} o \errval{EFAULT}.}
+ nel qual caso \var{errno} può essere \errval{EINVAL} o \errval{EFAULT}.}
\end{functions}
L'argomento \param{who} permette di specificare il processo di cui si vuole
-leggere l'uso delle risorse; esso può assumere solo i due valori
+leggere l'uso delle risorse; esso può assumere solo i due valori
\const{RUSAGE\_SELF} per indicare il processo corrente e
-\const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
+\const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
ricevuto lo stato di terminazione.
% TODO previsto in futuro \const{RUSAGE\_THREAD}, verificare.
\label{sec:sys_resource_limit}
Come accennato nell'introduzione il kernel mette a disposizione delle
-funzionalità che permettono non solo di mantenere dati statistici relativi
+funzionalità che permettono non solo di mantenere dati statistici relativi
all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
utilizzo da parte dei vari processi o degli utenti.
Per far questo esistono una serie di risorse e ad ogni processo vengono
associati due diversi limiti per ciascuna di esse; questi sono il
\textsl{limite corrente} (o \textit{current limit}) che esprime un valore
-massimo che il processo non può superare ad un certo momento, ed il
+massimo che il processo non può superare ad un certo momento, ed il
\textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
-valore massimo che può assumere il \textsl{limite corrente}. In generale il
-primo viene chiamato anche \textit{soft limit} dato che il suo valore può
-essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
+valore massimo che può assumere il \textsl{limite corrente}. In generale il
+primo viene chiamato anche \textit{soft limit} dato che il suo valore può
+essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
limit}.
esse falliranno con un errore di
\errcode{ENOMEM}, mentre se il superamento viene
causato dalla crescita dello \itindex{stack}
- \textit{stack} il processo riceverà un segnale di
+ \textit{stack} il processo riceverà un segnale di
\const{SIGSEGV}.\\
\const{RLIMIT\_CORE} & La massima dimensione per di un file di
\itindex{core~dump} \textit{core dump} (vedi
sez.~\ref{sec:sig_prog_error}) creato nella
terminazione di un processo; file di dimensioni
maggiori verranno troncati a questo valore,
- mentre con un valore si bloccherà la creazione
+ mentre con un valore si bloccherà la creazione
dei \itindex{core~dump} \textit{core dump}.\\
\const{RLIMIT\_CPU} & Il massimo tempo di CPU (vedi
- sez.~\ref{sec:sys_cpu_times}) che il processo può
+ sez.~\ref{sec:sys_cpu_times}) che il processo può
usare. Il superamento del limite corrente
comporta l'emissione di un segnale di
\const{SIGXCPU}, la cui azione predefinita (vedi
- sez.~\ref{sec:sig_classification}) è terminare
+ sez.~\ref{sec:sig_classification}) è terminare
il processo, una volta al secondo fino al
raggiungimento del limite massimo. Il
superamento del limite massimo
\const{RLIMIT\_DATA} & La massima dimensione del \index{segmento!dati}
segmento dati di un
processo (vedi sez.~\ref{sec:proc_mem_layout}).
- Il tentativo di allocare più memoria di quanto
+ Il tentativo di allocare più memoria di quanto
indicato dal limite corrente causa il fallimento
della funzione di allocazione (\func{brk} o
\func{sbrk}) con un errore di \errcode{ENOMEM}.\\
\const{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
- può creare. Se il processo cerca di scrivere
- oltre questa dimensione riceverà un segnale di
+ può creare. Se il processo cerca di scrivere
+ oltre questa dimensione riceverà un segnale di
\const{SIGXFSZ}, che di norma termina il
processo; se questo viene intercettato la
- system call che ha causato l'errore fallirà con
+ system call che ha causato l'errore fallirà con
un errore di \errcode{EFBIG}.\\
- \const{RLIMIT\_LOCKS}& È un limite presente solo nelle prime versioni
+ \const{RLIMIT\_LOCKS}& È un limite presente solo nelle prime versioni
del kernel 2.4 sul numero massimo di
\index{file!locking} \textit{file lock} (vedi
sez.~\ref{sec:file_locking}) che un
processo poteva effettuare.\\
- \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
+ \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
bloccata in RAM da un processo (vedi
sez.~\ref{sec:proc_mem_lock}). Dal kernel 2.6.9
- questo limite comprende anche la memoria che può
+ questo limite comprende anche la memoria che può
essere bloccata da ciascun utente nell'uso della
memoria condivisa (vedi
sez.~\ref{sec:ipc_sysv_shm}) che viene
% \const{RLIMIT\_RTPRIO}& Il numero massimo di \\
% aggiungere i limiti che mancano come RLIMIT_RTTIME introdotto con il 2.6.25
% vedi file include/asm-generic/resource.h
- \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
- aprire. L'apertura di un ulteriore file farà
+ \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
+ aprire. L'apertura di un ulteriore file farà
fallire la funzione (\func{open}, \func{dup} o
\func{pipe}) con un errore \errcode{EMFILE}.\\
\const{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
creati sullo stesso user id real. Se il limite
- viene raggiunto \func{fork} fallirà con un
+ viene raggiunto \func{fork} fallirà con un
\errcode{EAGAIN}.\\
\const{RLIMIT\_SIGPENDING}& Il numero massimo di segnali che possono
essere mantenuti in coda per ciascun utente,
considerando sia i segnali normali che real-time
- (vedi sez.~\ref{sec:sig_real_time}). Il limite è
+ (vedi sez.~\ref{sec:sig_real_time}). Il limite è
attivo solo per \func{sigqueue}, con \func{kill}
- si potrà sempre inviare un segnale che non sia
- già presente su una coda.\footnotemark\\
+ si potrà sempre inviare un segnale che non sia
+ già presente su una coda.\footnotemark\\
\const{RLIMIT\_STACK} & La massima dimensione dello \itindex{stack}
\textit{stack} del processo. Se il processo
esegue operazioni che estendano lo
\textit{stack} oltre questa dimensione
- riceverà un segnale di \const{SIGSEGV}.\\
+ riceverà un segnale di \const{SIGSEGV}.\\
\const{RLIMIT\_RSS} & L'ammontare massimo di pagine di memoria dato al
\index{segmento!testo} testo del processo. Il
- limite è solo una indicazione per il kernel,
+ limite è solo una indicazione per il kernel,
qualora ci fosse un surplus di memoria questa
verrebbe assegnata.\\
% TODO integrare con la roba di madvise
\label{tab:sys_rlimit_values}
\end{table}
-\footnotetext[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
+\footnotetext[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
- avviene quando viene superato il \textit{soft limit}; perciò per avere
- operazioni portabili è sempre opportuno intercettare il primo
+ avviene quando viene superato il \textit{soft limit}; perciò per avere
+ operazioni portabili è sempre opportuno intercettare il primo
\const{SIGXCPU} e terminare in maniera ordinata il processo.}
-\footnotetext{il limite su questa risorsa è stato introdotto con il kernel
+\footnotetext{il limite su questa risorsa è stato introdotto con il kernel
2.6.8.}
% TODO trattare prlimit64 introdotta con il 2.6.36 che dovrebbe sostituire
avviene al superamento del limite corrente, con l'eccezione
\const{RLIMIT\_CPU} in cui si ha in comportamento diverso per il superamento
dei due limiti.} comporta o l'emissione di un segnale o il fallimento della
-system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
+system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
\const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
creazione) dei file di \itindex{core~dump} \textit{core dump}.} per
permettere di leggere e di impostare i limiti di utilizzo delle risorse da
Imposta il limite per la risorsa \param{resource}.
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori:
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{EINVAL}] i valori per \param{resource} non sono validi.
\item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
(rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
poi effettuato attraverso la struttura \struct{rlimit} puntata da
-\param{rlim}, la cui definizione è riportata in
+\param{rlim}, la cui definizione è riportata in
fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
limite corrente e limite massimo.
\end{figure}
-Nello specificare un limite, oltre a fornire dei valori specifici, si può
+Nello specificare un limite, oltre a fornire dei valori specifici, si può
anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
di una risorsa; ma si ricordi che solo un processo con i privilegi di
-amministratore\footnote{per essere precisi in questo caso quello che serve è
+amministratore\footnote{per essere precisi in questo caso quello che serve è
la \itindex{capabilities} \textit{capability} \const{CAP\_SYS\_RESOURCE}
- (vedi sez.~\ref{sec:proc_capabilities}).} può innalzare un limite al di
+ (vedi sez.~\ref{sec:proc_capabilities}).} può innalzare un limite al di
sopra del valore corrente del limite massimo ed usare un valore qualsiasi per
entrambi i limiti. Si tenga conto infine che tutti i limiti vengono ereditati
dal processo padre attraverso una \func{fork} (vedi sez.~\ref{sec:proc_fork})
\subsection{Le risorse di memoria e processore}
\label{sec:sys_memory_res}
-La gestione della memoria è già stata affrontata in dettaglio in
+La gestione della memoria è già stata affrontata in dettaglio in
sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
meccanismo della \index{memoria~virtuale} memoria virtuale attraverso la
divisione della memoria fisica in pagine.
-In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
+In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
casi, come per l'I/O mappato in memoria (vedi sez.~\ref{sec:file_memory_map})
-che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
+che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
gestire in maniera ottimale l'interazione della memoria che si sta allocando
con il meccanismo della \index{paginazione} paginazione.
-Di solito la dimensione delle pagine di memoria è fissata dall'architettura
+Di solito la dimensione delle pagine di memoria è fissata dall'architettura
hardware, per cui il suo valore di norma veniva mantenuto in una costante che
bastava utilizzare in fase di compilazione, ma oggi, con la presenza di alcune
architetture (ad esempio Sun Sparc) che permettono di variare questa
dimensione, per non dover ricompilare i programmi per ogni possibile modello e
-scelta di dimensioni, è necessario poter utilizzare una funzione.
+scelta di dimensioni, è necessario poter utilizzare una funzione.
Dato che si tratta di una caratteristica generale del sistema, questa
-dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
+dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
\func{sysconf}, \footnote{nel caso specifico si dovrebbe utilizzare il
- parametro \const{\_SC\_PAGESIZE}.} ma in BSD 4.2 è stata introdotta una
+ parametro \const{\_SC\_PAGESIZE}.} ma in BSD 4.2 è stata introdotta una
apposita funzione, \funcd{getpagesize}, che restituisce la dimensione delle
-pagine di memoria; il suo prototipo è:
+pagine di memoria; il suo prototipo è:
\begin{prototype}{unistd.h}{int getpagesize(void)}
Legge le dimensioni delle pagine di memoria.
sono previsti errori.}
\end{prototype}
-La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
+La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
-ha eliminata. In Linux è implementata come una system call nelle architetture
-in cui essa è necessaria, ed in genere restituisce il valore del simbolo
+ha eliminata. In Linux è implementata come una system call nelle architetture
+in cui essa è necessaria, ed in genere restituisce il valore del simbolo
\const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
implementavano questa funzione restituendo sempre un valore statico.
\const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
Infine le \acr{glibc} riprendono da BSD la funzione \funcd{getloadavg} che
-permette di ottenere il carico di processore della macchina, in questo modo è
+permette di ottenere il carico di processore della macchina, in questo modo è
possibile prendere decisioni su quando far partire eventuali nuovi processi.
-Il suo prototipo è:
+Il suo prototipo è:
\begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
Legge il carico medio della macchina.
La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
di processi attivi sulla coda dello \itindex{scheduler} scheduler, calcolato
su diversi intervalli di tempo. Il numero di intervalli che si vogliono
-leggere è specificato da \param{nelem}, dato che nel caso di Linux il carico
+leggere è specificato da \param{nelem}, dato che nel caso di Linux il carico
viene valutato solo su tre intervalli (corrispondenti a 1, 5 e 15 minuti),
-questo è anche il massimo valore che può essere assegnato a questo argomento.
+questo è anche il massimo valore che può essere assegnato a questo argomento.
-\subsection{La \textsl{contabilità} in stile BSD}
+\subsection{La \textsl{contabilità} in stile BSD}
\label{sec:sys_bsd_accounting}
-Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
-kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
+Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
+kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
cosiddetto \textit{BSD accounting}, che consente di registrare su file una
serie di informazioni\footnote{contenute nella struttura \texttt{acct}
definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
-riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
+riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
che viene terminato.
-Linux consente di salvare la contabilità delle informazioni relative alle
+Linux consente di salvare la contabilità delle informazioni relative alle
risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
-prototipo è:
+prototipo è:
\begin{prototype}{unistd.h}{int acct(const char *filename)}
Abilita il \textit{BSD accounting}.
\bodydesc{La funzione ritorna 0 in caso di successo o $-1$ in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori:
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{EACCESS}] non si hanno i permessi per accedere a
\param{pathname}.
abilitare il \textit{BSD accounting}.
\item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
\item[\errcode{EUSER}] non sono disponibili nel kernel strutture per il
- file o si è finita la memoria.
+ file o si è finita la memoria.
\end{errlist}
ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
\errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
La funzione attiva il salvataggio dei dati sul file indicato dal pathname
contenuti nella stringa puntata da \param{filename}; la funzione richiede che
-il processo abbia i privilegi di amministratore (è necessaria la
+il processo abbia i privilegi di amministratore (è necessaria la
\itindex{capabilities} capability \const{CAP\_SYS\_PACCT}, vedi
sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \const{NULL} per
\param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
-semplice esempio per l'uso di questa funzione è riportato nel programma
+semplice esempio per l'uso di questa funzione è riportato nel programma
\texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
-Quando si attiva la contabilità, il file che si indica deve esistere; esso
-verrà aperto in sola scrittura;\footnote{si applicano al pathname indicato da
+Quando si attiva la contabilità, il file che si indica deve esistere; esso
+verrà aperto in sola scrittura;\footnote{si applicano al pathname indicato da
\param{filename} tutte le restrizioni viste in cap.~\ref{cha:file_intro}.}
le informazioni verranno registrate in \itindex{append~mode} \textit{append}
in coda al file tutte le volte che un processo termina. Le informazioni
\itindex{process~time} \textit{process time}, secondo le definizioni:
\begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
\item[\textit{calendar time}] \itindex{calendar~time} detto anche
- \textsl{tempo di calendario}. È il numero di secondi dalla mezzanotte del
+ \textsl{tempo di calendario}. È il numero di secondi dalla mezzanotte del
primo gennaio 1970, in tempo universale coordinato (o UTC), data che viene
usualmente indicata con 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the
Epoch}. Questo tempo viene anche chiamato anche GMT (Greenwich Mean Time)
- dato che l'UTC corrisponde all'ora locale di Greenwich. È il tempo su cui
+ dato che l'UTC corrisponde all'ora locale di Greenwich. È il tempo su cui
viene mantenuto l'orologio del kernel, e viene usato ad esempio per indicare
le date di modifica dei file o quelle di avvio dei processi. Per memorizzare
- questo tempo è stato riservato il tipo primitivo \type{time\_t}.
+ questo tempo è stato riservato il tipo primitivo \type{time\_t}.
\item[\textit{process time}] \itindex{process~time} detto talvolta
\textsl{tempo di processore}. Viene misurato in \itindex{clock~tick}
\textit{clock tick}. Un tempo questo corrispondeva al numero di interruzioni
sia pari al valore della costante \const{CLOCKS\_PER\_SEC}, che deve essere
definita come 1000000, qualunque sia la risoluzione reale dell'orologio di
sistema e la frequenza delle interruzioni del timer.\footnote{quest'ultima,
- come accennato in sez.~\ref{sec:proc_hierarchy}, è invece data dalla
- costante \const{HZ}.} Il dato primitivo usato per questo tempo è
+ come accennato in sez.~\ref{sec:proc_hierarchy}, è invece data dalla
+ costante \const{HZ}.} Il dato primitivo usato per questo tempo è
\type{clock\_t}, che ha quindi una risoluzione del microsecondo. Il numero
- di \itindex{clock~tick} \textit{tick} al secondo può essere ricavato anche
+ di \itindex{clock~tick} \textit{tick} al secondo può essere ricavato anche
attraverso \func{sysconf} (vedi sez.~\ref{sec:sys_sysconf}). Il vecchio
- simbolo \const{CLK\_TCK} definito in \file{time.h} è ormai considerato
+ simbolo \const{CLK\_TCK} definito in \file{time.h} è ormai considerato
obsoleto.
\end{basedescript}
Di solito questo tempo viene convertito automaticamente dal valore in UTC al
tempo locale, utilizzando le opportune informazioni di localizzazione
(specificate in \conffile{/etc/timezone}). E da tenere presente che questo
-tempo è mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
+tempo è mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
dall'orologio hardware del calcolatore.
Anche il \itindex{process~time} \textit{process time} di solito si esprime in
secondi, ma fornisce una precisione ovviamente superiore al \textit{calendar
- time} (che è mantenuto dal sistema con una granularità di un secondo) e
+ time} (che è mantenuto dal sistema con una granularità di un secondo) e
viene usato per tenere conto dei tempi di esecuzione dei processi. Per ciascun
processo il kernel calcola tre tempi diversi:
\begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
quanti altri processi stavano girando nello stesso periodo.
\item[\textit{user time}] il tempo effettivo che il processore ha impiegato
- nell'esecuzione delle istruzioni del processo in user space. È quello
+ nell'esecuzione delle istruzioni del processo in user space. È quello
riportato nella risorsa \var{ru\_utime} di \struct{rusage} vista in
sez.~\ref{sec:sys_resource_use}.
\item[\textit{system time}] il tempo effettivo che il processore ha impiegato
- per eseguire codice delle system call nel kernel per conto del processo. È
+ per eseguire codice delle system call nel kernel per conto del processo. È
quello riportato nella risorsa \var{ru\_stime} di \struct{rusage} vista in
sez.~\ref{sec:sys_resource_use}.
\end{basedescript}
In genere la somma di \textit{user time} e \textit{system time} indica il
tempo di processore totale che il sistema ha effettivamente utilizzato per
eseguire un certo processo, questo viene chiamato anche \textit{CPU time} o
-\textsl{tempo di CPU}. Si può ottenere un riassunto dei valori di questi tempi
+\textsl{tempo di CPU}. Si può ottenere un riassunto dei valori di questi tempi
quando si esegue un qualsiasi programma lanciando quest'ultimo come argomento
del comando \cmd{time}.
Di norma tutte le operazioni del sistema fanno sempre riferimento al
\itindex{calendar~time} \textit{calendar time}, l'uso del \textit{process
- time} è riservato a quei casi in cui serve conoscere i tempi di esecuzione
+ time} è riservato a quei casi in cui serve conoscere i tempi di esecuzione
di un processo (ad esempio per valutarne l'efficienza). In tal caso infatti
-fare ricorso al \textit{calendar time} è inutile in quanto il tempo può essere
+fare ricorso al \textit{calendar time} è inutile in quanto il tempo può essere
trascorso mentre un altro processo era in esecuzione o in attesa del risultato
di una operazione di I/O.
-La funzione più semplice per leggere il \textit{process time} di un processo è
+La funzione più semplice per leggere il \textit{process time} di un processo è
\funcd{clock}, che da una valutazione approssimativa del tempo di CPU
-utilizzato dallo stesso; il suo prototipo è:
+utilizzato dallo stesso; il suo prototipo è:
\begin{prototype}{time.h}{clock\_t clock(void)}
Legge il valore corrente del tempo di CPU.
1000000 indipendentemente dalla risoluzione del timer di sistema.} In genere
\type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
-riprenderà lo stesso valore iniziale.
+riprenderà lo stesso valore iniziale.
-Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di CPU è la somma di
+Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di CPU è la somma di
altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
-possono essere letti attraverso la funzione \funcd{times}, il cui prototipo è:
+possono essere letti attraverso la funzione \funcd{times}, il cui prototipo è:
\begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
Legge in \param{buf} il valore corrente dei tempi di processore.
\end{prototype}
La funzione restituisce i valori di \textit{process time} del processo
-corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
+corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
-\textit{system time} del processo, così come definiti in
+\textit{system time} del processo, così come definiti in
sez.~\ref{sec:sys_unix_time}.
\begin{figure}[!htb]
Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
time} ed del \textit{system time} di tutti i processi figli che sono
-terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
-\var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
+terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
+\var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.
Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
-viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
+viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
ritornata. Per questo motivo se un processo figlio termina prima di ricevere
lo stato di terminazione di tutti i suoi figli, questi processi
``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi.
\itindbeg{calendar~time}
-Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
+Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
mantenuto dal kernel in una variabile di tipo \type{time\_t},\footnote{in
- realtà il kernel usa una rappresentazione interna di che fornisce una
+ realtà il kernel usa una rappresentazione interna di che fornisce una
precisione molto maggiore, e consente per questo anche di usare
rappresentazioni diverse del \textit{calendar time}.} che usualmente
-corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
+corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
che di norma corrisponde a 32 bit). Il valore corrente del \textit{calendar
- time}, che indicheremo come \textsl{tempo di sistema}, può essere ottenuto
+ time}, che indicheremo come \textsl{tempo di sistema}, può essere ottenuto
con la funzione \funcd{time} che lo restituisce nel suddetto formato; il suo
-prototipo è:
+prototipo è:
\begin{prototype}{time.h}{time\_t time(time\_t *t)}
Legge il valore corrente del \textit{calendar time}.
\bodydesc{La funzione ritorna il valore del \textit{calendar time} in caso
- di successo e -1 in caso di errore, che può essere solo \errval{EFAULT}.}
+ di successo e -1 in caso di errore, che può essere solo \errval{EFAULT}.}
\end{prototype}
\noindent dove \param{t}, se non nullo, deve essere l'indirizzo di una
variabile su cui duplicare il valore di ritorno.
-Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
-l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
-sia necessario; il suo prototipo è:
+Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
+l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
+sia necessario; il suo prototipo è:
\begin{prototype}{time.h}{int stime(time\_t *t)}
Imposta a \param{t} il valore corrente del \textit{calendar time}.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
- che può essere \errval{EFAULT} o \errval{EPERM}.}
+ che può essere \errval{EFAULT} o \errval{EPERM}.}
\end{prototype}
\noindent dato che modificare l'ora ha un impatto su tutto il sistema
-il cambiamento dell'orologio è una operazione privilegiata e questa funzione
-può essere usata solo da un processo con i privilegi di amministratore,
-altrimenti la chiamata fallirà con un errore di \errcode{EPERM}.
+il cambiamento dell'orologio è una operazione privilegiata e questa funzione
+può essere usata solo da un processo con i privilegi di amministratore,
+altrimenti la chiamata fallirà con un errore di \errcode{EPERM}.
Data la scarsa precisione nell'uso di \type{time\_t} (che ha una risoluzione
massima di un secondo) quando si devono effettuare operazioni sui tempi di
-norma l'uso delle funzioni precedenti è sconsigliato, ed esse sono di solito
+norma l'uso delle funzioni precedenti è sconsigliato, ed esse sono di solito
sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le due
- funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
+ funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
\func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
in BSD4.3 sono indicate come sostitute delle precedenti.} i cui prototipi
sono:
Imposta il tempo di sistema.
\bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
- caso di errore, nel qual caso \var{errno} può assumere i valori
+ caso di errore, nel qual caso \var{errno} può assumere i valori
\errval{EINVAL} \errval{EFAULT} e per \func{settimeofday} anche
\errval{EPERM}.}
\end{functions}
Si noti come queste funzioni utilizzino per indicare il tempo una struttura di
-tipo \struct{timeval}, la cui definizione si è già vista in
+tipo \struct{timeval}, la cui definizione si è già vista in
fig.~\ref{fig:sys_timeval_struct}, questa infatti permette una espressione
alternativa dei valori del \textit{calendar time}, con una precisione,
-rispetto a \type{time\_t}, fino al microsecondo.\footnote{la precisione è solo
+rispetto a \type{time\_t}, fino al microsecondo.\footnote{la precisione è solo
teorica, la precisione reale della misura del tempo dell'orologio di sistema
non dipende dall'uso di queste strutture.}
Come nel caso di \func{stime} anche \func{settimeofday} (la cosa continua a
valere per qualunque funzione che vada a modificare l'orologio di sistema,
-quindi anche per quelle che tratteremo in seguito) può essere utilizzata solo
-da un processo coi privilegi di amministratore.\footnote{più precisamente la
+quindi anche per quelle che tratteremo in seguito) può essere utilizzata solo
+da un processo coi privilegi di amministratore.\footnote{più precisamente la
capabitity \const{CAP\_SYS\_TIME}.}
-Il secondo argomento di entrambe le funzioni è una struttura
+Il secondo argomento di entrambe le funzioni è una struttura
\struct{timezone}, che storicamente veniva utilizzata per specificare appunto
-la \textit{time zone}, cioè l'insieme del fuso orario e delle convenzioni per
+la \textit{time zone}, cioè l'insieme del fuso orario e delle convenzioni per
l'ora legale che permettevano il passaggio dal tempo universale all'ora
-locale. Questo argomento oggi è obsoleto ed in Linux non è mai stato
-utilizzato; esso non è supportato né dalle vecchie \textsl{libc5}, né dalle
+locale. Questo argomento oggi è obsoleto ed in Linux non è mai stato
+utilizzato; esso non è supportato né dalle vecchie \textsl{libc5}, né dalle
\textsl{glibc}: pertanto quando si chiama questa funzione deve essere sempre
impostato a \val{NULL}.
-Modificare l'orologio di sistema con queste funzioni è comunque problematico,
-in quanto esse effettuano un cambiamento immediato. Questo può creare dei
+Modificare l'orologio di sistema con queste funzioni è comunque problematico,
+in quanto esse effettuano un cambiamento immediato. Questo può creare dei
buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
conseguenze indesiderate. Ad esempio se si porta avanti l'orologio si possono
-perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
+perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
saltato. Oppure se si porta indietro l'orologio si possono eseguire due volte
delle operazioni previste nell'intervallo di tempo che viene ripetuto.
-Per questo motivo la modalità più corretta per impostare l'ora è quella di
-usare la funzione \funcd{adjtime}, il cui prototipo è:
+Per questo motivo la modalità più corretta per impostare l'ora è quella di
+usare la funzione \funcd{adjtime}, il cui prototipo è:
\begin{prototype}{sys/time.h}
{int adjtime(const struct timeval *delta, struct timeval *olddelta)}
Aggiusta del valore \param{delta} l'orologio di sistema.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} assumerà il valore \errcode{EPERM}.}
+ errore, nel qual caso \var{errno} assumerà il valore \errcode{EPERM}.}
\end{prototype}
Questa funzione permette di avere un aggiustamento graduale del tempo di
sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
-di \param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
-positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
-il tempo richiesto, altrimenti sarà rallentato. Il secondo argomento viene
+di \param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
+positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
+il tempo richiesto, altrimenti sarà rallentato. Il secondo argomento viene
usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
effettuato.
\label{fig:sys_timex_struct}
\end{figure}
-Linux poi prevede un'altra funzione, che consente un aggiustamento molto più
+Linux poi prevede un'altra funzione, che consente un aggiustamento molto più
dettagliato del tempo, permettendo ad esempio anche di modificare anche la
-velocità dell'orologio di sistema. La funzione è \funcd{adjtimex} ed il suo
-prototipo è:
+velocità dell'orologio di sistema. La funzione è \funcd{adjtimex} ed il suo
+prototipo è:
\begin{prototype}{sys/timex.h}
{int adjtimex(struct timex *buf)}
\bodydesc{La funzione restituisce lo stato dell'orologio (un valore $>0$) in
caso di successo e -1 in caso di errore, nel qual caso \var{errno}
- assumerà i valori \errval{EFAULT}, \errval{EINVAL} ed \errval{EPERM}.}
+ assumerà i valori \errval{EFAULT}, \errval{EINVAL} ed \errval{EPERM}.}
\end{prototype}
La funzione richiede una struttura di tipo \struct{timex}, la cui definizione,
-così come effettuata in \file{sys/timex.h}, è riportata in
+così come effettuata in \file{sys/timex.h}, è riportata in
fig.~\ref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore del
campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
specificato in un opportuno campo di \struct{timex}, deve essere impostato. Un
tab.~\ref{tab:sys_timex_mode}.
La funzione utilizza il meccanismo di David L. Mills, descritto
-nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
-protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
-portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
+nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
+protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
+portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
\func{ntp\_adjtime}. La trattazione completa di questa funzione necessita di
una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
-per il campo \var{mode}, un elenco più dettagliato del significato dei vari
-campi della struttura \struct{timex} può essere ritrovato in \cite{glibc}.
+per il campo \var{mode}, un elenco più dettagliato del significato dei vari
+campi della struttura \struct{timex} può essere ritrovato in \cite{glibc}.
\begin{table}[!htb]
\footnotesize
\label{tab:sys_timex_mode}
\end{table}
-Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
+Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
sintassi specificata per la forma equivalente di questa funzione definita come
\func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
\code{ADJ}.
\textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \const{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
+ \const{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
\const{TIME\_INS} & 1 & Insert leap second.\\
\const{TIME\_DEL} & 2 & Delete leap second.\\
\const{TIME\_OOP} & 3 & Leap second in progress.\\
\const{TIME\_WAIT} & 4 & Leap second has occurred.\\
- \const{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
+ \const{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
\hline
\end{tabular}
\caption{Possibili valori di ritorno di \func{adjtimex}.}
\end{table}
La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
-sistema; questo può assumere i valori riportati in
+sistema; questo può assumere i valori riportati in
tab.~\ref{tab:sys_adjtimex_return}. Un valore di -1 viene usato per riportare
-un errore; al solito se si cercherà di modificare l'orologio di sistema
+un errore; al solito se si cercherà di modificare l'orologio di sistema
(specificando un \var{mode} diverso da zero) senza avere i privilegi di
-amministratore si otterrà un errore di \errcode{EPERM}.
+amministratore si otterrà un errore di \errcode{EPERM}.
\label{sec:sys_date}
Le funzioni viste al paragrafo precedente sono molto utili per trattare le
-operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
+operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
illustrate, se han senso per specificare un intervallo, non sono molto
-intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
+intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
time}, che permette appunto di \textsl{suddividere} il \textit{calendar
time} usuale in ore, minuti, secondi, ecc.
Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
-definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
+definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
struttura che si utilizza quando si deve specificare un tempo a partire dai
dati naturali (ora e data), dato che essa consente anche di trattare la
-gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
+gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
\var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste da BSD e dalle
- \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
+ \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
fig.~\ref{fig:sys_tm_struct}.}
Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
"Wed Jun 30 21:49:08 1993\n"
\end{verbatim}
e impostano anche la variabile \var{tzname} con l'informazione della
-\textit{time zone} corrente; \func{ctime} è banalmente definita in termini di
+\textit{time zone} corrente; \func{ctime} è banalmente definita in termini di
\func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
statica rende le funzioni non \index{funzioni!rientranti} rientranti POSIX.1c
e SUSv2 prevedono due sostitute \index{funzioni!rientranti} rientranti, il cui
-nome è al solito ottenuto aggiungendo un \code{\_r}, che prendono un secondo
+nome è al solito ottenuto aggiungendo un \code{\_r}, che prendono un secondo
argomento \code{char *buf}, in cui l'utente deve specificare il buffer su cui
la stringa deve essere copiata (deve essere di almeno 26 caratteri).
Le altre tre funzioni, \func{gmtime}, \func{localtime} e \func{mktime} servono
per convertire il tempo dal formato \type{time\_t} a quello di \struct{tm} e
viceversa; \func{gmtime} effettua la conversione usando il tempo coordinato
-universale (UTC), cioè l'ora di Greenwich; mentre \func{localtime} usa l'ora
+universale (UTC), cioè l'ora di Greenwich; mentre \func{localtime} usa l'ora
locale; \func{mktime} esegue la conversione inversa.
Anche in questo caso le prime due funzioni restituiscono l'indirizzo di una
struttura allocata staticamente, per questo sono state definite anche altre
due versioni \index{funzioni!rientranti} rientranti (con la solita estensione
\code{\_r}), che prevedono un secondo argomento \code{struct tm *result},
-fornito dal chiamante, che deve preallocare la struttura su cui sarà
+fornito dal chiamante, che deve preallocare la struttura su cui sarà
restituita la conversione.
Come mostrato in fig.~\ref{fig:sys_tm_struct} il \textit{broken-down time}
variabili globali mostrate in fig.~\ref{fig:sys_tzname}, cui si accede quando
si include \file{time.h}. Queste variabili vengono impostate quando si chiama
una delle precedenti funzioni di conversione, oppure invocando direttamente la
-funzione \funcd{tzset}, il cui prototipo è:
+funzione \funcd{tzset}, il cui prototipo è:
\begin{prototype}{sys/timex.h}
{void tzset(void)}
Imposta le variabili globali della \textit{time zone}.
- \bodydesc{La funzione non ritorna niente e non dà errori.}
+ \bodydesc{La funzione non ritorna niente e non dà errori.}
\end{prototype}
La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire dal
-valore della variabile di ambiente \const{TZ}, se quest'ultima non è definita
-verrà usato il file \conffile{/etc/localtime}.
+valore della variabile di ambiente \const{TZ}, se quest'ultima non è definita
+verrà usato il file \conffile{/etc/localtime}.
\begin{figure}[!htb]
\footnotesize
\end{figure}
La variabile \var{tzname} contiene due stringhe, che indicano i due nomi
-standard della \textit{time zone} corrente. La prima è il nome per l'ora
+standard della \textit{time zone} corrente. La prima è il nome per l'ora
solare, la seconda per l'ora legale.\footnote{anche se sono indicati come
- \code{char *} non è il caso di modificare queste stringhe.} La variabile
+ \code{char *} non è il caso di modificare queste stringhe.} La variabile
\var{timezone} indica la differenza di fuso orario in secondi, mentre
-\var{daylight} indica se è attiva o meno l'ora legale.
+\var{daylight} indica se è attiva o meno l'ora legale.
-Benché la funzione \func{asctime} fornisca la modalità più immediata per
-stampare un tempo o una data, la flessibilità non fa parte delle sue
+Benché la funzione \func{asctime} fornisca la modalità più immediata per
+stampare un tempo o una data, la flessibilità non fa parte delle sue
caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
-giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
-il cui prototipo è:
+giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
+il cui prototipo è:
\begin{prototype}{time.h}
{size\_t strftime(char *s, size\_t max, const char *format,
const struct tm *tm)}
\end{prototype}
La funzione converte opportunamente il tempo \param{tm} in una stringa di
-testo da salvare in \param{s}, purché essa sia di dimensione, indicata da
+testo da salvare in \param{s}, purché essa sia di dimensione, indicata da
\param{size}, sufficiente. I caratteri generati dalla funzione vengono
restituiti come valore di ritorno, ma non tengono conto del terminatore
finale, che invece viene considerato nel computo della dimensione; se
-quest'ultima è eccessiva viene restituito 0 e lo stato di \param{s} è
+quest'ultima è eccessiva viene restituito 0 e lo stato di \param{s} è
indefinito.
\begin{table}[htb]
domenica).\\
\var{\%w}&\texttt{3} & Giorno della settimana. \\
\var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
- lunedì).\\
+ lunedì).\\
\var{\%x}&\texttt{04/24/02} & La data.\\
\var{\%X}&\texttt{18:40:50} & L'ora.\\
\var{\%y}&\texttt{02} & Anno nel secolo.\\
\label{tab:sys_strftime_format}
\end{table}
-Il risultato della funzione è controllato dalla stringa di formato
+Il risultato della funzione è controllato dalla stringa di formato
\param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
viene utilizzato come modificatore; alcuni\footnote{per la precisione quelli
definiti dallo standard ANSI C, che sono anche quelli riportati da POSIX.1;
le \acr{glibc} provvedono tutte le estensioni introdotte da POSIX.2 per il
comando \cmd{date}, i valori introdotti da SVID3 e ulteriori estensioni GNU;
- l'elenco completo dei possibili valori è riportato nella pagina di manuale
- della funzione.} dei possibili valori che esso può assumere sono riportati
+ l'elenco completo dei possibili valori è riportato nella pagina di manuale
+ della funzione.} dei possibili valori che esso può assumere sono riportati
in tab.~\ref{tab:sys_strftime_format}. La funzione tiene conto anche della
presenza di una localizzazione per stampare in maniera adeguata i vari nomi.
unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
semplicemente usando un opportuno valore di ritorno della funzione invocata.
-Inoltre il sistema di classificazione degli errori è basato sull'architettura
+Inoltre il sistema di classificazione degli errori è basato sull'architettura
a processi, e presenta una serie di problemi nel caso lo si debba usare con i
\itindex{thread} \textit{thread}.
\label{sec:sys_errno}
Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
-riportare condizioni di errore, ed è una norma fondamentale di buona
+riportare condizioni di errore, ed è una norma fondamentale di buona
programmazione controllare \textbf{sempre} che le funzioni chiamate si siano
concluse correttamente.
In genere le funzioni di libreria usano un valore speciale per indicare che
-c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
+c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
costante \val{EOF} (a seconda della funzione); ma questo valore segnala solo
-che c'è stato un errore, non il tipo di errore.
+che c'è stato un errore, non il tipo di errore.
Per riportare il tipo di errore il sistema usa la variabile globale
-\var{errno},\footnote{l'uso di una variabile globale può comportare alcuni
+\var{errno},\footnote{l'uso di una variabile globale può comportare alcuni
problemi (ad esempio nel caso dei \itindex{thread} \textit{thread}) ma lo
standard ISO C consente anche di definire \var{errno} come un
- \textit{modifiable lvalue}, quindi si può anche usare una macro, e questo è
+ \textit{modifiable lvalue}, quindi si può anche usare una macro, e questo è
infatti il modo usato da Linux per renderla locale ai singoli
\itindex{thread} \textit{thread}.} definita nell'header \file{errno.h}; la
-variabile è in genere definita come \direct{volatile} dato che può essere
+variabile è in genere definita come \direct{volatile} dato che può essere
cambiata in modo asincrono da un segnale (si veda sez.~\ref{sec:sig_sigchld}
per un esempio, ricordando quanto trattato in sez.~\ref{sec:proc_race_cond}),
ma dato che un gestore di segnale scritto bene salva e ripristina il valore
-della variabile, di questo non è necessario preoccuparsi nella programmazione
+della variabile, di questo non è necessario preoccuparsi nella programmazione
normale.
-I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
+I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
costanti numeriche che identificano i vari errori; essi iniziano tutti per
\val{E} e si possono considerare come nomi riservati. In seguito faremo
Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
programma, gran parte delle funzioni di libreria impostano \var{errno} ad un
-valore diverso da zero in caso di errore. Il valore è invece indefinito in
-caso di successo, perché anche se una funzione ha successo, può chiamarne
-altre al suo interno che falliscono, modificando così \var{errno}.
-
-Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
-essere il risultato di un errore precedente) e non lo si può usare per
-determinare quando o se una chiamata a funzione è fallita. La procedura da
-seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
+valore diverso da zero in caso di errore. Il valore è invece indefinito in
+caso di successo, perché anche se una funzione ha successo, può chiamarne
+altre al suo interno che falliscono, modificando così \var{errno}.
+
+Pertanto un valore non nullo di \var{errno} non è sintomo di errore (potrebbe
+essere il risultato di un errore precedente) e non lo si può usare per
+determinare quando o se una chiamata a funzione è fallita. La procedura da
+seguire è sempre quella di controllare \var{errno} immediatamente dopo aver
verificato il fallimento della funzione attraverso il suo codice di ritorno.
\subsection{Le funzioni \func{strerror} e \func{perror}}
\label{sec:sys_strerror}
-Benché gli errori siano identificati univocamente dal valore numerico di
+Benché gli errori siano identificati univocamente dal valore numerico di
\var{errno} le librerie provvedono alcune funzioni e variabili utili per
riportare in opportuni messaggi le condizioni di errore verificatesi. La
-prima funzione che si può usare per ricavare i messaggi di errore è
-\funcd{strerror}, il cui prototipo è:
+prima funzione che si può usare per ricavare i messaggi di errore è
+\funcd{strerror}, il cui prototipo è:
\begin{prototype}{string.h}{char *strerror(int errnum)}
Restituisce una stringa con il messaggio di errore relativo ad
\param{errnum}.
La funzione ritorna il puntatore alla stringa contenente il messaggio di
-errore corrispondente al valore di \param{errnum}, se questo non è un valore
-valido verrà comunque restituita una stringa valida contenente un messaggio
-che dice che l'errore è sconosciuto, e \var{errno} verrà modificata assumendo
+errore corrispondente al valore di \param{errnum}, se questo non è un valore
+valido verrà comunque restituita una stringa valida contenente un messaggio
+che dice che l'errore è sconosciuto, e \var{errno} verrà modificata assumendo
il valore \errval{EINVAL}.
In generale \func{strerror} viene usata passando \var{errno} come argomento,
-ed il valore di quest'ultima non verrà modificato. La funzione inoltre tiene
+ed il valore di quest'ultima non verrà modificato. La funzione inoltre tiene
conto del valore della variabile di ambiente \val{LC\_MESSAGES} per usare le
appropriate traduzioni dei messaggi d'errore nella localizzazione presente.
La funzione utilizza una stringa statica che non deve essere modificata dal
-programma; essa è utilizzabile solo fino ad una chiamata successiva a
+programma; essa è utilizzabile solo fino ad una chiamata successiva a
\func{strerror} o \func{perror}, nessun'altra funzione di libreria tocca
questa stringa. In ogni caso l'uso di una stringa statica rende la funzione
non \index{funzioni!rientranti} rientrante, per cui nel caso si usino i
\itindex{thread} \textit{thread} le librerie forniscono\footnote{questa
- funzione è la versione prevista dalle \acr{glibc}, ed effettivamente
+ funzione è la versione prevista dalle \acr{glibc}, ed effettivamente
definita in \file{string.h}, ne esiste una analoga nello standard SUSv3
(quella riportata dalla pagina di manuale), che restituisce \code{int} al
posto di \code{char *}, e che tronca la stringa restituita a
\param{size}.} una apposita versione \index{funzioni!rientranti} rientrante
-\func{strerror\_r}, il cui prototipo è:
+\func{strerror\_r}, il cui prototipo è:
\begin{prototype}{string.h}
{char * strerror\_r(int errnum, char *buf, size\_t size)}
\bodydesc{La funzione restituisce l'indirizzo del messaggio in caso di
successo e \val{NULL} in caso di errore; nel qual caso \var{errno}
- assumerà i valori:
+ assumerà i valori:
\begin{errlist}
- \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
+ \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
valido.
- \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
+ \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
contenere la stringa di errore.
\end{errlist}}
\end{prototype}
\noindent
-La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
+La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
nel buffer \param{buf} che il singolo \itindex{thread} \textit{thread} deve
allocare autonomamente per evitare i problemi connessi alla condivisione del
-buffer statico. Il messaggio è copiato fino alla dimensione massima del
+buffer statico. Il messaggio è copiato fino alla dimensione massima del
buffer, specificata dall'argomento
\param{size}, che deve comprendere pure il carattere di terminazione;
altrimenti la stringa viene troncata.
Una seconda funzione usata per riportare i codici di errore in maniera
-automatizzata sullo standard error (vedi sez.~\ref{sec:file_std_descr}) è
-\funcd{perror}, il cui prototipo è:
+automatizzata sullo standard error (vedi sez.~\ref{sec:file_std_descr}) è
+\funcd{perror}, il cui prototipo è:
\begin{prototype}{stdio.h}{void perror(const char *message)}
Stampa il messaggio di errore relativo al valore corrente di \var{errno}
sullo standard error; preceduto dalla stringa \param{message}.
in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
riferiscono all'ultimo errore avvenuto. La stringa specificata con
\param{message} viene stampato prima del messaggio d'errore, seguita dai due
-punti e da uno spazio, il messaggio è terminato con un a capo.
+punti e da uno spazio, il messaggio è terminato con un a capo.
-Il messaggio può essere riportato anche usando le due variabili globali:
+Il messaggio può essere riportato anche usando le due variabili globali:
\includecodesnip{listati/errlist.c}
dichiarate in \file{errno.h}. La prima contiene i puntatori alle stringhe di
-errore indicizzati da \var{errno}; la seconda esprime il valore più alto per
-un codice di errore, l'utilizzo di questa stringa è sostanzialmente
+errore indicizzati da \var{errno}; la seconda esprime il valore più alto per
+un codice di errore, l'utilizzo di questa stringa è sostanzialmente
equivalente a quello di \func{strerror}.
\begin{figure}[!htb]
\label{fig:sys_err_mess}
\end{figure}
-In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
-programma \cmd{errcode}, che può essere usato per stampare i messaggi di
+In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
+programma \cmd{errcode}, che può essere usato per stampare i messaggi di
errore e le costanti usate per identificare i singoli errori; il sorgente
-completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
+completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la
gestione delle opzioni e tutte le definizioni necessarie ad associare il
-valore numerico alla costante simbolica. In particolare si è riportata la
+valore numerico alla costante simbolica. In particolare si è riportata la
sezione che converte la stringa passata come argomento in un intero
(\texttt{\small 1--2}), controllando con i valori di ritorno di \func{strtol}
che la conversione sia avvenuta correttamente (\texttt{\small 4--10}), e poi
\label{sec:sys_err_GNU}
Le precedenti funzioni sono quelle definite ed usate nei vari standard; le
-\acr{glibc} hanno però introdotto una serie di estensioni ``GNU'' che
-forniscono alcune funzionalità aggiuntive per una gestione degli errori
-semplificata e più efficiente.
+\acr{glibc} hanno però introdotto una serie di estensioni ``GNU'' che
+forniscono alcune funzionalità aggiuntive per una gestione degli errori
+semplificata e più efficiente.
La prima estensione consiste in due variabili, \code{char *
program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
aggiungere il nome del programma (cosa comune quando si ha un programma che
non viene lanciato da linea di comando e salva gli errori in un file di log)
al messaggio d'errore. La prima contiene il nome usato per lanciare il
-programma (ed è equivalente ad \code{argv[0]}); la seconda mantiene solo il
+programma (ed è equivalente ad \code{argv[0]}); la seconda mantiene solo il
nome del programma (senza eventuali directory in testa).
-Uno dei problemi che si hanno con l'uso di \func{perror} è che non c'è
-flessibilità su quello che si può aggiungere al messaggio di errore, che può
+Uno dei problemi che si hanno con l'uso di \func{perror} è che non c'è
+flessibilità su quello che si può aggiungere al messaggio di errore, che può
essere solo una stringa. In molte occasioni invece serve poter scrivere dei
messaggi con maggiore informazione; ad esempio negli standard di
programmazione GNU si richiede che ogni messaggio di errore sia preceduto dal
-nome del programma, ed in generale si può voler stampare il contenuto di
+nome del programma, ed in generale si può voler stampare il contenuto di
qualche variabile; per questo le \acr{glibc} definiscono la funzione
-\funcd{error}, il cui prototipo è:
+\funcd{error}, il cui prototipo è:
\begin{prototype}{stdio.h}
{void error(int status, int errnum, const char *format, ...)}
nome del programma, come indicato dalla variabile globale \var{program\_name},
seguito da due punti ed uno spazio, poi dalla stringa generata da
\param{format} e dagli argomenti seguenti, seguita da due punti ed uno spazio
-infine il messaggio di errore relativo ad \param{errnum}, il tutto è terminato
+infine il messaggio di errore relativo ad \param{errnum}, il tutto è terminato
da un a capo.
-Il comportamento della funzione può essere ulteriormente controllato se si
+Il comportamento della funzione può essere ulteriormente controllato se si
definisce una variabile \var{error\_print\_progname} come puntatore ad una
funzione \ctyp{void} che restituisce \ctyp{void} che si incarichi di stampare
il nome del programma.
-L'argomento \param{status} può essere usato per terminare direttamente il
+L'argomento \param{status} può essere usato per terminare direttamente il
programma in caso di errore, nel qual caso \func{error} dopo la stampa del
messaggio di errore chiama \func{exit} con questo stato di uscita. Se invece
-il valore è nullo \func{error} ritorna normalmente ma viene incrementata
+il valore è nullo \func{error} ritorna normalmente ma viene incrementata
un'altra variabile globale, \var{error\_message\_count}, che tiene conto di
quanti errori ci sono stati.
-Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
-prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
-l'errore è \funcd{error\_at\_line}; il suo prototipo è:
+Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
+prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
+l'errore è \funcd{error\_at\_line}; il suo prototipo è:
\begin{prototype}{stdio.h}
{void error\_at\_line(int status, int errnum, const char *fname,
unsigned int lineno, const char *format, ...)}
\bodydesc{La funzione non restituisce nulla e non riporta errori.}
\end{prototype}
-\noindent ed il suo comportamento è identico a quello di \func{error} se non
+\noindent ed il suo comportamento è identico a quello di \func{error} se non
per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
nome di file indicato da \param{fname} ed un numero di linea subito dopo la
stampa del nome del programma. Inoltre essa usa un'altra variabile globale,
projects / gapil.git / blobdiff