-\chapter{La gestione del sistema, delle risorse, e degli errori}
+%% system.tex
+%%
+%% Copyright (C) 2000-2004 Simone Piccardi. Permission is granted to
+%% copy, distribute and/or modify this document under the terms of the GNU Free
+%% Documentation License, Version 1.1 or any later version published by the
+%% Free Software Foundation; with the Invariant Sections being "Prefazione",
+%% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the
+%% license is included in the section entitled "GNU Free Documentation
+%% License".
+%%
+\chapter{La gestione del sistema, del tempo e degli errori}
\label{cha:system}
In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
-\section{La lettura delle 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ò
opzioni di configurazione.
La definizione di queste caratteristiche ed il tentativo di provvedere dei
-meccanismi generali che i programmi potessero usare per ricavarle è uno degli
+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.
-Proveremo comunque a dare una descrizione dei principali metodi previsti dai
-vari standard per ricavare sia le caratteristiche specifiche del sistema, che
+Daremo comunque una descrizione dei principali metodi previsti dai vari
+standard per ricavare sia le caratteristiche specifiche del sistema, che
quelle della gestione dei file.
\subsection{Limiti e parametri di sistema}
\label{sec:sys_limits}
-Quando si devono determinare le le caratteristiche generali del sistema ci si
+Quando si devono determinare le caratteristiche generali del sistema ci si
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 dei \textit{saved
- id}), altre invece possono dipendere dalle opzioni 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à:
+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
+kernel), o dalla configurazione del medesimo; per questo motivo in generale
+sono necessari due tipi diversi di funzionalità:
\begin{itemize*}
\item la possibilità di determinare limiti ed opzioni al momento della
compilazione.
fissi essi vengono definiti come macro di preprocessore nel file
\file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
tramite la funzione \func{sysconf} (che esamineremo in
-\secref{sec:sys_sysconf}).
+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 \tabref{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, \macro{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.
\footnotesize
\begin{tabular}[c]{|l|r|l|}
\hline
- \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{MB\_LEN\_MAX}& 16 & massima dimensione di un
+ \const{MB\_LEN\_MAX}& 16 & massima dimensione di un
carattere esteso\\
- \macro{CHAR\_BIT} & 8 & bit di \ctyp{char}\\
- \macro{UCHAR\_MAX}& 255 & massimo di \ctyp{unsigned char}\\
- \macro{SCHAR\_MIN}& -128 & minimo di \ctyp{signed char}\\
- \macro{SCHAR\_MAX}& 127 & massimo di \ctyp{signed char}\\
- \macro{CHAR\_MIN} &\footnotemark& minimo di \ctyp{char}\\
- \macro{CHAR\_MAX} &\footnotemark& massimo di \ctyp{char}\\
- \macro{SHRT\_MIN} & -32768 & minimo di \ctyp{short}\\
- \macro{SHRT\_MAX} & 32767 & massimo di \ctyp{short}\\
- \macro{USHRT\_MAX}& 65535 & massimo di \ctyp{unsigned short}\\
- \macro{INT\_MAX} & 2147483647 & minimo di \ctyp{int}\\
- \macro{INT\_MIN} &-2147483648 & minimo di \ctyp{int}\\
- \macro{UINT\_MAX} & 4294967295 & massimo di \ctyp{unsigned int}\\
- \macro{LONG\_MAX} & 2147483647 & massimo di \ctyp{long}\\
- \macro{LONG\_MIN} &-2147483648 & minimo di \ctyp{long}\\
- \macro{ULONG\_MAX}& 4294967295 & massimo di \ctyp{unsigned long}\\
+ \const{CHAR\_BIT} & 8 & bit di \ctyp{char}\\
+ \const{UCHAR\_MAX}& 255 & massimo di \ctyp{unsigned char}\\
+ \const{SCHAR\_MIN}& -128 & minimo di \ctyp{signed char}\\
+ \const{SCHAR\_MAX}& 127 & massimo di \ctyp{signed char}\\
+ \const{CHAR\_MIN} &\footnotemark& minimo di \ctyp{char}\\
+ \const{CHAR\_MAX} &\footnotemark& massimo di \ctyp{char}\\
+ \const{SHRT\_MIN} & -32768 & minimo di \ctyp{short}\\
+ \const{SHRT\_MAX} & 32767 & massimo di \ctyp{short}\\
+ \const{USHRT\_MAX}& 65535 & massimo di \ctyp{unsigned short}\\
+ \const{INT\_MAX} & 2147483647 & minimo di \ctyp{int}\\
+ \const{INT\_MIN} &-2147483648 & minimo di \ctyp{int}\\
+ \const{UINT\_MAX} & 4294967295 & massimo di \ctyp{unsigned int}\\
+ \const{LONG\_MAX} & 2147483647 & massimo di \ctyp{long}\\
+ \const{LONG\_MIN} &-2147483648 & minimo di \ctyp{long}\\
+ \const{ULONG\_MAX}& 4294967295 & massimo di \ctyp{unsigned long}\\
\hline
\end{tabular}
\caption{Costanti definite in \file{limits.h} in conformità allo standard
\label{tab:sys_ansic_macro}
\end{table}
-\footnotetext[1]{il valore può essere 0 o \macro{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 \macro{UCHAR\_MAX} o \macro{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
\ctyp{long long} introdotto con il nuovo standard, i relativi valori sono in
-\tabref{tab:sys_isoc90_macro}.
+tab.~\ref{tab:sys_isoc90_macro}.
\begin{table}[htb]
\centering
\footnotesize
\begin{tabular}[c]{|l|r|l|}
\hline
- \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{LLONG\_MAX}& 9223372036854775807& massimo di \ctyp{long long}\\
- \macro{LLONG\_MIN}&-9223372036854775808& minimo di \ctyp{long long}\\
- \macro{ULLONG\_MAX}&18446744073709551615&
+ \const{LLONG\_MAX}& 9223372036854775807& massimo di \ctyp{long long}\\
+ \const{LLONG\_MIN}&-9223372036854775808& minimo di \ctyp{long long}\\
+ \const{ULLONG\_MAX}&18446744073709551615&
massimo di \ctyp{unsigned long long}\\
\hline
\end{tabular}
dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
limiti relativi alle caratteristiche dei file che vedremo in
-\secref{sec:sys_file_limits}.
+sez.~\ref{sec:sys_file_limits}.
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 ``standardese''.}. Lo standard prevede che ci siano 13 macro che
descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
-riportate in \tabref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
-file, riportate in \tabref{tab:sys_file_macro}).
+riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
+file, riportate in tab.~\ref{tab:sys_file_macro}).
\begin{table}[htb]
\centering
\footnotesize
- \begin{tabular}[c]{|l|r|p{8cm}|}
+ \begin{tabular}[c]{|l|r|p{7cm}|}
\hline
- \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{ARG\_MAX} &131072& dimensione massima degli argomenti
+ \const{ARG\_MAX} &131072& dimensione massima degli argomenti
passati ad una funzione della famiglia
\func{exec}.\\
- \macro{CHILD\_MAX} & 999& numero massimo di processi contemporanei
+ \const{CHILD\_MAX} & 999& numero massimo di processi contemporanei
che un utente può eseguire.\\
- \macro{OPEN\_MAX} & 256& numero massimo di file che un processo
+ \const{OPEN\_MAX} & 256& numero massimo di file che un processo
può mantenere aperti in contemporanea.\\
- \macro{STREAM\_MAX}& 8& massimo numero di stream aperti per
+ \const{STREAM\_MAX}& 8& massimo numero di stream aperti per
processo in contemporanea.\\
- \macro{TZNAME\_MAX}& 6& dimensione massima del nome di una
- \texttt{timezone} (vedi ).\\
- \macro{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
- processo (vedi \secref{sec:proc_access_id}).\\
- \macro{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
+ \const{TZNAME\_MAX}& 6& dimensione massima del nome di una
+ \texttt{timezone} (vedi
+ sez.~\ref{sec:sys_time_base})).\\
+ \const{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
+ processo (vedi sez.~\ref{sec:proc_access_id}).\\
+ \const{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
\hline
\hline
\end{tabular}
lasciate indefinite, ed i loro valori dei limiti devono essere accessibili
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 \macro{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
implementazione possa dichiararsi conforme allo standard; detti valori sono
-riportati in \tabref{tab:sys_posix1_general}.
+riportati in tab.~\ref{tab:sys_posix1_general}.
\begin{table}[htb]
\centering
\footnotesize
- \begin{tabular}[c]{|l|r|p{8cm}|}
+ \begin{tabular}[c]{|l|r|p{7cm}|}
\hline
- \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{\_POSIX\_ARG\_MAX} & 4096& dimensione massima degli argomenti
+ \const{\_POSIX\_ARG\_MAX} & 4096& dimensione massima degli argomenti
passati ad una funzione della famiglia
\func{exec}.\\
- \macro{\_POSIX\_CHILD\_MAX} & 6& numero massimo di processi
+ \const{\_POSIX\_CHILD\_MAX} & 6& numero massimo di processi
contemporanei che un utente può
eseguire.\\
- \macro{\_POSIX\_OPEN\_MAX} & 16& numero massimo di file che un processo
+ \const{\_POSIX\_OPEN\_MAX} & 16& numero massimo di file che un processo
può mantenere aperti in
contemporanea.\\
- \macro{\_POSIX\_STREAM\_MAX} & 8& massimo numero di stream aperti per
+ \const{\_POSIX\_STREAM\_MAX} & 8& massimo numero di stream aperti per
processo in contemporanea.\\
- \macro{\_POSIX\_TZNAME\_MAX} & & dimensione massima del nome di una
- \texttt{timezone} (vedi ).\\
- \macro{\_POSIX\_NGROUPS\_MAX}& 0& numero di gruppi supplementari per
+ \const{\_POSIX\_TZNAME\_MAX} & & dimensione massima del nome di una
+ \texttt{timezone} (vedi
+ sez.~\ref{sec:sys_date}). \\
+ \const{\_POSIX\_NGROUPS\_MAX}& 0& numero di gruppi supplementari per
processo (vedi
- \secref{sec:proc_access_id}).\\
- \macro{\_POSIX\_SSIZE\_MAX} &32767& valore massimo del tipo
+ sez.~\ref{sec:proc_access_id}).\\
+ \const{\_POSIX\_SSIZE\_MAX} &32767& valore massimo del tipo
\type{ssize\_t}.\\
- \macro{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
- \macro{\_POSIX\_AIO\_MAX} & 1& \\
+ \const{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
+ \const{\_POSIX\_AIO\_MAX} & 1& \\
\hline
\hline
\end{tabular}
\hline
\macro{\_POSIX\_JOB\_CONTROL}& il sistema supporta il
\textit{job control} (vedi
- \secref{sec:sess_xxx}).\\
- \macro{\_POSIX\_SAVED\_IDS} & il sistema supporta i \textit{saved id}
- (vedi \secref{sec:proc_access_id}).
+ sez.~\ref{sec:sess_job_control}).\\
+ \macro{\_POSIX\_SAVED\_IDS} & il sistema supporta gli identificatori del
+ gruppo \textit{saved} (vedi
+ sez.~\ref{sec:proc_access_id})
per il controllo di accesso dei processi\\
- \macro{\_POSIX\_VERSION} & fornisce la versione dello standard POSIX.1
+ \const{\_POSIX\_VERSION} & fornisce la versione dello standard POSIX.1
supportata nel formato YYYYMML (ad esempio
199009L).\\
\hline
\end{table}
Oltre ai precedenti valori (e a quelli relativi ai file elencati in
-\tabref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
+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, è
incluso automaticamente all'interno di \file{limits.h}). Di questi vale la
pena menzionare alcune macro di uso comune, (riportate in
-\tabref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
+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
-\textit{job control} o dei \textit{saved id}).
+\textit{job control} o degli identificatori del gruppo \textit{saved}).
Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
alle applicazioni di sistema presenti (come quelli su alcuni parametri delle
espressioni regolari o del comando \cmd{bc}), non li tratteremo
esplicitamente, se ne trova una menzione completa nell'header file
-\file{bits/posix2\_lim.h}, e alcuni di loro sono descritti nella man page di
-\func{sysconf} e nel manuale delle \acr{glibc}.
+\file{bits/posix2\_lim.h}, e alcuni di loro sono descritti nella pagina di
+manuale di \func{sysconf} e nel manuale delle \acr{glibc}.
\subsection{La funzione \func{sysconf}}
\label{sec:sys_sysconf}
-Come accennato in \secref{sec:sys_limits} quando uno dei limiti o delle
+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, è
-necessario ottenerne il valore attraverso la funzione \func{sysconf}. Il
+necessario ottenerne il valore attraverso la funzione \funcd{sysconf}. Il
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 settata).}
+ è 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 \tabref{tab:sys_sysconf_par}; l'elenco completo è
+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}.
\textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
\hline
\hline
- \texttt{\_SC\_ARG\_MAX} &\macro{ARG\_MAX}&
+ \texttt{\_SC\_ARG\_MAX} &\const{ARG\_MAX}&
La dimensione massima degli argomenti passati ad una funzione
della famiglia \func{exec}.\\
- \texttt{\_SC\_CHILD\_MAX}&\macro{\_CHILD\_MAX}&
+ \texttt{\_SC\_CHILD\_MAX}&\const{\_CHILD\_MAX}&
Il numero massimo di processi contemporanei che un utente può
eseguire.\\
- \texttt{\_SC\_OPEN\_MAX}&\macro{\_OPEN\_MAX}&
+ \texttt{\_SC\_OPEN\_MAX}&\const{\_OPEN\_MAX}&
Il numero massimo di file che un processo può mantenere aperti in
contemporanea.\\
- \texttt{\_SC\_STREAM\_MAX}& \macro{STREAM\_MAX}&
+ \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
Il massimo numero di stream che un processo può mantenere aperti in
contemporanea. Questo limite previsto anche dallo standard ANSI C, che
specifica la macro {FOPEN\_MAX}.\\
- \texttt{\_SC\_TZNAME\_MAX}&\macro{TZNAME\_MAX}&
- La dimensione massima di un nome di una \texttt{timezone} (vedi ).\\
- \texttt{\_SC\_NGROUPS\_MAX}&\macro{NGROUP\_MAX}&
+ \texttt{\_SC\_TZNAME\_MAX}&\const{TZNAME\_MAX}&
+ La dimensione massima di un nome di una \texttt{timezone} (vedi
+ sez.~\ref{sec:sys_date}).\\
+ \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
Massimo numero di gruppi supplementari che può avere un processo (vedi
- \secref{sec:proc_access_id}).\\
- \texttt{\_SC\_SSIZE\_MAX}&\macro{SSIZE\_MAX}&
+ sez.~\ref{sec:proc_access_id}).\\
+ \texttt{\_SC\_SSIZE\_MAX}&\const{SSIZE\_MAX}&
valore massimo del tipo di dato \type{ssize\_t}.\\
- \texttt{\_SC\_CLK\_TCK}& \macro{CLK\_TCK} &
+ \texttt{\_SC\_CLK\_TCK}& \const{CLK\_TCK} &
Il numero di \textit{clock tick} al secondo, cioè l'unità di misura del
- \textit{process time} (vedi \secref{sec:sys_unix_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 control} (vedi
- \secref{sec:sess_xxx}) in stile POSIX.\\
+ sez.~\ref{sec:sess_job_control}) in stile POSIX.\\
\texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
Indica se il sistema supporta i \textit{saved id} (vedi
- \secref{sec:proc_access_id}).\\
- \texttt{\_SC\_VERSION}& \macro{\_POSIX\_VERSION} &
+ sez.~\ref{sec:proc_access_id}).\\
+ \texttt{\_SC\_VERSION}& \const{\_POSIX\_VERSION} &
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, che indica il Settembre 1990.\\
In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
macro non è definita, quindi con un codice analogo al seguente:
-%\footnotesize
-\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
-get_child_max(void)
-{
-#ifdef CHILD_MAX
- return CHILD_MAX;
-#else
- int val = sysconf(_SC_CHILD_MAX);
- if (val < 0) {
- perror("fatal error");
- exit(-1);
- }
- return val;
-}
-\end{lstlisting}
-%\normalsize
+\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
da \func{sysconf}.
serie di limiti (come la lunghezza del nome del file o il numero massimo di
link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
in questo caso lo standard prevede alcune macro che ne specificano il valore,
-riportate in \tabref{tab:sys_file_macro}.
+riportate in tab.~\ref{tab:sys_file_macro}.
\begin{table}[htb]
\centering
\footnotesize
- \begin{tabular}[c]{|l|r|p{8cm}|}
+ \begin{tabular}[c]{|l|r|l|}
\hline
- \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
- \macro{PATH\_MAX}& 256 & lunghezza in byte di pathname.\\
- \macro{PIPE\_BUF}& 512 & byte scrivibili atomicamente in una pipe\\
- \macro{LINK\_MAX} &8 & numero massimo di link a un file\\
- \macro{MAX\_CANON}&255 & spazio disponibile nella coda di input
- canonica del terminale\\
- \macro{MAX\_INPUT}&255 & spazio disponibile nella coda di input
- del terminale\\
+ \const{LINK\_MAX} &8 & numero massimo di link a un file\\
+ \const{NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
+ \const{PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
+ \const{PIPE\_BUF}&4096 & byte scrivibili atomicamente in una pipe
+ (vedi sez.~\ref{sec:ipc_pipes}).\\
+ \const{MAX\_CANON}&255 & dimensione di una riga di terminale in modo
+ canonico (vedi sez.~\ref{sec:term_design}).\\
+ \const{MAX\_INPUT}&255 & spazio disponibile nella coda di input
+ del terminale (vedi
+ sez.~\ref{sec:term_design}).\\
\hline
\end{tabular}
- \caption{Macro per i limiti sulle caratteristiche dei file.}
+ \caption{Costanti per i limiti sulle caratteristiche dei file.}
\label{tab:sys_file_macro}
\end{table}
Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
minimi anche per queste caratteristiche, che ogni sistema che vuole essere
conforme deve rispettare; le relative macro sono riportate in
-\tabref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per le
-analoghe di \tabref{tab:sys_posix1_general}.
+tab.~\ref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per
+le analoghe di tab.~\ref{tab:sys_posix1_general}.
\begin{table}[htb]
\centering
\footnotesize
- \begin{tabular}[c]{|l|r|p{8cm}|}
+ \begin{tabular}[c]{|l|r|l|}
\hline
\textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
- \macro{\_POSIX\_LINK\_MAX} &8 & numero massimo di link a un file\\
- \macro{\_POSIX\_MAX\_CANON}&255 & spazio disponibile nella coda di input
- canonica del terminale\\
- \macro{\_POSIX\_MAX\_INPUT}&255 & spazio disponibile nella coda di input
- del terminale\\
- \macro{\_POSIX\_NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
- \macro{\_POSIX\_PATH\_MAX}& 256 & lunghezza in byte di pathname.\\
- \macro{\_POSIX\_PIPE\_BUF}& 512 & byte scrivibili atomicamente in una
- pipe\\
-% \macro{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
-% \macro{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
-% \macro{\_POSIX\_FD\_SETSIZE}& 16 & \\
-% \macro{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
+ \const{\_POSIX\_LINK\_MAX} &8 & numero massimo di link a un file.\\
+ \const{\_POSIX\_NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
+ \const{\_POSIX\_PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
+ \const{\_POSIX\_PIPE\_BUF}& 512 & byte scrivibili atomicamente in una
+ pipe.\\
+ \const{\_POSIX\_MAX\_CANON}&255 & dimensione di una riga di
+ terminale in modo canonico.\\
+ \const{\_POSIX\_MAX\_INPUT}&255 & spazio disponibile nella coda di input
+ del terminale.\\
+% \const{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
+% \const{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
+% \const{\_POSIX\_FD\_SETSIZE}& 16 & \\
+% \const{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
\hline
\end{tabular}
- \caption{Macro dei valori minimi delle caratteristiche dei file per la
+ \caption{Costanti dei valori minimi delle caratteristiche dei file per la
conformità allo standard POSIX.1.}
\label{tab:sys_posix1_file}
\end{table}
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 \func{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}.
\bodydesc{La funzione restituisce indietro il valore del parametro
- richiesto, o -1 in caso di errore (ed \var{errno} viene settata ad uno
+ richiesto, o -1 in caso di errore (ed \var{errno} viene impostata ad uno
degli errori possibili relativi all'accesso a \param{path}).}
\end{prototype}
E si noti come la funzione in questo caso richieda un parametro che specifichi
a quale file si fa riferimento, dato che il valore del limite cercato può
variare a seconda del filesystem. Una seconda versione della funzione,
-\func{fpathconf}, opera su un file descriptor invece che su un pathname. Il
+\funcd{fpathconf}, opera su un file descriptor invece che su un 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}.
\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 è \func{uname}; il
-suo prototipo è:
+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} viene settata a \macro{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 è
definita in \file{sys/utsname.h}, secondo quanto mostrato in
-\secref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
+sez.~\ref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
indicano rispettivamente:
\begin{itemize*}
\item il nome del sistema operativo;
\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 \figref{fig:sig_stack_t},
-solo definendo \macro{\_GNU\_SOURCE}.
+standard POSIX, essa è accessibile, come mostrato in
+fig.~\ref{fig:sys_utsname}, solo definendo \macro{\_GNU\_SOURCE}.
\begin{figure}[!htb]
\footnotesize \centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct utsname {
- char sysname[];
- char nodename[];
- char release[];
- char version[];
- char machine[];
-#ifdef _GNU_SOURCE
- char domainname[];
-#endif
-};
- \end{lstlisting}
+ \includestruct{listati/ustname.h}
\end{minipage}
\normalsize
- \caption{La struttura \var{utsname}.}
+ \caption{La struttura \structd{utsname}.}
\label{fig:sys_utsname}
\end{figure}
In generale si tenga presente che le dimensioni delle stringe di una
-\var{utsname} non è specificata, e che esse sono sempre terminate con
-\macro{NULL}; il manuale delle \acr{glibc} indica due diverse dimensioni,
-\macro{\_UTSNAME\_LENGTH} per i campi standard e
-\macro{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
-altri sistemi usano nomi diversi come \macro{SYS\_NMLN} o \macro{\_SYS\_NMLN}
-or \macro{UTSLEN} che possono avere valori diversi. Nel caso di Linux
-\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.
+\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
+ 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.}
\section{Opzioni e configurazione del sistema}
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 settaggio, pure un meccanismo di
-lettura.
-
-Affronteremo questi argomenti in questa sezione, insieme alle funzioni che si
-usano per il controllo di altre caratteristiche generali del sistema, come
-quelle per la gestione dei filesystem e di utenti e gruppi.
+questi occorre, oltre al meccanismo di impostazione, pure un meccanismo di
+lettura. Affronteremo questi argomenti in questa sezione, insieme alle
+funzioni che si usano per il controllo di altre caratteristiche generali del
+sistema, come quelle per la gestione dei filesystem e di utenti e gruppi.
\subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
\label{sec:sys_sysctl}
-La funzione che permette la lettura ed il settaggio dei parametri del sistema
-è \func{sysctl}; è una funzione derivata da BSD4.4, ma l'implementazione è
-specifica di Linux; il suo prototipo è:
+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 è:
\begin{functions}
\headdecl{unistd.h}
-\headdecl{linux/unistd.h}
-\headdecl{linux/sysctl.h}
\funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
*newval, size\_t newlen)}
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} viene settato ai valori:
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EPERM}] il processo non ha il permesso di accedere ad uno dei
- componenti nel cammino specificato per il parametro, o non ha il permesso
- di accesso al parametro nella modalità scelta.
- \item[\macro{ENOTDIR}] non esiste un parametro corrispondente al nome
+ \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.
+ \item[\errcode{ENOTDIR}] non esiste un parametro corrispondente al nome
\param{name}.
- \item[\macro{EFAULT}] si è specificato \param{oldlenp} zero quando
- \param{oldval} è non nullo.
- \item[\macro{EINVAL}] o si è specificato un valore non valido per il
- parametro che si vuole settare o lo spazio provvisto per il ritorno di un
+% \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[\macro{ENOMEM}] talvolta viene usato più correttamente questo errore
+ \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}.
}
\end{functions}
I parametri a cui la funzione permettere di accedere sono organizzati in
-maniera gerarchica all'interno un albero; 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 pathname (da cui l'uso alternativo del
-filesystem \file{/proc}, che vedremo dopo).
+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
+ \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 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
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
-complessa, per questo motivo il valori vengono passati come puntatori
+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
\param{oldlenp} (passato come puntatore per avere indietro la dimensione
-effettiva di quanto letto); il valore che si vuole settare 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
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*}
+\begin{itemize}
\item il nome di dominio
\item i parametri del meccanismo di \textit{paging}.
\item il filesystem montato come radice
\item la data di compilazione del kernel
\item i parametri dello stack TCP
\item il numero massimo di file aperti
-\end{itemize*}
+\end{itemize}
Come accennato in Linux si ha una modalità alternativa per accedere alle
stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc}
sono disponibili moltissime altre informazioni, fra cui ad esempio anche
-quelle fornite da \func{uname} (vedi \secref{sec:sys_config}) che sono
+quelle fornite da \func{uname} (vedi sez.~\ref{sec:sys_config}) che sono
mantenute nei file \file{ostype}, \file{hostname}, \file{osrelease},
\file{version} e \file{domainname} di \file{/proc/kernel/}.
\subsection{La gestione delle proprietà dei filesystem}
\label{sec:sys_file_config}
-Come accennato in \secref{sec:file_organization} per poter accedere ai file
+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 \func{mount} il cui prototipo
-è:
+ 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)}
fallimento, nel qual caso gli errori comuni a tutti i filesystem che possono
essere restituiti in \var{errno} sono:
\begin{errlist}
- \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
- \item[\macro{ENODEV}] \param{filesystemtype} non esiste o non è configurato
+ \item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
+ \item[\errcode{ENODEV}] \param{filesystemtype} non esiste o non è configurato
nel kernel.
- \item[\macro{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[\macro{EBUSY}] \param{source} è già montato, o non può essere
+ \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[\macro{EINVAL}] il device \param{source} presenta un
+ \item[\errcode{EINVAL}] il device \param{source} presenta un
\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{/}.
- \item[\macro{EACCES}] non si ha il permesso di accesso su uno dei componenti
- del 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 l'opzione \macro{MS\_NODEV}.
- \item[\macro{ENXIO}] il \textit{major number} del device \param{source} è
+ \item[\errcode{EACCES}] non si ha il permesso di accesso su uno dei
+ componenti del 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 l'opzione \const{MS\_NODEV}.
+ \item[\errcode{ENXIO}] il \textit{major number} del device \param{source} è
sbagliato.
- \item[\macro{EMFILE}] la tabella dei device \textit{dummy} è piena.
+ \item[\errcode{EMFILE}] la tabella dei device \textit{dummy} è piena.
\end{errlist}
- ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
- \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
+ 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},
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 \secref{sec:file_vfs} è molto
+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
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 \macro{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
+ 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
-vanno settati con un OR aritmetico della costante \macro{MS\_MGC\_VAL} con i
-valori riportati in \ntab.
+vanno impostati con un OR aritmetico della costante \const{MS\_MGC\_VAL} con i
+valori riportati in tab.~\ref{tab:sys_mount_flags}.
\begin{table}[htb]
\footnotesize
\textbf{Parametro} & \textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{MS\_RDONLY} & 1 & monta in sola lettura\\
- \macro{MS\_NOSUID} & 2 & ignora i bit \acr{suid} e \acr{sgid}\\
- \macro{MS\_NODEV} & 4 & impedisce l'accesso ai file di dispositivo\\
- \macro{MS\_NOEXEC} & 8 & impedisce di eseguire programmi \\
- \macro{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
- \macro{MS\_REMOUNT} & 32 & rimonta il filesystem cambiando i flag\\
- \macro{MS\_MANDLOCK} & 64 & consente il \textit{mandatory locking} (vedi
- \secref{sec:file_mand_locking})\\
- \macro{S\_WRITE} & 128 & scrive normalmente \\
- \macro{S\_APPEND} & 256 & consente la scrittura solo in \textit{append
- mode} (vedi \secref{sec:file_sharing})\\
- \macro{S\_IMMUTABLE} & 512 & impedisce che si possano modificare i file \\
- \macro{MS\_NOATIME} &1024 & non aggiorna gli \textit{access time} (vedi
- \secref{sec:file_file_times})\\
- \macro{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
+ \const{MS\_RDONLY} & 1 & monta in sola lettura\\
+ \const{MS\_NOSUID} & 2 & ignora i bit \acr{suid} e \acr{sgid}\\
+ \const{MS\_NODEV} & 4 & impedisce l'accesso ai file di dispositivo\\
+ \const{MS\_NOEXEC} & 8 & impedisce di eseguire programmi \\
+ \const{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
+ \const{MS\_REMOUNT} & 32 & rimonta il filesystem cambiando i flag\\
+ \const{MS\_MANDLOCK} & 64 & consente il \textit{mandatory locking} (vedi
+ sez.~\ref{sec:file_mand_locking})\\
+ \const{S\_WRITE} & 128 & scrive normalmente \\
+ \const{S\_APPEND} & 256 & consente la scrittura solo in \textit{append
+ mode} (vedi sez.~\ref{sec:file_sharing})\\
+ \const{S\_IMMUTABLE} & 512 & impedisce che si possano modificare i file \\
+ \const{MS\_NOATIME} &1024 & non aggiorna gli \textit{access time} (vedi
+ sez.~\ref{sec:file_file_times})\\
+ \const{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
directory\\
- \macro{MS\_BIND} &4096 & monta il filesystem altrove\\
- \macro{MS\_MOVE} &8192 & sposta atomicamente il punto di montaggio \\
+ \const{MS\_BIND} &4096 & monta il filesystem altrove\\
+ \const{MS\_MOVE} &8192 & sposta atomicamente il punto di montaggio \\
\hline
\end{tabular}
\caption{Tabella dei codici dei flag di montaggio di un filesystem.}
\label{tab:sys_mount_flags}
\end{table}
-Per il settaggio delle caratteristiche particolari di ciascun filesystem si
+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.
\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
-bit di \param{mountflags}, \macro{MS\_REMOUNT}, che se settato specifica che
+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 \func{umount}, il cui prototipo è:
+\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} viene settata a:
+ fallimento, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
- \item[\macro{EBUSY}] \param{target} è la directory di lavoro di qualche
+ \item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
+ \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 \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
- \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
+ 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 è
\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 è \macro{EBUSY}.
+restituito è \errcode{EBUSY}.
-Linux provvede inoltre una seconda funzione, \func{umount2}, che in alcuni
+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 è:
\begin{prototype}{sys/mount.h}{umount2(const char *target, int flags)}
\end{prototype}
Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
-definito è il bit \macro{MNT\_FORCE}; gli altri bit devono essere nulli.
-Specificando \macro{MNT\_FORCE} la funzione cercherà di liberare il filesystem
+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 \macro{EBUSY}. In tutti i casi prima dello smontaggio
+evitando l'errore di \errcode{EBUSY}. In tutti i casi prima dello smontaggio
viene eseguita una sincronizzazione dei dati.
Altre due funzioni specifiche di Linux,\footnote{esse si trovano anche su BSD,
ma con una struttura diversa.} utili per ottenere in maniera diretta
informazioni riguardo al filesystem su cui si trova un certo file, sono
-\func{statfs} e \func{fstatfs}, i cui prototipi sono:
+\funcd{statfs} e \funcd{fstatfs}, i cui prototipi sono:
\begin{functions}
\headdecl{sys/vfs.h}
\funcdecl{int statfs(const char *path, struct statfs *buf)}
posto il file specificato.
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} viene settato ai valori:
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{ENOSYS}] il filesystem su cui si trova il file specificato non
+ \item[\errcode{ENOSYS}] il filesystem su cui si trova il file specificato non
supporta la funzione.
\end{errlist}
- e \macro{EFAULT} ed \macro{EIO} per entrambe, \macro{EBADF} per
- \func{fstatfs}, \macro{ENOTDIR}, \macro{ENAMETOOLONG}, \macro{ENOENT},
- \macro{EACCES}, \macro{ELOOP} per \func{statfs}.}
+ e \errval{EFAULT} ed \errval{EIO} per entrambe, \errval{EBADF} per
+ \func{fstatfs}, \errval{ENOTDIR}, \errval{ENAMETOOLONG}, \errval{ENOENT},
+ \errval{EACCES}, \errval{ELOOP} per \func{statfs}.}
\end{functions}
Queste funzioni permettono di ottenere una serie di informazioni generali
riguardo al filesystem su cui si trova il file specificato; queste vengono
-restituite una struttura \param{buf} di tipo \type{statfs} definita come in
-\ref{fig:sys_statfs}, ed i campi che sono indefiniti per il filesystem in
-esame sono settati 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 \macro{XXX\_SUPER\_MAGIC}, dove \macro{XXX} in genere è il
-nome del filesystem stesso.
+restituite all'indirizzo \param{buf} di una struttura \struct{statfs} definita
+come in fig.~\ref{fig:sys_statfs}, ed i campi che sono indefiniti per il
+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.
\begin{figure}[!htb]
\footnotesize \centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct statfs {
- long f_type; /* tipo di filesystem */
- long f_bsize; /* dimensione ottimale dei blocchi di I/O */
- long f_blocks; /* blocchi totali nel filesystem */
- long f_bfree; /* blocchi liberi nel filesystem */
- long f_bavail; /* blocchi liberi agli utenti normali */
- long f_files; /* inodes totali nel filesystem */
- long f_ffree; /* inodes liberi nel filesystem */
- fsid_t f_fsid; /* filesystem id */
- long f_namelen; /* lunghezza massima dei nomi dei file */
- long f_spare[6]; /* riservati per uso futuro */
-};
-\end{lstlisting}
+ \includestruct{listati/statfs.h}
\end{minipage}
\normalsize
- \caption{La struttura \var{statfs}.}
+ \caption{La struttura \structd{statfs}.}
\label{fig:sys_statfs}
\end{figure}
Le \acr{glibc} provvedono infine una serie di funzioni per la gestione dei due
-file standard \file{/etc/fstab} e \file{/etc/mtab}, che convenzionalmente sono
-usati in quasi tutti i sistemi unix-like per mantenere rispettivamente le
+file \file{/etc/fstab} ed \file{/etc/mtab}, che convenzionalmente sono usati
+in quasi tutti i sistemi unix-like per mantenere rispettivamente le
informazioni riguardo ai filesystem da montare e a quelli correntemente
montati. Le funzioni servono a leggere il contenuto di questi file in
-opportune strutture \var{struct fstab} e \var{struct mntent}, e, per
-\file{/etc/mtab} per inserire e rimuovere le voci presenti nel file.
+opportune strutture \struct{fstab} e \struct{mntent}, e, per \file{/etc/mtab}
+per inserire e rimuovere le voci presenti nel file.
-In generale si dovrebbero usare queste funzioni (in particolar modo quelle
+In generale si dovrebbero usare queste funzioni (in particolare quelle
relative a \file{/etc/mtab}), quando si debba scrivere un programma che
effettua il montaggio di un filesystem; in realtà in questi casi è molto più
semplice invocare direttamente il programma \cmd{mount}, per cui ne
\cite{glibc} per la documentazione completa.
-\subsection{La gestione di utenti e gruppi}
+\subsection{La gestione delle informazioni su utenti e gruppi}
\label{sec:sys_user_group}
-Tradizionalmente l'informazione per la gestione di utenti e gruppi veniva
-tenuta tutta nei due file di testo \file{/etc/passwd} ed \file{/etc/group}, e
-tutte le funzioni facevano riferimento ad essi. Oggi la maggior parte delle
-distribuzioni di Linux usa la libreria PAM (sigla che sta \textit{Pluggable
- Authentication Method}) che permette di separare completamente i meccanismi
-di gestione degli utenti (autenticazione, riconoscimento, ecc.) dalle modalità
-in cui i relativi dati vengono mantenuti, per cui pur restando in gran parte
-le stesse\footnote{in genere quello che viene cambiato è l'informazione usata
- per l'autenticazione, che non è più necessariamente una password criptata da
- verificare, ma può assumere le forme più diverse, come impronte digitali,
- chiavi elettroniche, ecc.}, le informazioni non sono più necessariamente
-mantenute in quei file.
-
-In questo paragrafo ci limiteremo comunque alle funzioni classiche per la
-lettura delle informazioni relative a utenti e gruppi previste dallo standard
-POSIX.1, che fanno riferimento a quanto memorizzato nei due file appena
-citati, il cui formato è descritto dalle relative pagine del manuale (cioè
-\cmd{man 5 passwd} e \cmd{man 5 group}).
-
-Per leggere le informazioni relative ad un utente si possono usare due
-funzioni, \func{getpwuid} e \func{getpwnam}, i cui prototipi sono:
+Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
+(password, corripondenze fra nomi simbolici e user-id, home directory, ecc.)
+venivano registrate all'interno dei due file di testo \file{/etc/passwd} ed
+\file{/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 \file{/etc/shadow} e \file{/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 manuale\footnote{nella quinta sezione,
+ quella dei file di configurazione, 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
+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
+ 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
+ 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
+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
+e memorizzare dette informazioni su supporti diversi, introducendo il sistema
+del \textit{Name Service Switch} che tratteremo 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 trattere le funzioni classiche
+per la lettura delle informazioni relative a utenti e gruppi tralasciando
+completamente quelle relative all'autenticazione.
+% Per questo non tratteremo
+% affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
+% \textit{Name Service Switch}, un meccanismo messo a disposizione dalle
+% \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
+% necessario trovare una corrispondenza fra un nome ed un numero (od altra
+% informazione) ad esso associato, come appunto, quella fra uno username ed un
+% \acr{uid} o fra un \acr{gid} ed il nome del gruppo corrispondente.
+Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
+queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
+ Service Switch}, per cui sono in grado di ricevere informazioni qualunque
+sia il supporto su cui esse vengono mantenute. Per leggere le informazioni
+relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
+\funcd{getpwnam}, i cui prototipi sono:
\begin{functions}
\headdecl{pwd.h}
\headdecl{sys/types.h}
Restituiscono le informazioni relative all'utente specificato.
\bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
- informazioni in caso di successo e \macro{NULL} nel caso non sia stato
+ informazioni in caso di successo e \val{NULL} nel caso non sia stato
trovato nessun utente corrispondente a quanto specificato.}
\end{functions}
-Le due funzioni forniscono le informazioni memorizzate nel database degli
+Le due funzioni forniscono le informazioni memorizzate nel registro degli
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 \type{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
-riportata in \figref{fig:sys_passwd_struct}, dove è pure brevemente illustrato
-il significato dei vari campi.
+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]
\footnotesize
\centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct passwd {
- char *pw_name; /* user name */
- char *pw_passwd; /* user password */
- uid_t pw_uid; /* user id */
- gid_t pw_gid; /* group id */
- char *pw_gecos; /* real name */
- char *pw_dir; /* home directory */
- char *pw_shell; /* shell program */
-};
- \end{lstlisting}
+ \includestruct{listati/passwd.h}
\end{minipage}
\normalsize
- \caption{La struttura \var{passwd} contenente le informazioni relative ad un
- utente del sistema.}
+ \caption{La struttura \structd{passwd} contenente le informazioni relative ad
+ un utente del sistema.}
\label{fig:sys_passwd_struct}
\end{figure}
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 posono
-essere rientranti, per cui ne esistono anche due versioni alternative
-(denotate dalla solita estensione \code{\_r}), i cui prototipi sono:
+fanno riferimento. Ovviamente questo implica che dette funzioni non possono
+essere rientranti; per questo motivo ne esistono anche due versioni
+alternative (denotate dalla solita estensione \code{\_r}), i cui prototipi
+sono:
\begin{functions}
\headdecl{pwd.h}
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à settato 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
la memoria necessaria a contenere le informazioni. In particolare i valori
-della struttura \var{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 puntate dai
-campi di \param{password}. Infine all'indirizzo puntato da \param{result}
-viene restituito il puntatore ai dati ottenuti, cioè \param{buffer} nel caso
-l'utente esista, o \macro{NULL} altrimenti. Qualora i dati non possano essere
-contenuti nei byte specificati da \param{buflen}, la funzione fallirà
-restituendo \macro{ERANGE} (e \param{result} sarà comunque settato a
-\macro{NULL}).
-
-Del tutto analoghe alle precedenti sono le funzioni \func{getgrnam} e
-\func{getgrgid} (e le relative analoghe rientranti con la stessa estensione
+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
+puntate dai campi di \param{password}. Infine all'indirizzo puntato da
+\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
+impostato a \val{NULL}).
+
+Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
+\funcd{getgrgid} (e le relative analoghe rientranti con la stessa estensione
\code{\_r}) che permettono di leggere le informazioni relative ai gruppi, i
loro prototipi sono:
\begin{functions}
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à settato 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
in questo caso le informazioni vengono restituite in una struttura di tipo
-\type{group}, la cui definizione è riportata in \figref{fig:sys_group_struct}.
+\struct{group}, la cui definizione è riportata in
+fig.~\ref{fig:sys_group_struct}.
\begin{figure}[!htb]
\footnotesize
\centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct group {
- char *gr_name; /* group name */
- char *gr_passwd; /* group password */
- gid_t gr_gid; /* group id */
- char **gr_mem; /* group members */
-};
- \end{lstlisting}
+ \includestruct{listati/group.h}
\end{minipage}
\normalsize
- \caption{La struttura \var{group} contenente le informazioni relative ad un
- gruppo del sistema.}
+ \caption{La struttura \structd{group} contenente le informazioni relative ad
+ un gruppo del sistema.}
\label{fig:sys_group_struct}
\end{figure}
-Le funzioni viste finora sono in grado di leggere le informazioni sia dal file
-delle password in \file{/etc/passwd} che con qualunque altro metodo sia stato
-utilizzato per mantenere il database degli utenti. Non permettono però di
-settare direttamente le password; questo è possibile con un'altra interfaccia
-al database degli utenti, derivata da SVID, che però funziona soltanto con un
-database che sia tenuto su un file che abbia il formato classico di
-\file{/etc/passwd}.
+Le funzioni viste finora sono in grado di leggere le informazioni sia
+direttamente dal file delle password in \file{/etc/passwd} che tramite il
+sistema del \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 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 file di \textsl{registro}
+di utenti e gruppi, con il formato classico di \file{/etc/passwd} e
+\file{/etc/group}.
\begin{table}[htb]
\footnotesize
\textbf{Funzione} & \textbf{Significato}\\
\hline
\hline
- \func{fgetpwent} & Legge una voce dal database utenti da un file
- specificato aprendolo la prima volta.\\
+ \func{fgetpwent} & Legge una voce dal file di registro degli utenti
+ specificato.\\
\func{fgetpwent\_r}& Come la precedente, ma rientrante.\\
- \func{getpwent} & Legge una voce dal database utenti (da
- \file{/etc/passwd}) aprendolo la prima volta.\\
+ \func{putpwent} & Immette una voce in un file di registro degli
+ utenti.\\
+ \func{getpwent} & Legge una voce da \file{/etc/passwd}.\\
\func{getpwent\_r} & Come la precedente, ma rientrante.\\
- \func{setpwent} & Ritorna all'inizio del database.\\
- \func{putpwent} & Immette una voce nel database utenti.\\
- \func{endpwent} & Chiude il database degli utenti.\\
- \func{fgetgrent} & Legge una voce dal database dei gruppi da un file
- specificato aprendolo la prima volta.\\
+ \func{setpwent} & Ritorna all'inizio di \file{/etc/passwd}.\\
+ \func{endpwent} & Chiude \file{/etc/passwd}.\\
+ \func{fgetgrent} & Legge una voce dal file di registro dei gruppi
+ specificato.\\
\func{fgetgrent\_r}& Come la precedente, ma rientrante.\\
- \func{getgrent} & Legge una voce dal database dei gruppi (da
- \file{/etc/passwd}) aprendolo la prima volta.\\
+ \func{putgrent} & Immette una voce in un file di registro dei gruppi.\\
+ \func{getgrent} & Legge una voce da \file{/etc/group}.\\
\func{getgrent\_r} & Come la precedente, ma rientrante.\\
- \func{setgrent} & Immette una voce nel database dei gruppi.\\
- \func{putgrent} & Immette una voce nel database dei gruppi.\\
- \func{endgrent} & Chiude il database dei gruppi.\\
+ \func{setgrent} & Ritorna all'inizio di \file{/etc/group}.\\
+ \func{endgrent} & Chiude \file{/etc/group}.\\
\hline
\end{tabular}
\caption{Funzioni per la manipolazione dei campi di un file usato come
- database di utenti e gruppi nel formato di \file{/etc/passwd} e
+ registro per utenti o gruppi nel formato di \file{/etc/passwd} e
\file{/etc/groups}.}
\label{tab:sys_passwd_func}
\end{table}
-Dato che ormai la gran parte delle distribuzioni di Linux utilizzano PAM, che
-come minimo usa almeno le \textit{shadow password} (quindi con delle modifiche
-rispetto al formato classico di \file{/etc/passwd}), le funzioni che danno la
-capacità scrivere delle voci nel database (cioè \func{putpwent} e
-\func{putgrent}) non permettono di effettuarne una specificazione in maniera
-completa. Per questo motivo l'uso di queste funzioni è deprecato in favore
-dell'uso di PAM, ci limiteremo pertanto ad elencarle in
-\tabref{tab:sys_passwd_func}, rimandando chi fosse interessato alle rispettive
-man page e al manuale delle \acr{glibc} per i dettagli del loro funzionamento.
+Dato che oramai la gran parte delle distribuzioni di GNU/Linux utilizzano
+almeno le \textit{shadow password} (quindi con delle modifiche rispetto al
+formato classico del file \file{/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
+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
+riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
+delle \acr{glibc} per i dettagli del funzionamento.
-\subsection{Il database di accounting}
+\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 database di
-\textit{accounting}. 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 sistema, come il momento di lancio di
-processi da parte di \cmd{init}, il cambiamento dell'orologio di sistema, il
-cambiamento di runlevel o il riavvio della macchina.
+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
+sistema, come il momento di lancio di processi da parte di \cmd{init}, il
+cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
+della macchina.
I dati vengono usualmente\footnote{questa è la locazione specificata dal
\textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
connessione ed altre informazioni. La voce resta nel file fino al logout,
quando viene cancellata e spostata in \file{/var/log/wtmp}.
-In questo modo il primo file viene utilizzato per registrare sta utilizzando
-il sistema al momento corrente, mentre il secondo mantiene la 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}.
+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
+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}.
Questi file non devono mai essere letti direttamente, ma le informazioni che
contengono possono essere ricavate attraverso le opportune funzioni di
-libreria. Queste sono analoghe alle precedenti (vedi
-\tabref{tab:sys_passwd_func}) usate per accedere al database degli utenti,
-solo che in questo caso la struttura del database di accounting è molto più
-complessa, dato che contiene diversi tipi di informazione.
+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.
-Le prime tre funzioni, \func{setutent}, \func{endutent} e \func{utmpname}
+Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
servono rispettivamente a aprire e a chiudere il file che contiene il
-database, e a specificare su quale file esso viene mantenuto. I loro prototipi
+registro, e a specificare su quale file esso viene mantenuto. I loro prototipi
sono:
\begin{functions}
\headdecl{utmp.h}
\funcdecl{void utmpname(const char *file)} Specifica il file da usare come
- database di \textit{accounting}.
+ registro.
- \funcdecl{void setutent(void)} Apre il file del database di
- \textit{accounting}, posizionandosi al suo inizio.
+ \funcdecl{void setutent(void)} Apre il file del registro, posizionandosi al
+ suo inizio.
- \funcdecl{void endutent(void)} Chiude il file del database di
- \textit{accounting}.
+ \funcdecl{void endutent(void)} Chiude il file del registro.
\bodydesc{Le funzioni non ritornano codici di errore.}
\end{functions}
In caso questo non venga specificato nessun file viene usato il valore
-standard \macro{\_PATH\_UTMP} (che è definito in \file{paths.h}); in genere
+standard \const{\_PATH\_UTMP} (che è definito in \file{paths.h}); in genere
\func{utmpname} prevede due possibili valori:
\begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\macro{\_PATH\_UTMP}] Specifica il database di accounting per gli utenti
- correntemente collegati.
-\item[\macro{\_PATH\_WTMP}] Specifica il database di accounting per l'archivio
- storico degli utenti collegati.
+\item[\const{\_PATH\_UTMP}] Specifica il registro per gli utenti correntemente
+ collegati.
+\item[\const{\_PATH\_WTMP}] Specifica il registro per l'archivio storico degli
+ utenti collegati.
\end{basedescript}
corrispondenti ai file \file{/var/run/utmp} e \file{/var/log/wtmp} visti in
precedenza.
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/utmp.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{utmp} contenente le informazioni di una voce
+ del registro di \textsl{contabilità}.}
+ \label{fig:sys_utmp_struct}
+\end{figure}
+
Una volta aperto il file si può eseguire una scansione leggendo o scrivendo
-una voce con le funzioni \func{getutent}, \func{getutid}, \func{getutline} e
-\func{pututline}, i cui prototipi sono:
+una voce con le funzioni \funcd{getutent}, \funcd{getutid}, \funcd{getutline}
+e \funcd{pututline}, i cui prototipi sono:
\begin{functions}
\headdecl{utmp.h}
\funcdecl{struct utmp *getutent(void)}
- Legge una voce dal dalla posizione corrente nel database.
+ Legge una voce dal dalla posizione corrente nel registro.
- \funcdecl{struct utmp *getutid(struct utmp *ut)}
- Ricerca una voce sul database in base al contenuto di \param{ut}.
+ \funcdecl{struct utmp *getutid(struct utmp *ut)} Ricerca una voce sul
+ registro in base al contenuto di \param{ut}.
\funcdecl{struct utmp *getutline(struct utmp *ut)}
- Ricerca nel database la prima voce corrispondente ad un processo sulla linea
+ Ricerca nel registro la prima voce corrispondente ad un processo sulla linea
di terminale specificata tramite \param{ut}.
\funcdecl{struct utmp *pututline(struct utmp *ut)}
- Scrive una voce nel database.
-
- \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
- caso di successo e \macro{NULL} in caso di errore.}
+ Scrive una voce nel registro.
+
+ \bodydesc{Le funzioni ritornano il puntatore ad una struttura \struct{utmp}
+ in caso di successo e \val{NULL} in caso di errore.}
\end{functions}
-Tutte queste funzioni fanno riferimento ad una struttura di tipo \var{utmp},
-la cui definizione in Linux è riportata in \secref{fig:sys_utmp_struct}. Le
-prime tre funzioni servono per leggere una voce dal database; \func{getutent}
-legge semplicemente la prima voce disponibile; le altre due permettono di
-eseguire una ricerca.
-
-\begin{figure}[!htb]
- \footnotesize
- \centering
- \begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct utmp
-{
- short int ut_type; /* Type of login. */
- pid_t ut_pid; /* Process ID of login process. */
- char ut_line[UT_LINESIZE]; /* Devicename. */
- char ut_id[4]; /* Inittab ID. */
- char ut_user[UT_NAMESIZE]; /* Username. */
- char ut_host[UT_HOSTSIZE]; /* Hostname for remote login. */
- struct exit_status ut_exit; /* Exit status of a process marked
- as DEAD_PROCESS. */
- long int ut_session; /* Session ID, used for windowing. */
- struct timeval ut_tv; /* Time entry was made. */
- int32_t ut_addr_v6[4]; /* Internet address of remote host. */
- char __unused[20]; /* Reserved for future use. */
-};
- \end{lstlisting}
- \end{minipage}
- \normalsize
- \caption{La struttura \var{utmp} contenente le informazioni di una voce del
- database di \textit{accounting}.}
- \label{fig:sys_utmp_struct}
-\end{figure}
+Tutte queste funzioni fanno riferimento ad una struttura di tipo
+\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.
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 \tabref{tab:sys_ut_type}, quando assume i valori
-\macro{RUN\_LVL}, \macro{BOOT\_TIME}, \macro{OLD\_TIME}, \macro{NEW\_TIME},
+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
-invece assume i valori \macro{INIT\_PROCESS}, \macro{LOGIN\_PROCESS},
-\macro{USER\_PROCESS} o \macro{DEAD\_PROCESS} verrà restiuita la prima voce
-corripondente al valore del campo \var{ut\_id} specificato in \param{ut}.
+invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
+\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]
\footnotesize
\centering
\begin{tabular}[c]{|l|p{8cm}|}
\hline
- \textbf{Funzione} & \textbf{Significato}\\
+ \textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \macro{EMPTY} & Non contiene informazioni valide. \\
- \macro{RUN\_LVL} & Identica il runlevel del sistema. \\
- \macro{BOOT\_TIME} & Identifica il tempo di avvio del sistema \\
- \macro{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
+ \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
sistema. \\
- \macro{NEW\_TIME} & Identifica da quanto è stato modificato il
+ \const{NEW\_TIME} & Identifica da quanto è stato modificato il
sistema. \\
- \macro{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}. \\
- \macro{LOGIN\_PROCESS}& Identifica un processo di login. \\
- \macro{USER\_PROCESS} & Identifica un processo utente. \\
- \macro{DEAD\_PROCESS} & Identifica un processo terminato. \\
- \macro{ACCOUNTING} & ??? \\
+ \const{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}. \\
+ \const{LOGIN\_PROCESS}& Identifica un processo di login. \\
+ \const{USER\_PROCESS} & Identifica un processo utente. \\
+ \const{DEAD\_PROCESS} & Identifica un processo terminato. \\
+% \const{ACCOUNTING} & ??? \\
\hline
\end{tabular}
- \caption{Classificazione delle voci del database di accounting a seconda dei
+ \caption{Classificazione delle voci del registro a seconda dei
possibili valori del campo \var{ut\_type}.}
\label{tab:sys_ut_type}
\end{table}
La funzione \func{getutline} esegue la ricerca sulle voci che hanno
-\var{ut\_type} uguale a \macro{LOGIN\_PROCESS} o \macro{USER\_PROCESS},
+\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
\func{pututline} per trovare uno spazio dove inserire la voce specificata,
-qualora non sia trovata la voce viene aggiunta in coda al database.
+qualora non sia trovata la voce viene aggiunta in coda al registro.
In generale occorre però tenere conto che queste funzioni non sono
completamente standardizzate, e che in sistemi diversi possono esserci
\func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
sinonimi delle funzioni appena viste.
-Come visto in \secref{sec:sys_user_group}, l'uso di strutture allocate
+Come visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
staticamente rende le funzioni di lettura non rientranti; per questo motivo le
\acr{glibc} forniscono anche delle versioni rientranti: \func{getutent\_r},
\func{getutid\_r}, \func{getutline\_r}, che invece di restituire un puntatore
restituiscono un intero e prendono due argomenti aggiuntivi. Le funzioni si
-comportano esattamente come le analoge non rientranti, solo che restituiscono
+comportano esattamente come le analoghe non rientranti, solo che restituiscono
il risultato all'indirizzo specificato dal primo argomento aggiuntivo (di tipo
\code{struct utmp *buffer}) mentre il secondo (di tipo \code{struct utmp
**result)} viene usato per restituire il puntatore allo stesso buffer.
Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
-in \file{wmtp} altre due funzioni, \func{updwtmp} e \func{logwtmp}, i cui
+in \file{wmtp} altre due funzioni, \funcd{updwtmp} e \funcd{logwtmp}, i cui
prototipi sono:
\begin{functions}
\headdecl{utmp.h}
\funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
- Aggiunge la voce \param{ut} nel database di accounting \file{wmtp}.
+ Aggiunge la voce \param{ut} nel registro \file{wmtp}.
\funcdecl{void logwtmp(const char *line, const char *name, const char
- *host)} Aggiunge nel database di accounting una voce con i valori
- specificati.
-
- \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
- caso di successo e \macro{NULL} in caso di errore.}
+ *host)} Aggiunge nel registro una voce con i valori specificati.
\end{functions}
La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
-direttamente una struttura \type{utmp}, mentre la seconda utilizza gli
+direttamente una struttura \struct{utmp}, mentre la seconda utilizza gli
argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
poi aggiunge chiamando \func{updwtmp}.
Dopo aver esaminato le funzioni che permettono di controllare le varie
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 utilizzo.
+risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
+permettono di imporre a ciascuno di essi vincoli e limiti di
+utilizzo.
\subsection{L'uso delle risorse}
\label{sec:sys_resource_use}
-Come abbiamo accennato in \secref{sec:proc_wait4} le informazioni riguardo
+Come abbiamo accennato in sez.~\ref{sec:proc_wait4} le informazioni riguardo
l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
-di tipo \code{struct }\type{rusage}, la cui definizione (che si trova in
-\file{sys/resource.h}) è riportata in \figref{fig:sys_rusage_struct}.
+di tipo \struct{rusage}, la cui definizione (che si trova in
+\file{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
\begin{figure}[!htb]
\footnotesize
\centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct rusage {
- struct timeval ru_utime; /* user time used */
- struct timeval ru_stime; /* system time used */
- long ru_maxrss; /* maximum resident set size */
- long ru_ixrss; /* integral shared memory size */
- long ru_idrss; /* integral unshared data size */
- long ru_isrss; /* integral unshared stack size */
- long ru_minflt; /* page reclaims */
- long ru_majflt; /* page faults */
- long ru_nswap; /* swaps */
- long ru_inblock; /* block input operations */
- long ru_oublock; /* block output operations */
- long ru_msgsnd; /* messages sent */
- long ru_msgrcv; /* messages received */
- long ru_nsignals; ; /* signals received */
- long ru_nvcsw; /* voluntary context switches */
- long ru_nivcsw; /* involuntary context switches */
-};
- \end{lstlisting}
+ \includestruct{listati/rusage.h}
\end{minipage}
\normalsize
- \caption{La struttura \var{rusage} per la lettura delle informazioni dei
+ \caption{La struttura \structd{rusage} per la lettura delle informazioni dei
delle risorse usate da un processo.}
\label{fig:sys_rusage_struct}
\end{figure}
-La struttura è ripresa da BSD 4.3, ma attualmente (con i kernel della serie
-2.4.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 nell'eseguire le istruzioni in
-user space, e quello impiegato dal kernel nelle system call eseguite per conto
-del processo.
-
-Gli altri tre campi servono a quantificare l'uso della memoria virtuale e
-corrispondono rispettivamente al numero di \textit{page fault}\index{page
- fault} (vedi \secref{sec:proc_mem_gen}) avvenuti senza richiedere I/O (i
-cosiddetti \textit{minor page fault}), a quelli che invece han richiesto I/O
-(detti invece \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ù necessario,
-ma aumenta la portabilità, e serve comunque quando, come nella maggior parte
-dei casi, si debba accedere ai campi di \var{rusage} relativi ai tempi di
-utilizzo del processore, che sono definiti come \code{struct }\type{timeval}.
-
-
-Questa è la stessa struttura utilizzata da \func{wait4} per ricavare la
-quantità di risorse impiegato dal processo di cui si è letto lo stato di
-terminazione, ma essa può anche essere letta direttamente utilizzando la
-funzione \func{getrusage}, il cui prototipo è:
+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 \textit{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 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 nell'eseguire le istruzioni in user space, e quello impiegato dal
+kernel nelle system call eseguite per conto del processo.
+
+Gli altri tre campi servono a quantificare l'uso della memoria
+virtuale\index{memoria virtuale} e corrispondono rispettivamente al numero di
+\textit{page fault}\index{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
+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
+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}.
+
+Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
+visto in sez.~\ref{sec:proc_wait4}) 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 è:
\begin{functions}
\headdecl{sys/time.h}
\headdecl{sys/resource.h}
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
- nel qual caso \var{errno} può essere \macro{EINVAL} o \macro{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
-\macro{RUSAGE\_SELF} per indicare il processo corrente e
-\macro{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
+\const{RUSAGE\_SELF} per indicare il processo corrente e
+\const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
ricevuto lo stato di terminazione.
\subsection{Limiti sulle risorse}
\label{sec:sys_resource_limit}
-Come accennato nell'introduzione oltre a leggere l'uso delle risorse da parte
-di un processo si possono anche imporre dei limiti sulle sue capacità. Ogni
-processo ha in generale due limiti associati ad ogni risorsa; questi sono
-detti il \textsl{limite corrente} (o \textit{current limit}) che esprime il
-valore che attualmente il processo non può superare, ed il \textsl{limite
- massimo} (o \textit{maximum limit}) che esprime il valore massimo che può
-assumere il \textsl{limite corrente}.
-
-In generale il primo viene chiamato un limite \textsl{soffice} (o \textit{soft
- limit}) dato che il suo valore può essere aumentato, mentre il secondo è
-detto \textsl{duro} (o \textit{hard limit}), in quanto un processo normale non
-può modificarne il valore. Il valore di questi limiti è mantenuto in una
-struttura \var{rlimit}, la cui definizione è riportata in
-\figref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a limite
-corrente e massimo.
+Come accennato nell'introduzione oltre a mantenere i dati relativi all'uso
+delle risorse da parte dei vari processi, il kernel mette anche a disposizione
+delle funzioni con cui si possono imporre dei limiti sulle risorse che essi
+possono utilizzare. In generale ad ogni processo vengono associati due
+diversi limiti per ogni risorsa; questi sono detti il \textsl{limite corrente}
+(o \textit{current limit}) che esprime il valore massimo che attualmente il
+processo non può superare, ed il \textsl{limite massimo} (o \textit{maximum
+ limit}) che esprime il valore massimo che può assumere il \textsl{limite
+ corrente}.
\begin{figure}[!htb]
\footnotesize
\centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct rlimit {
- rlim_t rlim_cur;
- rlim_t rlim_max;
-};
- \end{lstlisting}
+ \includestruct{listati/rlimit.h}
\end{minipage}
\normalsize
- \caption{La struttura \var{rlimit} per impostare i limiti di utilizzo
+ \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
delle risorse usate da un processo.}
\label{fig:sys_rlimit_struct}
\end{figure}
+In generale il primo viene chiamato anche \textsl{limite soffice} (o
+\textit{soft limit}) dato che il suo valore può essere aumentato fino al
+valore del secondo, mentre il secondo è detto \textsl{limite duro} (o
+\textit{hard limit}), in quanto un processo normale può solo diminuirne il
+valore. Il valore di questi due limiti è mantenuto in una struttura
+\struct{rlimit}, la cui definizione è riportata in
+fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
+limite corrente e limite massimo.
+
In genere il superamento di un limite comporta o l'emissione di un segnale o
-il fallimento della system call che lo ha provocato; per far leggere o settare
-i limiti di utilizzo delle risorse da parte di un processo le \acr{glibc}
-prevedono due funzioni, \func{getrlimit} e \func{setrlimit}, i cui prototipi
-sono:
+il fallimento della system call che lo ha provocato; per permettere di leggere
+e di impostare i limiti di utilizzo delle risorse da parte di un processo
+Linux prevede due funzioni, \funcd{getrlimit} e \funcd{setrlimit}, i cui
+prototipi sono:
\begin{functions}
\headdecl{sys/time.h}
\headdecl{sys/resource.h}
\funcdecl{int setrlimit(int resource, const struct rlimit *rlim)}
- Setta il limite per la risorsa \param{resource}.
+ 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} viene settata ai valori:
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{INVAL}] I valori per \param{resource} non sono validi.
- \item[\macro{EPERM}] Un processo senza i privilegi di amministratore ha
+ \item[\errcode{EINVAL}] I valori per \param{resource} non sono validi.
+ \item[\errcode{EPERM}] Un processo senza i privilegi di amministratore ha
cercato di innalzare i propri limiti.
\end{errlist}
- ed \macro{EFAULT}.}
+ ed \errval{EFAULT}.}
\end{functions}
-Entrambe le funzioni permettono di specificare su quale risorsa si vuole
-operare attraverso \param{resource}, i cui possibili valori sono elencati in
-\secref{tab:sys_rlimit_values}, e utilizzano una struttura \var{rlimit} per
-specificarne i valori.
+
+Entrambe le funzioni permettono di specificare, attraverso l'argomento
+\param{resource}, su quale risorsa si vuole operare: i possibili valori di
+questo argomento sono elencati in sez.~\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}.
\begin{table}[htb]
\footnotesize
\textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \macro{RLIMIT\_CPU} & Il massimo tempo di CPU che il processo può
+ \const{RLIMIT\_CPU} & Il massimo tempo di CPU che il processo può
usare. Il superamento del limite comporta
- l'emissione di un segnale di \macro{SIGXCPU}.\\
- \macro{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
+ l'emissione di un segnale di \const{SIGXCPU}.\\
+ \const{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
può usare. Se il processo cerca di scrivere
oltre questa dimensione riceverà un segnale di
- \macro{SIGXFSZ}.\\
- \macro{RLIMIT\_DATA} & La massima dimensione della memoria dati di un
- processo. Il tentatico di allocare più memoria
+ \const{SIGXFSZ}.\\
+ \const{RLIMIT\_DATA} & La massima dimensione della memoria dati di un
+ processo. Il tentativo di allocare più memoria
causa il fallimento della funzione di
allocazione. \\
- \macro{RLIMIT\_STACK} & La massima dimensione dello stack del
+ \const{RLIMIT\_STACK} & La massima dimensione dello stack del
processo. Se il processo esegue operazioni che
estendano lo stack oltre questa dimensione
- riceverà un segnale di \macro{SIGSEGV}.\\
- \macro{RLIMIT\_CORE} & La massima dimensione di un file di \textit{core
+ riceverà un segnale di \const{SIGSEGV}.\\
+ \const{RLIMIT\_CORE} & La massima dimensione di un file di \textit{core
dump} creato da un processo. Nel caso le
dimensioni dovessero essere maggiori il file non
verrebbe generato.\footnotemark\\
- \macro{RLIMIT\_RSS} & L'ammontare massimo di memoria fisica dato al
+ \const{RLIMIT\_RSS} & L'ammontare massimo di memoria fisica dato al
processo. Il limite è solo una indicazione per
il kernel, qualora ci fosse un surplus di
memoria questa verrebbe assegnata.\\
- \macro{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
+ \const{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
creati sullo stesso user id. Se il limite viene
raggiunto \func{fork} fallirà con un
- \macro{EAGAIN}.\\
- \macro{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
+ \errcode{EAGAIN}.\\
+ \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
aprire. L'apertura di un ulteriore file fallirà
- con un errore \macro{EMFILE}.\\
- \macro{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
- bloccata (vedi \secref{sec:proc_mem_lock}).\\
- \macro{RLIMIT\_AS} & La dimensione massima di tutta la memoria che il
+ con un errore \errcode{EMFILE}.\\
+ \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
+ bloccata in RAM senza
+ paginazione\index{paginazione} (vedi
+ sez.~\ref{sec:proc_mem_lock}).\\
+ \const{RLIMIT\_AS} & La dimensione massima di tutta la memoria che il
processo può ottenere. Se il processo tenta di
allocarne di più funzioni come \func{brk},
\func{malloc} o \func{mmap} falliranno. \\
\label{tab:sys_rlimit_values}
\end{table}
-\footnotetext{Settare questo limite a zero è la maniera più semplice per
- evitare la creazione di \file{core} file.}
+\footnotetext{Impostare questo limite a zero è la maniera più semplice per
+ evitare la creazione di \file{core} file (al proposito si veda
+ sez.~\ref{sec:sig_prog_error}).}
-È inoltre definita la costante \macro{RLIM\_INFINITY} che permette di
-sbloccare l'uso di una risorsa, ma solo un processo con i privilegi di
+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 può innalzare un limite al di sopra del valore corrente del
limite massimo. Si tenga conto infine che tutti i limiti vengono ereditati dal
-processo padre attraverso una \func{fork} (vedi \secref{sec:proc_fork}) e
-mantenuti attraverso una \func{exec} (vedi \secref{sec:proc_exec}).
+processo padre attraverso una \func{fork} (vedi sez.~\ref{sec:proc_fork}) e
+mantenuti per gli altri programmi eseguiti attraverso una \func{exec} (vedi
+sez.~\ref{sec:proc_exec}).
\subsection{Le risorse di memoria e processore}
\label{sec:sys_memory_res}
La gestione della memoria è già stata affrontata in dettaglio in
-\secref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
-meccanismo della memoria virtuale attraverso la divisione della memoria fisica
-in pagine.
+sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
+meccanismo della memoria virtuale\index{memoria virtuale} attraverso la
+divisione della memoria fisica in pagine.
-In genere questo è del tutto trasparente al singolo processo, ma in certi
-casi, come per l'I/O mappato in memoria (vedi \ref{sec:file_memory_map}) che
-usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
+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
dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
-gestire in maniera ottimale l'interazione della memoria allocata con il
-meccanismo della paginazione.
+gestire in maniera ottimale l'interazione della memoria che si sta allocando
+con il meccanismo della paginazione\index{paginazione}.
Di solito la dimensione delle pagine di memoria è fissata dall'architettura
-hardware, per cui in genere la dimensione delle pagine di memoria era una
-costante definita in fase di compilazione, ma oggi alcune architetture (ad
-esempio su Sun Sparc) permettono di variare questa dimensione, e non volendo
-dover fornire binari diversi per ogni possibile modello, è necessario poter
-utilizzare una funzione.
-
-In genere questa dimensione può essere ottenuta attraverso una chiamata a
-\func{sysconf} come \func{sysconf(\_SC\_PAGESIZE)}, ma in BSD 4.2 è stata
-introdotta una apposita funzione, \func{getpagesize}, che restituisce la
+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.
+
+Dato che si tratta di una caratteristica generale del sistema, questa
+dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
+\func{sysconf} (nel caso \code{sysconf(\_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 è:
\begin{prototype}{unistd.h}{int getpagesize(void)}
Legge le dimensioni delle pagine di memoria.
sono previsti errori.}
\end{prototype}
-La funzione è prevista in SVr4, 4.4BSD 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
-\macro{PAGE\_SIZE} del kernel, anche se le versioni delle librerie del C
+\const{PAGE\_SIZE} del kernel, anche se le versioni delle librerie del C
precedenti le \acr{glibc} 2.1 implementavano questa funzione restituendo
sempre un valore statico.
Le \acr{glibc} forniscono, come specifica estensione GNU, altre due funzioni,
-\func{get\_phys\_pages} e \func{get\_avphys\_pages} che permettono di ottenere
-informazioni riguardo la memoria; i loro prototipi sono:
+\funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono di
+ottenere informazioni riguardo la memoria; i loro prototipi sono:
\begin{functions}
\headdecl{sys/sysinfo.h}
\end{functions}
Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
-rispettivamente con i parametri \macro{\_SC\_PHYS\_PAGES} e
-\macro{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
+rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
+\const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
corrispondenti alla RAM della macchina; la seconda invece la memoria
effettivamente disponibile per i processi.
-Le \acr{glibc} supportano inoltre, come estenzioni GNU, due funzioni che
+Le \acr{glibc} supportano inoltre, come estensioni GNU, due funzioni che
restituiscono il numero di processori della macchina (e quello dei processori
attivi); anche queste sono informazioni comunque ottenibili attraverso
\func{sysconf} utilizzando rispettivamente i parametri
-\macro{\_SC\_NPROCESSORS\_CONF} e \macro{\_SC\_NPROCESSORS\_ONLN}.
+\const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
-Infine le \acr{glibc} riprendono da BSD la funzione \func{getloadavg} che
+Infine le \acr{glibc} riprendono da BSD la funzione \funcd{getloadavg} che
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 è:
\end{prototype}
La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
-di processi attivi sulla coda dello scheduler, calcolato su un diverso
-intervalli di tempo. Il numero di intervalli che si vogliono 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.
+di processi attivi sulla coda dello scheduler\index{scheduler}, calcolato su
+un diverso intervalli di tempo. Il numero di intervalli che si vogliono
+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.
dati per la misure dei tempi all'interno del sistema: essi sono
rispettivamente chiamati \textit{calendar time} e \textit{process time},
secondo le definizioni:
-\begin{description}
-\item[\textit{calendar time}]: detto anche \textsl{tempo di calendario}. È il
+\begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
+\item[\textit{calendar time}] detto anche \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
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}.
-\item[\textit{process time}]: detto talvolta \textsl{tempo di processore}.
+\item[\textit{process time}] detto talvolta \textsl{tempo di processore}.
Viene misurato in \textit{clock tick}. Un tempo questo corrispondeva al
numero di interruzioni effettuate dal timer di sistema, adesso lo standard
POSIX richiede che esso sia pari al valore della costante
- \macro{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000, qualunque
+ \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
- \secref{sec:proc_hierarchy}, è invece data dalla costante \macro{HZ}.} Il
- dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi una
- risoluzione del microsecondo. Il numero di tick al secondo può essere
- ricavato anche attraverso \func{sysconf} (vedi \secref{sec:sys_sysconf}). Il
- vecchio simbolo \macro{CLK\_TCK} definito in \file{time.h} è ormai
+ 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 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 obsoleto.
-\end{description}
+\end{basedescript}
In genere si usa il \textit{calendar time} per esprimere le date dei file e le
informazioni analoghe che riguardano i cosiddetti \textsl{tempi di orologio},
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{description*}
-\item[\textit{clock time}]: il tempo \textsl{reale} (viene chiamato anche
- \textit{wall clock time}) passato dall'avvio del processo. Chiaramente tale
- tempo dipende anche dal carico del sistema e da quanti altri processi
- stavano girando nello stesso periodo.
-\item[\textit{user time}]: il tempo che la CPU ha impiegato nell'esecuzione
- delle istruzioni del processo in user space.
-\item[\textit{system time}]: il tempo che la CPU ha impiegato nel kernel per
- eseguire delle system call per conto del processo.
-\end{description*}
+\begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
+\item[\textit{clock time}] il tempo \textsl{reale} (viene chiamato anche
+ \textit{wall clock time} o \textit{elapsed time}) passato dall'avvio del
+ processo. Chiaramente tale tempo dipende anche dal carico del sistema e da
+ 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
+ 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. È
+ 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 in cui il sistema è stato effettivamente impegnato
-nell'eseguire un certo processo e viene chiamato \textit{CPU time} o
-\textsl{tempo di CPU}.
+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
+quando si esegue un qualsiasi programma lanciando quest'ultimo come argomento
+del comando \cmd{time}.
operazione di I/O.
La funzione più semplice per leggere il \textit{process time} di un processo è
-\func{clock}, che da una valutazione approssimativa del tempo di CPU
+\funcd{clock}, che da una valutazione approssimativa del tempo di CPU
utilizzato dallo stesso; il suo prototipo è:
\begin{prototype}{time.h}{clock\_t clock(void)}
Legge il valore corrente del tempo di CPU.
La funzione restituisce il tempo in tick, quindi se si vuole il tempo in
secondi occorre moltiplicare il risultato per la costante
-\macro{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
- POSIX richiede che \macro{CLOCKS\_PER\_SEC} sia definito pari a 1000000
- indipendetemente dalla risoluzione del timer di sistema.} In genere
+\const{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
+ POSIX richiede che \const{CLOCKS\_PER\_SEC} sia definito pari a 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.
-Come accennato in \secref{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 \func{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 process time del processo corrente in una
-struttura di tipo \var{tms}, la cui definizione è riportata in
-\secref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi due,
+struttura di tipo \struct{tms}, la cui definizione è riportata in
+sez.~\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
-\secref{sec:sys_unix_time}.
+sez.~\ref{sec:sys_unix_time}.
\begin{figure}[!htb]
\footnotesize
\centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct tms {
- clock_t tms_utime; /* user time */
- clock_t tms_stime; /* system time */
- clock_t tms_cutime; /* user time of children */
- clock_t tms_cstime; /* system time of children */
-};
- \end{lstlisting}
+ \includestruct{listati/tms.h}
\end{minipage}
\normalsize
- \caption{La struttura \var{tms} dei tempi di processore associati a un
+ \caption{La struttura \structd{tms} dei tempi di processore associati a un
processo.}
\label{fig:sys_tms_struct}
\end{figure}
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} è
ritornata. Per questo motivo se un processo figlio termina prima di ricevere
-lo stato di teminazione di tutti i suoi figli, questi processi ``nipoti'' non
+lo stato di terminazione di tutti i suoi figli, questi processi ``nipoti'' non
verranno considerati nel calcolo di questi tempi.
-
\subsection{Le funzioni per il \textit{calendar time}}
\label{sec:sys_time_base}
-Come anticipato in \secref{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}, che usualmente
-corrisponde ad un tipo nativo (in Linux è un intero a 32 bit). Il valore
-corrente del \textit{calendar time}, che indicheremo come \textsl{tempo di
- sistema}, può essere ottenuto con la funzione \func{time} che lo restituisce
-in nel suddetto formato; il suo prototipo è:
+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
+con la funzione \funcd{time} che lo restituisce nel suddetto formato; il suo
+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 \macro{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 \func{stime} che serve per effettuare
-l'operazione inversa, e cioè per settare il tempo di sistema qualora questo
+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)}
- Setta a \param{t} il valore corrente del \textit{calendar time}.
+ 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 \macro{EFAULT} o \macro{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 \macro{EPERM}.
+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
-sostituite da \func{gettimeofday} e \func{settimeofday},\footnote{le due
+sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le due
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.} mentre i cui
-prototipi sono:
+ in BSD4.3 sono indicate come sostitute delle precedenti.} i cui prototipi
+sono:
\begin{functions}
\headdecl{sys/time.h}
\headdecl{time.h}
\funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
*tz)}
- Setta il tempo di sistema.
+ 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 il valori
- \macro{EINVAL} \macro{EFAULT} e per \func{settimeofday} anche
- \macro{EPERM}.}
+ 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}
-Queste funzioni utilizzano una struttura di tipo \var{timeval}, la cui
-definizione, insieme a quella della analoga \var{timespec}, è riportata in
-\figref{fig:sys_timeval_struct}. Le \acr{glibc} infatti provvedono queste due
+Queste funzioni utilizzano una struttura di tipo \struct{timeval}, la cui
+definizione, insieme a quella della analoga \struct{timespec}, è riportata in
+fig.~\ref{fig:sys_timeval_struct}. Le \acr{glibc} infatti forniscono queste due
rappresentazioni alternative del \textit{calendar time} che rispetto a
\type{time\_t} consentono rispettivamente precisioni del microsecondo e del
nanosecondo.\footnote{la precisione è solo teorica, la precisione reale della
\begin{figure}[!htb]
\footnotesize \centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct timeval
-{
- long tv_sec; /* seconds */
- long tv_usec; /* microseconds */
-};
-struct timespec {
- time_t tv_sec; /* seconds */
- long tv_nsec; /* nanoseconds */
-};
- \end{lstlisting}
+ \includestruct{listati/timeval.h}
\end{minipage}
\normalsize
- \caption{Le strutture \var{timeval} e \var{timespec} usate per una
+ \caption{Le strutture \structd{timeval} e \structd{timespec} usate per una
rappresentazione ad alta risoluzione del \textit{calendar time}.}
\label{fig:sys_timeval_struct}
\end{figure}
-Come nel caso di \func{stime} anche \func{settimeofday} (e qualunque funzione
-vada a modificare l'orologio di sistema, come quelle che tratteremo in
-seguito) può essere utilizzata solo da un processo coi privilegi di
-amministratore. Il secondo parametro di entrambe le funzioni è una struttura
-\var{timezone}, che storicamente veniva utilizzata per specificare appunto la
-\textit{timezone}, cioè l'insieme del fuso orario e delle convenzioni per
+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.
+
+Il secondo parametro 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
l'ora legale che permettevano il passaggio dal tempo universale all'ora
-locale. Questo parametro è obsoleto e in Linux non è mai stato utilizzato e
-non è supportato né dalle vecchie \textsl{libc5}, né dalle \textsl{glibc}:
-pertanto deve essere sempre settato a \macro{NULL}.
+locale. Questo parametro 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. Ad esempio se si porta
-avanti l'orologio si possono perdere delle esecuzioni di \cmd{cron}
-programmate nell'intervallo che si è saltato. Per questo motivo la modalità
-più corretta per settare l'ora è quella di usare la funzione \func{adjtime},
-il cui prototipo è:
+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 è
+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 è:
\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 \macro{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 monotonicamente crescente. Il valore di
-\param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
+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 parametro viene
usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
-effettuto.
+effettuato.
+
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/timex.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{timex} per il controllo dell'orologio di
+ sistema.}
+ \label{fig:sys_timex_struct}
+\end{figure}
-Linux poi prevede un'altra funzione, \func{adjtimex}, che consente un
-aggiustamento molto più dettagliato, permettendo ad esempio anche di
-modificare anche la velocità dell'orologio di sistema. Il suo prototipo è:
+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 è:
\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 \macro{EFAULT}, \macro{EINVAL} ed \macro{EPERM}.}
+ assumerà i valori \errval{EFAULT}, \errval{EINVAL} ed \errval{EPERM}.}
\end{prototype}
-La funzione richiede una struttura di tipo \var{timex}, la cui definizione,
+La funzione richiede una struttura di tipo \struct{timex}, la cui definizione,
così come effettuata in \file{sys/timex.h}, è riportata in
-\figref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore del
+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 \var{timex}, deve essere settato. Un
+specificato in un opportuno campo di \struct{timex}, deve essere impostato. Un
valore nullo serve per leggere i parametri correnti; i valori diversi da zero
devono essere specificati come OR binario delle costanti riportate in
-\secref{tab:sys_timex_mode}.
-
-\begin{figure}[!htb]
- \footnotesize \centering
- \begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct timex {
- unsigned int modes; /* mode selector */
- long int offset; /* time offset (usec) */
- long int freq; /* frequency offset (scaled ppm) */
- long int maxerror; /* maximum error (usec) */
- long int esterror; /* estimated error (usec) */
- int status; /* clock command/status */
- long int constant; /* pll time constant */
- long int precision; /* clock precision (usec) (read only) */
- long int tolerance; /* clock frequency tolerance (ppm) (read only) */
- struct timeval time; /* (read only) */
- long int tick; /* (modified) usecs between clock ticks */
- long int ppsfreq; /* pps frequency (scaled ppm) (ro) */
- long int jitter; /* pps jitter (us) (ro) */
- int shift; /* interval duration (s) (shift) (ro) */
- long int stabil; /* pps stability (scaled ppm) (ro) */
- long int jitcnt; /* jitter limit exceeded (ro) */
- long int calcnt; /* calibration intervals (ro) */
- long int errcnt; /* calibration errors (ro) */
- long int stbcnt; /* stability limit exceeded (ro) */
-};
- \end{lstlisting}
- \end{minipage}
- \normalsize
- \caption{La struttura \var{timex} per il controllo dell'orologio di sistema.}
- \label{fig:sys_timex_struct}
-\end{figure}
-
-La funzione utilizza il meccanismo di David L. Mills, descritto nell'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 \tabref{tab:sys_timex_mode} i
-principali valori utilizzabili per il campo \var{mode}, un elenco più
-dettagliato del significato dei vari campi della struttura \var{timex} può
-essere ritrovato in \cite{glibc}.
+sez.~\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
+\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}.
\begin{table}[htb]
\footnotesize
\centering
- \begin{tabular}[c]{|l|c| p{10cm}|}
+ \begin{tabular}[c]{|l|c|p{7cm}|}
\hline
\textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \macro{ADJ\_OFFSET} & 0x0001 & Setta la differenza fra il tempo
+ \const{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
reale e l'orologio di sistema, che
deve essere indicata in microsecondi
nel campo \var{offset} di
- \var{timex}.\\
- \macro{ADJ\_FREQUENCY} & 0x0002 & Setta la differenze in frequenza
+ \struct{timex}.\\
+ \const{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenze in frequenza
fra il tempo reale e l'orologio di
sistema, che deve essere indicata
in parti per milione nel campo
- \var{frequency} di \var{timex}.\\
- \macro{ADJ\_MAXERROR} & 0x0004 & Setta il valore massimo dell'errore
+ \var{frequency} di \struct{timex}.\\
+ \const{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo
+ dell'errore
sul tempo, espresso in microsecondi
nel campo \var{maxerror} di
- \var{timex}.\\
- \macro{ADJ\_ESTERROR} & 0x0008 & Setta la stima dell'errore
+ \struct{timex}.\\
+ \const{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
sul tempo, espresso in microsecondi
nel campo \var{esterror} di
- \var{timex}.\\
- \macro{ADJ\_STATUS} & 0x0010 & Setta alcuni
+ \struct{timex}.\\
+ \const{ADJ\_STATUS} & 0x0010 & Imposta alcuni
valori di stato interni usati dal
sistema nella gestione
dell'orologio specificati nel campo
- \var{status} di \var{timex}.\\
- \macro{ADJ\_TIMECONST} & 0x0020 & Setta la larghezza di banda del PLL
- implementato dal kernel,
+ \var{status} di \struct{timex}.\\
+ \const{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del
+ PLL implementato dal kernel,
specificato nel campo
- \var{constant} di \var{timex}.\\
- \macro{ADJ\_TICK} & 0x4000 & Setta il valore dei tick del timer
+ \var{constant} di \struct{timex}.\\
+ \const{ADJ\_TICK} & 0x4000 & Imposta il valore dei tick del timer
in microsecondi, espresso nel campo
- \var{tick} di \var{timex}.\\
- \macro{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Setta uno spostamento una tantum
+ \var{tick} di \struct{timex}.\\
+ \const{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Imposta uno spostamento una tantum
dell'orologio secondo il valore del
campo \var{offset} simulando il
comportamento di \func{adjtime}.\\
\hline
\end{tabular}
\caption{Costanti per l'assegnazione del valore del campo \var{mode} della
- struttura \var{timex}.}
+ struttura \struct{timex}.}
\label{tab:sys_timex_mode}
\end{table}
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 \macro{MOD} al posto di
-\macro{ADJ}.
+\func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
+\code{ADJ}.
\begin{table}[htb]
\footnotesize
\centering
- \begin{tabular}[c]{|l|c| p{10cm}|}
+ \begin{tabular}[c]{|l|c|l|}
\hline
\textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \macro{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
- \macro{TIME\_INS} & 1 & insert leap second.\\
- \macro{TIME\_DEL} & 2 & delete leap second.\\
- \macro{TIME\_OOP} & 3 & leap second in progress.\\
- \macro{TIME\_WAIT} & 4 & leap second has occurred.\\
- \macro{TIME\_BAD} & 5 & L'orologio non è 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.\\
\hline
\end{tabular}
\caption{Possibili valori di ritorno di \func{adjtimex}.}
La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
sistema; questo può assumere i valori riportati in
-\tabref{tab:sys_adjtimex_return}. Un valore di -1 viene usato per riportare
+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
(specificando un \var{mode} diverso da zero) senza avere i privilegi di
-amministratore si otterrà un errore di \macro{EPERM}.
+amministratore si otterrà un errore di \errcode{EPERM}.
\subsection{La gestione delle date.}
\label{sec:sys_date}
Le funzioni viste al paragrafo precedente sono molto utili per trattare le
-operazioni elementari sui tempi, però esprimere il tempo in numero di secondi,
-se ha senso per un intervallo, non è molto intuitivo quando si deve esprimere
-un'ora o una data in forma naturale. Per questo motivo esiste una ulteriore
-rappresentazione, detta \textit{broken-down time}, che permette appunto di
-\textsl{suddividere} il \textit{calendar time} in ore, minuti, secondi, ecc.
+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 è
+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
+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
+ \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
+ fig.~\ref{fig:sys_tm_struct}.}
+
+Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
+da quelle usate per convertire gli altri formati in questo, usando o meno
+l'ora locale o il tempo universale, a quelle per trasformare il valore di un
+tempo in una stringa contenente data ed ora, i loro prototipi sono:
+\begin{functions}
+ \headdecl{time.h}
+ \funcdecl{char *asctime(const struct tm *tm)}
+ Produce una stringa con data e ora partendo da un valore espresso in
+ \textit{broken-down time}.
+
+ \funcdecl{char *ctime(const time\_t *timep)}
+ Produce una stringa con data e ora partendo da un valore espresso in
+ in formato \type{time\_t}.
+
+ \funcdecl{struct tm *gmtime(const time\_t *timep)}
+ Converte il \textit{calendar time} dato in formato \type{time\_t} in un
+ \textit{broken-down time} espresso in UTC.
+ \funcdecl{struct tm *localtime(const time\_t *timep)}
+ Converte il \textit{calendar time} dato in formato \type{time\_t} in un
+ \textit{broken-down time} espresso nell'ora locale.
+
+ \funcdecl{time\_t mktime(struct tm *tm)}
+ Converte il \textit{broken-down time} in formato \type{time\_t}.
+
+ \bodydesc{Tutte le funzioni restituiscono un puntatore al risultato in caso
+ di successo e \val{NULL} in caso di errore, tranne che \func{mktime} che
+ restituisce direttamente il valore o -1 in caso di errore.}
+\end{functions}
\begin{figure}[!htb]
\footnotesize \centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct tm {
- int tm_sec; /* seconds */
- int tm_min; /* minutes */
- int tm_hour; /* hours */
- int tm_mday; /* day of the month */
- int tm_mon; /* month */
- int tm_year; /* year */
- int tm_wday; /* day of the week */
- int tm_yday; /* day in the year */
- int tm_isdst; /* daylight saving time */
-};
- \end{lstlisting}
+ \includestruct{listati/tm.h}
\end{minipage}
\normalsize
- \caption{La struttura \var{tm} .}
+ \caption{La struttura \structd{tm} per una rappresentazione del tempo in
+ termini di ora, minuti, secondi, ecc.}
\label{fig:sys_tm_struct}
\end{figure}
-Questo viene effettuato attraverso una opportuna struttura \var{tm}, la cui
-definizione è riportata in \figref{fig:sys_tm_struct}, e a questo livello
-diventa anche possibile inserire la gestione dell'ora locale.
+
+
+Le prime due funzioni, \func{asctime} e \func{ctime} servono per poter
+stampare in forma leggibile un tempo; esse restituiscono il puntatore ad una
+stringa, allocata staticamente, nella forma:
+\begin{verbatim}
+"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
+\func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
+statica rende le funzioni non rientranti POSIX.1c e SUSv2 prevedono due
+sostitute rientranti, il cui nome è al solito ottenuto appendendo un
+\code{\_r}, che prendono un secondo parametro \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
+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 rientranti (con la solita estensione \code{\_r}), che prevedono
+un secondo parametro \code{struct tm *result}, 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}
+permette di tenere conto anche della differenza fra tempo universale e ora
+locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
+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 è:
+\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.}
+\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 \file{/etc/localtime}.
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/time_zone_var.c}
+ \end{minipage}
+ \normalsize
+ \caption{Le variabili globali usate per la gestione delle \textit{time
+ zone}.}
+ \label{fig:sys_tzname}
+\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
+solare, la seconda per l'ora legale.\footnote{anche se sono indicati come
+ \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.
+
+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 è:
+\begin{prototype}{time.h}
+{size\_t strftime(char *s, size\_t max, const char *format,
+ const struct tm *tm)}
+
+Stampa il tempo \param{tm} nella stringa \param{s} secondo il formato
+\param{format}.
+
+ \bodydesc{La funzione ritorna il numero di caratteri stampati in \param{s},
+ altrimenti restituisce 0.}
+\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
+\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} è
+indefinito.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|c|l|p{6cm}|}
+ \hline
+ \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
+ \hline
+ \hline
+ \var{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
+ \var{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
+ \var{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
+ \var{\%B}&\texttt{April} & Nome del mese, completo.\\
+ \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
+ \var{\%d}&\texttt{24} & Giorno del mese.\\
+ \var{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
+ \var{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
+ \var{\%j}&\texttt{114} & Giorno dell'anno.\\
+ \var{\%m}&\texttt{04} & Mese dell'anno.\\
+ \var{\%M}&\texttt{40} & Minuto.\\
+ \var{\%p}&\texttt{PM} & AM/PM.\\
+ \var{\%S}&\texttt{50} & Secondo.\\
+ \var{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
+ domenica).\\
+ \var{\%w}&\texttt{3} & Giorno della settimana. \\
+ \var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
+ lunedì).\\
+ \var{\%x}&\texttt{04/24/02} & La data.\\
+ \var{\%X}&\texttt{18:40:50} & L'ora.\\
+ \var{\%y}&\texttt{02} & Anno nel secolo.\\
+ \var{\%Y}&\texttt{2002} & Anno.\\
+ \var{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
+ \var{\%\%}&\texttt{\%} & Il carattere \%.\\
+ \hline
+ \end{tabular}
+ \caption{Valori previsti dallo standard ANSI C per modificatore della
+ stringa di formato di \func{strftime}.}
+ \label{tab:sys_strftime_format}
+\end{table}
+
+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
+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.
+
\section{La gestione degli errori}
\label{sec:sys_errors}
-La gestione degli errori è in genere una materia complessa. Inoltre il modello
-utilizzato dai sistema unix-like è basato sull'architettura a processi, e
-presenta una serie di problemi nel caso lo si debba usare con i thread.
-Esamineremo in questa sezione le sue caratteristiche principali.
+In questa sezione esamineremo le caratteristiche principali della gestione
+degli errori in un sistema unix-like. Infatti a parte il caso particolare di
+alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
+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
+a processi, e presenta una serie di problemi nel caso lo si debba usare con i
+thread.
\subsection{La variabile \var{errno}}
\label{sec:sys_errno}
Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
-riportare condizioni di errore, ed è una buona norma di programmazione
-controllare sempre che le funzioni chiamate si siano concluse correttamente.
+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
-costante \macro{EOF} (a seconda della funzione); ma questo valore segnala solo
-che c'è stato un errore, non il tipo di errore.
+costante \val{EOF} (a seconda della funzione); ma questo valore segnala solo
+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
anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
può anche usare una macro, e questo è infatti il modo usato da Linux per
renderla locale ai singoli thread.} definita nell'header \file{errno.h}; la
-variabile è in genere definita come \ctyp{volatile} dato che può essere
-cambiata in modo asincrono da un segnale (si veda \ref{sec:sig_sigchld} per un
-esempio, ricordando quanto trattato in \ref{sec:proc_race_cond}), ma dato che
-un manipolatore di segnale scritto bene salva e ripristina il valore della
-variabile, di questo non è necessario preoccuparsi nella programmazione
+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
normale.
-I valori che può assumere \var{errno} sono riportati in \capref{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
-\macro{E} e si possono considerare come nomi riservati. In seguito faremo
+\val{E} e si possono considerare come nomi riservati. In seguito faremo
sempre riferimento a tali valori, quando descriveremo i possibili errori
restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
codice relativo ad un valore numerico con l'opzione \cmd{-l}.
-Il valore di \var{errno} viene sempre settato a zero all'avvio di un
-programma, gran parte delle funzioni di libreria settano \var{errno} ad un
+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}.
\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 è
-\func{strerror}, il cui prototipo è:
+\funcd{strerror}, il cui prototipo è:
\begin{prototype}{string.h}{char *strerror(int errnum)}
- Ritorna una stringa (statica) che descrive l'errore il cui codice è passato
- come parametro.
+ Restituisce una stringa con il messaggio di errore relativo ad
+ \param{errnum}.
+
+ \bodydesc{La funzione ritorna il puntatore ad una stringa di errore.}
\end{prototype}
-In generale \func{strerror} viene usata passando \var{errno} come parametro;
-nel caso si specifichi un codice sbagliato verrà restituito un messaggio di
-errore sconosciuto. La funzione utilizza una stringa statica che non deve
-essere modificata dal programma e che è utilizzabile solo fino ad una chiamata
-successiva a \func{strerror}; nel caso si usino i thread è
-provvista\footnote{questa funzione è una estensione GNU, non fa parte dello
- standard POSIX.} una versione apposita:
+
+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
+il valore \errval{EINVAL}.
+
+In generale \func{strerror} viene usata passando \var{errno} come parametro,
+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
+\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 rientrante, per cui nel caso nel caso si usino i thread le librerie
+forniscono\footnote{questa 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 rientrante \func{strerror\_r}, il cui
+prototipo è:
\begin{prototype}{string.h}
-{char *strerror\_r(int errnum, char *buff, size\_t size)}
- Analoga a \func{strerror} ma ritorna il messaggio in un buffer
- specificato da \param{buff} di lunghezza massima (compreso il terminatore)
- \param{size}.
+ {char * strerror\_r(int errnum, char *buf, size\_t size)}
+
+ Restituisce una stringa con il messaggio di errore relativo ad
+ \param{errnum}.
+
+ \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:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] si è specificato un valore di \param{errnum} non
+ valido.
+ \item[\errcode{ERANGE}] la lunghezza di \param{buf} è insufficiente a
+ contenere la stringa di errore.
+ \end{errlist}}
\end{prototype}
\noindent
-che utilizza un buffer che il singolo thread deve allocare, per evitare i
-problemi connessi alla condivisione del buffer statico. Infine, per completare
-la caratterizzazione dell'errore, si può usare anche la variabile
-globale\footnote{anche questa è un'estensione GNU.}
-\var{program\_invocation\_short\_name} che riporta il nome del programma
-attualmente in esecuzione.
+
+La funzione è analoga a \func{strerror} ma restituisce la stringa di errore
+nel buffer \param{buf} che il singolo thread deve allocare autonomamente per
+evitare i problemi connessi alla condivisione 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 \secref{sec:file_std_descr}) è
-\func{perror}, il cui prototipo è:
-\begin{prototype}{stdio.h}{void perror (const char *message)}
+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 \var{message}.
+ sullo standard error; preceduto dalla stringa \param{message}.
\end{prototype}
-i messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
-in \capref{cha:errors}), e, usando il valore corrente di \var{errno}, si
+
+I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
+in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
riferiscono all'ultimo errore avvenuto. La stringa specificata con
-\var{message} viene stampato prime del messaggio d'errore, seguita dai due
+\param{message} viene stampato prima del messaggio d'errore, seguita dai due
punti e da uno spazio, il messaggio è terminato con un a capo.
-Il messaggio può essere riportato anche usando altre variabili globali
-dichiarate in \file{errno.h}:
-\begin{verbatim}
- const char *sys_errlist[];
- int sys_nerr;
-\end{verbatim}
-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 equivalente a quello di
-\func{strerror}.
-
-In \nfig\ è 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 gestione
-delle opzioni e tutte le definizioni necessarie ad associare il valore
-numerico alla costante simbolica. In particolare si è riportata la sezione che
-converte la stringa passata come parametro 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 stampa,
-a seconda dell'opzione scelta il messaggio di errore (\texttt{\small 11--14})
-o la macro (\texttt{\small 15--17}) associate a quel codice.
+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
+equivalente a quello di \func{strerror}.
\begin{figure}[!htb]
- \footnotesize
- \begin{lstlisting}{}
- /* convert string to number */
- err = strtol(argv[optind], NULL, 10);
- /* testing error condition on conversion */
- if (err==LONG_MIN) {
- perror("Underflow on error code");
- return 1;
- } else if (err==LONG_MIN) {
- perror("Overflow on error code");
- return 1;
- }
- /* conversion is fine */
- if (message) {
- printf("Error message for %d is %s\n", err, strerror(err));
- }
- if (label) {
- printf("Error label for %d is %s\n", err, err_code[err]);
- }
- \end{lstlisting}
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/errcode_mess.c}
+ \end{minipage}
+ \normalsize
\caption{Codice per la stampa del messaggio di errore standard.}
\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
+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
+gestione delle opzioni e tutte le definizioni necessarie ad associare il
+valore numerico alla costante simbolica. In particolare si è riportata la
+sezione che converte la stringa passata come parametro 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
+stampa, a seconda dell'opzione scelta il messaggio di errore (\texttt{\small
+ 11--14}) o la macro (\texttt{\small 15--17}) associate a quel codice.
+
+
+
+\subsection{Alcune estensioni GNU}
+\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.
+
+La prima estensione consiste in due variabili, \code{char *
+ program\_invocation\_name} e \code{char * program\_invocation\_short\_name}
+servono per ricavare il nome del programma; queste sono utili quando si deve
+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
+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ò
+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
+qualche variabile; per questo le \acr{glibc} definiscono la funzione
+\funcd{error}, il cui prototipo è:
+\begin{prototype}{stdio.h}
+{void error(int status, int errnum, const char *format, ...)}
+
+Stampa un messaggio di errore formattato.
+
+\bodydesc{La funzione non restituisce nulla e non riporta errori.}
+\end{prototype}
+
+La funzione fa parte delle estensioni GNU per la gestione degli errori,
+l'argomento \param{format} prende la stessa sintassi di \func{printf}, ed i
+relativi parametri devono essere forniti allo stesso modo, mentre
+\param{errnum} indica l'errore che si vuole segnalare (non viene quindi usato
+il valore corrente di \var{errno}); la funzione stampa sullo standard error il
+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
+da un a capo.
+
+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
+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
+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 è:
+\begin{prototype}{stdio.h}
+{void error\_at\_line(int status, int errnum, const char *fname,
+ unsigned int lineno, const char *format, ...)}
+
+Stampa un messaggio di errore formattato.
+
+\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
+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,
+\var{error\_one\_per\_line}, che impostata ad un valore diverso da zero fa si
+che errori relativi alla stessa linea non vengano ripetuti.
+
+
%%% Local Variables:
projects / gapil.git / blobdiff