+\item[\constd{RLIMIT\_MSGQUEUE}] Questa risorsa indica il numero massimo di
+ byte che possono essere utilizzati da un utente, identificato con
+ l'\ids{UID} reale del processo chiamante, per le code di messaggi POSIX
+ (vedi sez.~\ref{sec:ipc_posix_mq}). Per ciascuna coda che viene creata viene
+ calcolata un'occupazione pari a:
+\includecodesnip{listati/mq_occupation.c}
+dove \var{attr} è la struttura \struct{mq\_attr} (vedi
+fig.~\ref{fig:ipc_mq_attr}) usata nella creazione della coda. Il primo addendo
+consente di evitare la creazione di una coda con un numero illimitato di
+messaggi vuoti che comunque richiede delle risorse di gestione. Questa risorsa
+è stata introdotta con il kernel 2.6.8.
+
+\item[\constd{RLIMIT\_NICE}] Questa risorsa indica il numero massimo a cui può
+ essere il portato il valore di \textit{nice} (vedi
+ sez.~\ref{sec:proc_sched_stand}). Dato che non possono essere usati numeri
+ negativi per specificare un limite, il valore di \textit{nice} viene
+ calcolato come \code{20-rlim\_cur}. Questa risorsa è stata introdotta con il
+ kernel 2.6.12.
+
+\item[\constd{RLIMIT\_NOFILE}] Questa risorsa indica il numero massimo di file
+ che un processo può aprire. Il tentativo di creazione di un ulteriore file
+ descriptor farà fallire la funzione (\func{open}, \func{dup}, \func{pipe},
+ ecc.) con un errore \errcode{EMFILE}.
+
+\item[\constd{RLIMIT\_NPROC}] Questa risorsa indica il numero massimo di
+ processi che possono essere creati dallo stesso utente, che viene
+ identificato con l'\ids{UID} reale (vedi sez.~\ref{sec:proc_access_id}) del
+ processo chiamante. Se il limite viene raggiunto \func{fork} fallirà con un
+ \errcode{EAGAIN}.
+
+\item[\constd{RLIMIT\_RSS}] Questa risorsa indica, in pagine di memoria, la
+ dimensione massima della memoria residente (il cosiddetto RSS
+ \itindex{Resident~Set~Size~(RSS)} \textit{Resident Set Size}) cioè
+ l'ammontare della memoria associata al processo che risiede effettivamente
+ in RAM e non a quella eventualmente portata sulla \textit{swap} o non ancora
+ caricata dal filesystem per il segmento testo del programma. Ha effetto
+ solo sulle chiamate a \func{madvise} con \const{MADV\_WILLNEED} (vedi
+ sez.~\ref{sec:file_memory_map}). Presente solo sui i kernel precedenti il
+ 2.4.30.
+
+\item[\constd{RLIMIT\_RTPRIO}] Questa risorsa indica il valore massimo della
+ priorità statica che un processo può assegnarsi o assegnare con
+ \func{sched\_setscheduler} e \func{sched\_setparam} (vedi
+ sez.~\ref{sec:proc_real_time}). Il limite è stato introdotto a partire dal
+ kernel 2.6.12 (ma per un bug è effettivo solo a partire dal 2.6.13). In
+ precedenza solo i processi con privilegi amministrativi potevano avere una
+ priorità statica ed utilizzare una politica di \textit{scheduling} di tipo
+ \textit{real-time}.
+
+\item[\constd{RLIMIT\_RTTIME}] Questa risorsa indica, in microsecondi, il tempo
+ massimo di CPU che un processo eseguito con una priorità statica può
+ consumare. Il superamento del limite corrente comporta l'emissione di un
+ segnale di \signal{SIGXCPU}, e quello del limite massimo di \signal{SIGKILL}
+ con le stesse regole viste \const{RLIMIT\_CPU}: se \signal{SIGXCPU} viene
+ intercettato ed ignorato il segnale verrà riemesso ogni secondo fino al
+ superamento del limite massimo. Questo limite è stato introdotto con il
+ kernel 2.6.25 per impedire che un processo \textit{real-time} possa bloccare
+ il sistema.
+
+\item[\constd{RLIMIT\_SIGPENDING}] Questa risorsa indica il numero massimo di
+ segnali che possono essere mantenuti in coda per ciascun utente,
+ identificato per \ids{UID} reale. Il limite comprende sia i segnali normali
+ che quelli \textit{real-time} (vedi sez.~\ref{sec:sig_real_time}) ed è
+ attivo solo per \func{sigqueue}, con \func{kill} si potrà sempre inviare un
+ segnale che non sia già presente su una coda. Questo limite è stato
+ introdotto con il kernel 2.6.8.
+
+\item[\constd{RLIMIT\_STACK}] Questa risorsa indica, in byte, la massima
+ dimensione dello \textit{stack} del processo. Se il processo esegue
+ operazioni che estendano lo \textit{stack} oltre questa dimensione riceverà
+ un segnale di \signal{SIGSEGV}.
+
+ A partire dal kernel 2.6.23 questo stesso limite viene applicato per la gran
+ parte delle architetture anche ai dati che possono essere passati come
+ argomenti e variabili di ambiente ad un programma posto in esecuzione con
+ \func{execve}, nella misura di un quarto del valore indicato per lo
+ \textit{stack}. Questo valore in precedenza era fisso e pari a 32 pagine di
+ memoria, corrispondenti per la gran parte delle architetture a 128kb di
+ dati, dal 2.6.25, per evitare problemi di compatibilità quando
+ \const{RLIMIT\_STACK} è molto basso, viene comunque garantito uno spazio
+ base di 32 pagine qualunque sia l'architettura.
+
+\end{basedescript}
+
+Si tenga conto infine che tutti i limiti eventualmente presenti su un processo
+vengono ereditati dai figli da esso creati attraverso una \func{fork} (vedi
+sez.~\ref{sec:proc_fork}) e mantenuti invariati per i programmi messi in
+esecuzione attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
+
+Si noti come le due funzioni \func{getrlimit} e \func{setrlimit} consentano di
+operare solo sul processo corrente. Per questo motivo a partire dal kernel
+2.6.36 (e dalla \acr{glibc} 2.13) è stata introdotta un'altra funzione di
+sistema \funcd{prlimit} il cui scopo è quello di estendere e sostituire le
+precedenti. Il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{sys/resource.h}
+\fdecl{int prlimit(pid\_t pid, int resource, const struct rlimit *new\_limit,\\
+\phantom{int prlimit(}struct rlimit *old\_limit}
+\fdesc{Legge e imposta i limiti di una risorsa.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi o
+ nell'impostazione si è specificato \var{rlim->rlim\_cur} maggiore di
+ \var{rlim->rlim\_max}.
+ \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
+ cercato di innalzare i propri limiti o si è cercato di modificare i limiti
+ di un processo di un altro utente.
+ \item [\errcode{ESRCH}] il process \param{pid} non esiste.
+ \end{errlist}
+ ed inoltre \errval{EFAULT} nel suo significato generico.
+}
+\end{funcproto}
+
+La funzione è specifica di Linux e non portabile; per essere usata richiede
+che sia stata definita la macro \macro{\_GNU\_SOURCE}. Il primo argomento
+indica il \ids{PID} del processo di cui si vogliono cambiare i limiti e si può
+usare un valore nullo per indicare il processo chiamante. Per modificare i
+limiti di un altro processo, a meno di non avere privilegi
+amministrativi,\footnote{anche in questo caso la \textit{capability}
+ necessaria è \const{CAP\_SYS\_RESOURCE} (vedi
+ sez.~\ref{sec:proc_capabilities}).} l'\ids{UID} ed il \ids{GID} reale del
+chiamante devono coincidere con \ids{UID} e \ids{GID} del processo indicato
+per i tre gruppi reale, effettivo e salvato.
+
+Se \param{new\_limit} non è \val{NULL} verrà usato come puntatore alla
+struttura \struct{rlimit} contenente i valori dei nuovi limiti da impostare,
+mentre se \param{old\_limit} non è \val{NULL} verranno letti i valori correnti
+del limiti nella struttura \struct{rlimit} da esso puntata. In questo modo è
+possibile sia leggere che scrivere, anche in contemporanea, i valori dei
+limiti. Il significato dell'argomento \param{resource} resta identico rispetto
+a \func{getrlimit} e \func{setrlimit}, così come i restanti requisiti.
+
+
+\subsection{Le informazioni sulle risorse di memoria e processore}
+\label{sec:sys_memory_res}
+
+La gestione della memoria è già stata affrontata in dettaglio in
+sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
+meccanismo della memoria virtuale attraverso la divisione della memoria fisica
+in pagine. In genere tutto ciò è del tutto trasparente al singolo processo,
+ma in certi casi, come per l'I/O mappato in memoria (vedi
+sez.~\ref{sec:file_memory_map}) che usa lo stesso meccanismo per accedere ai
+file, è necessario conoscere le dimensioni delle pagine usate dal kernel. Lo
+stesso vale quando si vuole gestire in maniera ottimale l'interazione della
+memoria che si sta allocando con il meccanismo della paginazione.
+
+Un tempo la dimensione delle pagine di memoria era fissata una volta per tutte
+dall'architettura hardware, per cui il relativo valore veniva mantenuto in una
+costante che bastava utilizzare in fase di compilazione. Oggi invece molte
+architetture permettono di variare questa dimensione (ad esempio sui PC
+recenti si possono usare pagine di 4kb e di 4 Mb) per cui per non dover
+ricompilare i programmi per ogni possibile caso e relativa scelta di
+dimensioni, è necessario poter utilizzare una funzione che restituisca questi
+valori quando il programma viene eseguito.
+
+Dato che si tratta di una caratteristica generale del sistema come abbiamo
+visto in sez.~\ref{sec:sys_characteristics} questa dimensione può essere
+ottenuta come tutte le altre attraverso una chiamata a \func{sysconf}, nel
+caso specifico si dovrebbe utilizzare il parametro \const{\_SC\_PAGESIZE}. Ma
+in BSD 4.2 è stata introdotta una apposita funzione di sistema
+\funcd{getpagesize} che restituisce la dimensione delle pagine di memoria. La
+funzione è disponibile anche su Linux (ma richiede che sia definita la macro
+\macro{\_BSD\_SOURCE}) ed il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{int getpagesize(void)}
+\fdesc{Legge la dimensione delle pagine di memoria.}
+}
+
+{La funzione ritorna la dimensione di una pagina in byte, e non sono previsti
+ errori.}
+\end{funcproto}
+
+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, ed i programmi che intendono essere portabili devono ricorrere
+alla chiamata a \func{sysconf}.
+
+In Linux è implementata come una \textit{system call} nelle architetture in
+cui essa è necessaria, ed in genere restituisce il valore del simbolo
+\const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
+se le versioni delle librerie del C precedenti la \acr{glibc} 2.1
+implementavano questa funzione restituendo sempre un valore statico.
+
+% TODO verificare meglio la faccenda di const{PAGE\_SIZE}
+
+La \textsl{glibc} fornisce, come specifica estensione GNU, altre due
+funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
+di ottenere informazioni riguardo le pagine di memoria; i loro prototipi sono:
+
+\begin{funcproto}{
+\fhead{sys/sysinfo.h}
+\fdecl{long int get\_phys\_pages(void)}
+\fdesc{Legge il numero totale di pagine di memoria.}
+\fdecl{long int get\_avphys\_pages(void)}
+\fdesc{Legge il numero di pagine di memoria disponibili nel sistema.}
+}
+
+{La funzioni ritornano il numero di pagine, e non sono previsti
+ errori.}
+\end{funcproto}
+
+Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
+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.
+
+La \acr{glibc} supporta inoltre, come estensioni GNU, due funzioni che
+restituiscono il numero di processori della macchina (e quello dei processori
+attivi); anche queste sono informazioni comunque ottenibili attraverso
+\func{sysconf} utilizzando rispettivamente i parametri
+\const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
+
+Infine la \acr{glibc} riprende 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 è:
+
+\begin{funcproto}{
+\fhead{stdlib.h}
+\fdecl{int getloadavg(double loadavg[], int nelem)}
+\fdesc{Legge il carico medio della macchina.}
+}
+
+{La funzione ritorna il numero di campionamenti restituiti e $-1$ se non
+ riesce ad ottenere il carico medio, \var{errno} non viene modificata.}
+\end{funcproto}
+
+La funzione restituisce in ciascun elemento di \param{loadavg} il numero medio
+di processi attivi sulla coda dello \textit{scheduler}, calcolato su diversi
+intervalli di tempo. Il numero di intervalli che si vogliono leggere è
+specificato da \param{nelem}, dato che nel caso di Linux il carico 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.
+
+
+\subsection{La \textsl{contabilità} in stile BSD}
+\label{sec:sys_bsd_accounting}
+
+Una ultima modalità per monitorare l'uso delle risorse è, se si è compilato il
+kernel con il relativo supporto,\footnote{se cioè si è abilitata l'opzione di
+ compilazione \texttt{CONFIG\_BSD\_PROCESS\_ACCT}.} quella di attivare il
+cosiddetto \textit{BSD accounting}, che consente di registrare su file una
+serie di informazioni\footnote{contenute nella struttura \texttt{acct}
+ definita nel file \texttt{include/linux/acct.h} dei sorgenti del kernel.}
+riguardo alla \textsl{contabilità} delle risorse utilizzate da ogni processo
+che viene terminato.
+
+Linux consente di salvare la contabilità delle informazioni relative alle
+risorse utilizzate dai processi grazie alla funzione \funcd{acct}, il cui
+prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{int acct(const char *filename)}
+\fdesc{Abilita il \textit{BSD accounting}.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EACCES}] non si hanno i permessi per accedere a
+ \param{pathname}.
+ \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
+ \item[\errcode{EPERM}] il processo non ha privilegi sufficienti ad
+ abilitare il \textit{BSD accounting}.
+ \item[\errcode{EUSERS}] non sono disponibili nel kernel strutture per il
+ file o si è finita la memoria.
+ \end{errlist}
+ ed inoltre \errval{EFAULT}, \errval{EIO}, \errval{ELOOP},
+ \errval{ENAMETOOLONG}, \errval{ENFILE}, \errval{ENOENT}, \errval{ENOMEM},
+ \errval{ENOTDIR}, \errval{EROFS} nel loro significato generico.}
+\end{funcproto}
+
+La funzione attiva il salvataggio dei dati sul file indicato dal
+\textit{pathname} contenuti nella stringa puntata da \param{filename}; la
+funzione richiede che il processo abbia i privilegi di amministratore (è
+necessaria la \textit{capability} \const{CAP\_SYS\_PACCT}, vedi
+sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \val{NULL} per
+\param{filename} il \textit{BSD accounting} viene invece disabilitato. Un
+semplice esempio per l'uso di questa funzione è riportato nel programma
+\texttt{AcctCtrl.c} dei sorgenti allegati alla guida.
+
+Quando si attiva la contabilità, il file che si indica deve esistere; esso
+verrà aperto in sola scrittura e le informazioni verranno registrate in
+\textit{append} in coda al file tutte le volte che un processo termina. Le
+informazioni vengono salvate in formato binario, e corrispondono al contenuto
+della apposita struttura dati definita all'interno del kernel.
+
+Il funzionamento di \func{acct} viene inoltre modificato da uno specifico
+parametro di sistema, modificabile attraverso \sysctlfiled{kernel/acct} (o
+tramite la corrispondente \func{sysctl}). Esso contiene tre valori interi, il
+primo indica la percentuale di spazio disco libero sopra il quale viene
+ripresa una registrazione che era stata sospesa per essere scesi sotto il
+minimo indicato dal secondo valore (sempre in percentuale di spazio disco
+libero). Infine l'ultimo valore indica la frequenza in secondi con cui deve
+essere controllata detta percentuale.
+
+% TODO: bassa priorità, trattare la lettura del file di accounting, da
+% programma, vedi man 5 acct
+
+
+\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}
+
+\itindbeg{calendar~time}
+\itindbeg{process~time}
+
+Tradizionalmente nei sistemi unix-like sono sempre stati previsti due tipi
+distinti di tempi, caratterizzati da altrettante modalità di misura ed
+espressi con diversi tipi di dati, chiamati rispettivamente \textit{calendar
+ time} e \textit{process time}, secondo le seguenti definizioni:
+\begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
+
+\item[\textit{calendar time}] detto anche \textsl{tempo di calendario},
+ \textsl{tempo d'orologio} o \textit{tempo reale}. Si tratta di un tempo
+ assoluto o di un intervallo di tempo come lo intende normalmente per le
+ misure fatte con un orologio. Per esprimere questo tempo è stato riservato
+ il tipo \type{time\_t}, e viene tradizionalmente misurato nel cosiddetto
+ \itindex{unix-time} \textit{unix-time}, espresso in secondi a partire dalla
+ mezzanotte del primo gennaio 1970, data che viene chiamata \textit{the
+ Epoch}.
+
+\item[\textit{process time}] detto anche \textsl{tempo di processore} o
+ \textsl{tempo di CPU}. Si tratta del tempo impiegato da un processore
+ nell'esecuzione del codice di un programma all'interno di un processo. Per
+ esprimere questo tempo è stato riservato il tipo \type{clock\_t}, e viene
+ misurato nei cosiddetti \textit{clock tick}, tradizionalmente corrispondenti
+ al numero di interruzioni del processore da parte del timer di sistema. A
+ differenza del precedente indica soltanto un intervallo di durata.
+\end{basedescript}
+
+Il \textit{calendar time} viene sempre mantenuto facendo riferimento
+al cosiddetto \textit{tempo universale coordinato} UTC, anche se
+talvolta viene usato il cosiddetto GMT (\textit{Greenwich Mean Time})
+dato che l'UTC corrisponde all'ora locale di Greenwich. Si tratta del
+tempo su cui viene mantenuto il cosiddetto \textsl{orologio di
+ sistema}, e viene usato per indicare i tempi dei file (quelli di
+sez.~\ref{sec:file_file_times}) o le date di avvio dei processi, ed è
+il tempo che viene usato dai demoni che compiono lavori amministrativi
+ad orari definito, come \cmd{cron}.
+
+Si tenga presente che questo tempo è mantenuto dal kernel e non è detto che
+corrisponda al tempo misurato dall'orologio hardware presente su praticamente
+tutte le piastre madri dei computer moderni (il cosiddetto \textit{hardware
+ clock}), il cui valore viene gestito direttamente dall'hardware in maniera
+indipendente e viene usato dal kernel soltanto all'avvio per impostare un
+valore iniziale dell'orologio di sistema. La risoluzione tradizionale data dal
+tipo di dato \type{time\_t} è di un secondo, ma nei sistemi più recenti sono
+disponibili altri tipi di dati con precisioni maggiori.
+
+Si tenga presente inoltre che a differenza di quanto avviene con altri sistemi
+operativi,\footnote{è possibile, ancorché assolutamente sconsigliabile,
+ forzare l'orologio di sistema all'ora locale per compatibilità con quei
+ sistemi operativi che han fatto questa deprecabile scelta.} l'orologio di
+sistema viene mantenuto sempre in UTC e che la conversione all'ora locale del
+proprio fuso orario viene effettuata dalle funzioni di libreria utilizzando le
+opportune informazioni di localizzazione (specificate in
+\conffiled{/etc/timezone}). In questo modo si ha l'assicurazione che l'orologio
+di sistema misuri sempre un tempo monotono crescente come nella realtà, anche
+in presenza di cambi di fusi orari.
+
+\itindend{calendar~time}
+
+Il \textit{process time} invece indica sempre una misura di un lasso di tempo
+e viene usato per tenere conto dei tempi di esecuzione dei processi. Esso
+viene sempre diviso in \textit{user time} e \textit{system time}, per misurare
+la durata di ciascun processo il kernel infatti calcola tre tempi:
+\begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
+\item[\textit{clock time}] il tempo \textsl{reale}, viene chiamato anche
+ \textit{wall clock time} o \textit{elapsed time}, passato dall'avvio del
+ processo. Questo tempo fa riferimento al
+ \textit{calendar time} e dice la durata effettiva dell'esecuzione del
+ processo, ma chiaramente dipende dal carico del sistema e da quanti altri
+ processi stanno girando nello stesso momento.
+
+\item[\textit{user time}] il tempo effettivo che il processore ha impiegato
+ nell'esecuzione delle istruzioni del programma in \textit{user space}. È
+ anche quello riportato nella risorsa \var{ru\_utime} di \struct{rusage}
+ vista in sez.~\ref{sec:sys_resource_use}.
+
+\item[\textit{system time}] il tempo effettivo che il processore ha impiegato
+ per eseguire codice delle \textit{system call} nel kernel per conto del
+ processo. È anche quello riportato nella risorsa \var{ru\_stime} di
+ \struct{rusage} vista in sez.~\ref{sec:sys_resource_use}.
+\end{basedescript}
+
+La somma di \textit{user time} e \textit{system time} indica il
+\textit{process time}, vale a dire il tempo di processore totale che il
+sistema ha effettivamente utilizzato per eseguire il programma di un certo
+processo. Si può ottenere un riassunto dei valori di questi tempi quando si
+esegue un qualsiasi programma lanciando quest'ultimo come argomento del
+comando \cmd{time}.
+
+\itindend{process~time}
+\itindbeg{clock~tick}
+
+Come accennato il \textit{process time} viene misurato nei cosiddetti
+\textit{clock tick}. Un tempo questo corrispondeva al numero di interruzioni
+effettuate dal timer di sistema, oggi lo standard POSIX richiede che esso sia
+espresso come multiplo della costante \constd{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 che, come accennato in
+sez.~\ref{sec:proc_hierarchy} e come vedremo a breve, è invece data dalla
+costante \const{HZ}.
+
+Il tipo di dato usato per questo tempo, \type{clock\_t}, con questa
+convenzione ha una risoluzione del microsecondo. Ma non tutte le funzioni di
+sistema come vedremo seguono questa convenzione, in tal caso il numero di
+\textit{clock tick} al secondo può essere ricavato anche attraverso
+\func{sysconf} richiedendo il valore della costante \const{\_SC\_CLK\_TCK}
+(vedi sez.~\ref{sec:sys_limits}). Il vecchio simbolo \const{CLK\_TCK}
+definito in \headfile{time.h} è ormai considerato obsoleto e non deve essere
+usato.
+
+\constbeg{HZ}
+
+In realtà tutti calcoli dei tempi vengono effettuati dal kernel per il
+cosiddetto \textit{software clock}, utilizzando il \textit{timer di sistema} e
+facendo i conti in base al numero delle interruzioni generate dello stesso, i
+cosiddetti \itindex{jiffies} ``\textit{jiffies}''. La durata di un
+``\textit{jiffy}'' è determinata dalla frequenza di interruzione del timer,
+indicata in Hertz, come accennato in sez.~\ref{sec:proc_hierarchy}, dal valore
+della costante \const{HZ} del kernel, definita in \file{asm/param.h}.
+
+Fino al kernel 2.4 il valore di \const{HZ} era 100 su tutte le architetture
+tranne l'alpha, per cui era 1000. Con il 2.6.0 è stato portato a 1000 su tutte
+le architetture, ma dal 2.6.13 il valore è diventato una opzione di
+compilazione del kernel, con un default di 250 e valori possibili di 100, 250,
+1000. Dal 2.6.20 è stato aggiunto anche il valore 300 che è divisibile per le
+frequenze di refresh della televisione (50 o 60 Hz). Si può pensare che questi
+valori determinino anche la corrispondente durata dei \textit{clock tick}, ma
+in realtà questa granularità viene calcolata in maniera indipendente usando la
+costante del kernel \const{USER\_HZ}.
+
+\constend{HZ}
+
+Fino al kernel 2.6.21 la durata di un \textit{jiffy} costituiva la risoluzione
+massima ottenibile nella misura dei tempi impiegabile in una \textit{system
+ call} (ad esempio per i timeout). Con il 2.6.21 e l'introduzione degli
+\textit{high-resolution timers} (HRT) è divenuto possibile ottenere, per le
+funzioni di attesa ed i timer, la massima risoluzione possibile fornita
+dall'hardware. Torneremo su questo in sez.~\ref{sec:sig_timer_adv}.
+
+\itindend{clock~tick}
+
+
+\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 è
+\funcd{clock}, che da una valutazione approssimativa del tempo di CPU
+utilizzato dallo stesso; il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{clock\_t clock(void)}
+\fdesc{Legge il valore corrente del tempo di CPU.}
+}
+
+{La funzione ritorna il tempo di CPU in caso di successo e $-1$ se questo non
+ è ottenibile o rappresentabile in un valore di tipo \type{clock\_t},
+ \var{errno} non viene usata.}
+\end{funcproto}
+
+La funzione restituisce il tempo in \textit{clock tick} ma la \acr{glibc}
+segue lo standard POSIX e quindi se si vuole il tempo in secondi occorre
+dividere il risultato per la costante \const{CLOCKS\_PER\_SEC}. 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.
+
+La funzione è presente anche nello standard ANSI C, ma in tal caso non è
+previsto che il valore ritornato indichi un intervallo di tempo ma solo un
+valore assoluto, per questo se si vuole la massima portabilità anche al di
+fuori di kernel unix-like, può essere opportuno chiamare la funzione
+all'inizio del programma ed ottenere il valore del tempo con una differenza.
+
+Si tenga presente inoltre che con altri kernel unix-like il valore riportato
+dalla funzione può includere anche il tempo di processore usato dai processi
+figli di cui si è ricevuto lo stato di terminazione con \func{wait} e
+affini. Questo non vale per Linux, in cui questa informazione deve essere
+ottenuta separatamente.
+
+Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di processore è 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 separatamente attraverso la funzione \funcd{times}, il
+cui prototipo è:
+
+\begin{funcproto}{
+\fhead{sys/times.h}
+\fdecl{clock\_t times(struct tms *buf)}
+\fdesc{Legge il valore corrente dei tempi di processore.}
+}
+
+{La funzione ritorna un numero di \textit{clock tick} in caso di successo e
+ $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il valore
+ \errval{EFAULT} nel suo significato generico.}
+\end{funcproto}
+
+La funzione restituisce i valori di \textit{process time} del processo
+corrente in una struttura di tipo \struct{tms}, la cui definizione è riportata
+in fig.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi
+due, \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
+\textit{system time} del processo, così come definiti in
+sez.~\ref{sec:sys_unix_time}. Gli altri due campi, \var{tms\_cutime} e
+\var{tms\_cstime}, riportano la somma dell'\textit{user time} e del
+\textit{system time} di tutti processi figli di cui si è ricevuto lo stato di
+terminazione.
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{0.8\textwidth}
+ \includestruct{listati/tms.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{tms} dei tempi di processore associati a un
+ processo.}
+ \label{fig:sys_tms_struct}
+\end{figure}
+
+
+Si tenga presente che i tempi di processore dei processi figli di un processo
+vengono sempre sommati al valore corrente ogni volta che se ne riceve lo stato
+di terminazione, e detto valore è quello che viene a sua volta ottenuto dal
+processo padre. Pertanto nei campi \var{tms\_cutime} e \var{tms\_cstime} si
+sommano anche i tempi di ulteriori discendenti di cui i rispettivi genitori
+abbiano ricevuto lo stato di terminazione.
+
+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 terminazione di tutti i suoi figli, questi processi
+``\textsl{nipoti}'' non verranno considerati nel calcolo di questi tempi e
+così via per i relativi ``\textsl{discendenti}''.
+
+Come accennato in sez.~\ref{sec:sys_resource_use} per i kernel precedenti la
+versione 2.6.9 il tempo di processore dei processi figli veniva sommato
+comunque chiedendo di ignorare \signal{SIGCHLD} anche se lo standard POSIX
+richiede esplicitamente che questo avvenga solo quando si riceve lo stato di
+uscita con una funzione della famiglia delle \func{wait}, anche in questo caso
+il comportamento è stato adeguato allo standard a partire dalla versione
+2.6.9.
+
+A differenza di quanto avviene per \func{clock} i valori restituiti nei campi
+di una struttura \struct{tms} sono misurati in numero di \textit{clock tick}
+effettivi e non in multipli di \const{CLOCKS\_PER\_SEC}, pertanto per ottenere
+il valore effettivo del tempo in secondi occorrerà dividere per il risultato
+di \code{sysconf(\_SC\_CLK\_TCK)}.
+
+Lo stesso vale per il valore di ritorno della funzione, il cui significato fa
+riferimento ad un tempo relativo ad un certo punto nel passato la cui
+definizione dipende dalle diverse implementazioni, e varia anche fra diverse
+versioni del kernel. Fino al kernel 2.4 si faceva infatti riferimento al
+momento dell'avvio del kernel. Con il kernel 2.6 si fa riferimento a
+$2^{32}/\mathtt{HZ}-300$ secondi prima dell'avvio.
+
+Considerato che il numero dei \textit{clock tick} per un kernel che è attivo
+da molto tempo può eccedere le dimensioni per il tipo \type{clock\_t} il
+comportamento più opportuno per i programmi è di ignorare comunque il valore
+di ritorno della funzione e ricorrere alle funzioni per il tempo di calendario
+del prossimo paragrafo qualora si voglia calcolare il tempo effettivamente
+trascorso dall'inizio del programma.
+
+Infine si tenga presente che per dei limiti nelle convenzioni per il ritorno
+dei valori delle \textit{system call} su alcune architetture hardware (ed in
+particolare la \texttt{i386} dei PC a 32 bit) nel kernel della serie 2.6 il
+valore di ritorno della funzione può risultare erroneamente uguale a $-1$,
+indicando un errore, nei primi secondi dopo il boot (per la precisione nei
+primi 41 secondi) e se il valore del contatore eccede le dimensione del tipo
+\type{clock\_t}.
+
+
+\subsection{Le funzioni per il \textit{calendar time}}
+\label{sec:sys_time_base}
+
+\itindbeg{calendar~time}
+
+Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time}
+viene espresso normalmente con una variabile di tipo \type{time\_t}, che
+usualmente 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{funcproto}{
+\fhead{time.h}
+\fdecl{time\_t time(time\_t *t)}
+\fdesc{Legge il valore corrente del \textit{calendar time}.}
+}
+
+{La funzione ritorna il valore del \textit{calendar time} in caso di successo
+ e $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il
+ valore \errval{EFAULT} nel suo significato generico.}
+\end{funcproto}
+
+L'argomento \param{t}, se non nullo, deve essere l'indirizzo di una variabile
+su cui duplicare il valore di ritorno.
+
+Analoga a \func{time} è la funzione \funcd{stime} che serve per effettuare
+l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
+sia necessario; il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{int stime(time\_t *t)}
+\fdesc{Imposta il valore corrente del \textit{calendar time}.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EPERM}] non si hanno i permessi di amministrazione.
+ \end{errlist}
+ ed inoltre \errval{EFAULT} nel suo significato generico.}
+\end{funcproto}
+
+
+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 (per la precisione la
+\textit{capability} \const{CAP\_SYS\_TIME}), 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 due funzioni precedenti è sconsigliato, ed esse sono di
+solito sostituite da \funcd{gettimeofday} e \funcd{settimeofday},\footnote{le
+ due funzioni \func{time} e \func{stime} sono più antiche e derivano da SVr4,
+ \func{gettimeofday} e \func{settimeofday} sono state introdotte da BSD, ed
+ in BSD4.3 sono indicate come sostitute delle precedenti, \func{gettimeofday}
+ viene descritta anche in POSIX.1-2001.} i cui prototipi sono:
+
+\begin{funcproto}{
+\fhead{sys/time.h}
+\fhead{time.h}
+\fdecl{int gettimeofday(struct timeval *tv, struct timezone *tz)}
+\fdesc{Legge il tempo corrente del sistema.}
+\fdecl{int settimeofday(const struct timeval *tv, const struct timezone *tz)}
+\fdesc{Imposta il tempo di sistema.}
+}
+
+{La funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà i valori \errval{EINVAL}, \errval{EFAULT} e per
+ \func{settimeofday} anche \errval{EPERM}, nel loro significato generico.}
+\end{funcproto}
+
+
+Si noti come queste funzioni utilizzino per indicare il tempo una struttura di
+tipo \struct{timeval}, la cui definizione si è già vista in
+fig.~\ref{fig:sys_timeval_struct}, questa infatti permette una espressione
+alternativa dei valori del \textit{calendar time}, con una precisione,
+rispetto a \type{time\_t}, fino al microsecondo, ma la precisione è solo
+teorica, e la precisione reale della misura del tempo dell'orologio di sistema
+non dipende dall'uso di queste strutture.
+
+Come nel caso di \func{stime} anche \func{settimeofday} può essere utilizzata
+solo da un processo coi privilegi di amministratore e più precisamente con la
+capacità \const{CAP\_SYS\_TIME}. Si tratta comunque di una condizione generale
+che continua a valere per qualunque funzione che vada a modificare l'orologio
+di sistema, comprese tutte quelle che tratteremo in seguito.
+
+\itindbeg{timezone}
+
+Il secondo argomento di entrambe le funzioni è una struttura
+\struct{timezone}, che storicamente veniva utilizzata per specificare appunto
+la cosiddetta \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 argomento oggi è obsoleto ed in Linux non è
+mai stato utilizzato; esso non è supportato né dalla vecchia \textsl{libc5},
+né dalla \textsl{glibc}: pertanto quando si chiama questa funzione deve essere
+sempre impostato a \val{NULL}.
+
+\itindbeg{timezone}
+
+Modificare l'orologio di sistema con queste funzioni è comunque problematico,
+in quanto esse effettuano un cambiamento immediato. Questo può creare dei
+buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
+conseguenze indesiderate. Ad esempio se si porta avanti l'orologio si possono
+perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
+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{funcproto}{
+\fhead{sys/time.h}
+\fdecl{int adjtime(const struct timeval *delta, struct timeval *olddelta)}
+\fdesc{Aggiusta l'orologio di sistema.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] il valore di \param{delta} eccede il massimo
+ consentito.
+ \item[\errcode{EPERM}] il processo non i privilegi di amministratore.
+ \end{errlist}
+}
+\end{funcproto}
+
+
+Questa funzione permette di avere un aggiustamento graduale del tempo di
+sistema in modo che esso sia sempre crescente in maniera monotona. Il valore
+indicato nella struttura \struct{timeval} puntata da \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.
+
+La funzione è intesa per piccoli spostamenti del tempo di sistema, ed esistono
+pertanto dei limiti massimi per i valori che si possono specificare
+per \param{delta}. La \acr{glibc} impone un intervallo compreso fra
+\code{INT\_MIN/1000000 + 2} e \code{INT\_MAX/1000000 - 2}, corrispondente, su
+una architettura PC ordinaria a 32 bit, ad un valore compreso fra $-2145$ e
+$2145$ secondi.
+
+Inoltre se si invoca la funzione prima che una precedente richiesta di
+aggiustamento sia stata completata, specificando un altro valore, il
+precedente aggiustamento viene interrotto, ma la parte dello stesso che è già
+stata completata non viene rimossa. Però è possibile in questo caso farsi
+restituire nella struttura puntata da \param{olddelta} il tempo restante della
+precedente richiesta. Fino al kernel 2.6.26 ed alla \acr{glibc} 2.8 questo
+però era possibile soltanto specificando un diverso aggiustamento
+per \param{delta}, il bug è stato corretto a partire dalle versioni citate e
+si può ottenere l'informazione relativa alla frazione di aggiustamento
+mancante usando il valore \val{NULL} per \param{delta}.
+
+Linux poi prevede una specifica funzione di sistema che consente un
+aggiustamento molto più dettagliato del tempo, permettendo ad esempio anche di
+regolare anche la velocità e le derive dell'orologio di sistema. La funzione
+è \funcd{adjtimex} ed il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{sys/timex.h}
+\fdecl{int adjtimex(struct timex *buf)}
+\fdesc{Regola l'orologio di sistema.}
+}
+
+{La funzione ritorna lo stato dell'orologio (un valore $\ge 0$) in caso di
+ successo e $-1$ per un errore, nel qual caso \var{errno} assumerà uno dei
+ valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] si sono indicati valori fuori dall'intervallo
+ consentito per qualcuno dei campi di \param{buf}.
+ \item[\errcode{EPERM}] si è richiesta una modifica dei parametri ed il
+ processo non ha i privilegi di amministratore.
+ \end{errlist}
+ ed inoltre \errval{EFAULT} nel suo significato generico.}
+\end{funcproto}
+
+In caso di successo la funzione restituisce un valore numerico non negativo
+che indica lo stato dell'orologio, che può essere controllato con i valori
+delle costanti elencate in tab.~\ref{tab:adjtimex_return}.
+
+\begin{table}[!htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|c|l|}
+ \hline
+ \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \constd{TIME\_OK} & 0 & Orologio sincronizzato.\\
+ \constd{TIME\_INS} & 1 & Inserimento di un \textit{leap second}.\\
+ \constd{TIME\_DEL} & 2 & Cancellazione di un \textit{leap second}.\\
+ \constd{TIME\_OOP} & 3 & \textit{leap second} in corso.\\
+ \constd{TIME\_WAIT} & 4 & \textit{leap second} avvenuto.\\
+ \constd{TIME\_BAD} & 5 & Orologio non sincronizzato.\\
+ \hline
+ \end{tabular}
+ \caption{Possibili valori ritornati da \func{adjtimex} in caso di successo.}
+ \label{tab:adjtimex_return}
+\end{table}
+
+La funzione richiede come argomento il puntatore ad una struttura di tipo
+\struct{timex}, la cui definizione, effettuata in \headfiled{sys/timex.h}, è
+riportata in fig.~\ref{fig:sys_timex_struct} per i campi che interessano la
+possibilità di essere modificati documentati anche nella pagina di manuale. In
+realtà la struttura è stata estesa con ulteriori campi, i cui valori sono
+utilizzabili solo in lettura, la cui definizione si può trovare direttamente
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{\textwidth}
+ \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}
+
+L'azione della funzione dipende dal valore del campo \var{mode}
+di \param{buf}, che specifica quale parametro dell'orologio di sistema,
+specificato nel corrispondente 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 tab.~\ref{tab:sys_timex_mode}.
+
+\begin{table}[!htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|c|p{8cm}|}
+ \hline
+ \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \constd{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
+ reale e l'orologio di sistema:
+ deve essere indicata in microsecondi
+ nel campo \var{offset} di
+ \struct{timex}.\\
+ \constd{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenza in frequenza
+ fra il tempo reale e l'orologio di
+ sistema: deve essere indicata
+ in parti per milione nel campo
+ \var{frequency} di \struct{timex}.\\
+ \constd{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo
+ dell'errore sul tempo, espresso in
+ microsecondi nel campo
+ \var{maxerror} di \struct{timex}.\\
+ \constd{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
+ sul tempo, espresso in microsecondi
+ nel campo \var{esterror} di
+ \struct{timex}.\\
+ \constd{ADJ\_STATUS} & 0x0010 & Imposta alcuni valori di stato
+ interni usati dal
+ sistema nella gestione
+ dell'orologio specificati nel campo
+ \var{status} di \struct{timex}.\\
+ \constd{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del
+ PLL implementato dal kernel,
+ specificato nel campo
+ \var{constant} di \struct{timex}.\\
+ \constd{ADJ\_TICK} & 0x4000 & Imposta il valore dei \textit{tick}
+ del timer in
+ microsecondi, espresso nel campo
+ \var{tick} di \struct{timex}.\\
+ \constd{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Chiede 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 \struct{timex}.}
+ \label{tab:sys_timex_mode}
+\end{table}
+
+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, la \acr{glibc} provvede anche un suo omonimo
+\func{ntp\_adjtime}. La trattazione completa di questa funzione necessita di
+una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
+a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
+per il campo \var{mode}, un elenco più dettagliato del significato dei vari
+campi della struttura \struct{timex} può essere ritrovato in \cite{GlibcMan}.
+
+Il valore delle costanti per \var{mode} può essere anche espresso, secondo la
+sintassi specificata per la forma equivalente di questa funzione definita come
+\func{ntp\_adjtime}, utilizzando il prefisso \code{MOD} al posto di
+\code{ADJ}.
+
+Si tenga presente infine che con l'introduzione a partire dal kernel 2.6.21
+degli \textit{high-resolution timer} ed il supporto per i cosiddetti POSIX
+\textit{real-time clock}, si può ottenere il \textit{calendar time}
+direttamente da questi, come vedremo in sez.~\ref{sec:sig_timer_adv}, con la
+massima risoluzione possibile per l'hardware della macchina.
+
+
+
+\subsection{La gestione delle date.}
+\label{sec:sys_date}
+
+\itindbeg{broken-down~time}
+
+Le funzioni viste al paragrafo precedente sono molto utili per trattare le
+operazioni elementari sui tempi, però le rappresentazioni del tempo ivi
+illustrate, se han senso per specificare un intervallo, non sono molto
+intuitive quando si deve esprimere un'ora o una data. Per questo motivo è
+stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
+ time}, che permette appunto di \textsl{suddividere} il \textit{calendar
+ time} usuale in ore, minuti, secondi, ecc. e viene usata tenendo conto
+anche dell'eventuale utilizzo di un fuso orario.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{.8\textwidth}
+ \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}
+
+Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
+definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
+struttura che si utilizza quando si deve specificare un tempo a partire dai
+dati naturali (ora e data), dato che essa consente anche di tenere conto della
+gestione del fuso orario e dell'ora legale. In particolare gli ultimi due
+campi, \var{tm\_gmtoff} e \var{tm\_zone}, sono estensioni previste da BSD e
+supportate dalla \acr{glibc} quando è definita la macro \macro{\_BSD\_SOURCE}.
+
+Ciascuno dei campi di \struct{tm} ha dei precisi intervalli di valori
+possibili, con convenzioni purtroppo non troppo coerenti. Ad esempio
+\var{tm\_sec} che indica i secondi deve essere nell'intervallo da 0 a 59, ma è
+possibile avere anche il valore 60 per un cosiddetto \textit{leap second} (o
+\textsl{secondo intercalare}), cioè uno di quei secondi aggiunti al calcolo
+dell'orologio per effettuare gli aggiustamenti del calendario per tenere conto
+del disallineamento con il tempo solare.\footnote{per dettagli si consulti
+ \url{http://it.wikipedia.org/wiki/Leap_second}.}
+
+I campi \var{tm\_min} e\var{tm\_hour} che indicano rispettivamente minuti ed
+ore hanno valori compresi rispettivamente fra 0 e 59 e fra 0 e 23. Il campo
+\var{tm\_mday} che indica il giorno del mese prevede invece un valore compreso
+fra 1 e 31, ma la \acr{glibc} supporta pure il valore 0 come indicazione
+dell'ultimo giorno del mese precedente. Il campo \var{tm\_mon} indica il mese
+dell'anno a partire da gennaio con valori compresi fra 0 e 11.
+
+I campi \var{tm\_wday} e \var{tm\_yday} indicano invece rispettivamente il
+giorno della settimana, a partire dalla Domenica, ed il giorno dell'anno, a
+partire del primo gennaio, ed hanno rispettivamente valori compresi fra 0 e 6
+e fra 0 e 365. L'anno espresso da \var{tm\_year} viene contato come numero di
+anni a partire dal 1900. Infine \var{tm\_isdst} è un valore che indica se per
+gli altri campi si intende come attiva l'ora legale ed influenza il
+comportamento di \func{mktime}.
+
+
+Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
+da quelle usate per convertire gli altri formati in questo, usando o meno
+l'ora locale o il tempo universale, a quelle per trasformare il valore di un
+tempo in una stringa contenente data ed ora. Le prime due funzioni,
+\funcd{asctime} e \funcd{ctime} servono per poter stampare in forma leggibile
+un tempo, i loro prototipi sono:
+
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{char * asctime(const struct tm *tm)}
+\fdesc{Converte un \textit{broken-down time} in una stringa.}
+\fdecl{char * ctime(const time\_t *timep)}
+\fdesc{Converte un \textit{calendar time} in una stringa.}
+}
+
+{Le funzioni ritornano un puntatore al risultato in caso di successo e
+ \val{NULL} per un errore, \var{errno} non viene modificata.}
+\end{funcproto}
+
+Le funzioni prendono rispettivamente come argomenti i puntatori ad una
+struttura \struct{tm} contenente un \textit{broken-down time} o ad una
+variabile di tipo \type{time\_t} che esprime il \textit{calendar time},
+restituendo il puntatore ad una stringa che esprime la data, usando le
+abbreviazioni standard di giorni e mesi in inglese, nella forma:
+\begin{Example}
+Sun Apr 29 19:47:44 2012\n"
+\end{Example}
+
+Nel caso di \func{ctime} la funzione tiene conto della eventuale impostazione
+di una \textit{timezone} e effettua una chiamata preventiva a \func{tzset}
+(che vedremo a breve), in modo che la data espressa tenga conto del fuso
+orario. In realtà \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 aggiungendo un \code{\_r}, che prendono un secondo argomento
+\code{char *buf}, in cui l'utente deve specificare il buffer su cui la stringa
+deve essere copiata (deve essere di almeno 26 caratteri).
+
+Per la conversione fra \textit{broken-down time} e \textit{calendar time} sono
+invece disponibili altre tre funzioni, \funcd{gmtime}, \funcd{localtime} e
+\funcd{mktime} i cui prototipi sono:
+
+\begin{funcproto}{
+\fdecl{struct tm * gmtime(const time\_t *timep)}
+\fdesc{Converte un \textit{calendar time} in un \textit{broken-down time} in
+ UTC.}
+\fdecl{struct tm * localtime(const time\_t *timep)}
+\fdesc{Converte un \textit{calendar time} in un \textit{broken-down time}
+ nell'ora locale.}
+\fdecl{time\_t mktime(struct tm *tm)}
+\fdesc{Converte un \textit{broken-down time} in un \textit{calendar time}.}
+
+}
+
+{Le funzioni ritornano un puntatore al risultato in caso di successo e
+ \val{NULL} per un errore, tranne che \func{mktime} che restituisce
+ direttamente il valore o $-1$ in caso di errore, \var{errno} non viene
+ modificata.}
+\end{funcproto}
+
+Le le prime funzioni, \func{gmtime}, \func{localtime} servono per convertire
+il tempo in \textit{calendar time} specificato da un argomento di tipo
+\type{time\_t} restituendo un \textit{broken-down time} con il puntatore ad
+una struttura \struct{tm}. La prima effettua la conversione senza tenere conto
+del fuso orario, esprimendo la data in tempo coordinato universale (UTC), cioè
+l'ora di Greenwich, mentre \func{localtime} usa l'ora locale e per questo
+effettua una chiamata preventiva a \func{tzset}.
+
+Anche in questo caso le due funzioni restituiscono l'indirizzo di una
+struttura allocata staticamente, per questo sono state definite anche altre
+due versioni rientranti (con la solita estensione \code{\_r}), che prevedono
+un secondo argomento \code{struct tm *result}, fornito dal chiamante, che deve
+preallocare la struttura su cui sarà restituita la conversione. La versione
+rientrante di \func{localtime} però non effettua la chiamata preventiva a
+\func{tzset} che deve essere eseguita a cura dell'utente.
+
+Infine \func{mktime} esegue la conversione di un \textit{broken-down time} a
+partire da una struttura \struct{tm} restituendo direttamente un valore di
+tipo \type{time\_t} con il \textit{calendar time}. La funzione ignora i campi
+\var{tm\_wday} e \var{tm\_yday} e per gli altri campi normalizza eventuali
+valori fuori degli intervalli specificati in precedenza: se cioè si indica un
+12 per \var{tm\_mon} si prenderà il gennaio dell'anno successivo. Inoltre la
+funzione tiene conto del valore di \var{tm\_isdst} per effettuare le
+correzioni relative al fuso orario: un valore positivo indica che deve essere
+tenuta in conto l'ora legale, un valore nullo che non deve essere applicata
+nessuna correzione, un valore negativo che si deve far ricorso alle
+informazioni relative al proprio fuso orario per determinare lo stato dell'ora
+legale.
+
+La funzione inoltre modifica i valori della struttura \struct{tm} in forma di
+\textit{value result argument}, normalizzando i valori dei vari campi,
+impostando i valori risultanti per \var{tm\_wday} e \var{tm\_yday} e
+assegnando a \var{tm\_isdst} il valore (positivo o nullo) corrispondente allo
+stato dell'ora legale. La funzione inoltre provvede ad impostare il valore
+della variabile globale \var{tzname}.
+
+\itindend{calendar~time}
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{.75\textwidth}
+ \includestruct{listati/time_zone_var.c}
+ \end{minipage}
+ \normalsize
+ \caption{Le variabili globali usate per la gestione delle
+ \textit{timezone}.}
+ \label{fig:sys_tzname}
+\end{figure}
+
+Come accennato l'uso del \textit{broken-down time} permette di tenere conto
+anche della differenza fra tempo universale e ora locale, compresa l'eventuale
+ora legale. Questo viene fatto dalle funzioni di conversione grazie alle
+informazioni riguardo la propria \textit{timezone} mantenute nelle tre
+variabili globali mostrate in fig.~\ref{fig:sys_tzname}, cui si può accedere
+direttamente includendo \headfile{time.h}. Come illustrato queste variabili
+vengono impostate internamente da alcune delle precedenti funzioni di
+conversione, ma lo si può fare esplicitamente chiamando direttamente la
+funzione \funcd{tzset}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{void tzset(void)}
+\fdesc{Imposta le variabili globali della \textit{timezone}.}
+}
+
+{La funzione non ritorna niente e non dà errori.}
+\end{funcproto}
+
+La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire
+dal valore della variabile di ambiente \envvar{TZ}, se quest'ultima non è
+definita verrà usato il file \conffiled{/etc/localtime}. La variabile
+\var{tzname} contiene due stringhe, che indicano i due nomi standard della
+\textit{timezone} corrente. La prima è il nome per l'ora solare, la seconda
+per l'ora legale. Anche se in fig.~\ref{fig:sys_tzname} sono indicate come
+\code{char *} non è il caso di modificare queste stringhe. La variabile
+\var{timezone} indica la differenza di fuso orario in secondi, mentre
+\var{daylight} indica se è attiva o meno l'ora legale.
+
+Benché la funzione \func{asctime} fornisca la modalità più immediata per
+stampare un tempo o una data, la flessibilità non fa parte delle sue
+caratteristiche; quando si vuole poter stampare solo una parte (l'ora, o il
+giorno) di un tempo si può ricorrere alla più sofisticata \funcd{strftime},
+il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{size\_t strftime(char *s, size\_t max, const char *format,
+ const struct tm *tm)}
+\fdesc{Crea una stringa con una data secondo il formato indicato.}
+}
+
+{La funzione ritorna il numero di caratteri inseriti nella stringa \param{s}
+ oppure $0$, \var{errno} non viene modificata.}
+\end{funcproto}
+
+
+La funzione converte il \textit{broken-down time} indicato nella struttura
+puntata dall'argomento \param{tm} in una stringa di testo da salvare
+all'indirizzo puntato dall'argomento \param{s}, purché essa sia di dimensione
+inferiore al massimo indicato dall'argomento \param{max}. Il numero di
+caratteri generati dalla funzione viene restituito come valore di ritorno,
+senza tener però conto del terminatore finale, che invece viene considerato
+nel computo della dimensione. Se quest'ultima è eccessiva viene restituito 0 e
+lo stato di \param{s} è indefinito.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|c|l|p{6cm}|}
+ \hline
+ \textbf{Modificatore} & \textbf{Esempio} & \textbf{Significato}\\
+ \hline
+ \hline
+ \var{\%a}&\texttt{Wed} & Nome del giorno, abbreviato.\\
+ \var{\%A}&\texttt{Wednesday} & Nome del giorno, completo.\\
+ \var{\%b}&\texttt{Apr} & Nome del mese, abbreviato.\\
+ \var{\%B}&\texttt{April} & Nome del mese, completo.\\
+ \var{\%c}&\texttt{Wed Apr 24 18:40:50 2002}& Data e ora.\\
+ \var{\%d}&\texttt{24} & Giorno del mese.\\
+ \var{\%H}&\texttt{18} & Ora del giorno, da 0 a 24.\\
+ \var{\%I}&\texttt{06} & Ora del giorno, da 0 a 12.\\
+ \var{\%j}&\texttt{114} & Giorno dell'anno.\\
+ \var{\%m}&\texttt{04} & Mese dell'anno.\\
+ \var{\%M}&\texttt{40} & Minuto.\\
+ \var{\%p}&\texttt{PM} & AM/PM.\\
+ \var{\%S}&\texttt{50} & Secondo.\\
+ \var{\%U}&\texttt{16} & Settimana dell'anno (partendo dalla
+ domenica).\\
+ \var{\%w}&\texttt{3} & Giorno della settimana.\\
+ \var{\%W}&\texttt{16} & Settimana dell'anno (partendo dal
+ lunedì).\\
+ \var{\%x}&\texttt{04/24/02} & La data.\\
+ \var{\%X}&\texttt{18:40:50} & L'ora.\\
+ \var{\%y}&\texttt{02} & Anno nel secolo.\\
+ \var{\%Y}&\texttt{2002} & Anno.\\
+ \var{\%Z}&\texttt{CEST} & Nome della \textit{timezone}.\\
+ \var{\%\%}&\texttt{\%} & Il carattere \%.\\
+ \hline
+ \end{tabular}
+ \caption{Valori previsti dallo standard ANSI C per modificatore della
+ stringa di formato di \func{strftime}.}
+ \label{tab:sys_strftime_format}
+\end{table}
+
+Il risultato della funzione è controllato dalla stringa di formato
+\param{format}, tutti i caratteri restano invariati eccetto \texttt{\%} che
+viene utilizzato come modificatore. Alcuni dei possibili valori che esso può
+assumere sono riportati in tab.~\ref{tab:sys_strftime_format}.\footnote{per la
+ precisione si sono riportati definiti dallo standard ANSI C, che sono anche
+ quelli ripresi in POSIX.1; la \acr{glibc} fornisce anche 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.} La funzione tiene conto
+anche delle eventuali impostazioni di localizzazione per stampare i vari nomi
+in maniera adeguata alla lingua scelta, e con le convenzioni nazionali per i
+formati di data ed ora.
+
+Infine per effettuare l'operazione di conversione inversa, da una stringa ad
+un \textit{broken-down time}, si può utilizzare la funzione \funcd{strptime},
+il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{time.h}
+\fdecl{char *strptime(const char *s, const char *format, struct tm *tm)}
+\fdesc{Converte una stringa con in un \textit{broken-down time} secondo un
+ formato.}
+}
+
+{La funzione ritorna il puntatore al primo carattere non processato della
+ stringa o al terminatore finale qualora questa sia processata interamente,
+ \var{errno} non viene modificata.}
+\end{funcproto}
+
+La funzione processa la stringa puntata dall'argomento \param{s} da sinistra a
+destra, utilizzando il formato contenuto nella stringa puntata
+dall'argomento \param{format}, avvalorando volta volta i corrispondenti campi
+della struttura puntata dall'argomento \param{tm}. La scansione si interrompe
+immediatamente in caso di mancata corrispondenza a quanto indicato nella
+stringa di formato, che usa una sintassi analoga a quella già vista per
+\func{strftime}. La funzione supporta i modificatori di
+tab.~\ref{tab:sys_strftime_format} più altre estensioni, ma per i dettagli a
+questo riguardo si rimanda alla lettura della pagina di manuale.
+
+Si tenga presente comunque che anche in caso di scansione completamente
+riuscita la funzione sovrascrive soltanto i campi di \param{tm} indicati dal
+formato, la struttura originaria infatti non viene inizializzati e gli altri
+campi restano ai valori che avevano in precedenza.
+
+
+\itindend{broken-down~time}