+{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.