+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
+\const{RUSAGE\_SELF} per indicare il processo corrente e
+\const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
+ricevuto lo stato di terminazione.
+
+
+\subsection{Limiti sulle risorse}
+\label{sec:sys_resource_limit}
+
+Come accennato nell'introduzione il kernel mette a disposizione delle
+funzionalità che permettono non solo di mantenere dati statistici relativi
+all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
+utilizzo da parte dei vari processi o degli utenti.
+
+Per far questo esistono una serie di risorse e ad ogni processo vengono
+associati due diversi limiti per ciascuna di esse; questi sono il
+\textsl{limite corrente} (o \textit{current limit}) che esprime un valore
+massimo che il processo non può superare ad un certo momento, ed il
+\textsl{limite massimo} (o \textit{maximum limit}) che invece esprime il
+valore massimo che può assumere il \textsl{limite corrente}. In generale il
+primo viene chiamato anche \textit{soft limit} dato che il suo valore può
+essere aumentato dal processo stesso durante l'esecuzione, ciò può però essere
+fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
+ limit}.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{12cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \const{RLIMIT\_AS} & La dimensione massima della memoria virtuale di
+ un processo, il cosiddetto \textit{Address
+ Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se
+ il limite viene superato dall'uso di funzioni
+ come \func{brk}, \func{mremap} o \func{mmap}
+ esse falliranno con un errore di
+ \errcode{ENOMEM}, mentre se il superamento viene
+ causato dalla crescita dello \itindex{stack}
+ stack il processo riceverà un segnale di
+ \const{SIGSEGV}. \\
+ \const{RLIMIT\_CORE} & La massima dimensione per di un file di
+ \itindex{core~dump} \textit{core dump} (vedi
+ sez.~\ref{sec:sig_prog_error}) creato nella
+ terminazione di un processo; file di dimensioni
+ maggiori verranno troncati a questo valore,
+ mentre con un valore si bloccherà la creazione
+ dei \itindex{core~dump} \textit{core dump}.\\
+ \const{RLIMIT\_CPU} & Il massimo tempo di CPU (vedi
+ sez.~\ref{sec:sys_cpu_times}) che il processo può
+ usare. Il superamento del limite corrente
+ comporta l'emissione di un segnale di
+ \const{SIGXCPU} la cui azione predefinita (vedi
+ sez.~\ref{sec:sig_classification}) è terminare
+ il processo. Il superamento del limite massimo
+ comporta l'emissione di un segnale di
+ \const{SIGKILL}.\footnotemark\\
+ \const{RLIMIT\_DATA} & La massima dimensione del \index{segmento!dati}
+ segmento dati di un
+ processo (vedi sez.~\ref{sec:proc_mem_layout}).
+ Il tentativo di allocare più memoria di quanto
+ indicato dal limite corrente causa il fallimento
+ della funzione di allocazione (\func{brk} o
+ \func{sbrk}) con un errore di \errcode{ENOMEM}.\\
+ \const{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
+ può creare. Se il processo cerca di scrivere
+ oltre questa dimensione riceverà un segnale di
+ \const{SIGXFSZ}, che di norma termina il
+ processo; se questo viene intercettato la
+ system call che ha causato l'errore fallirà con
+ un errore di \errcode{EFBIG}.\\
+ \const{RLIMIT\_LOCKS}& È un limite presente solo nelle prime versioni
+ del kernel 2.4 sul numero massimo di
+ \index{file!locking} \textit{file lock} (vedi
+ sez.~\ref{sec:file_locking}) che un
+ processo poteva effettuare.\\
+ \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
+ bloccata in RAM da un processo (vedi
+ sez.~\ref{sec:proc_mem_lock}). Dal kernel 2.6.9
+ questo limite comprende anche la memoria che può
+ essere bloccata da ciascun utente nell'uso della
+ memoria condivisa (vedi
+ sez.~\ref{sec:ipc_sysv_shm}) che viene
+ contabilizzata separatamente ma sulla quale
+ viene applicato questo stesso limite.\\
+ \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
+ aprire. L'apertura di un ulteriore file farà
+ fallire la funzione (\func{open}, \func{dup} o
+ \func{pipe}) con un errore \errcode{EMFILE}.\\
+ \const{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
+ creati sullo stesso user id real. Se il limite
+ viene raggiunto \func{fork} fallirà con un
+ \errcode{EAGAIN}.\\
+ \const{RLIMIT\_SIGPENDING}& Il numero massimo di segnali che possono
+ essere mantenuti in coda per ciascun utente,
+ considerando sia i segnali normali che real-time
+ (vedi sez.~\ref{sec:sig_real_time}). Il limite è
+ attivo solo per \func{sigqueue}, con \func{kill}
+ si potrà sempre inviare un segnale che non sia
+ già presente su una coda.\footnotemark\\
+ \const{RLIMIT\_STACK} & La massima dimensione dello \itindex{stack}
+ stack del
+ processo. Se il processo esegue operazioni che
+ estendano lo stack oltre questa dimensione
+ riceverà un segnale di \const{SIGSEGV}.\\
+ \const{RLIMIT\_RSS} & L'ammontare massimo di pagine di memoria dato al
+ \index{segmento!testo} testo del processo. Il
+ limite è solo una indicazione per il kernel,
+ qualora ci fosse un surplus di memoria questa
+ verrebbe assegnata.\\
+% TODO integrare con la roba di madvise
+ \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[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
+ oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
+ avviene quando viene superato il \textit{soft limit}; perciò per avere
+ operazioni portabili è sempre opportuno intercettare \const{SIGXCPU} e
+ terminare in maniera ordinata il processo.}
+
+\footnotetext{il limite su questa risorsa è stato introdotto con il kernel
+ 2.6.8.}
+
+In generale il superamento di un limite corrente\footnote{di norma quanto
+ riportato in tab.~\ref{tab:sys_rlimit_values} fa riferimento a quanto
+ avviene al superamento del limite corrente, con l'eccezione
+ \const{RLIMIT\_CPU} in cui si ha in comportamento diverso per il superamento
+ dei due limiti.} comporta o l'emissione di un segnale o il fallimento della
+system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
+ \const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
+ creazione) dei file di \itindex{core~dump} \textit{core dump}.} per
+permettere di leggere e di impostare i limiti di utilizzo delle risorse da
+parte di un processo sono previste due funzioni, \funcd{getrlimit} e
+\funcd{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)}
+
+ Imposta il limite per la risorsa \param{resource}.
+
+ \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EINVAL}] I valori per \param{resource} non sono validi.
+ \item[\errcode{EPERM}] Un processo senza i privilegi di amministratore ha
+ cercato di innalzare i propri limiti.
+ \end{errlist}
+ ed \errval{EFAULT}.}
+\end{functions}
+
+
+Entrambe le funzioni permettono di specificare, attraverso l'argomento
+\param{resource}, su quale risorsa si vuole operare: i possibili valori di
+questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
+(rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
+poi effettuato attraverso la struttura \struct{rlimit} puntata da
+\param{rlim}, la cui definizione è riportata in
+fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
+limite corrente e limite massimo.
+
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{15cm}
+ \includestruct{listati/rlimit.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo
+ delle risorse usate da un processo.}
+ \label{fig:sys_rlimit_struct}
+\end{figure}
+
+
+Nello specificare un limite, oltre a fornire dei valori specifici, si può
+anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
+di una risorsa; ma si ricordi che solo un processo con i privilegi di
+amministratore\footnote{per essere precisi in questo caso quello che serve è
+ la \itindex{capabilities} \textit{capability} \const{CAP\_SYS\_RESOURCE}.}
+può innalzare un limite al di sopra del valore corrente del limite massimo ed
+usare un valore qualsiasi per entrambi i limiti. Si tenga conto infine che
+tutti i limiti vengono ereditati dal processo padre attraverso una \func{fork}
+(vedi sez.~\ref{sec:proc_fork}) e mantenuti per gli altri programmi eseguiti
+attraverso una \func{exec} (vedi sez.~\ref{sec:proc_exec}).
+
+
+\subsection{Le risorse di memoria e processore}
+\label{sec:sys_memory_res}
+
+La gestione della memoria è già stata affrontata in dettaglio in
+sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
+meccanismo della \index{memoria~virtuale} 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 \index{paginazione} paginazione.
+
+Di solito la dimensione delle pagine di memoria è fissata dall'architettura
+hardware, per cui il suo valore di norma veniva mantenuto in una costante che
+bastava utilizzare in fase di compilazione, ma oggi, con la presenza di alcune
+architetture (ad esempio Sun Sparc) che permettono di variare questa
+dimensione, per non dover ricompilare i programmi per ogni possibile modello e
+scelta di dimensioni, è necessario poter utilizzare una funzione.
+
+Dato che si tratta di una caratteristica generale del sistema, questa
+dimensione può essere ottenuta come tutte le altre attraverso una chiamata a
+\func{sysconf}, \footnote{nel caso specifico si dovrebbe utilizzare il
+ parametro \const{\_SC\_PAGESIZE}.} ma in BSD 4.2 è stata introdotta una
+apposita funzione, \funcd{getpagesize}, che restituisce la dimensione delle
+pagine di memoria; il suo prototipo è:
+\begin{prototype}{unistd.h}{int getpagesize(void)}
+ Legge le dimensioni delle pagine di memoria.
+
+ \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
+ sono previsti errori.}
+\end{prototype}
+
+La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
+standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
+ha eliminata. In Linux è implementata come una system call nelle architetture
+in cui essa è necessaria, ed in genere restituisce il valore del simbolo
+\const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
+se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
+implementavano questa funzione restituendo sempre un valore statico.
+
+% TODO verificare meglio la faccenda di const{PAGE\_SIZE}
+
+Le \textsl{glibc} forniscono, come specifica estensione GNU, altre due
+funzioni, \funcd{get\_phys\_pages} e \funcd{get\_avphys\_pages} che permettono
+di ottenere informazioni riguardo la memoria; i loro prototipi sono:
+\begin{functions}
+ \headdecl{sys/sysinfo.h}
+
+ \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 \const{\_SC\_PHYS\_PAGES} e
+\const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
+corrispondenti alla RAM della macchina; la seconda invece la memoria
+effettivamente disponibile per i processi.
+
+Le \acr{glibc} supportano inoltre, come 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 le \acr{glibc} riprendono da BSD la funzione \funcd{getloadavg} che
+permette di ottenere il carico di processore della macchina, in questo modo è
+possibile prendere decisioni su quando far partire eventuali nuovi processi.
+Il suo prototipo è:
+\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 \itindex{scheduler} 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{prototype}{unistd.h}{int acct(const char *filename)}
+ Abilita il \textit{BSD accounting}.
+
+ \bodydesc{La funzione ritorna 0 in caso di successo o $-1$ in caso di
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EACCESS}] non si hanno i permessi per accedere a
+ \param{pathname}.
+ \item[\errcode{EPERM}] Il processo non ha privilegi sufficienti ad
+ abilitare il \textit{BSD accounting}.
+ \item[\errcode{ENOSYS}] il kernel non supporta il \textit{BSD accounting}.
+ \item[\errcode{EUSER}] 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}.}
+\end{prototype}
+
+La funzione attiva il salvataggio dei dati sul file indicato dal pathname
+contenuti nella stringa puntata da \param{filename}; la funzione richiede che
+il processo abbia i privilegi di amministratore (è necessaria la
+\itindex{capabilities} capability \const{CAP\_SYS\_PACCT}, vedi
+sez.~\ref{sec:proc_capabilities}). Se si specifica il valore \const{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;\footnote{si applicano al pathname indicato da
+ \param{filename} tutte le restrizioni viste in cap.~\ref{cha:file_intro}.}
+le informazioni verranno registrate in \itindex{append~mode} \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 \file{/proc/sys/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.