%% system.tex
%%
-%% Copyright (C) 2000-2002 Simone Piccardi. Permission is granted to
+%% Copyright (C) 2000-2003 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",
%% license is included in the section entitled "GNU Free Documentation
%% License".
%%
-\chapter{La gestione del sistema, delle risorse, e degli errori}
+\chapter{La gestione del sistema, del tempo e degli errori}
\label{cha:system}
In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
\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 del gruppo degli
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
\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}
\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
+ \const{TZNAME\_MAX}& 6& dimensione massima del nome di una
\texttt{timezone} (vedi
\secref{sec:sys_time_base})).\\
- \macro{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
+ \const{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{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
\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
+ \const{\_POSIX\_TZNAME\_MAX} & & dimensione massima del nome di una
\texttt{timezone} (vedi
\secref{sec:sys_date}). \\
- \macro{\_POSIX\_NGROUPS\_MAX}& 0& numero di gruppi supplementari per
+ \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
+ \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}
gruppo \textit{saved} (vedi
\secref{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
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}.
\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}&
+ \texttt{\_SC\_TZNAME\_MAX}&\const{TZNAME\_MAX}&
La dimensione massima di un nome di una \texttt{timezone} (vedi
\secref{sec:sys_date}).\\
- \texttt{\_SC\_NGROUPS\_MAX}&\macro{NGROUP\_MAX}&
+ \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}&
+ \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}).\\
\texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
\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} &
+ \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}.
\footnotesize
\begin{tabular}[c]{|l|r|l|}
\hline
- \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{LINK\_MAX} &8 & numero massimo di link a un file\\
- \macro{NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
- \macro{PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
- \macro{PIPE\_BUF}&4096 & byte scrivibili atomicamente in una pipe
+ \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 \secref{sec:ipc_pipes}).\\
- \macro{MAX\_CANON}&255 & dimensione di una riga di terminale in modo
+ \const{MAX\_CANON}&255 & dimensione di una riga di terminale in modo
canonico (vedi \secref{sec:term_design}).\\
- \macro{MAX\_INPUT}&255 & spazio disponibile nella coda di input
+ \const{MAX\_INPUT}&255 & spazio disponibile nella coda di input
del terminale (vedi \secref{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}
\textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{\_POSIX\_LINK\_MAX} &8 & numero massimo di link a un file.\\
- \macro{\_POSIX\_NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
- \macro{\_POSIX\_PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
- \macro{\_POSIX\_PIPE\_BUF}& 512 & byte scrivibili atomicamente in una
+ \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.\\
- \macro{\_POSIX\_MAX\_CANON}&255 & dimensione di una riga di
+ \const{\_POSIX\_MAX\_CANON}&255 & dimensione di una riga di
terminale in modo canonico.\\
- \macro{\_POSIX\_MAX\_INPUT}&255 & spazio disponibile nella coda di input
+ \const{\_POSIX\_MAX\_INPUT}&255 & spazio disponibile nella coda di input
del terminale.\\
-% \macro{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
-% \macro{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
-% \macro{\_POSIX\_FD\_SETSIZE}& 16 & \\
-% \macro{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
+% \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}.
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} assumerà il valore \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
\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}
-o \macro{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.}
+\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}
\label{sec:sys_sysctl}
La funzione che permette la lettura ed l'impostazione dei parametri del
-sistema è \func{sysctl}; è una funzione derivata da BSD4.4, ma
+sistema è \funcd{sysctl}; è una funzione derivata da BSD4.4, ma
l'implementazione è specifica di Linux; il suo prototipo è:
\begin{functions}
\headdecl{unistd.h}
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{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[\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
+% \item[\errcode{EFAULT}] si è specificato \param{oldlenp} zero quando
% \param{oldval} è non nullo.
- \item[\macro{EINVAL}] o si è specificato un valore non valido per il
+ \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 \macro{EFAULT}.
+ ed inoltre \errval{EFAULT}.
}
\end{functions}
I parametri a cui la funzione permettere di accedere sono organizzati in
-maniera gerarchica all'interno un albero;\footnote{si tenga presente che
+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
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 è
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
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},
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 impostati con un OR aritmetico della costante \macro{MS\_MGC\_VAL} con i
+vanno impostati con un OR aritmetico della costante \const{MS\_MGC\_VAL} con i
valori riportati in \tabref{tab:sys_mount_flags}.
\begin{table}[htb]
\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
+ \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
\secref{sec:file_mand_locking})\\
- \macro{S\_WRITE} & 128 & scrive normalmente \\
- \macro{S\_APPEND} & 256 & consente la scrittura solo in \textit{append
+ \const{S\_WRITE} & 128 & scrive normalmente \\
+ \const{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
+ \const{S\_IMMUTABLE} & 512 & impedisce che si possano modificare i file \\
+ \const{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\_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.}
\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 impostato 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} 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)}
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
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 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 \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 \figref{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 \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.
+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 \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 particolare quelle
relative a \file{/etc/mtab}), quando si debba scrivere un programma che
\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:
+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}
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}) è
+tipo \struct{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.
\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}
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 impostato 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}
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
+\figref{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}
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
+libreria. Queste sono analoghe alle precedenti funzioni (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.
-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
sono:
\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
+\item[\const{\_PATH\_UTMP}] Specifica il database di accounting per gli utenti
correntemente collegati.
-\item[\macro{\_PATH\_WTMP}] Specifica il database di accounting per l'archivio
+\item[\const{\_PATH\_WTMP}] Specifica il database di accounting 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 database di \textit{accounting}.}
+ \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 *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.}
+
+ \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
+Tutte queste funzioni fanno riferimento ad una struttura di tipo \struct{utmp},
+la cui definizione in Linux è riportata in \figref{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}
-
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},
+\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à restituita la prima voce
+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]
\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
\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
**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 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.}
\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}.
Come abbiamo accennato in \secref{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
+di tipo \struct{rusage}, la cui definizione (che si trova in
\file{sys/resource.h}) è riportata in \figref{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.
+La definizione della struttura in \figref{fig:sys_rusage_struct} è 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\index{memoria virtuale} e corrispondono rispettivamente al numero di
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}.
+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
+\struct{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 è:
+Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
+visto in \secref{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.
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
+struttura \struct{rlimit}, la cui definizione è riportata in
\figref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a limite
-corrente e massimo.
-
-\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}
- \end{minipage}
- \normalsize
- \caption{La struttura \var{rlimit} per impostare i limiti di utilizzo
- delle risorse usate da un processo.}
- \label{fig:sys_rlimit_struct}
-\end{figure}
+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
-impostare i limiti di utilizzo delle risorse da parte di un processo le
-\acr{glibc} prevedono due funzioni, \func{getrlimit} e \func{setrlimit}, i cui
+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}
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EINVAL}] 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.
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/rlimit.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
+ delle risorse usate da un processo.}
+ \label{fig:sys_rlimit_struct}
+\end{figure}
+
+
+
+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 \secref{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
+ \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
+ \secref{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. \\
\end{table}
\footnotetext{Impostare questo limite a zero è la maniera più semplice per
- evitare la creazione di \file{core} file.}
+ evitare la creazione di \file{core} file (al proposito si veda
+ \secref{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}).
+mantenuti per gli altri programmi eseguiti attraverso una \func{exec} (vedi
+\secref{sec:proc_exec}).
\subsection{Le risorse di memoria e processore}
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
+In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
casi, come per l'I/O mappato in memoria (vedi \secref{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 \code{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.
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.
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
+ \secref{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 \secref{sec:sys_sysconf}). Il
- vecchio simbolo \macro{CLK\_TCK} definito in \file{time.h} è ormai
+ vecchio simbolo \const{CLK\_TCK} definito in \file{time.h} è ormai
considerato obsoleto.
\end{description}
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*}
+\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.
+ \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 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*}
+\end{description}
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
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
+\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
Come accennato in \secref{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
+struttura di tipo \struct{tms}, la cui definizione è riportata in
\secref{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
\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}
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} è
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
+Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
sia necessario; il suo prototipo è:
\begin{prototype}{time.h}{int stime(time\_t *t)}
Imposta a \param{t} il valore corrente del \textit{calendar time}.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
- che può essere \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.} i cui prototipi
\bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
caso di errore, nel qual caso \var{errno} può assumere i valori
- \macro{EINVAL} \macro{EFAULT} e per \func{settimeofday} anche
- \macro{EPERM}.}
+ \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
+Queste funzioni utilizzano una struttura di tipo \struct{timeval}, la cui
+definizione, insieme a quella della analoga \struct{timespec}, è riportata in
\figref{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
\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{time zone}, 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 impostato 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. 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
+conseguenze indesiderate. 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 impostare l'ora è quella
-di usare la funzione \func{adjtime}, il cui prototipo è:
+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
usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
effettuato.
-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 è:
+
+\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, 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
campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
-specificato in un opportuno campo di \var{timex}, deve essere impostato. 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}.
+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 \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 \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{9cm}|}
\hline
\textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \macro{ADJ\_OFFSET} & 0x0001 & Imposta 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 & Imposta 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 & Imposta 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 & Imposta 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 & Imposta 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 & Imposta 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 & Imposta 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&Imposta 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
\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}.}
\tabref{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.}
time}, che permette appunto di \textsl{suddividere} il \textit{calendar
time} usuale in ore, minuti, secondi, ecc.
-\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 */
- long int tm_gmtoff; /* Seconds east of UTC. */
- cost char *tm_zone; /* Timezone abbreviation. */
-};
- \end{lstlisting}
- \end{minipage}
- \normalsize
- \caption{La struttura \var{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
+Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
definizione è riportata in \figref{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
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 \macro{NULL} in caso di errore, tranne che \func{mktime} che
+ 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}
+ \includestruct{listati/tm.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{tm} per una rappresentazione del tempo in
+ termini di ora, minuti, secondi, ecc.}
+ \label{fig:sys_tm_struct}
+\end{figure}
+
+
+
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
+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
(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 \var{tm} e
+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.
variabili globali mostrate in \figref{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 \func{tzset}, il cui prototipo è:
+funzione \funcd{tzset}, il cui prototipo è:
\begin{prototype}{sys/timex.h}
{void tzset(void)}
\end{prototype}
La funzione inizializza le variabili di \figref{fig:sys_tzname} a partire dal
-valore della variabile di ambiente \macro{TZ}, se quest'ultima non è definita
+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}
- \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-extern char *tzname[2];
-extern long timezone;
-extern int daylight;
- \end{lstlisting}
+ \includestruct{listati/time_zone_var.c}
\end{minipage}
\normalsize
\caption{Le variabili globali usate per la gestione delle \textit{time
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
-gionrno) di un tempo si può ricorrere alla più sofisticata \func{strftime}, il
-cui prototipo è:
+giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
+il cui prototipo è:
\begin{prototype}{time.h}
{size\_t strftime(char *s, size\_t max, const char *format,
const struct tm *tm)}
\param{format}.
\bodydesc{La funzione ritorna il numero di caratteri stampati in \param{s},
- altrimenti restuisce 0.}
+ altrimenti restituisce 0.}
\end{prototype}
La funzione converte opportunamente il tempo \param{tm} in una stringa di
\textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
\hline
\hline
- \macro{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
- \macro{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
- \macro{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
- \macro{\%B}&\texttt{April} & Nome del mese, completo.\\
- \macro{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
- \macro{\%d}&\texttt{24} & Giorno del mese.\\
- \macro{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
- \macro{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
- \macro{\%j}&\texttt{114} & Giorno dell'anno.\\
- \macro{\%m}&\texttt{04} & Mese dell'anno.\\
- \macro{\%M}&\texttt{40} & Minuto.\\
- \macro{\%p}&\texttt{PM} & AM/PM.\\
- \macro{\%S}&\texttt{50} & Secondo.\\
- \macro{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
- domenica).\\
- \macro{\%w}&\texttt{3} & Giorno della settimana. \\
- \macro{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
- lunedì).\\
- \macro{\%x}&\texttt{04/24/02} & La data.\\
- \macro{\%X}&\texttt{18:40:50} & L'ora.\\
- \macro{\%y}&\texttt{02} & Anno nel secolo.\\
- \macro{\%Y}&\texttt{2002} & Anno.\\
- \macro{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
- \macro{\%\%}&\texttt{\%} & Il carattere \%.\\
+ \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
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 ripotati in
+ della funzione.} dei possibili valori che esso può assumere sono riportati in
\tabref{tab:sys_strftime_format}. La funzione tiene conto anche della presenza
di una localizzazione per stampare in maniera adeguata i vari nomi.
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 \secref{sec:sig_sigchld} per
+un esempio, ricordando quanto trattato in \secref{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},
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}.
\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)}
Restituisce una stringa con il messaggio di errore relativo ad
\param{errnum}.
- \bodydesc{La funzione ritorna il puntatore alla stringa col messaggio di
- errore in caso di successo e \macro{NULL} in caso di errore, nel qual caso
- \var{errno} assumerà il valore \macro{EINVAL} se si è specificato un
- numero di errore non valido.}
+ \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, e la funzione restituirà come errore \macro{EINVAL}. La
-funzione tiene conto del valore della variabile di ambiente
-\macro{LC\_MESSAGES} per usare eventuali traduzioni dei messaggi d'errore
-nella localizzazione presente.
+
+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 e che è utilizzabile solo fino ad una chiamata successiva a
-\func{strerror}; per questo motivo non è rientrante e nel caso si usino i
-thread è provvista\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 versione apposita:
+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 *buf, size\_t size)}
- Analoga a \func{strerror} ma usa il buffer \param{buf} di lunghezza massima
- (compreso il terminatore) \param{size}.
-
- \bodydesc{La funzione restituisce il puntatore alla stringa; in caso di
- errore \var{errno} oltre a \macro{EINVAL} può assumere anche il valore
- \macro{ERANGE} per indicare che non c'è sufficiente memoria per contenere
- la stringa di descrizione.}
+ 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. La funzione
-restituisce l'indirizzo della stringa usata, che può essere contenuta nel
-buffer specificato da \param{buf}, per una lunghezza non superiore a
-\param{size}, nel qual caso la stringa sarebbe troncata e terminata con
-\macro{NUL}.
+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 è:
+\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
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}.
+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}
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
-\func{error}, il cui prototipo è:
+\funcd{error}, il cui prototipo è:
\begin{prototype}{stdio.h}
{void error(int status, int errnum, const char *format, ...)}
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, è
-\func{error\_at\_line}, che prende due argomenti aggiuntivi per indicare linea
-e file su cui è avvenuto l'errore; il suo prototipo è:
+Un'altra funzione per la stampa degli errori, ancora più sofisticata, che
+prende due argomenti aggiuntivi per indicare linea e file su cui è avvenuto
+l'errore è \funcd{error\_at\_line}; il suo prototipo è:
\begin{prototype}{stdio.h}
{void error\_at\_line(int status, int errnum, const char *fname,
unsigned int lineno, const char *format, ...)}
projects / gapil.git / blobdiff