+{Le funzioni ritornano $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.
+ \end{errlist}
+ ed inoltre \errval{EFAULT} nel suo significato generico.
+}
+\end{funcproto}
+
+Entrambe le funzioni permettono di specificare attraverso l'argomento
+\param{resource} su quale risorsa si vuole operare. L'accesso (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]{0.8\textwidth}
+ \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}
+
+Come accennato processo ordinario può alzare il proprio limite corrente fino
+al valore del limite massimo, può anche ridurre, irreversibilmente, il valore
+di quest'ultimo. Nello specificare un limite, oltre a fornire dei valori
+specifici, si può anche usare la costante \const{RLIM\_INFINITY} che permette
+di sbloccare completamente l'uso di una risorsa. Si ricordi però 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} (vedi sez.~\ref{sec:proc_capabilities}).} può
+innalzare un limite al di sopra del valore corrente del limite massimo ed
+usare un valore qualsiasi per entrambi i limiti.
+
+Ciascuna risorsa su cui si possono applicare dei limiti è identificata da uno
+specifico valore dell'argomento \param{resource}, i valori possibili per
+questo argomento, ed il significato della risorsa corrispondente, dei
+rispettivi limiti e gli effetti causati dal superamento degli stessi sono
+riportati nel seguente elenco:
+
+\begin{basedescript}{\desclabelwidth{2.2cm}}%\desclabelstyle{\nextlinelabel}}
+\item[\const{RLIMIT\_AS}] Questa risorsa indica, in byte, la dimensione
+ massima consentita per la 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}
+ \textit{stack} il processo riceverà un segnale di \signal{SIGSEGV}. Dato che
+ il valore usato è un intero di tipo \ctyp{long} nelle macchine a 32 bit
+ questo può assumere un valore massimo di 2Gb (anche se la memoria
+ disponibile può essere maggiore), in tal caso il limite massimo indicabile
+ resta 2Gb, altrimenti la risorsa si dà per non limitata.
+
+\item[\const{RLIMIT\_CORE}] Questa risorsa indica, in byte, la massima
+ dimensione per un file di \itindex{core~dump} \textit{core dump} (vedi
+ sez.~\ref{sec:sig_standard}) creato nella terminazione di un processo. File
+ di dimensioni maggiori verranno troncati a questo valore, mentre con un
+ valore nullo si bloccherà la creazione dei \itindex{core~dump} \textit{core
+ dump}.
+
+\item[\const{RLIMIT\_CPU}] Questa risorsa indica, in secondi, 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
+ \signal{SIGXCPU}, la cui azione predefinita (vedi
+ sez.~\ref{sec:sig_classification}) è terminare il processo. Il segnale però
+ può essere intercettato e ignorato, in tal caso esso verrà riemesso una
+ volta al secondo fino al raggiungimento del limite massimo. Il superamento
+ del limite massimo comporta comunque l'emissione di un segnale di
+ \signal{SIGKILL}. Si tenga presente che questo è il comportamento presente
+ su Linux dai kernel della serie 2.2 ad oggi, altri kernel possono avere
+ comportamenti diversi per quanto avviene quando viene superato il
+ \textit{soft limit}, pertanto per avere operazioni portabili è suggerito di
+ intercettare sempre \signal{SIGXCPU} e terminare in maniera ordinata il
+ processo con la prima ricezione.
+
+\item[\const{RLIMIT\_DATA}] Questa risorsa indica, in byte, 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 eseguita (\func{brk} o \func{sbrk}) con un errore di
+ \errcode{ENOMEM}.
+
+\item[\const{RLIMIT\_FSIZE}] Questa risorsa indica, in byte, la massima
+ dimensione di un file che un processo può usare. Se il processo cerca di
+ scrivere o di estendere il file oltre questa dimensione riceverà un segnale
+ di \signal{SIGXFSZ}, che di norma termina il processo. Se questo segnale
+ viene intercettato la \textit{system call} che ha causato l'errore fallirà
+ con un errore di \errcode{EFBIG}.
+
+\item[\const{RLIMIT\_LOCKS}] Questa risorsa indica il numero massimo di
+ \itindex{file~locking} \textit{file lock} (vedi sez.~\ref{sec:file_locking})
+ e di \textit{file lease} (vedi sez.~\ref{sec:file_asyncronous_lease}) che un
+ processo poteva effettuare. È un limite presente solo nelle prime versioni
+ del kernel 2.4, pertanto non deve essere più utilizzato.
+
+\item[\const{RLIMIT\_MEMLOCK}] Questa risorsa indica, in byte, l'ammontare
+ massimo di memoria che può essere bloccata in RAM da un processo (vedi
+ sez.~\ref{sec:proc_mem_lock}). Dato che il \itindex{memory~locking}
+ \textit{memory locking} viene effettuato sulle pagine di memoria, il valore
+ indicato viene automaticamente arrotondato al primo multiplo successivo
+ della dimensione di una pagina di memoria. Il limite comporta il fallimento
+ delle \textit{system call} che eseguono il \textit{memory locking}
+ (\func{mlock}, \func{mlockall} ed anche, vedi
+ sez.~\ref{sec:file_memory_map}, \func{mmap} con l'operazione
+ \const{MAP\_LOCKED}).
+
+ 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}) con \func{shmctl}, che viene contabilizzata
+ separatamente ma sulla quale viene applicato questo stesso limite. In
+ precedenza invece questo limite veniva applicato sulla memoria condivisa per
+ processi con privilegi amministrativi, il limite su questi è stato rimosso e
+ la semantica della risorsa cambiata.
+
+
+\item[\const{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[\const{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[\const{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[\const{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[\const{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 \index{segmento!testo} 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[\const{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[\const{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.
+
+% TODO trattare i seguenti...
+% aggiungere i limiti che mancano come RLIMIT_RTTIME introdotto con il 2.6.25
+% vedi file include/asm-generic/resource.h
+
+
+\item[\const{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[\const{RLIMIT\_STACK}] Questa risorsa indica, in byte, la massima
+ dimensione dello \itindex{stack} \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 \itindex{capabilities}
+ \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}