+Quando si devono determinare le caratteristiche generali del sistema ci si
+trova di fronte a diverse possibilità; alcune di queste infatti possono
+dipendere dall'architettura dell'hardware (come le dimensioni dei tipi
+interi), o dal sistema operativo (come la presenza o meno del gruppo degli
+identificatori \textit{saved}), altre invece possono dipendere dalle opzioni
+con cui si è costruito il sistema (ad esempio da come si è compilato il
+kernel), o dalla configurazione del medesimo; per questo motivo in generale
+sono necessari due tipi diversi di funzionalità:
+\begin{itemize*}
+\item la possibilità di determinare limiti ed opzioni al momento della
+ compilazione.
+\item la possibilità di determinare limiti ed opzioni durante l'esecuzione.
+\end{itemize*}
+
+La prima funzionalità si può ottenere includendo gli opportuni header file che
+contengono le costanti necessarie definite come macro di preprocessore, per la
+seconda invece sono ovviamente necessarie delle funzioni. La situazione è
+complicata dal fatto che ci sono molti casi in cui alcuni di questi limiti
+sono fissi in un'implementazione mentre possono variare in un altra: tutto
+questo crea una ambiguità che non è sempre possibile risolvere in maniera
+chiara. In generale quello che succede è che quando i limiti del sistema sono
+fissi essi vengono definiti come macro di preprocessore nel file
+\headfile{limits.h}, se invece possono variare, il loro valore sarà ottenibile
+tramite la funzione \func{sysconf} (che esamineremo a breve).
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|r|l|}
+ \hline
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
+ \hline
+ \hline
+ \constd{MB\_LEN\_MAX}& 16 & Massima dimensione di un
+ carattere esteso.\\
+ \constd{CHAR\_BIT} & 8 & Numero di bit di \ctyp{char}.\\
+ \constd{UCHAR\_MAX}& 255 & Massimo di \ctyp{unsigned char}.\\
+ \constd{SCHAR\_MIN}& -128 & Minimo di \ctyp{signed char}.\\
+ \constd{SCHAR\_MAX}& 127 & Massimo di \ctyp{signed char}.\\
+ \constd{CHAR\_MIN} & 0 o -128 & Minimo di \ctyp{char}.\footnotemark\\
+ \constd{CHAR\_MAX} & 127 o 255 & Massimo di \ctyp{char}.\footnotemark\\
+ \constd{SHRT\_MIN} & -32768 & Minimo di \ctyp{short}.\\
+ \constd{SHRT\_MAX} & 32767 & Massimo di \ctyp{short}.\\
+ \constd{USHRT\_MAX}& 65535 & Massimo di \ctyp{unsigned short}.\\
+ \constd{INT\_MAX} & 2147483647 & Minimo di \ctyp{int}.\\
+ \constd{INT\_MIN} &-2147483648 & Minimo di \ctyp{int}.\\
+ \constd{UINT\_MAX} & 4294967295 & Massimo di \ctyp{unsigned int}.\\
+ \constd{LONG\_MAX} & 2147483647 & Massimo di \ctyp{long}.\\
+ \constd{LONG\_MIN} &-2147483648 & Minimo di \ctyp{long}.\\
+ \constd{ULONG\_MAX}& 4294967295 & Massimo di \ctyp{unsigned long}.\\
+ \hline
+ \end{tabular}
+ \caption{Costanti definite in \headfile{limits.h} in conformità allo standard
+ ANSI C.}
+ \label{tab:sys_ansic_macro}
+\end{table}
+
+\footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
+ sistema usi caratteri con segno o meno.}
+
+\footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
+ a seconda che il sistema usi caratteri con segno o meno.}
+
+Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
+saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
+da \headfile{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si
+può vedere per la maggior parte questi limiti attengono alle dimensioni dei
+dati interi, che sono in genere fissati dall'architettura hardware, le
+analoghe informazioni per i dati in virgola mobile sono definite a parte, ed
+accessibili includendo \headfiled{float.h}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|r|l|}
+ \hline
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
+ \hline
+ \hline
+ \constd{LLONG\_MAX} & 9223372036854775807& Massimo di \ctyp{long long}.\\
+ \constd{LLONG\_MIN} &-9223372036854775808& Minimo di \ctyp{long long}.\\
+ \constd{ULLONG\_MAX}&18446744073709551615& Massimo di \ctyp{unsigned long
+ long}.\\
+ \hline
+ \end{tabular}
+ \caption{Macro definite in \headfile{limits.h} in conformità allo standard
+ ISO C90.}
+ \label{tab:sys_isoc90_macro}
+\end{table}
+
+Lo standard prevede anche un'altra costante, \constd{FOPEN\_MAX}, che può non
+essere fissa e che pertanto non è definita in \headfile{limits.h}, essa deve
+essere definita in \headfile{stdio.h} ed avere un valore minimo di 8. A questi
+valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo \ctyp{long
+ long} introdotto con il nuovo standard, i relativi valori sono in
+tab.~\ref{tab:sys_isoc90_macro}.
+
+Ovviamente le dimensioni dei vari tipi di dati sono solo una piccola parte
+delle caratteristiche del sistema; mancano completamente tutte quelle che
+dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
+sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
+limiti relativi alle caratteristiche dei file che vedremo in
+sez.~\ref{sec:sys_file_limits}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|r|p{8cm}|}
+ \hline
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
+ \hline
+ \hline
+ \constd{ARG\_MAX} &131072& Dimensione massima degli argomenti
+ passati ad una funzione della famiglia
+ \func{exec}.\\
+ \constd{CHILD\_MAX} & 999& Numero massimo di processi contemporanei
+ che un utente può eseguire.\\
+ \constd{OPEN\_MAX} & 256& Numero massimo di file che un processo
+ può mantenere aperti in contemporanea.\\
+ \constd{STREAM\_MAX}& 8& Massimo numero di stream aperti per
+ processo in contemporanea.\\
+ \constd{TZNAME\_MAX}& 6& Dimensione massima del nome di una
+ \textit{timezone} (vedi
+ sez.~\ref{sec:sys_time_base})).\\
+ \constd{NGROUPS\_MAX}& 32& Numero di gruppi supplementari per
+ processo (vedi sez.~\ref{sec:proc_access_id}).\\
+ \constd{SSIZE\_MAX}&32767& Valore massimo del tipo \type{ssize\_t}.\\
+ \hline
+ \end{tabular}
+ \caption{Costanti per i limiti del sistema.}
+ \label{tab:sys_generic_macro}
+\end{table}
+
+Purtroppo la sezione dello standard che tratta questi argomenti è una delle
+meno chiare, tanto che Stevens, in \cite{APUE}, la porta come esempio di
+``\textsl{standardese}''. Lo standard prevede che ci siano 13 macro che
+descrivono le caratteristiche del sistema: 7 per le caratteristiche generiche,
+riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
+file, riportate in tab.~\ref{tab:sys_file_macro}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|r|p{8cm}|}
+ \hline
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
+ \hline
+ \hline
+ \macrod{\_POSIX\_ARG\_MAX} & 4096& Dimensione massima degli argomenti
+ passati ad una funzione della famiglia
+ \func{exec}.\\
+ \macrod{\_POSIX\_CHILD\_MAX} & 6& Numero massimo di processi
+ contemporanei che un utente può
+ eseguire.\\
+ \macrod{\_POSIX\_OPEN\_MAX} & 16& Numero massimo di file che un processo
+ può mantenere aperti in
+ contemporanea.\\
+ \macrod{\_POSIX\_STREAM\_MAX}& 8& Massimo numero di stream aperti per
+ processo in contemporanea.\\
+ \macrod{\_POSIX\_TZNAME\_MAX}& 6& Dimensione massima del nome di una
+ \textit{timezone}
+ (vedi sez.~\ref{sec:sys_date}). \\
+ \macrod{\_POSIX\_RTSIG\_MAX} & 8& Numero massimo di segnali
+ \textit{real-time} (vedi
+ sez.~\ref{sec:sig_real_time}).\\
+ \macrod{\_POSIX\_NGROUPS\_MAX}& 0& Numero di gruppi supplementari per
+ processo (vedi
+ sez.~\ref{sec:proc_access_id}).\\
+ \macrod{\_POSIX\_SSIZE\_MAX} &32767& Valore massimo del tipo
+ \type{ssize\_t}.\\
+ % \macrod{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
+ % \macrod{\_POSIX\_AIO\_MAX} & 1& \\
+ \hline
+ \end{tabular}
+ \caption{Macro dei valori minimi di alcune caratteristiche generali del
+ sistema per la conformità allo standard POSIX.1.}
+ \label{tab:sys_posix1_general}
+\end{table}
+
+Lo standard dice che queste macro devono essere definite in
+\headfile{limits.h} quando i valori a cui fanno riferimento sono fissi, e
+altrimenti devono essere lasciate indefinite, ed i loro valori dei limiti
+devono essere accessibili solo attraverso \func{sysconf}. In realtà queste
+vengono sempre definite ad un valore generico. Si tenga presente poi che
+alcuni di questi limiti possono assumere valori molto elevati (come
+\const{CHILD\_MAX}), e non è pertanto il caso di utilizzarli per allocare
+staticamente della memoria.
+
+A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
+altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
+definiscono i valori minimi le stesse caratteristiche devono avere, perché una
+implementazione possa dichiararsi conforme allo standard, alcuni dei questi
+valori sono riportati in tab.~\ref{tab:sys_posix1_general}.
+
+In genere questi valori non servono a molto, la loro unica utilità è quella di
+indicare un limite superiore che assicura la portabilità senza necessità di
+ulteriori controlli. Tuttavia molti di essi sono ampiamente superati in tutti
+i sistemi POSIX in uso oggigiorno. Per questo è sempre meglio utilizzare i
+valori ottenuti da \func{sysconf}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Macro}&\textbf{Significato}\\
+ \hline
+ \hline
+ \macrod{\_POSIX\_JOB\_CONTROL}& Il sistema supporta il
+ \textit{job control} (vedi
+ sez.~\ref{sec:sess_job_control}).\\
+ \macrod{\_POSIX\_SAVED\_IDS} & Il sistema supporta gli identificatori del
+ gruppo \textit{saved} (vedi
+ sez.~\ref{sec:proc_access_id})
+ per il controllo di accesso dei processi.\\
+ \macrod{\_POSIX\_VERSION} & Fornisce la versione dello standard POSIX.1
+ supportata nel formato YYYYMML (ad esempio
+ 199009L).\\
+ \hline
+ \end{tabular}
+ \caption{Alcune macro definite in \headfile{limits.h} in conformità allo
+ standard POSIX.1.}
+ \label{tab:sys_posix1_other}
+\end{table}
+
+Oltre ai precedenti valori e a quelli relativi ai file elencati in
+tab.~\ref{tab:sys_posix1_file}, che devono essere obbligatoriamente definiti,
+lo standard POSIX.1 ne prevede molti altri. La lista completa si trova
+dall'header file \file{bits/posix1\_lim.h}, da non usare mai direttamente (è
+incluso automaticamente all'interno di \headfile{limits.h}). Di questi vale la
+pena menzionarne alcune macro di uso comune, riportate in
+tab.~\ref{tab:sys_posix1_other}, che non indicano un valore specifico, ma
+denotano la presenza di alcune funzionalità nel sistema, come il supporto del
+\textit{job control} o degli identificatori del gruppo \textit{saved}.
+
+Oltre allo standard POSIX.1, anche lo standard POSIX.2 definisce una serie di
+altre costanti. Siccome queste sono principalmente attinenti a limiti relativi
+alle applicazioni di sistema presenti, come quelli su alcuni parametri delle
+espressioni regolari o del comando \cmd{bc}, non li tratteremo esplicitamente,
+se ne trova una menzione completa nell'header file \file{bits/posix2\_lim.h},
+e alcuni di loro sono descritti nella pagina di manuale di \func{sysconf} e
+nel manuale della \acr{glibc}.
+
+Quando uno dei limiti o delle caratteristiche del sistema può variare, per non
+dover essere costretti a ricompilare un programma tutte le volte che si
+cambiano le opzioni con cui è compilato il kernel, o alcuni dei parametri
+modificabili al momento dell'esecuzione, è necessario ottenerne il valore
+attraverso la funzione \funcd{sysconf}, cui prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{long sysconf(int name)}
+\fdesc{Restituisce il valore di un parametro di sistema.}
+}
+
+{La funzione ritorna in caso di successo il valore del parametro richiesto, o
+ 1 se si tratta di un'opzione disponibile, 0 se l'opzione non è disponibile e
+ $-1$ per un errore, nel qual caso però \var{errno} non viene impostata.}
+\end{funcproto}
+
+La funzione prende come argomento un intero che specifica quale dei limiti si
+vuole conoscere. Uno specchietto contenente i principali valori disponibili in
+Linux è riportato in tab.~\ref{tab:sys_sysconf_par}, l'elenco completo è
+contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
+relative spiegazioni, si può trovare nel manuale della \acr{glibc}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|l|p{8cm}|}
+ \hline
+ \textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
+ \hline
+ \hline
+ \texttt{\_SC\_ARG\_MAX} & \const{ARG\_MAX}&
+ La dimensione massima degli argomenti passati
+ ad una funzione della famiglia \func{exec}.\\
+ \texttt{\_SC\_CHILD\_MAX} & \const{CHILD\_MAX}&
+ Il numero massimo di processi contemporanei
+ che un utente può eseguire.\\
+ \texttt{\_SC\_OPEN\_MAX} & \const{OPEN\_MAX}&
+ Il numero massimo di file che un processo può
+ mantenere aperti in contemporanea.\\
+ \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
+ Il massimo numero di stream che un processo
+ può mantenere aperti in contemporanea. Questo
+ limite è previsto anche dallo standard ANSI C,
+ che specifica la macro \const{FOPEN\_MAX}.\\
+ \texttt{\_SC\_TZNAME\_MAX}& \const{TZNAME\_MAX}&
+ La dimensione massima di un nome di una
+ \texttt{timezone} (vedi
+ sez.~\ref{sec:sys_date}).\\
+ \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
+ Massimo numero di gruppi supplementari che
+ può avere un processo (vedi
+ sez.~\ref{sec:proc_access_id}).\\
+ \texttt{\_SC\_SSIZE\_MAX} & \const{SSIZE\_MAX}&
+ Valore massimo del tipo di dato
+ \type{ssize\_t}.\\
+ \texttt{\_SC\_CLK\_TCK} & \const{CLK\_TCK} &
+ Il numero di \textit{clock tick} al secondo,
+ cioè l'unità di misura del
+ \textit{process time} (vedi
+ sez.~\ref{sec:sys_unix_time}).\\
+ \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
+ Indica se è supportato il \textit{job
+ control} (vedi
+ sez.~\ref{sec:sess_job_control}) in stile
+ POSIX.\\
+ \texttt{\_SC\_SAVED\_IDS} & \macro{\_POSIX\_SAVED\_IDS}&
+ Indica se il sistema supporta i
+ \textit{saved id} (vedi
+ sez.~\ref{sec:proc_access_id}).\\
+ \texttt{\_SC\_VERSION} & \macro{\_POSIX\_VERSION} &
+ Indica il mese e l'anno di approvazione
+ della revisione dello standard POSIX.1 a cui
+ il sistema fa riferimento, nel formato
+ YYYYMML, la revisione più recente è 199009L,
+ che indica il Settembre 1990.\\
+ \hline
+ \end{tabular}
+ \caption{Parametri del sistema leggibili dalla funzione \func{sysconf}.}
+ \label{tab:sys_sysconf_par}
+\end{table}
+
+In generale ogni limite o caratteristica del sistema per cui è definita una
+macro, sia dagli standard ANSI C e ISO C90, che da POSIX.1 e POSIX.2, può
+essere ottenuto attraverso una chiamata a \func{sysconf}. Il nome della
+costante da utilizzare come valore dell'argomento \param{name} si otterrà
+aggiungendo \code{\_SC\_} ai nomi delle costanti definite dai primi due
+standard (quelle di tab.~\ref{tab:sys_generic_macro}), o sostituendolo a
+\code{\_POSIX\_} per le costanti definite dagli altri due standard (quelle di
+tab.~\ref{tab:sys_posix1_general}).
+
+In linea teorica si dovrebbe fare uso di \func{sysconf} solo quando la
+relativa costante di sistema non è definita, quindi con un codice analogo al
+seguente:
+\includecodesnip{listati/get_child_max.c}
+ma in realtà con Linux queste costanti sono comunque definite, indicando però
+un limite generico che non è detto sia corretto; per questo motivo è sempre
+meglio usare i valori restituiti da \func{sysconf}.
+
+
+\subsection{Limiti e caratteristiche dei file}
+\label{sec:sys_file_limits}
+
+Come per le caratteristiche generali del sistema anche per i file esistono una
+serie di limiti (come la lunghezza del nome del file o il numero massimo di
+link) che dipendono sia dall'implementazione che dal filesystem in uso. Anche
+in questo caso lo standard prevede alcune macro che ne specificano il valore,
+riportate in tab.~\ref{tab:sys_file_macro}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|r|l|}
+ \hline
+ \textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
+ \hline
+ \hline
+ \constd{LINK\_MAX} &8 & Numero massimo di link a un file.\\
+ \constd{NAME\_MAX}& 14 & Lunghezza in byte di un nome di file. \\
+ \constd{PATH\_MAX}& 256 & Lunghezza in byte di un \textit{pathname}.\\
+ \constd{PIPE\_BUF}&4096 & Byte scrivibili atomicamente in una \textit{pipe}
+ (vedi sez.~\ref{sec:ipc_pipes}).\\
+ \constd{MAX\_CANON}&255 & Dimensione di una riga di terminale in modo
+ canonico (vedi sez.~\ref{sec:term_io_design}).\\
+ \constd{MAX\_INPUT}&255 & Spazio disponibile nella coda di input
+ del terminale (vedi
+ sez.~\ref{sec:term_io_design}).\\
+ \hline
+ \end{tabular}
+ \caption{Costanti per i limiti sulle caratteristiche dei file.}
+ \label{tab:sys_file_macro}
+\end{table}
+
+Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
+minimi anche per queste caratteristiche, che ogni sistema che vuole essere
+conforme deve rispettare. Le relative macro sono riportate in
+tab.~\ref{tab:sys_posix1_file} e per esse vale lo stesso discorso fatto per le
+analoghe di tab.~\ref{tab:sys_posix1_general}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|r|l|}
+ \hline
+ \textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
+ \hline
+ \hline
+ \macrod{\_POSIX\_LINK\_MAX} &8 & Numero massimo di link a un file.\\
+ \macrod{\_POSIX\_NAME\_MAX}& 14 & Lunghezza in byte di un nome di file.\\
+ \macrod{\_POSIX\_PATH\_MAX}& 256 & Lunghezza in byte di un
+ \textit{pathname}.\\
+ \macrod{\_POSIX\_PIPE\_BUF}& 512 & Byte scrivibili atomicamente in una
+ \textit{pipe}.\\
+ \macrod{\_POSIX\_MAX\_CANON}&255 & Dimensione di una riga di
+ terminale in modo canonico.\\
+ \macrod{\_POSIX\_MAX\_INPUT}&255 & Spazio disponibile nella coda di input
+ del terminale.\\
+% \macrod{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
+% \macrod{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
+% \macrod{\_POSIX\_FD\_SETSIZE}& 16 & \\
+% \macrod{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
+ \hline
+ \end{tabular}
+ \caption{Costanti dei valori minimi delle caratteristiche dei file per la
+ conformità allo standard POSIX.1.}
+ \label{tab:sys_posix1_file}
+\end{table}
+
+Tutti questi limiti sono definiti in \headfile{limits.h}; come nel caso
+precedente il loro uso è di scarsa utilità in quanto ampiamente superati in
+tutte le implementazioni moderne. In generale i limiti per i file sono molto
+più soggetti ad essere variabili rispetto ai limiti generali del sistema; ad
+esempio parametri come la lunghezza del nome del file o il numero di link
+possono variare da filesystem a filesystem.
+
+Per questo motivo quando si ha a che fare con limiti relativi ai file questi
+devono essere sempre controllati con la funzione \funcd{pathconf}, il cui
+prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{long pathconf(char *path, int name)}
+\fdesc{Restituisce il valore di un parametro dei file.}
+}
+
+{La funzione ritorna il valore del parametro richiesto in caso di successo e
+ $-1$ per un errore, nel qual caso \var{errno} viene impostata ad uno degli
+ errori possibili relativi all'accesso a \param{path}.}
+\end{funcproto}
+
+La funzione richiede che si specifichi il limite che si vuole controllare con
+l'argomento \param{name}, per il quale si deve usare la relativa costante
+identificativa, il cui nome si ottiene da quelle descritte in
+tab.~\ref{tab:sys_file_macro} e tab.~\ref{tab:sys_posix1_file} con la stessa
+convenzione già vista con \func{sysconf}, ma un questo caso con l'uso del
+suffisso ``\texttt{\_PC\_}''.
+
+In questo caso la funzione richiede anche un secondo argomento \param{path}
+che specifichi a quale file si fa riferimento, dato che il valore del limite
+cercato può variare a seconda del filesystem su cui si trova il file. Una
+seconda versione della funzione, \funcd{fpathconf}, opera su un file
+descriptor invece che su un \textit{pathname}, il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{long fpathconf(int fd, int name)}
+\fdesc{Restituisce il valore di un parametro dei file.}
+}
+
+{È identica a \func{pathconf} solo che utilizza un file descriptor invece di
+ un \textit{pathname}; pertanto gli errori restituiti in \var{errno} cambiano
+ di conseguenza.}
+\end{funcproto}
+\noindent ed il suo comportamento è identico a quello di \func{pathconf} a
+parte quello di richiedere l'indicazione di un file descriptor
+nell'argomento \param{fd}.
+
+
+
+\subsection{I parametri del kernel ed il filesystem \texttt{/proc}}
+\label{sec:sys_sysctl}
+
+Tradizionalmente la funzione che permette la lettura ed l'impostazione dei
+parametri del sistema è \funcm{sysctl}. Si tratta di una funzione derivata da
+BSD4.4 ed introdotta su Linux a partire dal kernel 1.3.57, ma oggi il suo uso
+è totalmente deprecato. Una \textit{system call} \funcm{\_sysctl} continua ad
+esistere, ma non dispone più di una interfaccia nella \acr{glibc} ed il suo
+utilizzo può essere effettuato solo tramite \func{syscall}, ma di nuovo questo
+viene sconsigliato in quanto la funzionalità non è più mantenuta e molto
+probabilmente sarà rimossa nel prossimo futuro. Per questo motivo eviteremo di
+trattarne i particolari.
+
+Lo scopo di \funcm{sysctl} era quello di fornire ai programmi una modalità per
+modificare i parametri di sistema. Questi erano organizzati in maniera
+gerarchica all'interno di un albero e per accedere a ciascuno di essi
+occorreva specificare un percorso attraverso i vari nodi dell'albero, in
+maniera analoga a come avviene per la risoluzione di un \textit{pathname}.
+
+I parametri accessibili e modificabili attraverso questa funzione sono
+moltissimi, dipendendo anche dallo stato corrente del kernel, ad esempio dai
+moduli che sono stati caricati nel sistema. Inoltre non essendo standardizzati
+i loro nomi possono variare da una versione di kernel all'altra, alcuni esempi
+di questi parametri sono:
+\begin{itemize*}
+\item il nome di dominio
+\item i parametri del meccanismo di \textit{paging}.
+\item il filesystem montato come radice
+\item la data di compilazione del kernel
+\item i parametri dello stack TCP
+\item il numero massimo di file aperti
+\end{itemize*}
+
+
+
+\index{file!filesystem~\texttt {/proc}!definizione|(}
+
+Dato che fin dall'inizio i parametri erano organizzati in una struttura
+albero, è parso naturale rimappare questa organizzazione utilizzando il
+filesystem \file{/proc}. Questo è un filesystem completamente virtuale, il cui
+contenuto è generato direttamente dal kernel, che non fa riferimento a nessun
+dispositivo fisico, ma presenta in forma di file e directory i dati di alcune
+delle strutture interne del kernel stesso. Il suo utilizzo principale, come
+denuncia il nome stesso, è quello di fornire una interfaccia per ottenere i
+dati relativi ai processi (venne introdotto a questo scopo su BSD), ma nel
+corso del tempo il suo uso è stato ampliato.
+
+All'interno di questo filesystem sono pertanto presenti una serie di file che
+riflettono il contenuto dei parametri del kernel (molti dei quali accessibili
+in sola lettura) e in altrettante directory, nominate secondo il relativo
+\ids{PID}, vengono mantenute le informazioni relative a ciascun processo
+attivo nel sistema.
+
+In particolare l'albero dei valori dei parametri di sistema impostabili con
+\func{sysctl} viene presentato in forma di una gerarchia di file e directory a
+partire dalla directory \file{/proc/sys}, cosicché è possibile accedere al
+valore di un parametro del kernel tramite il \textit{pathname} ad un file
+sotto \file{/proc/sys} semplicemente leggendone il contenuto, così come si può
+modificare un parametro scrivendo sul file ad esso corrispondente.
+
+Il kernel si occupa di generare al volo il contenuto ed i nomi dei file
+corrispondenti ai vari parametri che sono presenti, e questo ha il grande
+vantaggio di rendere accessibili gli stessi ad un qualunque comando di shell e
+di permettere la navigazione dell'albero in modo da riconoscere quali
+parametri sono presenti senza dover cercare un valore all'interno di una
+pagina di manuale.
+
+Inizialmente l'uso del filesystem \file{/proc} serviva soltanto a replicare
+l'accesso, con altrettante corrispondenze ai file presenti in
+\file{/proc/sys}, ai parametri impostabili tradizionalmente con \func{sysctl},
+ma vista la assoluta naturalità dell'interfaccia, e la sua maggiore
+efficienza, nelle versioni più recenti del kernel questa è diventata la
+modalità canonica per modificare i parametri del kernel, evitando di dover
+ricorrere all'uso di una \textit{system call} specifica che pur essendo ancora
+presente, prima o poi verrà eliminata.
+
+Nonostante la semplificazione nella gestione ottenuta con l'uso di
+\file{/proc/sys} resta il problema generale di conoscere il significato di
+ciascuno degli innumerevoli parametri che vi si trovano. Purtroppo la
+documentazione degli stessi spesso risulta incompleta e non aggiornata, ma
+buona parte di quelli può importanti sono descritti dalla documentazione
+inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
+
+Ma oltre alle informazioni che sostituiscono quelle ottenibili dalla ormai
+deprecata \func{sysctl} dentro \file{/proc} sono disponibili moltissime altre
+informazioni, fra cui ad esempio anche quelle fornite dalla funzione di
+sistema \funcd{uname},\footnote{con Linux ci sono in realtà 3 \textit{system
+ call} diverse per le dimensioni delle stringhe restituite, le prime due
+ usano rispettivamente delle lunghezze di 9 e 65 byte, la terza usa anch'essa
+ 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con una
+ lunghezza di 257 byte, la \acr{glibc} provvede a mascherare questi dettagli
+ usando la versione più recente disponibile.} il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{sys/utsname.h}
+\fdecl{int uname(struct utsname *info)}
+\fdesc{Restituisce informazioni generali sul sistema.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} può assumere solo il valore \errval{EFAULT}.}
+\end{funcproto}
+
+La funzione, che viene usata dal comando \cmd{uname}, restituisce una serie di
+informazioni relative al sistema nelle stringhe che costituiscono i campi
+della struttura \struct{utsname} (la cui definizione è riportata in
+fig.~\ref{fig:sys_utsname}) che viene scritta nel buffer puntato
+dall'argomento \param{info}.
+
+\begin{figure}[!ht!b]
+ \footnotesize \centering
+ \begin{minipage}[c]{0.85\textwidth}
+ \includestruct{listati/ustname.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{utsname}.}
+ \label{fig:sys_utsname}
+\end{figure}
+
+Si noti come in fig.~\ref{fig:sys_utsname} le dimensioni delle stringhe di
+\struct{utsname} non sono specificate. Il manuale della \acr{glibc} indica
+due costanti per queste dimensioni, \constd{\_UTSNAME\_LENGTH} per i campi
+standard e \constd{\_UTSNAME\_DOMAIN\_LENGTH} per quello relativo al nome di
+dominio, altri sistemi usano nomi diversi come \constd{SYS\_NMLN} o
+\constd{\_SYS\_NMLN} o \constd{UTSLEN} che possono avere valori diversi. Dato
+che il buffer per \struct{utsname} deve essere preallocato l'unico modo per
+farlo in maniera sicura è allora usare come dimensione il valore ottenuto con
+\code{sizeof(utsname)}.
+
+Le informazioni vengono restituite in ciascuno dei singoli campi di
+\struct{utsname} in forma di stringhe terminate dal carattere NUL. In
+particolare dette informazioni sono:
+\begin{itemize*}
+\item il nome del sistema operativo;
+\item il nome della macchine (l'\textit{hostname});
+\item il nome della release del kernel;
+\item il nome della versione del kernel;
+\item il tipo di hardware della macchina;
+\item il nome del domino (il \textit{domainname});
+\end{itemize*}
+ma l'ultima di queste informazioni è stata aggiunta di recente e non è
+prevista dallo standard POSIX, per questo essa è accessibile, come mostrato in
+fig.~\ref{fig:sys_utsname}, solo se si è definita la macro
+\macro{\_GNU\_SOURCE}.
+
+Come accennato queste stesse informazioni, anche se a differenza di
+\func{sysctl} la funzione continua ad essere mantenuta, si possono ottenere
+direttamente tramite il filesystem \file{/proc}, esse infatti sono mantenute
+rispettivamente nei file \sysctlrelfiled{kernel}{ostype},
+\sysctlrelfiled{kernel}{hostname}, \sysctlrelfiled{kernel}{osrelease},
+\sysctlrelfiled{kernel}{version} e \sysctlrelfiled{kernel}{domainname} che si
+trovano sotto la directory \file{/proc/sys/kernel/}.
+
+\index{file!filesystem~\texttt {/proc}!definizione|)}
+
+
+
+\section{La gestione del sistema}
+\label{sec:sys_management}
+
+In questa sezione prenderemo in esame le interfacce di programmazione messe a
+disposizione per affrontare una serie di tematiche attinenti la gestione
+generale del sistema come quelle relative alla gestione di utenti e gruppi, al
+trattamento delle informazioni relative ai collegamenti al sistema, alle
+modalità per effettuare lo spegnimento o il riavvio di una macchina.
+
+
+\subsection{La gestione delle informazioni su utenti e gruppi}
+\label{sec:sys_user_group}
+
+Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
+(password, corrispondenze fra nomi simbolici e \ids{UID} numerici, home
+directory, ecc.) venivano registrate all'interno dei due file di testo
+\conffiled{/etc/passwd} ed \conffiled{/etc/group}, il cui formato è descritto
+dalle relative pagine del manuale\footnote{nella quinta sezione, quella dei
+ file di configurazione (esistono comandi corrispondenti), una trattazione
+ sistemistica dell'intero argomento coperto in questa sezione si consulti
+ sez.~4.3 di \cite{AGL}.} e tutte le funzioni che richiedevano l'accesso a
+queste informazione andavano a leggere direttamente il contenuto di questi
+file.
+
+In realtà oltre a questi due file da molto tempo gran parte dei sistemi
+unix-like usano il cosiddetto sistema delle \textit{shadow password} che
+prevede anche i due file \conffiled{/etc/shadow} e \conffiled{/etc/gshadow}, in
+cui sono state spostate le informazioni di autenticazione (ed inserite alcune
+estensioni di gestione avanzata) per toglierle dagli altri file che devono
+poter essere letti da qualunque processo per poter effettuare l'associazione
+fra username e \ids{UID}.
+
+Col tempo però questa impostazione ha incominciato a mostrare dei limiti. Da
+una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
+la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
+che sta per \textit{Pluggable Authentication Method}) che fornisce una
+interfaccia comune per i processi di autenticazione, svincolando completamente
+le singole applicazioni dai dettagli del come questa viene eseguita e di dove
+vengono mantenuti i dati relativi. Si tratta di un sistema modulare, in cui è
+possibile utilizzare anche più meccanismi insieme, diventa così possibile
+avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
+diversi formati per le password e diversi supporti per le informazioni. Il
+tutto avviene in maniera trasparente per le applicazioni purché per ciascun
+meccanismo si disponga della opportuna libreria che implementa l'interfaccia
+di PAM.
+
+Dall'altra parte, il diffondersi delle reti e la necessità di centralizzare le
+informazioni degli utenti e dei gruppi per insiemi di macchine e servizi
+all'interno di una stessa organizzazione, in modo da mantenere coerenti i
+dati, ha portato anche alla necessità di poter recuperare e memorizzare dette
+informazioni su supporti diversi dai file citati, introducendo il sistema del
+\textit{Name Service Switch} (che tratteremo brevemente in
+sez.~\ref{sec:sock_resolver}) dato che la sua applicazione è cruciale nella
+procedura di risoluzione di nomi di rete.
+
+In questo paragrafo ci limiteremo comunque a trattare le funzioni classiche
+per la lettura delle informazioni relative a utenti e gruppi tralasciando
+completamente quelle relative all'autenticazione.
+% Per questo non tratteremo
+% affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
+% \textit{Name Service Switch}, un meccanismo messo a disposizione dalla
+% \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
+% necessario trovare una corrispondenza fra un nome ed un numero (od altra
+% informazione) ad esso associato, come appunto, quella fra uno username ed un
+% \ids{UID} o fra un \ids{GID} ed il nome del gruppo corrispondente.
+Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
+queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
+ Service Switch}, per cui sono in grado di ricevere informazioni qualunque
+sia il supporto su cui esse vengono mantenute. Per leggere le informazioni
+relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
+\funcd{getpwnam}, i cui prototipi sono:
+
+\begin{funcproto}{
+\fhead{pwd.h}
+\fhead{sys/types.h}
+\fdecl{struct passwd *getpwuid(uid\_t uid)}
+\fdecl{struct passwd *getpwnam(const char *name)}
+\fdesc{Restituiscono le informazioni relative all'utente specificato.}
+}
+
+{Le funzioni ritornano il puntatore alla struttura contenente le informazioni
+ in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
+ utente corrispondente a quanto specificato, nel qual caso \var{errno}
+ assumerà il valore riportato dalle funzioni di sistema sottostanti.}
+\end{funcproto}
+
+Le due funzioni forniscono le informazioni memorizzate nel registro degli
+utenti (che nelle versioni più recenti per la parte di credenziali di
+autenticazione vengono ottenute attraverso PAM) relative all'utente
+specificato attraverso il suo \ids{UID} o il nome di login. Entrambe le
+funzioni restituiscono un puntatore ad una struttura di tipo \struct{passwd}
+la cui definizione (anch'essa eseguita in \headfiled{pwd.h}) è riportata in
+fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente illustrato il
+significato dei vari campi.
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{0.8\textwidth}
+ \includestruct{listati/passwd.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{passwd} contenente le informazioni relative
+ ad un utente del sistema.}
+ \label{fig:sys_passwd_struct}
+\end{figure}
+
+La struttura usata da entrambe le funzioni è allocata staticamente, per questo
+motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
+memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
+fanno riferimento. Ovviamente questo implica che dette funzioni non possono
+essere rientranti; per questo motivo ne esistono anche due versioni
+alternative (denotate dalla solita estensione \code{\_r}), i cui prototipi
+sono:
+
+\begin{funcproto}{
+\fhead{pwd.h}
+\fhead{sys/types.h}
+\fdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
+ char *buffer,\\
+\phantom{struct passwd *getpwuid\_r(}size\_t buflen, struct passwd **result)}
+\fdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
+ *password, char *buffer,\\
+\phantom{struct passwd *getpwnam\_r(}size\_t buflen, struct passwd **result)}
+\fdesc{Restituiscono le informazioni relative all'utente specificato.}
+}
+
+{Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà il valore riportato dalle di sistema funzioni
+ sottostanti.}
+\end{funcproto}
+
+In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
+la memoria necessaria a contenere le informazioni. In particolare i valori
+della struttura \struct{passwd} saranno restituiti all'indirizzo
+\param{password} mentre la memoria allocata all'indirizzo \param{buffer}, per
+un massimo di \param{buflen} byte, sarà utilizzata per contenere le stringhe
+puntate dai campi di \param{password}. Infine all'indirizzo puntato da
+\param{result} viene restituito il puntatore ai dati ottenuti, cioè
+\param{buffer} nel caso l'utente esista, o \val{NULL} altrimenti. Qualora i
+dati non possano essere contenuti nei byte specificati da \param{buflen}, la
+funzione fallirà restituendo \errcode{ERANGE} (e \param{result} sarà comunque
+impostato a \val{NULL}).
+
+Sia queste versioni rientranti che precedenti gli errori eventualmente
+riportati in \var{errno} in caso di fallimento dipendono dalla sottostanti
+funzioni di sistema usate per ricavare le informazioni (si veda quanto
+illustrato in sez.~\ref{sec:sys_errno}) per cui se lo si vuole utilizzare è
+opportuno inizializzarlo a zero prima di invocare le funzioni per essere
+sicuri di non avere un residuo di errore da una chiamata precedente. Il non
+aver trovato l'utente richiesto infatti può essere dovuto a diversi motivi (a
+partire dal fatto che non esista) per cui si possono ottenere i valori di
+errore più vari a seconda dei casi.
+
+Del tutto analoghe alle precedenti sono le funzioni \funcd{getgrnam} e
+\funcd{getgrgid} che permettono di leggere le informazioni relative ai gruppi,
+i loro prototipi sono:
+
+\begin{funcproto}{
+\fhead{grp.h}
+\fhead{sys/types.h}
+\fdecl{struct group *getgrgid(gid\_t gid)}
+\fdecl{struct group *getgrnam(const char *name)}
+\fdesc{Restituiscono le informazioni relative al gruppo specificato.}
+}
+
+{Le funzioni ritornano il puntatore alla struttura contenente le informazioni
+ in caso di successo e \val{NULL} nel caso non sia stato trovato nessun
+ utente corrispondente a quanto specificato, nel qual caso \var{errno}
+ assumerà il valore riportato dalle funzioni di sistema sottostanti.}
+\end{funcproto}
+
+Come per le precedenti per gli utenti esistono anche le analoghe versioni
+rientranti che di nuovo utilizzano la stessa estensione \code{\_r}; i loro
+prototipi sono:
+
+\begin{funcproto}{
+\fhead{grp.h}
+\fhead{sys/types.h}
+\fdecl{int getgrgid\_r(gid\_t gid, struct group *grp, char *buf,
+ size\_t buflen,\\
+\phantom{int getgrgid\_r(}struct group **result)}
+\fdecl{int getgrnam\_r(const char *name, struct group *grp, char *buf,
+ size\_t buflen,\\
+\phantom{int getgrnam\_r(}struct group **result)}
+\fdesc{Restituiscono le informazioni relative al gruppo specificato.}
+}
+
+{Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
+ sottostanti.}
+\end{funcproto}
+
+Il comportamento di tutte queste funzioni è assolutamente identico alle
+precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
+in questo caso le informazioni vengono restituite in una struttura di tipo
+\struct{group}, la cui definizione è riportata in
+fig.~\ref{fig:sys_group_struct}.
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{0.8\textwidth}
+ \includestruct{listati/group.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{group} contenente le informazioni relative ad
+ un gruppo del sistema.}
+ \label{fig:sys_group_struct}
+\end{figure}
+
+Le funzioni viste finora sono in grado di leggere le informazioni sia
+direttamente dal file delle password in \conffile{/etc/passwd} che tramite il
+sistema del \textit{Name Service Switch} e sono completamente generiche. Si
+noti però che non c'è una funzione che permetta di impostare direttamente una
+password.\footnote{in realtà questo può essere fatto ricorrendo alle funzioni
+ della libreria PAM, ma questo non è un argomento che tratteremo qui.} Dato
+che POSIX non prevede questa possibilità esiste un'altra interfaccia che lo
+fa, derivata da SVID le cui funzioni sono riportate in
+tab.~\ref{tab:sys_passwd_func}. Questa interfaccia però funziona soltanto
+quando le informazioni sono mantenute su un apposito file di \textsl{registro}
+di utenti e gruppi, con il formato classico di \conffile{/etc/passwd} e
+\conffile{/etc/group}.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Funzione} & \textbf{Significato}\\
+ \hline
+ \hline
+ \funcm{fgetpwent} & Legge una voce dal file di registro degli utenti
+ specificato.\\
+ \funcm{fgetpwent\_r}& Come la precedente, ma rientrante.\\
+ \funcm{putpwent} & Immette una voce in un file di registro degli
+ utenti.\\
+ \funcm{getpwent} & Legge una voce da \conffile{/etc/passwd}.\\
+ \funcm{getpwent\_r} & Come la precedente, ma rientrante.\\
+ \funcm{setpwent} & Ritorna all'inizio di \conffile{/etc/passwd}.\\
+ \funcm{endpwent} & Chiude \conffile{/etc/passwd}.\\
+ \funcm{fgetgrent} & Legge una voce dal file di registro dei gruppi
+ specificato.\\
+ \funcm{fgetgrent\_r}& Come la precedente, ma rientrante.\\
+ \funcm{putgrent} & Immette una voce in un file di registro dei gruppi.\\
+ \funcm{getgrent} & Legge una voce da \conffile{/etc/group}.\\
+ \funcm{getgrent\_r} & Come la precedente, ma rientrante.\\
+ \funcm{setgrent} & Ritorna all'inizio di \conffile{/etc/group}.\\
+ \funcm{endgrent} & Chiude \conffile{/etc/group}.\\
+ \hline
+ \end{tabular}
+ \caption{Funzioni per la manipolazione dei campi di un file usato come
+ registro per utenti o gruppi nel formato di \conffile{/etc/passwd} e
+ \conffile{/etc/group}.}
+ \label{tab:sys_passwd_func}
+\end{table}
+
+% TODO mancano i prototipi di alcune delle funzioni
+
+Dato che oramai tutte le distribuzioni di GNU/Linux utilizzano le
+\textit{shadow password} (quindi con delle modifiche rispetto al formato
+classico del file \conffile{/etc/passwd}), si tenga presente che le funzioni
+di questa interfaccia che permettono di scrivere delle voci in un
+\textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
+hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
+questa estensione.
+
+Per questo motivo l'uso di queste funzioni è deprecato, in quanto comunque non
+funzionale rispetto ad un sistema attuale, pertanto ci limiteremo a fornire
+soltanto l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
+ulteriore. Chi volesse insistere ad usare questa interfaccia può fare
+riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
+della \acr{glibc} per i dettagli del funzionamento.
+
+
+
+\subsection{Il registro della \textsl{contabilità} degli utenti}
+\label{sec:sys_accounting}
+
+Un altro insieme di funzioni relative alla gestione del sistema che
+esamineremo è quello che permette di accedere ai dati del registro della
+cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti. In esso
+vengono mantenute una serie di informazioni storiche relative sia agli utenti
+che si sono collegati al sistema, tanto per quelli correntemente collegati,
+che per la registrazione degli accessi precedenti, sia relative all'intero
+sistema, come il momento di lancio di processi da parte di \cmd{init}, il
+cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
+della macchina.
+
+I dati vengono usualmente memorizzati nei due file \file{/var/run/utmp} e
+\file{/var/log/wtmp}. che sono quelli previsti dal \textit{Linux Filesystem
+ Hierarchy Standard}, adottato dalla gran parte delle distribuzioni. Quando
+un utente si collega viene aggiunta una voce a \file{/var/run/utmp} in cui
+viene memorizzato il nome di login, il terminale da cui ci si collega,
+l'\ids{UID} della shell di login, l'orario della connessione ed altre
+informazioni. La voce resta nel file fino al logout, quando viene cancellata
+e spostata in \file{/var/log/wtmp}.
+
+In questo modo il primo file viene utilizzato per registrare chi sta
+utilizzando il sistema al momento corrente, mentre il secondo mantiene la
+registrazione delle attività degli utenti. A quest'ultimo vengono anche
+aggiunte delle voci speciali per tenere conto dei cambiamenti del sistema,
+come la modifica del runlevel, il riavvio della macchina, ecc. Tutte queste
+informazioni sono descritte in dettaglio nel manuale della \acr{glibc}.
+
+Questi file non devono mai essere letti direttamente, ma le informazioni che
+contengono possono essere ricavate attraverso le opportune funzioni di
+libreria. Queste sono analoghe alle precedenti funzioni (vedi
+tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
+solo che in questo caso la struttura del registro della \textsl{contabilità} è
+molto più complessa, dato che contiene diversi tipi di informazione.
+
+Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
+servono rispettivamente a aprire e a chiudere il file che contiene il registro
+della \textsl{contabilità} degli, e a specificare su quale file esso viene
+mantenuto. I loro prototipi sono:
+
+\begin{funcproto}{
+\fhead{utmp.h}
+\fdecl{void utmpname(const char *file)}
+\fdesc{Specifica il file da usare come registro.}
+\fdecl{void setutent(void)}
+\fdesc{Apre il file del registro.}
+\fdecl{void endutent(void)}
+\fdesc{Chiude il file del registro.}
+}
+
+{Le funzioni non ritornano nulla.}
+\end{funcproto}
+
+Si tenga presente che le funzioni non restituiscono nessun valore, pertanto
+non è possibile accorgersi di eventuali errori, ad esempio se si è impostato
+un nome di file sbagliato con \func{utmpname}.
+
+Nel caso non si sia utilizzata \func{utmpname} per specificare un file di
+registro alternativo, sia \func{setutent} che \func{endutent} operano usando
+il default che è \sysfile{/var/run/utmp} il cui nome, così come una serie di
+altri valori di default per i \textit{pathname} di uso più comune, viene
+mantenuto nei valori di una serie di costanti definite includendo
+\headfiled{paths.h}, in particolare quelle che ci interessano sono:
+\begin{basedescript}{\desclabelwidth{2.0cm}}
+\item[\constd{\_PATH\_UTMP}] specifica il file che contiene il registro per
+ gli utenti correntemente collegati, questo è il valore che viene usato se
+ non si è utilizzato \func{utmpname} per modificarlo;
+\item[\constd{\_PATH\_WTMP}] specifica il file che contiene il registro per
+ l'archivio storico degli utenti collegati;
+\end{basedescript}
+che nel caso di Linux hanno un valore corrispondente ai file
+\sysfile{/var/run/utmp} e \sysfile{/var/log/wtmp} citati in precedenza.
+
+Una volta aperto il file del registro degli utenti si può eseguire una
+scansione leggendo o scrivendo una voce con le funzioni \funcd{getutent},
+\funcd{getutid}, \funcd{getutline} e \funcd{pututline}, i cui prototipi sono:
+
+
+\begin{funcproto}{
+\fhead{utmp.h}
+\fdecl{struct utmp *getutent(void)}
+\fdesc{Legge una voce dalla posizione corrente nel registro.}
+\fdecl{struct utmp *getutid(struct utmp *ut)}
+\fdesc{Ricerca una voce sul registro.}
+\fdecl{struct utmp *getutline(struct utmp *ut)}
+\fdesc{Ricerca una voce sul registro attinente a un terminale.}
+\fdecl{struct utmp *pututline(struct utmp *ut)}
+\fdesc{Scrive una voce nel registro.}
+}
+
+{Le funzioni ritornano il puntatore ad una struttura \struct{utmp} in caso di
+ successo e \val{NULL} in caso di errore, nel qual caso \var{errno} assumerà
+ il valore riportato dalle funzioni di sistema sottostanti.}
+\end{funcproto}
+
+Tutte queste funzioni fanno riferimento ad una struttura di tipo
+\struct{utmp}, la cui definizione in Linux è riportata in
+fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
+voce dal registro: \func{getutent} legge semplicemente la prima voce
+disponibile, le altre due permettono di eseguire una ricerca. Aprendo il
+registro con \func{setutent} ci si posiziona al suo inizio, ogni chiamata di
+queste funzioni eseguirà la lettura sulle voci seguenti, pertanto la posizione
+sulla voce appena letta, in modo da consentire una scansione del file. Questo
+vale anche per \func{getutid} e \func{getutline}, il che comporta che queste
+funzioni effettuano comunque una ricerca ``\textsl{in avanti}''.
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{0.9\textwidth}
+ \includestruct{listati/utmp.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{utmp} contenente le informazioni di una voce
+ del registro di \textsl{contabilità}.}
+ \label{fig:sys_utmp_struct}
+\end{figure}
+
+Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
+campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
+riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
+\const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
+verrà restituito la prima voce che corrisponde al tipo determinato; quando
+invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
+\const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
+corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \constd{EMPTY} & Non contiene informazioni valide.\\
+ \constd{RUN\_LVL} & Identica il runlevel del sistema.\\
+ \constd{BOOT\_TIME} & Identifica il tempo di avvio del sistema.\\
+ \constd{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
+ sistema.\\
+ \constd{NEW\_TIME} & Identifica da quanto è stato modificato il
+ sistema.\\
+ \constd{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}.\\
+ \constd{LOGIN\_PROCESS}& Identifica un processo di login.\\
+ \constd{USER\_PROCESS} & Identifica un processo utente.\\
+ \constd{DEAD\_PROCESS} & Identifica un processo terminato.\\
+% \constd{ACCOUNTING} & ??? \\
+ \hline
+ \end{tabular}
+ \caption{Classificazione delle voci del registro a seconda dei
+ possibili valori del campo \var{ut\_type}.}
+ \label{tab:sys_ut_type}
+\end{table}
+
+La funzione \func{getutline} esegue la ricerca sulle voci che hanno un
+\var{ut\_type} con valore uguale a \const{LOGIN\_PROCESS} o
+\const{USER\_PROCESS}, restituendo la prima che corrisponde al valore di
+\var{ut\_line}, che specifica il dispositivo di terminale che interessa, da
+indicare senza il \file{/dev/} iniziale. Lo stesso criterio di ricerca è usato
+da \func{pututline} per trovare uno spazio dove inserire la voce specificata;
+qualora questo spazio non venga trovato la voce viene aggiunta in coda al
+registro.
+
+In generale occorre però tenere conto che queste funzioni non sono
+completamente standardizzate, e che in sistemi diversi possono esserci
+differenze; ad esempio \func{pututline} restituisce \code{void} in vari
+sistemi (compreso Linux, fino alle \acr{libc5}). Qui seguiremo la sintassi
+fornita dalla \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
+introdotto delle nuove strutture (e relativi file) di tipo \struct{utmpx}, che
+sono un sovrainsieme della \struct{utmp} usata tradizionalmente ed altrettante
+funzioni che le usano al posto di quelle citate.
+
+La \acr{glibc} utilizzava già una versione estesa di \struct{utmp}, che
+rende inutili queste nuove strutture, per questo su Linux \struct{utmpx} viene
+definita esattamente come \struct{utmp}, con gli stessi campi di
+fig.~\ref{fig:sys_utmp_struct}. Altrettanto dicasi per le nuove funzioni di
+gestione previste dallo standard: \funcm{getutxent}, \funcm{getutxid},
+\funcm{getutxline}, \funcm{pututxline}, \funcm{setutxent} e \funcm{endutxent}.
+
+Tutte queste funzioni, definite con \struct{utmpx} dal file di dichiarazione
+\headfile{utmpx.h}, su Linux sono ridefinite come sinonimi delle funzioni
+appena viste, con argomento di tipo \struct{utmpx} anziché \struct{utmp} ed
+hanno lo stesso identico comportamento. Per completezza viene definita anche
+\funcm{utmpxname} che non è prevista da POSIX.1-2001.
+
+Come già visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
+staticamente rende le funzioni di lettura dei dati appena illustrate non
+rientranti. Per questo motivo la \acr{glibc} fornisce anche delle versioni
+rientranti: \func{getutent\_r}, \func{getutid\_r}, \func{getutline\_r}, che
+invece di restituire un puntatore restituiscono un intero e prendono due
+argomenti aggiuntivi, i rispettivi prototipi sono:
+
+\begin{funcproto}{
+\fhead{utmp.h}
+\fdecl{int *getutent\_r(struct utmp *buffer, struct utmp **result)}
+\fdesc{Legge una voce dalla posizione corrente nel registro.}
+\fdecl{int *getutid\_r(struct utmp *buffer, struct utmp **result, struct utmp
+ *ut)}
+\fdesc{Ricerca una voce sul registro.}
+\fdecl{int *getutline\_r(struct utmp *buffer, struct utmp **result, struct utmp
+ *ut)}
+\fdesc{Ricerca una voce sul registro attinente a un terminale.}
+}
+
+{Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà il valore riportato dalle funzioni di sistema
+ sottostanti.}
+\end{funcproto}
+
+Le funzioni si comportano esattamente come le precedenti analoghe non
+rientranti, solo che restituiscono il risultato all'indirizzo specificato dal
+primo argomento aggiuntivo \param{buffer} mentre il secondo, \param{result)}
+viene usato per restituire il puntatore al buffer stesso.
+
+Infine la \acr{glibc} fornisce altre due funzioni, \funcd{updwtmp} e
+\funcd{logwtmp}, come estensione per scrivere direttamente delle voci nel file
+sul registro storico \sysfile{/var/log/wtmp}; i rispettivi prototipi sono:
+
+\begin{funcproto}{
+\fhead{utmp.h}
+\fdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
+\fdesc{Aggiunge una voce in coda al registro.}
+\fdecl{void logwtmp(const char *line, const char *name, const char *host)}
+\fdesc{Aggiunge nel registro una voce con i valori specificati.}
+}
+
+{Le funzioni non restituiscono nulla.}
+\end{funcproto}
+
+La prima funzione permette l'aggiunta di una voce in coda al file del registro
+storico, indicato dal primo argomento, specificando direttamente una struttura
+\struct{utmp}. La seconda invece utilizza gli argomenti \param{line},
+\param{name} e \param{host} per costruire la voce che poi aggiunge chiamando
+\func{updwtmp}.
+
+Queste funzioni non sono previste da POSIX.1-2001, anche se sono presenti in
+altri sistemi (ad esempio Solaris e NetBSD), per mantenere una coerenza con le
+altre funzioni definite nello standard che usano la struttura \struct{utmpx}
+la \acr{glibc} definisce anche una funzione \funcm{updwtmpx}, che come in
+precedenza è identica a \func{updwtmp} con la sola differenza di richiedere
+l'uso di \headfiled{utmpx.h} e di una struttura \struct{utmpx} come secondo
+argomento.
+
+
+\subsection{La gestione dello spegnimento e del riavvio}
+\label{sec:sys_reboot}
+
+Una delle operazioni di gestione generale del sistema è quella che attiene
+alle modalità con cui se ne può gestire lo spegnimento ed il riavvio. Perché
+questo avvenga in maniera corretta, in particolare per le parti che comportano
+lo spegnimento effettivo della macchina, occorre che il kernel effettui le
+opportune operazioni interagendo con il BIOS ed i dispositivi che controllano
+l'erogazione della potenza.
+
+La funzione di sistema che controlla lo spegnimento ed il riavvio (ed altri
+aspetti della relativa procedura) è \funcd{reboot},\footnote{la funzione
+ illustrata è quella fornita dalla \acr{glibc} che maschera i dettagli di
+ basso livello della \textit{system call} la quale richiede attualmente tre
+ argomenti; fino al kernel 2.1.30 la \textit{system call} richiedeva un
+ ulteriore quarto argomento, i primi due indicano dei \textit{magic number}
+ interi che possono assumere solo alcuni valori predefiniti, il terzo un
+ comando, corrispondente all'unico argomento della funzione della \acr{glibc}
+ ed il quarto argomento aggiuntivo, ora ignorato, un puntatore generico ad
+ ulteriori dati.} il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{unistd.h}
+\fhead{sys/reboot.h}
+\fdecl{int reboot(int cmd)}
+\fdesc{Controlla il riavvio o l'arresto della macchina.}
+}
+
+{La funzione non ritorna o ritorna $0$ in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà uno dei valori:
+ \begin{errlist}
+ \item[\errcode{EFAULT}] c'è un indirizzo non valido nel passaggio degli
+ argomenti con il comando \const{LINUX\_REBOOT\_CMD\_RESTART2} (obsoleto).
+ \item[\errcode{EINVAL}] si sono specificati valori non validi per gli
+ argomenti.
+ \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
+ \textit{capability} \const{CAP\_SYS\_BOOT}).
+ \end{errlist}
+}
+\end{funcproto}
+
+La funzione, oltre al riavvio ed allo spegnimento, consente anche di
+controllare l'uso della combinazione di tasti tradizionalmente usata come
+scorciatoia da tastiera per richiedere il riavvio (\texttt{Ctrl-Alt-Del},
+denominata in breve nella documentazione CAD) ed i suoi effetti specifici
+dipendono dalla architettura hardware. Se si è richiesto un riavvio o uno
+spegnimento in caso di successo la funzione, non esistendo più il programma,
+ovviamente non ritorna, pertanto bisogna avere cura di aver effettuato tutte
+le operazioni preliminari allo spegnimento prima di eseguirla.
+
+Il comportamento della funzione viene controllato dall'argomento \param{cmd}
+e deve assumere indicato con una delle costanti seguente elenco, che
+illustra i comandi attualmente disponibili:
+
+\begin{basedescript}{\desclabelwidth{2.cm}\desclabelstyle{\nextlinelabel}}
+\item[\constd{LINUX\_REBOOT\_CMD\_CAD\_OFF}] Disabilita l'uso diretto della
+ combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce nell'invio
+ del segnale \signal{SIGINT} a \texttt{init} (o più in generale al processo
+ con \ids{PID} 1) il cui effetto dipende dalla configurazione di
+ quest'ultimo.
+\item[\constd{LINUX\_REBOOT\_CMD\_CAD\_ON}] Attiva l'uso diretto della
+ combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce
+ nell'esecuzione dell'azione che si avrebbe avuto chiamando \func{reboot} con
+ il comando \const{LINUX\_REBOOT\_CMD\_RESTART}.
+\item[\constd{LINUX\_REBOOT\_CMD\_HALT}] Viene inviato sulla console il
+ messaggio ``\textit{System halted.}'' l'esecuzione viene bloccata
+ immediatamente ed il controllo passato al monitor nella ROM (se esiste e
+ l'architettura lo consente). Se non si è eseguita una sincronizzazione dei
+ dati su disco con \func{sync} questi saranno perduti.
+\item[\constd{LINUX\_REBOOT\_CMD\_KEXEC}] viene eseguito direttamente il nuovo
+ kernel che è stato opportunamente caricato in memoria da una
+ \func{kexec\_load} (che tratteremo a breve) eseguita in precedenza. La
+ funzionalità è disponibile solo a partire dal kernel 2.6.13 e se il kernel
+ corrente è stato compilato includendo il relativo supporto.\footnote{deve
+ essere stata abilitata l'opzione di compilazione \texttt{CONFIG\_KEXEC}.}
+ Questo meccanismo consente di eseguire una sorta di riavvio rapido che evita
+ di dover ripassare dalla inizializzazione da parte del BIOS ed il lancio del
+ kernel attraverso un bootloader. Se non si è eseguita una sincronizzazione
+ dei dati su disco con \func{sync} questi saranno perduti.
+\item[\constd{LINUX\_REBOOT\_CMD\_POWER\_OFF}] Viene inviato sulla console il
+ messaggio ``\textit{Power down.}'' l'esecuzione viene bloccata
+ immediatamente e la macchina, se possibile, viene spenta. Se non si è
+ eseguita una sincronizzazione dei dati su disco con \func{sync} questi
+ saranno perduti.
+\item[\constd{LINUX\_REBOOT\_CMD\_RESTART}] Viene inviato sulla console il
+ messaggio ``\textit{Restarting system.}'' ed avviata immediatamente la
+ procedura di riavvio ordinaria. Se non si è eseguita una sincronizzazione
+ dei dati su disco con \func{sync} questi saranno perduti.
+\item[\constd{LINUX\_REBOOT\_CMD\_RESTART2}] Viene inviato sulla console il
+ messaggio ``\textit{Restarting system with command '\%s'.}'' ed avviata
+ immediatamente la procedura di riavvio usando il comando fornito
+ nell'argomento \param{arg} che viene stampato al posto di \textit{'\%s'}
+ (veniva usato per lanciare un altro programma al posto di \cmd{init}). Nelle
+ versioni recenti questo argomento viene ignorato ed il riavvio può essere
+ controllato dall'argomento di avvio del kernel \texttt{reboot=...} Se non
+ si è eseguita una sincronizzazione dei dati su disco con \func{sync} questi
+ saranno perduti.
+\end{basedescript}
+
+
+Come appena illustrato usando il comando \const{LINUX\_REBOOT\_CMD\_KEXEC} si
+può eseguire un riavvio immediato pre-caricando una immagine del kernel, che
+verrà eseguita direttamente. Questo meccanismo consente di evitare la
+reinizializzazione della macchina da parte del BIOS, ed oltre a velocizzare un
+eventuale riavvio, ha il vantaggio poter accedere allo stato corrente della
+macchina e della memoria, per cui viene usato spesso per installare un kernel
+di emergenza da eseguire in caso di crollo del sistema per recuperare il
+maggior numero di informazioni possibili.
+
+La funzione di sistema che consente di caricare questa immagine del kernel è
+\funcd{kexec\_load}, la funzione non viene definita nella \acr{glibc} e deve
+pertanto essere invocata con \func{syscall}, il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{linux/kexec.h}
+\fdecl{long kexec\_load(unsigned long entry, unsigned long nr\_segments,
+struct kexec\_segment\\
+\phantom{long kexec\_load(}*segments, unsigned long flags)}
+
+\fdesc{Carica un kernel per un riavvio immediato.}
+}
+
+{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{EBUSY}] c'è già un caricamento in corso, o un altro kernel è
+ già in uso.
+ \item[\errcode{EINVAL}] il valore di \param{flags} non è valido o si è
+ indicato un valore eccessivo per \param{nr\_segments}.
+ \item[\errcode{EPERM}] il chiamante non ha i privilegi di amministratore (la
+ \textit{capability} \const{CAP\_SYS\_BOOT}).
+ \end{errlist}
+}
+\end{funcproto}
+
+Il primo argomento indica l'indirizzo fisico di esecuzione del nuovo kernel
+questo viene caricato usando un vettore di strutture \struct{kexec\_segment}
+(la cui definizione è riportata in fig.~\ref{fig:kexec_segment}) che
+contengono i singoli segmenti dell'immagine. I primi due campi indicano
+indirizzo e dimensione del segmento di memoria in \textit{user space}, i
+secondi indirizzo e dimensione in \textit{kernel space}.
+
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{0.8\textwidth}
+ \includestruct{listati/kexec_segment.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{kexec\_segment} per il caricamento di un
+ segmento di immagine del kernel.}
+ \label{fig:kexec_segment}
+\end{figure}
+
+L'argomento \param{flags} è una maschera binaria contenente i flag che
+consentono di indicare le modalità con cui dovrà essere eseguito il nuovo
+kernel. La parte meno significativa viene usata per impostare l'architettura
+di esecuzione. Il valore \const{KEXEC\_ARCH\_DEFAULT} indica l'architettura
+corrente, ma se ne può specificare anche una diversa, con i valori della
+seconda parte di tab.~\ref{tab:kexec_load_flags}, e questa verrà usato posto
+che sia effettivamente eseguibile sul proprio processore.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \constd{KEXEC\_ON\_CRASH} & Il kernel caricato sarà eseguito
+ automaticamente in caso di crollo del
+ sistema.\\
+ \constd{KEXEC\_PRESERVE\_CONTEXT}& Viene preservato lo stato dei programmi
+ e dei dispositivi prima dell'esecuzione
+ del nuovo kernel. Viene usato
+ principalmente per l'ibernazione del
+ sistema ed ha senso solo se si è
+ indicato un numero di segmento maggiore
+ di zero.\\
+ \hline
+ \constd{KEXEC\_ARCH\_DEFAULT} & Il kernel caricato verrà eseguito nella
+ architettura corrente. \\
+ \texttt{KEXEC\_ARCH\_XXX} & Il kernel caricato verrà eseguito nella
+ architettura indicata (con \texttt{XXX}
+ che può essere: \texttt{386},
+ \texttt{X86\_64}, \texttt{PPC},
+ \texttt{PPC64}, \texttt{IA\_64},
+ \texttt{ARM}, \texttt{S390},
+ \texttt{SH}\texttt{MIPS}
+ e \texttt{MIPS\_LE}).\\
+% \const{} & \\
+ \hline
+ \end{tabular}
+ \caption{Valori per l'argomento \param{flags} di \func{kexec\_load}.}
+ \label{tab:kexec_load_flags}
+\end{table}
+
+I due valori più importanti sono però quelli della parte più significativa
+(riportati nella prima sezione di tab.~\ref{tab:kexec_load_flags}). Il primo,
+\const{KEXEC\_ON\_CRASH}, consente di impostare l'esecuzione automatica del
+nuovo kernel caricato in caso di crollo del sistema, e viene usato quando si
+carica un kernel di emergenza da utilizzare per poter raccogliere informazioni
+diagnostiche che altrimenti verrebbero perdute non essendo il kernel ordinario
+più in grado di essere eseguito in maniera coerente. Il secondo valore,
+\const{KEXEC\_PRESERVE\_CONTEXT}, indica invece di preservare lo stato dei
+programmi e dei dispositivi, e viene in genere usato per realizzare la
+cosiddetta ibernazione in RAM.
+
+% TODO: introdotta con il kernel 3.17 è stata introdotta
+% kexec_file_load, per caricare immagine firmate per il secure boot,
+% vedi anche http://lwn.net/Articles/603116/
+
+% TODO documentare keyctl ????
+% (fare sezione dedicata ????)
+
+% TODO documentare la Crypto API del kernel
+
+% TODO documentare la syscall getrandom, introdotta con il kernel 3.17, vedi
+% http://lwn.net/Articles/606141/, ed introdotta con le glibc solo con la
+% versione 2.25, vedi https://lwn.net/Articles/711013/
+
+%\subsection{La gestione delle chiavi crittografiche}
+%\label{sec:keyctl_management}
+
+%TODO non è chiaro se farlo qui, ma documentare la syscall bpf aggiunta con il
+% kernel 3.18, vedi http://lwn.net/Articles/612878/; al riguardo vedi anche
+% https://lwn.net/Articles/660331/
+
+\section{Il controllo dell'uso delle risorse}
+\label{sec:sys_res_limits}
+
+
+Dopo aver esaminato in sez.~\ref{sec:sys_management} le funzioni che
+permettono di controllare le varie caratteristiche, capacità e limiti del
+sistema a livello globale, in questa sezione tratteremo le varie funzioni che
+vengono usate per quantificare le risorse (CPU, memoria, ecc.) utilizzate da
+ogni singolo processo e quelle che permettono di imporre a ciascuno di essi
+vincoli e limiti di utilizzo.
+
+
+\subsection{L'uso delle risorse}
+\label{sec:sys_resource_use}
+
+Come abbiamo accennato in sez.~\ref{sec:proc_wait} le informazioni riguardo
+l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
+di tipo \struct{rusage}, la cui definizione (che si trova in
+\headfiled{sys/resource.h}) è riportata in
+fig.~\ref{fig:sys_rusage_struct}. Si ricordi che questa è una delle
+informazioni preservate attraverso una \func{exec}.
+
+\begin{figure}[!htb]
+ \footnotesize
+ \centering
+ \begin{minipage}[c]{0.8\textwidth}
+ \includestruct{listati/rusage.h}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \structd{rusage} per la lettura delle informazioni dei
+ delle risorse usate da un processo.}
+ \label{fig:sys_rusage_struct}
+\end{figure}
+
+La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
+da BSD 4.3,\footnote{questo non ha a nulla a che fare con il cosiddetto
+ \textit{BSD accounting} (vedi sez. \ref{sec:sys_bsd_accounting}) che si
+ trova nelle opzioni di compilazione del kernel (e di norma è disabilitato)
+ che serve per mantenere una contabilità delle risorse usate da ciascun
+ processo in maniera molto più dettagliata.} ma attualmente solo alcuni dei
+campi definiti sono effettivamente mantenuti. Con i kernel della serie 2.4 i
+soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
+\var{ru\_minflt} e \var{ru\_majflt}. Con i kernel della serie 2.6 si
+aggiungono anche \var{ru\_nvcsw} e \var{ru\_nivcsw}, a partire dal 2.6.22
+anche \var{ru\_inblock} e \var{ru\_oublock} e dal 2.6.32 anche
+\var{ru\_maxrss}.
+
+In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
+necessario, ma aumenta la portabilità, e serve comunque quando, come nella
+maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
+ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
+\struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
+
+La struttura \struct{rusage} è la struttura utilizzata da \func{wait4} (si
+ricordi quando visto in sez.~\ref{sec:proc_wait}) per ricavare la quantità di
+risorse impiegate dal processo di cui si è letto lo stato di terminazione, ma
+essa può anche essere letta direttamente utilizzando la funzione di sistema
+\funcd{getrusage}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{sys/time.h}
+\fhead{sys/resource.h}
+\fhead{unistd.h}
+\fdecl{int getrusage(int who, struct rusage *usage)}
+
+\fdesc{Legge la quantità di risorse usate da un processo.}
+}
+
+{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}] l'argomento \param{who} non è valido
+ \end{errlist}
+ ed inoltre \errval{EFAULT} nel suo significato generico.
+}
+\end{funcproto}
+
+La funzione ritorna i valori per l'uso delle risorse nella struttura
+\struct{rusage} puntata dall'argomento \param{usage}. L'argomento \param{who}
+permette di specificare il soggetto di cui si vuole leggere l'uso delle
+risorse; esso può assumere solo i valori illustrati in
+tab.~\ref{tab:getrusage_who}, di questi \const{RUSAGE\_THREAD} è specifico di
+Linux ed è disponibile solo a partire dal kernel 2.6.26. La funzione è stata
+recepita nello standard POSIX.1-2001, che però indica come campi di
+\struct{rusage} soltanto \var{ru\_utime} e \var{ru\_stime}.
+
+\begin{table}[htb]
+ \footnotesize
+ \centering
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \constd{RUSAGE\_SELF} & Ritorna l'uso delle risorse del processo
+ corrente, che in caso di uso dei
+ \textit{thread} ammonta alla somma delle
+ risorse utilizzate da tutti i \textit{thread}
+ del processo.\\
+ \constd{RUSAGE\_CHILDREN} & Ritorna l'uso delle risorse dell'insieme dei
+ processi figli di cui è ricevuto lo stato di
+ terminazione, che a loro volta comprendono
+ quelle dei loro figli e così via.\\
+ \constd{RUSAGE\_THREAD} & Ritorna l'uso delle risorse del \textit{thread}
+ chiamante.\\
+ \hline
+ \end{tabular}
+ \caption{Valori per l'argomento \param{who} di \func{getrusage}.}
+ \label{tab:getrusage_who}
+\end{table}
+
+I campi più utilizzati sono comunque \var{ru\_utime} e \var{ru\_stime} che
+indicano rispettivamente il tempo impiegato dal processo nell'eseguire le
+istruzioni in \textit{user space}, e quello impiegato dal kernel nelle
+\textit{system call} eseguite per conto del processo (vedi
+sez.~\ref{sec:sys_unix_time}). I campi \var{ru\_minflt} e \var{ru\_majflt}
+servono a quantificare l'uso della memoria virtuale e corrispondono
+rispettivamente al numero di \textit{page fault} (vedi
+sez.~\ref{sec:proc_mem_gen}) avvenuti senza richiedere I/O su disco (i
+cosiddetti \textit{minor page fault}), a quelli che invece han richiesto I/O
+su disco (detti invece \textit{major page
+ fault}).% mentre \var{ru\_nswap} ed al numero di volte che
+% il processo è stato completamente tolto dalla memoria per essere inserito
+% nello swap.
+% TODO verificare \var{ru\_nswap} non citato nelle pagine di manuali recenti e
+% dato per non utilizzato.
+
+I campi \var{ru\_nvcsw} e \var{ru\_nivcsw} indicano il numero di volte che un
+processo ha subito un \textit{context switch} da parte dello
+\textit{scheduler} rispettivamente nel caso un cui questo avviene prima
+dell'esaurimento della propria \textit{time-slice} (in genere a causa di una
+\textit{system call} bloccante), o per averla esaurita o essere stato
+interrotto da un processo a priorità maggiore. I campi \var{ru\_inblock} e
+\var{ru\_oublock} indicano invece il numero di volte che è stata eseguita una
+attività di I/O su un filesystem (rispettivamente in lettura e scrittura) ed
+infine \var{ru\_maxrss} indica il valore più alto della \textit{Resident Set
+ Size} raggiunto dal processo stesso o, nel caso sia stato usato
+\const{RUSAGE\_CHILDREN}, da uno dei suoi figli.
+
+Si tenga conto che per un errore di implementazione nei i kernel precedenti il
+2.6.9, nonostante questo fosse esplicitamente proibito dallo standard POSIX.1,
+l'uso di \const{RUSAGE\_CHILDREN} comportava l'inserimento dell'ammontare
+delle risorse usate dai processi figli anche quando si era impostata una
+azione di \const{SIG\_IGN} per il segnale \signal{SIGCHLD} (per i segnali si
+veda cap.~\ref{cha:signals}). Il comportamento è stato corretto per aderire
+allo standard a partire dal kernel 2.6.9.
+
+
+\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 sia dei singoli processi che degli utenti.
+
+Per far questo sono definite 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}.
+
+In generale il superamento di un limite corrente comporta o l'emissione di uno
+specifico segnale o il fallimento della \textit{system call} che lo ha
+provocato. A questo comportamento generico fanno eccezione \const{RLIMIT\_CPU}
+in cui si ha in comportamento diverso per il superamento dei due limiti e
+\const{RLIMIT\_CORE} che influenza soltanto la dimensione o l'eventuale
+creazione dei file di \textit{core dump} (vedi sez.~\ref{sec:sig_standard}).
+
+Per permettere di leggere e di impostare i limiti di utilizzo delle risorse da
+parte di un processo sono previste due funzioni di sistema, \funcd{getrlimit}
+e \funcd{setrlimit}, i cui prototipi sono:
+
+\begin{funcproto}{
+\fhead{sys/time.h}
+\fhead{sys/resource.h}
+\fhead{unistd.h}
+\fdecl{int getrlimit(int resource, struct rlimit *rlim)}
+\fdesc{Legge i limiti di una risorsa.}
+\fdecl{int setrlimit(int resource, const struct rlimit *rlim)}
+\fdesc{Imposta i limiti di una risorsa.}
+}
+
+{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 \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[\constd{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 \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[\constd{RLIMIT\_CORE}] Questa risorsa indica, in byte, la massima
+ dimensione per un file di \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 \textit{core dump}.
+
+\item[\constd{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[\constd{RLIMIT\_DATA}] Questa risorsa indica, in byte, la massima
+ dimensione del 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}.