+\subsection{Il database di accounting}
+\label{sec:sys_accounting}
+
+L'ultimo insieme di funzioni relative alla gestione del sistema che
+esamineremo è quello che permette di accedere ai dati del database di
+\textit{accounting}. In esso vengono mantenute una serie di informazioni
+storiche relative sia agli utenti che si sono collegati al sistema, (tanto per
+quelli correntemente collegati, che per la registrazione degli accessi
+precedenti), sia relative all'intero sistema, come il momento di lancio di
+processi da parte di \cmd{init}, il cambiamento dell'orologio di sistema, il
+cambiamento di runlevel o il riavvio della macchina.
+
+I dati vengono usualmente\footnote{questa è la locazione specificata dal
+ \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
+ delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
+\file{/var/log/wtmp}. Quando un utente si collega viene aggiunta una voce a
+\file{/var/run/utmp} in cui viene memorizzato il nome di login, il terminale
+da cui ci si collega, l'\acr{uid} della shell di login, l'orario della
+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}.
+
+Questi file non devono mai essere letti direttamente, ma le informazioni che
+contengono possono essere ricavate attraverso le opportune funzioni di
+libreria. Queste sono analoghe alle precedenti (vedi
+\tabref{tab:sys_passwd_func}) usate per accedere al database degli utenti,
+solo che in questo caso la struttura del database di accounting è molto più
+complessa, dato che contiene diversi tipi di informazione.
+
+Le prime tre funzioni, \func{setutent}, \func{endutent} e \func{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:
+\begin{functions}
+ \headdecl{utmp.h}
+
+ \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
+ database di \textit{accounting}.
+
+ \funcdecl{void setutent(void)} Apre il file del database di
+ \textit{accounting}, posizionandosi al suo inizio.
+
+ \funcdecl{void endutent(void)} Chiude il file del database di
+ \textit{accounting}.
+
+ \bodydesc{Le funzioni non ritornano codici di errore.}
+\end{functions}
+
+In caso questo non venga specificato nessun file viene usato il valore
+standard \macro{\_PATH\_UTMP} (che è definito in \file{paths.h}); in genere
+\func{utmpname} prevede due possibili valori:
+\begin{basedescript}{\desclabelwidth{2.0cm}}
+\item[\macro{\_PATH\_UTMP}] Specifica il database di accounting per gli utenti
+ correntemente collegati.
+\item[\macro{\_PATH\_WTMP}] Specifica il database di accounting per l'archivio
+ storico degli utenti collegati.
+\end{basedescript}
+corrispondenti ai file \file{/var/run/utmp} e \file{/var/log/wtmp} visti in
+precedenza.
+
+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:
+\begin{functions}
+ \headdecl{utmp.h}
+
+ \funcdecl{struct utmp *getutent(void)}
+ Legge una voce dal dalla posizione corrente nel database.
+
+ \funcdecl{struct utmp *getutid(struct utmp *ut)}
+ Ricerca una voce sul database in base al contenuto di \param{ut}.
+
+ \funcdecl{struct utmp *getutline(struct utmp *ut)}
+ Ricerca nel database la prima voce corrispondente ad un processo sulla linea
+ di terminale specificata tramite \param{ut}.
+
+ \funcdecl{struct utmp *pututline(struct utmp *ut)}
+ Scrive una voce nel database.
+
+ \bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
+ caso di successo e \macro{NULL} in caso di errore.}
+\end{functions}
+
+Tutte queste funzioni fanno riferimento ad una struttura di tipo \var{utmp},
+la cui definizione in Linux è riportata in \secref{fig:sys_utmp_struct}. Le
+prime tre funzioni servono per leggere una voce dal database; \func{getutent}
+legge semplicemente la prima voce disponibile; le altre due permettono di
+eseguire una ricerca.
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{15cm}
+ \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
+struct utmp
+{
+ short int ut_type; /* Type of login. */
+ pid_t ut_pid; /* Process ID of login process. */
+ char ut_line[UT_LINESIZE]; /* Devicename. */
+ char ut_id[4]; /* Inittab ID. */
+ char ut_user[UT_NAMESIZE]; /* Username. */
+ char ut_host[UT_HOSTSIZE]; /* Hostname for remote login. */
+ struct exit_status ut_exit; /* Exit status of a process marked
+ as DEAD_PROCESS. */
+ long int ut_session; /* Session ID, used for windowing. */
+ struct timeval ut_tv; /* Time entry was made. */
+ int32_t ut_addr_v6[4]; /* Internet address of remote host. */
+ char __unused[20]; /* Reserved for future use. */
+};
+ \end{lstlisting}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \var{utmp} contenente le informazioni di una voce del
+ database di \textit{accounting}.}
+ \label{fig:sys_utmp_struct}
+\end{figure}
+
+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},
+verrà restituito la prima voce che corrisponde al tipo determinato; quando
+invece assume i valori \macro{INIT\_PROCESS}, \macro{LOGIN\_PROCESS},
+\macro{USER\_PROCESS} o \macro{DEAD\_PROCESS} verrà restiuita la prima voce
+corripondente al valore del campo \var{ut\_id} specificato in \param{ut}.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Funzione} & \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
+ sistema. \\
+ \macro{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} & ??? \\
+ \hline
+ \end{tabular}
+ \caption{Classificazione delle voci del database di accounting a seconda dei
+ possibili valori del campo \var{ut\_type}.}
+ \label{tab:sys_ut_type}
+\end{table}
+
+La funzione \func{getutline} esegue la ricerca sulle voci che hanno
+\var{ut\_type} uguale a \macro{LOGIN\_PROCESS} o \macro{USER\_PROCESS},
+restituendo la prima che corrisponde al valore di \var{ut\_line}, che
+specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
+terminale che interessa. Lo stesso criterio di ricerca è usato da
+\func{pututline} per trovare uno spazio dove inserire la voce specificata,
+qualora non sia trovata la voce viene aggiunta in coda al database.
+
+In generale occorre però tenere conto che queste funzioni non sono
+completamente standardizzate, e che in sistemi diversi possono esserci
+differenze; ad esempio \func{pututline} restituisce \code{void} in vari
+sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
+fornita dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
+introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
+sono un sovrainsieme di \code{utmp}.
+
+Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
+inutili queste nuove strutture; pertanto esse e le relative funzioni di
+gestione (\func{getutxent}, \func{getutxid}, \func{getutxline},
+\func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
+sinonimi delle funzioni appena viste.
+
+Come visto in \secref{sec:sys_user_group}, l'uso di strutture allocate
+staticamente rende le funzioni di lettura non rientranti; per questo motivo le
+\acr{glibc} forniscono anche delle versioni rientranti: \func{getutent\_r},
+\func{getutid\_r}, \func{getutline\_r}, che invece di restituire un puntatore
+restituiscono un intero e prendono due argomenti aggiuntivi. Le funzioni si
+comportano esattamente come le analoge non rientranti, solo che restituiscono
+il risultato all'indirizzo specificato dal primo argomento aggiuntivo (di tipo
+\code{struct utmp *buffer}) mentre il secondo (di tipo \code{struct utmp
+ **result)} viene usato per restituire il puntatore allo stesso buffer.
+
+Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
+in \file{wmtp} altre due funzioni, \func{updwtmp} e \func{logwtmp}, i cui
+prototipi sono:
+\begin{functions}
+ \headdecl{utmp.h}
+
+ \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
+ Aggiunge la voce \param{ut} nel database di accounting \file{wmtp}.
+
+ \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
+argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
+poi aggiunge chiamando \func{updwtmp}.
+
+
+\section{Limitazione ed uso delle risorse}
+\label{sec:sys_res_limits}
+
+
+Dopo aver esaminato le funzioni che permettono di controllare le varie
+caratteristiche, capacità e limiti del sistema a livello globale, in questa
+sezione tratteremo le varie funzioni che vengono usate per quantificare le
+risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
+permettono di imporre a ciascuno di essi vincoli e limiti di utilizzo.
+
+
+\subsection{L'uso delle risorse}
+\label{sec:sys_resource_use}
+
+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
+\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}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \var{rusage} per la lettura delle informazioni dei
+ delle risorse usate da un processo.}
+ \label{fig:sys_rusage_struct}
+\end{figure}
+
+La struttura è ripresa da BSD 4.3, ma attualmente (con i kernel della serie
+2.4.x) i soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
+\var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I primi due indicano
+rispettivamente il tempo impiegato dal processo nell'eseguire le istruzioni in
+user space, e quello impiegato dal kernel nelle system call eseguite per conto
+del processo.
+
+Gli altri tre campi servono a quantificare l'uso della memoria virtuale e
+corrispondono rispettivamente al numero di \textit{page fault}\index{page
+ fault} (vedi \secref{sec:proc_mem_gen}) avvenuti senza richiedere I/O (i
+cosiddetti \textit{minor page fault}), a quelli che invece han richiesto I/O
+(detti invece \textit{major page fault}) ed al numero di volte che il processo
+è stato completamente tolto dalla memoria per essere inserito nello swap.
+
+In genere includere esplicitamente \file{<sys/time.h>} non è più necessario,
+ma aumenta la portabilità, e serve comunque quando, come nella maggior parte
+dei casi, si debba accedere ai campi di \var{rusage} relativi ai tempi di
+utilizzo del processore, che sono definiti come \code{struct }\type{timeval}.
+
+
+Questa è la stessa struttura utilizzata da \func{wait4} per ricavare la
+quantità di risorse impiegato dal processo di cui si è letto lo stato di
+terminazione, ma essa può anche essere letta direttamente utilizzando la
+funzione \func{getrusage}, il cui prototipo è:
+\begin{functions}
+ \headdecl{sys/time.h}
+ \headdecl{sys/resource.h}
+ \headdecl{unistd.h}
+
+ \funcdecl{int getrusage(int who, struct rusage *usage)}
+ Legge la quantità di risorse usate da un processo.
+
+
+ \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}.}
+\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 è
+ricevuto lo stato di terminazione.
+
+
+\subsection{Limiti sulle risorse}
+\label{sec:sys_resource_limit}
+
+Come accennato nell'introduzione oltre a leggere l'uso delle risorse da parte
+di un processo si possono anche imporre dei limiti sulle sue capacità. Ogni
+processo ha in generale due limiti associati ad ogni risorsa; questi sono
+detti il \textsl{limite corrente} (o \textit{current limit}) che esprime il
+valore che attualmente il processo non può superare, ed il \textsl{limite
+ massimo} (o \textit{maximum limit}) che esprime il valore massimo che può
+assumere il \textsl{limite corrente}.
+
+In generale il primo viene chiamato un limite \textsl{soffice} (o \textit{soft
+ limit}) dato che il suo valore può essere aumentato, mentre il secondo è
+detto \textsl{duro} (o \textit{hard limit}), in quanto un processo normale non
+può modificarne il valore. Il valore di questi limiti è mantenuto in una
+struttura \var{rlimit}, la cui definizione è riportata in
+\figref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a limite
+corrente e massimo.
+
+\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}
+
+In genere il superamento di un limite comporta o l'emissione di un segnale o
+il fallimento della system call che lo ha provocato; per far leggere o settare
+i limiti di utilizzo delle risorse da parte di un processo le \acr{glibc}
+prevedono due funzioni, \func{getrlimit} e \func{setrlimit}, i cui prototipi
+sono:
+\begin{functions}
+ \headdecl{sys/time.h}
+ \headdecl{sys/resource.h}
+ \headdecl{unistd.h}
+
+ \funcdecl{int getrlimit(int resource, struct rlimit *rlim)}
+
+ Legge il limite corrente per la risorsa \param{resource}.
+
+ \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)}
+
+ Setta il limite per la risorsa \param{resource}.
+
+ \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
+ errore, nel qual caso \var{errno} viene settata ai valori:
+ \begin{errlist}
+ \item[\macro{INVAL}] I valori per \param{resource} non sono validi.
+ \item[\macro{EPERM}] Un processo senza i privilegi di amministratore ha
+ cercato di innalzare i propri limiti.
+ \end{errlist}
+ ed \macro{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{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{12cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \macro{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
+ può usare. Se il processo cerca di scrivere
+ oltre questa dimensione riceverà un segnale di
+ \macro{SIGXFSZ}.\\
+ \macro{RLIMIT\_DATA} & La massima dimensione della memoria dati di un
+ processo. Il tentatico di allocare più memoria
+ causa il fallimento della funzione di
+ allocazione. \\
+ \macro{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
+ 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
+ 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
+ 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ò
+ 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
+ processo può ottenere. Se il processo tenta di
+ allocarne di più funzioni come \func{brk},
+ \func{malloc} o \func{mmap} falliranno. \\
+ \hline
+ \end{tabular}
+ \caption{Valori possibili dell'argomento \param{resource} delle funzioni
+ \func{getrlimit} e \func{setrlimit}.}
+ \label{tab:sys_rlimit_values}
+\end{table}
+
+\footnotetext{Settare questo limite a zero è la maniera più semplice per
+ evitare la creazione di \file{core} file.}
+
+È inoltre definita la costante \macro{RLIM\_INFINITY} che permette di
+sbloccare l'uso di una risorsa, ma 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}).
+
+
+\subsection{Le risorse di memoria e processore}
+\label{sec:sys_memory_res}
+
+La gestione della memoria è già stata affrontata in dettaglio in
+\secref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
+meccanismo della memoria virtuale attraverso la divisione della memoria fisica
+in pagine.
+
+In genere questo è del tutto trasparente al singolo processo, ma in certi
+casi, come per l'I/O mappato in memoria (vedi \ref{sec:file_memory_map}) che
+usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
+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.
+
+Di solito la dimensione delle pagine di memoria è fissata dall'architettura
+hardware, per cui in genere la dimensione delle pagine di memoria era una
+costante definita in fase di compilazione, ma oggi alcune architetture (ad
+esempio su Sun Sparc) permettono di variare questa dimensione, e non volendo
+dover fornire binari diversi per ogni possibile modello, è necessario poter
+utilizzare una funzione.
+
+In genere questa dimensione può essere ottenuta attraverso una chiamata a
+\func{sysconf} come \func{sysconf(\_SC\_PAGESIZE)}, ma in BSD 4.2 è stata
+introdotta una apposita funzione, \func{getpagesize}, che restituisce la
+dimensione delle pagine di memoria; il suo prototipo è:
+\begin{prototype}{unistd.h}{int getpagesize(void)}
+ Legge le dimensioni delle pagine di memoria.
+
+ \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
+ sono previsti errori.}
+\end{prototype}
+
+La funzione è prevista in SVr4, 4.4BSD 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
+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:
+\begin{functions}
+ \headdecl{sys/sysinfo.h}
+
+ \funcdecl{long int get\_phys\_pages(void)}
+
+ Legge il numero totale di pagine di memoria disponibili per il sistema.
+
+ \funcdecl{long int get\_avphys\_pages(void)}
+
+ Legge il numero di pagine di memoria disponibili nel sistema.
+
+ \bodydesc{Le funzioni restituiscono un numero di pagine.}
+\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
+corrispondenti alla RAM della macchina; la seconda invece la memoria
+effettivamente disponibile per i processi.
+
+Le \acr{glibc} supportano inoltre, come estenzioni GNU, due funzioni che
+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}.
+
+Infine le \acr{glibc} riprendono da BSD la funzione \func{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 è:
+\begin{prototype}{stdlib.h}{int getloadavg(double loadavg[], int nelem)}
+ Legge il carico medio della macchina.
+
+ \bodydesc{La funzione ritorna il numero di elementi scritti o -1 in caso di
+ errore.}
+\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.
+
+
+
+\section{La gestione dei tempi del sistema}
+\label{sec:sys_time}
+
+In questa sezione, una volta introdotti i concetti base della gestione dei
+tempi da parte del sistema, tratteremo le varie funzioni attinenti alla
+gestione del tempo in un sistema unix-like, a partire da quelle per misurare i
+veri tempi di sistema associati ai processi, a quelle per convertire i vari
+tempi nelle differenti rappresentazioni che vengono utilizzate, a quelle della
+gestione di data e ora.
+
+
+\subsection{La misura del tempo in Unix}
+\label{sec:sys_unix_time}
+
+Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
+dati per la misure dei tempi all'interno del sistema: essi sono
+rispettivamente chiamati \textit{calendar time} e \textit{process time},
+secondo le definizioni:
+\begin{description}
+\item[\textit{calendar time}]: detto anche \textsl{tempo di calendario}. È il
+ numero di secondi dalla mezzanotte del primo gennaio 1970, in tempo
+ universale coordinato (o UTC), data che viene usualmente indicata con
+ 00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the Epoch}. Questo tempo viene
+ anche chiamato anche GMT (Greenwich Mean Time) dato che l'UTC corrisponde
+ all'ora locale di Greenwich. È il tempo su cui viene mantenuto l'orologio
+ del kernel, e viene usato ad esempio per indicare le date di modifica dei
+ file o quelle di avvio dei processi. Per memorizzare questo tempo è stato
+ riservato il tipo primitivo \type{time\_t}.
+\item[\textit{process time}]: detto talvolta \textsl{tempo di processore}.
+ Viene misurato in \textit{clock tick}. Un tempo questo corrispondeva al
+ numero di interruzioni effettuate dal timer di sistema, adesso lo standard
+ POSIX richiede che esso sia pari al valore della costante
+ \macro{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000, qualunque
+ sia la risoluzione reale dell'orologio di sistema e la frequenza delle
+ interruzioni del timer.\footnote{quest'ultima, come accennato in
+ \secref{sec:proc_hierarchy}, è invece data dalla costante \macro{HZ}.} Il
+ dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi una
+ risoluzione del microsecondo. Il numero di tick al secondo può essere
+ ricavato anche attraverso \func{sysconf} (vedi \secref{sec:sys_sysconf}). Il
+ vecchio simbolo \macro{CLK\_TCK} definito in \file{time.h} è ormai
+ considerato obsoleto.
+\end{description}
+
+In genere si usa il \textit{calendar time} per esprimere le date dei file e le
+informazioni analoghe che riguardano i cosiddetti \textsl{tempi di orologio},
+che vengono usati ad esempio per i demoni che compiono lavori amministrativi
+ad ore definite, come \cmd{cron}.
+
+Di solito questo tempo viene convertito automaticamente dal valore in UTC al
+tempo locale, utilizzando le opportune informazioni di localizzazione
+(specificate in \file{/etc/timezone}). E da tenere presente che questo tempo è
+mantenuto dal sistema e non è detto che corrisponda al tempo tenuto
+dall'orologio hardware del calcolatore.
+
+Anche il \textit{process time} di solito si esprime in secondi, ma provvede
+una precisione ovviamente superiore al \textit{calendar time} (che è mantenuto
+dal sistema con una granularità di un secondo) e viene usato per tenere conto
+dei tempi di esecuzione dei processi. Per ciascun processo il kernel calcola
+tre tempi diversi:
+\begin{description*}
+\item[\textit{clock time}]: il tempo \textsl{reale} (viene chiamato anche
+ \textit{wall clock time}) passato dall'avvio del processo. Chiaramente tale
+ tempo dipende anche dal carico del sistema e da quanti altri processi
+ stavano girando nello stesso periodo.
+\item[\textit{user time}]: il tempo che la CPU ha impiegato nell'esecuzione
+ delle istruzioni del processo in user space.
+\item[\textit{system time}]: il tempo che la CPU ha impiegato nel kernel per
+ eseguire delle system call per conto del processo.
+\end{description*}
+
+In genere la somma di \textit{user time} e \textit{system time} indica il
+tempo di processore totale in cui il sistema è stato effettivamente impegnato
+nell'eseguire un certo processo e viene chiamato \textit{CPU time} o
+\textsl{tempo di CPU}.
+
+
+
+\subsection{La gestione del \textit{process time}}
+\label{sec:sys_cpu_times}
+
+Di norma tutte le operazioni del sistema fanno sempre riferimento al
+\textit{calendar time}, l'uso del \textit{process time} è riservato a quei
+casi in cui serve conoscere i tempi di esecuzione di un processo (ad esempio
+per valutarne l'efficienza). In tal caso infatti fare ricorso al
+\textit{calendar time} è inutile in quanto il tempo può essere trascorso mentre
+un altro processo era in esecuzione o in attesa del risultato di una
+operazione di I/O.
+
+La funzione più semplice per leggere il \textit{process time} di un processo è
+\func{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.
+
+ \bodydesc{La funzione ritorna il tempo di CPU usato dal programma e -1 in
+ caso di errore.}
+\end{prototype}
+
+La funzione restituisce il tempo in tick, quindi se si vuole il tempo in
+secondi occorre moltiplicare il risultato per la costante
+\macro{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
+ POSIX richiede che \macro{CLOCKS\_PER\_SEC} sia definito pari a 1000000
+ indipendetemente dalla risoluzione del timer di sistema.} In genere
+\type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
+valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
+riprenderà lo stesso valore iniziale.
+
+Come accennato in \secref{sec:sys_unix_time} il tempo di CPU è la somma di
+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 è:
+\begin{prototype}{sys/times.h}{clock\_t times(struct tms *buf)}
+ Legge in \param{buf} il valore corrente dei tempi di processore.
+
+ \bodydesc{La funzione ritorna il numero di clock tick dall'avvio del sistema
+ in caso di successo e -1 in caso di errore.}
+\end{prototype}
+
+La funzione restituisce i valori di process time del processo corrente in una
+struttura di tipo \var{tms}, la cui definizione è riportata in
+\secref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi due,
+\var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
+\textit{system time} del processo, così come definiti in
+\secref{sec:sys_unix_time}.
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{15cm}
+ \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
+struct tms {
+ clock_t tms_utime; /* user time */
+ clock_t tms_stime; /* system time */
+ clock_t tms_cutime; /* user time of children */
+ clock_t tms_cstime; /* system time of children */
+};
+ \end{lstlisting}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \var{tms} dei tempi di processore associati a un
+ processo.}
+ \label{fig:sys_tms_struct}
+\end{figure}
+
+Gli altri due campi mantengono rispettivamente la somma dell'\textit{user
+ time} ed del \textit{system time} di tutti i processi figli che sono
+terminati; il kernel cioè somma in \var{tms\_cutime} il valore di
+\var{tms\_utime} e \var{tms\_cutime} per ciascun figlio del quale è stato
+ricevuto lo stato di terminazione, e lo stesso vale per \var{tms\_cstime}.
+
+Si tenga conto che l'aggiornamento di \var{tms\_cutime} e \var{tms\_cstime}
+viene eseguito solo quando una chiamata a \func{wait} o \func{waitpid} è
+ritornata. Per questo motivo se un processo figlio termina prima di ricevere
+lo stato di teminazione di tutti i suoi figli, questi processi ``nipoti'' non
+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 è:
+\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}.}
+\end{prototype}
+\noindent dove \param{t}, se non nullo, deve essere l'indirizzo di una
+variabile su cui duplicare il valore di ritorno.
+
+Analoga a \func{time} è la funzione \func{stime} che serve per effettuare
+l'operazione inversa, e cioè per settare il tempo di sistema qualora questo
+sia necessario; il suo prototipo è:
+\begin{prototype}{time.h}{int stime(time\_t *t)}
+ Setta a \param{t} il valore corrente del \textit{calendar time}.
+
+ \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
+ che può essere \macro{EFAULT} o \macro{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}.
+
+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
+ funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
+ \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
+ in BSD4.3 sono indicate come sostitute delle precedenti.} mentre i cui
+prototipi sono:
+\begin{functions}
+ \headdecl{sys/time.h}
+ \headdecl{time.h}
+
+ \funcdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
+
+ Legge il tempo corrente del sistema.
+
+ \funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
+ *tz)}
+
+ Setta il tempo di sistema.
+
+ \bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
+ caso di errore, nel qual caso \var{errno} può assumere il valori
+ \macro{EINVAL} \macro{EFAULT} e per \func{settimeofday} anche
+ \macro{EPERM}.}
+\end{functions}
+
+Queste funzioni utilizzano una struttura di tipo \var{timeval}, la cui
+definizione, insieme a quella della analoga \var{timespec}, è riportata in
+\figref{fig:sys_timeval_struct}. Le \acr{glibc} infatti provvedono queste due
+rappresentazioni alternative del \textit{calendar time} che rispetto a
+\type{time\_t} consentono rispettivamente precisioni del microsecondo e del
+nanosecondo.\footnote{la precisione è solo teorica, la precisione reale della
+ misura del tempo dell'orologio di sistema non dipende dall'uso di queste
+ strutture.}
+
+\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}
+ \end{minipage}
+ \normalsize
+ \caption{Le strutture \var{timeval} e \var{timespec} usate per una
+ rappresentazione ad alta risoluzione del \textit{calendar time}.}
+ \label{fig:sys_timeval_struct}
+\end{figure}
+
+Come nel caso di \func{stime} anche \func{settimeofday} (e qualunque funzione
+vada a modificare l'orologio di sistema, come quelle che tratteremo in
+seguito) può essere utilizzata solo da un processo coi privilegi di
+amministratore. Il secondo parametro di entrambe le funzioni è una struttura
+\var{timezone}, che storicamente veniva utilizzata per specificare appunto la
+\textit{timezone}, cioè l'insieme del fuso orario e delle convenzioni per
+l'ora legale che permettevano il passaggio dal tempo universale all'ora
+locale. Questo parametro è obsoleto e in Linux non è mai stato utilizzato e
+non è supportato né dalle vecchie \textsl{libc5}, né dalle \textsl{glibc}:
+pertanto deve essere sempre settato a \macro{NULL}.
+
+Modificare l'orologio di sistema con queste funzioni è comunque problematico,
+in quanto esse effettuano un cambiamento immediato. Ad esempio se si porta
+avanti l'orologio si possono perdere delle esecuzioni di \cmd{cron}
+programmate nell'intervallo che si è saltato. Per questo motivo la modalità
+più corretta per settare l'ora è quella di usare la funzione \func{adjtime},
+il cui prototipo è:
+\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}.}
+\end{prototype}
+
+Questa funzione permette di avere un aggiustamento graduale del tempo di
+sistema in modo che esso sia sempre monotonicamente crescente. Il valore di
+\param{delta} esprime il valore di cui si vuole spostare l'orologio; se è
+positivo l'orologio sarà accelerato per un certo tempo in modo da guadagnare
+il tempo richiesto, altrimenti sarà rallentato. Il secondo parametro viene
+usato, se non nullo, per ricevere il valore dell'ultimo aggiustamento
+effettuto.
+
+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{prototype}{sys/timex.h}
+{int adjtimex(struct timex *buf)}
+
+ Aggiusta del valore \param{delta} l'orologio di sistema.
+
+ \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}.}
+\end{prototype}
+
+La funzione richiede una struttura di tipo \var{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 settato. 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}.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|c| p{10cm}|}
+ \hline
+ \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \macro{ADJ\_OFFSET} & 0x0001 & Setta la differenza fra il tempo
+ reale e l'orologio di sistema, che
+ deve essere indicata in microsecondi
+ nel campo \var{offset} di
+ \var{timex}.\\
+ \macro{ADJ\_FREQUENCY} & 0x0002 & Setta la differenze in frequenza
+ fra il tempo reale e l'orologio di
+ sistema, che deve essere indicata
+ in parti per milione nel campo
+ \var{frequency} di \var{timex}.\\
+ \macro{ADJ\_MAXERROR} & 0x0004 & Setta il valore massimo dell'errore
+ sul tempo, espresso in microsecondi
+ nel campo \var{maxerror} di
+ \var{timex}.\\
+ \macro{ADJ\_ESTERROR} & 0x0008 & Setta la stima dell'errore
+ sul tempo, espresso in microsecondi
+ nel campo \var{esterror} di
+ \var{timex}.\\
+ \macro{ADJ\_STATUS} & 0x0010 & Setta alcuni
+ valori di stato interni usati dal
+ sistema nella gestione
+ dell'orologio specificati nel campo
+ \var{status} di \var{timex}.\\
+ \macro{ADJ\_TIMECONST} & 0x0020 & Setta la larghezza di banda del PLL
+ implementato dal kernel,
+ specificato nel campo
+ \var{constant} di \var{timex}.\\
+ \macro{ADJ\_TICK} & 0x4000 & Setta il valore dei tick del timer
+ in microsecondi, espresso nel campo
+ \var{tick} di \var{timex}.\\
+ \macro{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Setta uno spostamento una tantum
+ 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}.}
+ \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}.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|c| p{10cm}|}
+ \hline
+ \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \macro{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
+ \macro{TIME\_INS} & 1 & insert leap second.\\
+ \macro{TIME\_DEL} & 2 & delete leap second.\\
+ \macro{TIME\_OOP} & 3 & leap second in progress.\\
+ \macro{TIME\_WAIT} & 4 & leap second has occurred.\\
+ \macro{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
+ \hline
+ \end{tabular}
+ \caption{Possibili valori di ritorno di \func{adjtimex}.}
+ \label{tab:sys_adjtimex_return}
+\end{table}
+
+La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
+sistema; questo può assumere i valori riportati in
+\tabref{tab:sys_adjtimex_return}. Un valore di -1 viene usato per riportare
+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}.
+
+
+\subsection{La gestione delle date.}
+\label{sec:sys_date}
+
+Le funzioni viste al paragrafo precedente sono molto utili per trattare le
+operazioni elementari sui tempi, però esprimere il tempo in numero di secondi,
+se ha senso per un intervallo, non è molto intuitivo quando si deve esprimere
+un'ora o una data in forma naturale. Per questo motivo esiste una ulteriore
+rappresentazione, detta \textit{broken-down time}, che permette appunto di
+\textsl{suddividere} il \textit{calendar time} in ore, minuti, secondi, ecc.
+
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
+struct tm {
+ int tm_sec; /* seconds */
+ int tm_min; /* minutes */
+ int tm_hour; /* hours */
+ int tm_mday; /* day of the month */
+ int tm_mon; /* month */
+ int tm_year; /* year */
+ int tm_wday; /* day of the week */
+ int tm_yday; /* day in the year */
+ int tm_isdst; /* daylight saving time */
+};
+ \end{lstlisting}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \var{tm} .}
+ \label{fig:sys_tm_struct}
+\end{figure}
+
+Questo viene effettuato attraverso una opportuna struttura \var{tm}, la cui
+definizione è riportata in \figref{fig:sys_tm_struct}, e a questo livello
+diventa anche possibile inserire la gestione dell'ora locale.
+