+\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; 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} (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.
+
+Come accennato ciascuna risorsa è 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_prog_error}) 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 codiddetto 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
+
+% TODO trattare i seguenti...
+% \const{RLIMIT\_RTPRIO}& Il numero massimo di \\
+% 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}] 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.\footnote{il limite su questa
+ risorsa è stato introdotto con il kernel 2.6.8.}
+
+
+\item[\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.
+
+\item[\const{RLIMIT\_STACK}] 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}.
+
+% TODO dal 2.6.23 il significato è cambiato, vedi anche man execve
+
+% TODO: aggiungere a \const{RLIMIT\_STACK} i dati di execve:
+% Questi fino al kernel 2.6.23 erano fissi e costituiti da
+% 32 pagine di memoria (corrispondenti per la gran parte delle architetture a
+% 128kb di dati). Dal 2.6.23 su molte architettire il limite viene stabilito in
+% base al valore della risorsa \const{RLIMIT\_STACK} (vedi
+% sez.~\ref{sec:sys_resource_limit}), ad un quarto dello spazio da essa
+% indicato). Dal 2.6.25 viene comunque garantito uno spazio base di 32 pagine.
+
+% TODO integrare con la roba di madvise
+% TODO integrare con le ultime aggiunte, vedi pagina di manuale
+
+% TODO trattare prlimit64 introdotta con il 2.6.36 che dovrebbe sostituire
+% setrlimit
+
+\end{basedescript}
+
+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}).