e degli errori.
-
-\section{Capacità e caratteristiche del sistema}
+\section{La gestione di catteristiche e parametri del sistema}
\label{sec:sys_characteristics}
In questa sezione tratteremo le varie modalità con cui un programma può
-ottenere informazioni riguardo alle capacità del sistema. Ogni sistema
-unix-like infatti è contraddistinto da un gran numero di limiti e costanti che
-lo caratterizzano, e che possono dipendere da fattori molteplici, come
-l'architettura hardware, l'implementazione del kernel e delle librerie, le
-opzioni di configurazione.
+ottenere informazioni riguardo alle capacità del sistema, e, per quelle per
+cui è possibile, sul come modificarle. Ogni sistema unix-like infatti è
+contraddistinto da un gran numero di limiti e costanti che lo caratterizzano,
+e che possono dipendere da fattori molteplici, come l'architettura hardware,
+l'implementazione del kernel e delle librerie, le opzioni di
+configurazione. Il kernel inoltre mette a disposizione l'accesso ad alcuni
+parametri che possono modificarne il comportamento.
La definizione di queste caratteristiche ed il tentativo di provvedere dei
meccanismi generali che i programmi possono usare per ricavarle è uno degli
sono dovute confrontare, spesso con risultati spesso tutt'altro che chiari.
Daremo comunque una descrizione dei principali metodi previsti dai vari
standard per ricavare sia le caratteristiche specifiche del sistema, che
-quelle della gestione dei file.
-
+quelle della gestione dei file e prenderemo in esame le modalità con cui è
+possibile intervenire sui parametri del kernel.
-\subsection{Limiti e parametri di sistema}
+\subsection{Limiti e caratteristiche del sistema}
\label{sec:sys_limits}
Quando si devono determinare le caratteristiche generali del sistema ci si
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
+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
+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 in
-sez.~\ref{sec:sys_sysconf}).
-
-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 \headfile{float.h}). Lo standard prevede anche un'altra
-costante, \const{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.
+tramite la funzione \func{sysconf} (che esamineremo a breve).
\begin{table}[htb]
\centering
\const{UCHAR\_MAX}& 255 & Massimo di \ctyp{unsigned char}.\\
\const{SCHAR\_MIN}& -128 & Minimo di \ctyp{signed char}.\\
\const{SCHAR\_MAX}& 127 & Massimo di \ctyp{signed char}.\\
- \const{CHAR\_MIN} &\footnotemark& Minimo di \ctyp{char}.\\
- \const{CHAR\_MAX} &\footnotemark& Massimo di \ctyp{char}.\\
+ \const{CHAR\_MIN} & 0 o -128 & Minimo di \ctyp{char}.\footnotemark\\
+ \const{CHAR\_MAX} & 127 o 255 & Massimo di \ctyp{char}.\footnotemark\\
\const{SHRT\_MIN} & -32768 & Minimo di \ctyp{short}.\\
\const{SHRT\_MAX} & 32767 & Massimo di \ctyp{short}.\\
\const{USHRT\_MAX}& 65535 & Massimo di \ctyp{unsigned short}.\\
\footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
a seconda che il sistema usi caratteri con segno o meno.}
-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}.
+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 \headfile{float.h}.
\begin{table}[htb]
\centering
\label{tab:sys_isoc90_macro}
\end{table}
+Lo standard prevede anche un'altra costante, \const{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,
limiti relativi alle caratteristiche dei file che vedremo in
sez.~\ref{sec:sys_file_limits}.
-Purtroppo la sezione dello standard che tratta questi argomenti è una delle
-meno chiare\footnote{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{7cm}|}
+ \begin{tabular}[c]{|l|r|p{8cm}|}
\hline
\textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
\hline
\label{tab:sys_generic_macro}
\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; detti valori sono
-riportati in tab.~\ref{tab:sys_posix1_general}.
+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{7cm}|}
+ \begin{tabular}[c]{|l|r|p{8cm}|}
\hline
\textbf{Costante}&\textbf{Valore}&\textbf{Significato}\\
\hline
contemporanea.\\
\const{\_POSIX\_STREAM\_MAX} & 8& Massimo numero di stream aperti per
processo in contemporanea.\\
- \const{\_POSIX\_TZNAME\_MAX} & & Dimensione massima del nome di una
+ \const{\_POSIX\_TZNAME\_MAX} & 6& Dimensione massima del nome di una
\textit{timezone} (vedi
sez.~\ref{sec:sys_date}). \\
+ \const{\_POSIX\_RTSIG\_MAX} & 8& Numero massimo di segnali
+ \textit{real-time} (vedi
+ sez.~\ref{sec:sig_real_time}).\\
\const{\_POSIX\_NGROUPS\_MAX}& 0& Numero di gruppi supplementari per
processo (vedi
sez.~\ref{sec:proc_access_id}).\\
\const{\_POSIX\_SSIZE\_MAX} &32767& Valore massimo del tipo
\type{ssize\_t}.\\
- \const{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
- \const{\_POSIX\_AIO\_MAX} & 1& \\
+ % \const{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
+ % \const{\_POSIX\_AIO\_MAX} & 1& \\
\hline
\end{tabular}
- \caption{Macro dei valori minimi delle caratteristiche generali del sistema
- per la conformità allo standard POSIX.1.}
+ \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
\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 parecchi altri. La lista completa si trova
-dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
+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 menzionare 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}).
+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 delle \acr{glibc}.
-
-
-\subsection{La funzione \func{sysconf}}
-\label{sec:sys_sysconf}
-
-Come accennato in sez.~\ref{sec:sys_limits} 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 a run time, è
-necessario ottenerne il valore attraverso la funzione \funcd{sysconf}. Il
-prototipo di questa funzione è:
-\begin{prototype}{unistd.h}{long sysconf(int name)}
- Restituisce il valore del parametro di sistema \param{name}.
-
- \bodydesc{La funzione restituisce indietro il valore del parametro
- richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
- è disponibile e -1 in caso di errore (ma \var{errno} non viene impostata).}
-\end{prototype}
+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 delle \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 è
+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 delle \acr{glibc}.
\begin{table}[htb]
\centering
\footnotesize
- \begin{tabular}[c]{|l|l|p{9cm}|}
+ \begin{tabular}[c]{|l|l|p{8cm}|}
\hline
\textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
\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}&
+ \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}&
+ \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}&
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 valore si otterrà
-specificando come valore dell'argomento \param{name} il nome ottenuto
-aggiungendo \code{\_SC\_} ai nomi delle macro definite dai primi due, o
-sostituendolo a \code{\_POSIX\_} per le macro definite dagli gli altri due.
-
-In generale si dovrebbe fare uso di \func{sysconf} solo quando la relativa
-macro non è definita, quindi con un codice analogo al seguente:
+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à in Linux queste macro sono comunque definite, indicando però un
-limite generico. Per questo motivo è sempre meglio usare i valori restituiti
-da \func{sysconf}.
+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{I limiti dei file}
+\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
+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}.
\const{PIPE\_BUF}&4096 & Byte scrivibili atomicamente in una pipe
(vedi sez.~\ref{sec:ipc_pipes}).\\
\const{MAX\_CANON}&255 & Dimensione di una riga di terminale in modo
- canonico (vedi sez.~\ref{sec:term_design}).\\
+ canonico (vedi sez.~\ref{sec:term_io_design}).\\
\const{MAX\_INPUT}&255 & Spazio disponibile nella coda di input
del terminale (vedi
- sez.~\ref{sec:term_design}).\\
+ sez.~\ref{sec:term_io_design}).\\
\hline
\end{tabular}
\caption{Costanti per i limiti sulle caratteristiche dei file.}
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}.
+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
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.
+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 è:
-\subsection{La funzione \func{pathconf}}
-\label{sec:sys_pathconf}
+\begin{funcproto}{
+\fhead{unistd.h}
+\fdecl{long pathconf(char *path, int name)}
+\fdesc{Restituisce il valore di un parametro dei file.}
+}
-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 questi limiti devono essere sempre controllati
-con la funzione \funcd{pathconf}, il cui prototipo è:
-\begin{prototype}{unistd.h}{long pathconf(char *path, int name)}
- Restituisce il valore del parametro \param{name} per il file \param{path}.
-
- \bodydesc{La funzione restituisce indietro il valore del parametro
- richiesto, o -1 in caso di errore (ed \var{errno} viene impostata ad uno
- degli errori possibili relativi all'accesso a \param{path}).}
-\end{prototype}
+{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.}
+}
-E si noti come la funzione in questo caso richieda un argomento che specifichi
-a quale file si fa riferimento, dato che il valore del limite cercato può
-variare a seconda del filesystem. Una seconda versione della funzione,
-\funcd{fpathconf}, opera su un file descriptor invece che su un
-\textit{pathname}. Il suo prototipo è:
-\begin{prototype}{unistd.h}{long fpathconf(int fd, int name)}
- Restituisce il valore del parametro \param{name} per il file \param{fd}.
-
- \bodydesc{È identica a \func{pathconf} solo che utilizza un file descriptor
- invece di un \textit{pathname}; pertanto gli errori restituiti cambiano di
- conseguenza.}
-\end{prototype}
-\noindent ed il suo comportamento è identico a quello di \func{pathconf}.
+{È 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{La funzione \func{uname}}
-\label{sec:sys_uname}
-Un'altra funzione che si può utilizzare per raccogliere informazioni sia
-riguardo al sistema che al computer su cui esso sta girando è \funcd{uname};
-il suo prototipo è:
-\begin{prototype}{sys/utsname.h}{int uname(struct utsname *info)}
- Restituisce informazioni sul sistema nella struttura \param{info}.
-
- \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
- fallimento, nel qual caso \var{errno} assumerà il valore \errval{EFAULT}.}
-\end{prototype}
+\subsection{I parametri del kernel ed il filesystem \texttt{/proc}}
+\label{sec:sys_sysctl}
-La funzione, che viene usata dal comando \cmd{uname}, restituisce le
-informazioni richieste nella struttura \param{info}; anche questa struttura è
-definita in \headfile{sys/utsname.h}, secondo quanto mostrato in
-fig.~\ref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
-indicano rispettivamente:
+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 del sistema operativo;
-\item il nome della release del kernel;
-\item il nome della versione del kernel;
-\item il tipo di macchina in uso;
-\item il nome della stazione;
-\item il nome del domino.
+\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*}
-l'ultima informazione è stata aggiunta di recente e non è prevista dallo
-standard POSIX, essa è accessibile, come mostrato in
-fig.~\ref{fig:sys_utsname}, solo definendo \macro{\_GNU\_SOURCE}.
-\begin{figure}[!htb]
+
+
+\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]{\textwidth}
+ \begin{minipage}[c]{0.8\textwidth}
\includestruct{listati/ustname.h}
\end{minipage}
\normalsize
\label{fig:sys_utsname}
\end{figure}
-In generale si tenga presente che le dimensioni delle stringhe di una
-struttura \struct{utsname} non è specificata, e che esse sono sempre terminate
-con NUL; il manuale delle \acr{glibc} indica due diverse dimensioni,
-\const{\_UTSNAME\_LENGTH} per i campi standard e
-\const{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
-altri sistemi usano nomi diversi come \const{SYS\_NMLN} o \const{\_SYS\_NMLN}
-o \const{UTSLEN} che possono avere valori diversi.\footnote{nel caso di Linux
- \func{uname} corrisponde in realtà a 3 system call diverse, le prime due
- usano rispettivamente delle lunghezze delle stringhe 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.}
-
-
-\section{Opzioni e configurazione del sistema}
-\label{sec:sys_config}
-
-Come abbiamo accennato nella sezione precedente, non tutti i limiti che
-caratterizzano il sistema sono fissi, o perlomeno non lo sono in tutte le
-implementazioni. Finora abbiamo visto come si può fare per leggerli, ci manca
-di esaminare il meccanismo che permette, quando questi possono variare durante
-l'esecuzione del sistema, di modificarli.
-
-Inoltre, al di la di quelli che possono essere limiti caratteristici previsti
-da uno standard, ogni sistema può avere una sua serie di altri parametri di
-configurazione, che, non essendo mai fissi e variando da sistema a sistema,
-non sono stati inclusi nella standardizzazione della sezione precedente. Per
-questi occorre, oltre al meccanismo di impostazione, pure un meccanismo di
-lettura. Affronteremo questi argomenti in questa sezione, insieme alle
-funzioni che si usano per il controllo di altre caratteristiche generali del
-sistema, come quelle per la gestione dei filesystem e di utenti e gruppi.
-
-% TODO ristrutturare ?
-
-\subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
-\label{sec:sys_sysctl}
-
-La funzione che permette la lettura ed l'impostazione dei parametri del
-sistema è \funcd{sysctl}; è una funzione derivata da BSD4.4, ma
-l'implementazione è specifica di Linux; il suo prototipo è:
-\begin{functions}
-\headdecl{unistd.h}
-\funcdecl{int sysctl(int *name, int nlen, void *oldval, size\_t *oldlenp, void
- *newval, size\_t newlen)}
-
-Legge o scrive uno dei parametri di sistema.
-
-\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori:
- \begin{errlist}
- \item[\errcode{EPERM}] non si ha il permesso di accedere ad uno dei
- componenti nel cammino specificato per il parametro, o di accedere al
- parametro nella modalità scelta.
- \item[\errcode{ENOTDIR}] non esiste un parametro corrispondente al nome
- \param{name}.
-% \item[\errcode{EFAULT}] si è specificato \param{oldlenp} zero quando
-% \param{oldval} è non nullo.
- \item[\errcode{EINVAL}] o si è specificato un valore non valido per il
- parametro che si vuole impostare o lo spazio provvisto per il ritorno di un
- valore non è delle giuste dimensioni.
- \item[\errcode{ENOMEM}] talvolta viene usato più correttamente questo errore
- quando non si è specificato sufficiente spazio per ricevere il valore di un
- parametro.
- \end{errlist}
- ed inoltre \errval{EFAULT}.
-}
-\end{functions}
+Si noti come in fig.~\ref{fig:sys_utsname} le dimensioni delle stringhe di
+\struct{utsname} non sono specificate. Il manuale delle \acr{glibc} indica
+due costanti per queste dimensioni, \const{\_UTSNAME\_LENGTH} per i campi
+standard e \const{\_UTSNAME\_DOMAIN\_LENGTH} per quello relativo al nome di
+dominio, altri sistemi usano nomi diversi come \const{SYS\_NMLN} o
+\const{\_SYS\_NMLN} o \const{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}.
-I parametri a cui la funzione permettere di accedere sono organizzati in
-maniera gerarchica all'interno di un albero;\footnote{si tenga presente che
- includendo solo \headfile{unistd.h}, saranno definiti solo i parametri
- generici; dato che ce ne sono molti specifici dell'implementazione, nel caso
- di Linux occorrerà includere anche i file \file{linux/unistd.h} e
- \file{linux/sysctl.h}.} per accedere ad uno di essi occorre specificare un
-cammino attraverso i vari nodi dell'albero, in maniera analoga a come avviene
-per la risoluzione di un \textit{pathname} (da cui l'uso alternativo del
-filesystem \file{/proc}, che vedremo dopo).
-
-Ciascun nodo dell'albero è identificato da un valore intero, ed il cammino che
-arriva ad identificare un parametro specifico è passato alla funzione
-attraverso l'array \param{name}, di lunghezza \param{nlen}, che contiene la
-sequenza dei vari nodi da attraversare. Ogni parametro ha un valore in un
-formato specifico che può essere un intero, una stringa o anche una struttura
-complessa, per questo motivo i valori vengono passati come puntatori
-\ctyp{void}.
-
-L'indirizzo a cui il valore corrente del parametro deve essere letto è
-specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
-\param{oldlenp} (passato come puntatore per avere indietro la dimensione
-effettiva di quanto letto); il valore che si vuole impostare nel sistema è
-passato in \param{newval} e la sua dimensione in \param{newlen}.
-
-Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
-valore letto restituito dalla funzione è quello precedente alla scrittura.
-
-I parametri accessibili attraverso questa funzione sono moltissimi, e possono
-essere trovati in \headfile{sysctl.h}, essi inoltre dipendono anche dallo
-stato corrente del kernel (ad esempio dai moduli che sono stati caricati nel
-sistema) e in genere i loro nomi possono variare da una versione di kernel
-all'altra; per questo è sempre il caso di evitare l'uso di \func{sysctl}
-quando esistono modalità alternative per ottenere le stesse informazioni.
-Alcuni esempi di parametri ottenibili 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}
-
-Come accennato in Linux si ha una modalità alternativa per accedere alle
-stesse informazioni di \func{sysctl} attraverso l'uso del filesystem
-\file{/proc}. Questo è un filesystem virtuale, generato direttamente dal
-kernel, che non fa riferimento a nessun dispositivo fisico, ma presenta in
-forma di file alcune delle strutture interne del kernel stesso.
-
-In particolare l'albero dei valori di \func{sysctl} viene presentato in forma
-di file nella directory \file{/proc/sys}, cosicché è possibile accedervi
-specificando un \textit{pathname} e leggendo e scrivendo sul file
-corrispondente al parametro scelto. Il kernel si occupa di generare al volo
-il contenuto ed i nomi dei file corrispondenti, e questo ha il grande
-vantaggio di rendere accessibili i vari parametri a qualunque comando di shell
-e di permettere la navigazione dell'albero dei valori.
-
-Alcune delle corrispondenze dei file presenti in \file{/proc/sys} con i valori
-di \func{sysctl} sono riportate nei commenti del codice che può essere trovato
-in \file{linux/sysctl.h},\footnote{indicando un file di definizioni si fa
- riferimento alla directory standard dei file di include, che in ogni
- distribuzione che si rispetti è \file{/usr/include}.} la informazione
-disponibile in \file{/proc/sys} è riportata inoltre nella documentazione
-inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
+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 \sysctlrelfile{kernel}{ostype},
+\sysctlrelfile{kernel}{hostname}, \sysctlrelfile{kernel}{osrelease},
+\sysctlrelfile{kernel}{version} e \sysctlrelfile{kernel}{domainname} che si
+trovano sotto la directory \file{/proc/sys/kernel/}.
-Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc} sono
-disponibili moltissime altre informazioni, fra cui ad esempio anche quelle
-fornite da \func{uname} (vedi sez.~\ref{sec:sys_uname}) che sono mantenute nei
-file \sysctlrelfile{kernel}{ostype}, \sysctlrelfile{kernel}{hostname},
-\sysctlrelfile{kernel}{osrelease}, \sysctlrelfile{kernel}{version} e
-\sysctlrelfile{kernel}{domainname} di \file{/proc/sys/kernel/}.
+\index{file!filesystem~\texttt {/proc}!definizione|)}
-% TODO documentare keyctl ????
-% (fare sezione dedicata ????)
-%\subsection{La gestione delle chiavi crittografiche}
-%\label{sec:keyctl_management}
+\section{La gestione del sistema}
+\label{sec:sys_management}
-%
-% \subsection{La gestione dello spegnimento e del riavvio}
-%\label{sec:sys_reboot}
-% TODO trattare reboot, kexec_load, ...
+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 user-id, home directory, ecc.)
-venivano registrate all'interno dei due file di testo \conffile{/etc/passwd}
-ed \conffile{/etc/group},\footnote{in realtà oltre a questi nelle
- distribuzioni più recenti è stato introdotto il sistema delle \textit{shadow
- password} che prevede anche i due file \conffile{/etc/shadow} e
- \conffile{/etc/gshadow}, in cui sono state spostate le informazioni di
- autenticazione (ed inserite alcune estensioni) per toglierle dagli altri
- file che devono poter essere letti per poter effettuare l'associazione fra
- username e \ids{UID}.} il cui formato è descritto dalle relative pagine del
-manuale\footnote{nella quinta sezione, quella dei file di configurazione,
- occorre cioè usare \cmd{man 5 passwd} dato che altrimenti si avrebbe la
- pagina di manuale del comando \cmd{passwd}.} e tutte le funzioni che
-richiedevano l'accesso a queste informazione andavano a leggere direttamente
-il contenuto di questi file.
-
-Col tempo però questa impostazione ha incominciato a mostrare dei limiti: da
+(password, corrispondenze fra nomi simbolici e \ids{UID} numerici, home
+directory, ecc.) venivano registrate all'interno dei due file di testo
+\conffile{/etc/passwd} ed \conffile{/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 \conffile{/etc/shadow} e \conffile{/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,\footnote{il
- \textit{Pluggable Authentication Method} è 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 in maniera trasparente per le applicazioni purché per ciascun
- meccanismo si disponga della opportuna libreria che implementa l'interfaccia
- di PAM.} svincolando completamente le singole applicazione dai dettagli del
-come questa viene eseguita e di dove vengono mantenuti i dati relativi;
-dall'altra con il diffondersi delle reti la necessità di centralizzare le
-informazioni degli utenti e dei gruppi per insiemi di macchine, in modo da
-mantenere coerenti i dati, ha portato anche alla necessità di poter recuperare
-e memorizzare dette informazioni su supporti diversi, introducendo il sistema
-del \itindex{Name~Service~Switch~(NSS)} \textit{Name Service Switch} che
+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
+\itindex{Name~Service~Switch~(NSS)} \textit{Name Service Switch} che
tratteremo brevemente più avanti (in sez.~\ref{sec:sock_resolver}) dato che la
-maggior parte delle sua applicazioni sono relative alla risoluzioni di nomi di
-rete.
+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
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{functions}
- \headdecl{pwd.h}
- \headdecl{sys/types.h}
- \funcdecl{struct passwd *getpwuid(uid\_t uid)}
-
- \funcdecl{struct passwd *getpwnam(const char *name)}
- Restituiscono le informazioni relative all'utente specificato.
-
- \bodydesc{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.}
-\end{functions}
+\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 possono essere 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
-\headfile{pwd.h}) è riportata in fig.~\ref{fig:sys_passwd_struct}, dove è pure
-brevemente illustrato il significato dei vari campi.
+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 \headfile{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]{\textwidth}
+ \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.}
+ \caption{La struttura \structd{passwd} contenente le informazioni relative
+ ad un utente del sistema.}
\label{fig:sys_passwd_struct}
\end{figure}
essere \index{funzioni!rientranti} rientranti; per questo motivo ne esistono
anche due versioni alternative (denotate dalla solita estensione \code{\_r}),
i cui prototipi sono:
-\begin{functions}
- \headdecl{pwd.h}
-
- \headdecl{sys/types.h}
-
- \funcdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
+
+\begin{funcproto}{
+\fhead{pwd.h}
+\fhead{sys/types.h}
+\fdecl{struct passwd *getpwuid\_r(uid\_t uid, struct passwd *password,
char *buffer, size\_t buflen, struct passwd **result)}
-
- \funcdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
+\fdecl{struct passwd *getpwnam\_r(const char *name, struct passwd
*password, char *buffer, size\_t buflen, struct passwd **result)}
+\fdesc{Restituiscono le informazioni relative all'utente specificato.}
+}
- Restituiscono le informazioni relative all'utente specificato.
-
- \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
- altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
-\end{functions}
+{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
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} (e le relative analoghe \index{funzioni!rientranti}
-rientranti con la stessa estensione \code{\_r}) che permettono di leggere le
-informazioni relative ai gruppi, i loro prototipi sono:
-\begin{functions}
- \headdecl{grp.h}
- \headdecl{sys/types.h}
+\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.}
+}
- \funcdecl{struct group *getgrgid(gid\_t gid)}
-
- \funcdecl{struct group *getgrnam(const char *name)}
-
- \funcdecl{struct group *getpwuid\_r(gid\_t gid, struct group *password,
- char *buffer, size\_t buflen, struct group **result)}
-
- \funcdecl{struct group *getpwnam\_r(const char *name, struct group
- *password, char *buffer, size\_t buflen, struct group **result)}
+{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
+\index{funzioni!rientranti} 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, struct group **result)}
+\fdecl{int getgrnam\_r(const char *name, struct group *grp, char *buf,
+ size\_t buflen, 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}
- Restituiscono le informazioni relative al gruppo specificato.
-
- \bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
- altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
-\end{functions}
Il comportamento di tutte queste funzioni è assolutamente identico alle
precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
\begin{figure}[!htb]
\footnotesize
\centering
- \begin{minipage}[c]{\textwidth}
+ \begin{minipage}[c]{0.8\textwidth}
\includestruct{listati/group.h}
\end{minipage}
\normalsize
sistema del \itindex{Name~Service~Switch~(NSS)} \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 a PAM, ma questo è un altro discorso.} 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 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}.
+ essere fatto ricorrendo alle funzioni della libreria PAM, ma questo non è un
+ argomento che trattremo 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
% TODO mancano i prototipi di alcune delle funzioni
-Dato che oramai la gran parte delle distribuzioni di GNU/Linux utilizzano
-almeno 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
+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, pertanto ci limiteremo a fornire soltanto
-l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
+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
delle \acr{glibc} per i dettagli del funzionamento.
\subsection{Il registro della \textsl{contabilità} degli utenti}
\label{sec:sys_accounting}
-L'ultimo insieme di funzioni relative alla gestione del sistema che
+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
+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\footnote{questa è la locazione specificata dal
- \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
- delle distribuzioni.} memorizzati nei due file \file{/var/run/utmp} e
-\file{/var/log/wtmp}.\footnote{non si confonda quest'ultimo con il simile
- \file{/var/log/btmp} dove invece vengono memorizzati dal programma di login
- tutti tentativi di accesso fallito.} 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}.
+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
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, e a specificare su quale file esso viene mantenuto. I loro prototipi
-sono:
-\begin{functions}
- \headdecl{utmp.h}
-
- \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
- registro.
-
- \funcdecl{void setutent(void)} Apre il file del registro, posizionandosi al
- suo inizio.
-
- \funcdecl{void endutent(void)} Chiude il file del registro.
-
- \bodydesc{Le funzioni non ritornano codici di errore.}
-\end{functions}
-e 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}).
+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 nome di questo file, 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 \headfile{paths.h}, in particolare quelle che ci interessano sono:
+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
+\headfile{paths.h}, in particolare quelle che ci interessano sono:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\const{\_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.
+ utenti correntemente collegati, questo è il valore che viene usato se non si
+ è utilizzato \func{utmpname} per modificarlo;
\item[\const{\_PATH\_WTMP}] specifica il file che contiene il registro per
- l'archivio storico degli utenti collegati.
+ 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{functions}
- \headdecl{utmp.h}
- \funcdecl{struct utmp *getutent(void)}
- Legge una voce dalla posizione corrente nel registro.
-
- \funcdecl{struct utmp *getutid(struct utmp *ut)} Ricerca una voce sul
- registro in base al contenuto di \param{ut}.
- \funcdecl{struct utmp *getutline(struct utmp *ut)}
- Ricerca nel registro la prima voce corrispondente ad un processo sulla linea
- di terminale specificata tramite \param{ut}.
+\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.}
+}
- \funcdecl{struct utmp *pututline(struct utmp *ut)}
- Scrive una voce nel registro.
-
- \bodydesc{Le funzioni ritornano il puntatore ad una struttura \struct{utmp}
- in caso di successo e \val{NULL} in caso di errore.}
-\end{functions}
+{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.
-
+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, portanto 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]{\textwidth}
+ \begin{minipage}[c]{0.9\textwidth}
\includestruct{listati/utmp.h}
\end{minipage}
\normalsize
La funzione \func{getutline} esegue la ricerca sulle voci che hanno
\var{ut\_type} uguale a \const{LOGIN\_PROCESS} o \const{USER\_PROCESS},
restituendo la prima che corrisponde al valore di \var{ut\_line}, che
-specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
-terminale che interessa. Lo stesso criterio di ricerca è usato da
-\func{pututline} per trovare uno spazio dove inserire la voce specificata,
-qualora non sia trovata la voce viene aggiunta in coda al registro.
+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 dalle \acr{glibc}, ma gli standard POSIX 1003.1-2001 e XPG4.2 hanno
-introdotto delle nuove strutture (e relativi file) di tipo \code{utmpx}, che
-sono un sovrainsieme di \code{utmp}.
-
-Le \acr{glibc} utilizzano già una versione estesa di \code{utmp}, che rende
-inutili queste nuove strutture; pertanto esse e le relative funzioni di
-gestione (\funcm{getutxent}, \funcm{getutxid}, \funcm{getutxline},
-\funcm{pututxline}, \funcm{setutxent} e \funcm{endutxent}) sono ridefinite come
-sinonimi delle funzioni appena viste.
-
-% TODO (verificare le funzioni di cui sopra )
-
-Come visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
-staticamente rende le funzioni di lettura non \index{funzioni!rientranti}
-rientranti; per questo motivo le \acr{glibc} forniscono anche delle versioni
-\index{funzioni!rientranti} rientranti: \funcm{getutent\_r}, \funcm{getutid\_r},
-\funcm{getutline\_r}, che invece di restituire un puntatore restituiscono un
-intero e prendono due argomenti aggiuntivi. Le funzioni si comportano
-esattamente come le analoghe non \index{funzioni!rientranti} rientranti, solo
-che restituiscono il risultato all'indirizzo specificato dal primo argomento
-aggiuntivo (di tipo \code{struct utmp *buffer}) mentre il secondo (di tipo
-\code{struct utmp **result)} viene usato per restituire il puntatore allo
-stesso buffer.
-
-Infine le \acr{glibc} forniscono come estensione per la scrittura delle voci
-in \file{wmtp} altre due funzioni, \funcd{updwtmp} e \funcd{logwtmp}, i cui
-prototipi sono:
-\begin{functions}
- \headdecl{utmp.h}
-
- \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
- Aggiunge la voce \param{ut} nel registro \file{wmtp}.
-
- \funcdecl{void logwtmp(const char *line, const char *name, const char
- *host)} Aggiunge nel registro una voce con i valori specificati.
-\end{functions}
+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.
+
+Le \acr{glibc} utilizzavano 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
+\index{funzioni!rientranti} rientranti. Per questo motivo le \acr{glibc}
+forniscono anche delle versioni \index{funzioni!rientranti} 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
+\index{funzioni!rientranti} 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 le \acr{glibc} forniscono 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 \headfile{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.
+
+Ia 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[\const{LINUX\_REBOOT\_CMD\_CAD\_OFF}] Disabilita l'uso diretto della
+ combinazione \texttt{Ctrl-Alt-Del}, la cui pressione si traduce nell'invio
+ del segnale \const{SIGINT} a \texttt{init} (o più in generale al processo
+ con \ids{PID} 1) il cui effetto dipende dalla configurazione di
+ quest'ultimo.
+\item[\const{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[\const{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[\const{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 inlcudendo 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[\const{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[\const{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[\const{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 direttettamente. 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 che contiene i flag che
+consentono di indicare alcune specifiche relative alle 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
+ \const{KEXEC\_ON\_CRASH} & Il kernel caricato sarà eseguito
+ automaticamente in caso di crollo del
+ sistema.\\
+ \const{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
+ \const{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}
-La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
-direttamente una struttura \struct{utmp}, mentre la seconda utilizza gli
-argomenti \param{line}, \param{name} e \param{host} per costruire la voce che
-poi aggiunge chiamando \func{updwtmp}.
+I due valori più importanti sono però quelli della parte più significativa
+di \param{flags} (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 documentare keyctl ????
+% (fare sezione dedicata ????)
+%\subsection{La gestione delle chiavi crittografiche}
+%\label{sec:keyctl_management}
\section{Il controllo dell'uso delle risorse}
\label{sec:sys_res_limits}
-Dopo aver esaminato 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.
+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}
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
-\headfile{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
+\headfile{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]{\textwidth}
+ \begin{minipage}[c]{0.8\textwidth}
\includestruct{listati/rusage.h}
\end{minipage}
\normalsize
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 (con i kernel della serie
-2.4.x e 2.6.x) i soli campi che sono mantenuti sono: \var{ru\_utime},
-\var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. I
-primi due indicano rispettivamente il tempo impiegato dal processo
-nell'eseguire le istruzioni in user space, e quello impiegato dal kernel nelle
-system call eseguite per conto del processo.
-
-Gli altri tre campi servono a quantificare l'uso della memoria
+ \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}, \var{ru\_majflt}, e \var{ru\_nswap}. Con i kernel della
+serie 2.6 si aggiungono anche \var{ru\_nvcsw} e \var{ru\_nivcsw}, e a partire
+dal 2.6.22 anche \var{ru\_inblock} e \var{ru\_oublock}.
+
+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 user space, e quello impiegato dal kernel nelle \textit{system
+ call} eseguite per conto del processo. I campi \var{ru\_minflt} e
+\var{ru\_majflt} servono a quantificare l'uso della memoria
virtuale\index{memoria~virtuale} e corrispondono rispettivamente al numero di
\itindex{page~fault} \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}) ed al numero di volte che il processo è stato
-completamente tolto dalla memoria per essere inserito nello swap.
+\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
In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
necessario, ma aumenta la portabilità, e serve comunque quando, come nella
ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
\struct{timeval} (vedi fig.~\ref{fig:sys_timeval_struct}).
-Questa è la stessa 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 \funcd{getrusage}, il
-cui prototipo è:
-\begin{functions}
- \headdecl{sys/time.h}
- \headdecl{sys/resource.h}
- \headdecl{unistd.h}
-
- \funcdecl{int getrusage(int who, struct rusage *usage)}
- Legge la quantità di risorse usate da un processo.
+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)}
- \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
- nel qual caso \var{errno} può essere \errval{EINVAL} o \errval{EFAULT}.}
-\end{functions}
+\fdesc{Legge la quantità di risorse usate da un processo.}
+}
-L'argomento \param{who} permette di specificare il processo di cui si vuole
-leggere l'uso delle risorse; esso può assumere solo i due valori
-\const{RUSAGE\_SELF} per indicare il processo corrente e
-\const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
-ricevuto lo stato di terminazione.
+{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
+ \const{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.\\
+ \const{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.\\
+ \const{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}
+
+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\_ING} per il segnale \const{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.
-% TODO previsto in futuro \const{RUSAGE\_THREAD}, verificare.
\subsection{Limiti sulle risorse}
\label{sec:sys_resource_limit}
Come accennato nell'introduzione il kernel mette a disposizione delle
funzionalità che permettono non solo di mantenere dati statistici relativi
all'uso delle risorse, ma anche di imporre dei limiti precisi sul loro
-utilizzo da parte dei vari processi o degli utenti.
+utilizzo da parte sia dei singoli processi che degli utenti.
-Per far questo esistono una serie di risorse e ad ogni processo vengono
+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
fatto solo fino al valore del secondo, che per questo viene detto \textit{hard
limit}.
-%TODO: tabella troppo grossa, trasformare in lista
+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 \itindex{core~dump} \textit{core dump}.
+
+Per permettere di leggere e di impostare i limiti di utilizzo delle risorse da
+parte di un processo sono previste due funzioni 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 il limite corrente di una risorsa.}
+\fdecl{int setrlimit(int resource, const struct rlimit *rlim)}
+\fdesc{Imposta il limite di una risorsa.}
+}
-\begin{table}[htb]
+{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.
+ \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{tabular}[c]{|l|p{12cm}|}
- \hline
- \textbf{Valore} & \textbf{Significato}\\
- \hline
- \hline
- \const{RLIMIT\_AS} & La dimensione massima della memoria virtuale di
- un processo, il cosiddetto \textit{Address
- Space}, (vedi sez.~\ref{sec:proc_mem_gen}). Se
- il limite viene superato dall'uso di funzioni
- come \func{brk}, \func{mremap} o \func{mmap}
- esse falliranno con un errore di
- \errcode{ENOMEM}, mentre se il superamento viene
- causato dalla crescita dello \itindex{stack}
- \textit{stack} il processo riceverà un segnale di
- \signal{SIGSEGV}.\\
- \const{RLIMIT\_CORE} & La massima dimensione per di un file di
- \itindex{core~dump} \textit{core dump} (vedi
- sez.~\ref{sec:sig_prog_error}) creato nella
- terminazione di un processo; file di dimensioni
- maggiori verranno troncati a questo valore,
- mentre con un valore si bloccherà la creazione
- dei \itindex{core~dump} \textit{core dump}.\\
- \const{RLIMIT\_CPU} & Il massimo tempo di CPU (vedi
- sez.~\ref{sec:sys_cpu_times}) che il processo può
- usare. Il superamento del limite corrente
- comporta l'emissione di un segnale di
- \signal{SIGXCPU}, la cui azione predefinita (vedi
- sez.~\ref{sec:sig_classification}) è terminare
- il processo, una volta al secondo fino al
- raggiungimento del limite massimo. Il
- superamento del limite massimo
- comporta l'emissione di un segnale di
- \signal{SIGKILL}.\footnotemark\\
- \const{RLIMIT\_DATA} & La massima dimensione del \index{segmento!dati}
- segmento dati di un
- processo (vedi sez.~\ref{sec:proc_mem_layout}).
- Il tentativo di allocare più memoria di quanto
- indicato dal limite corrente causa il fallimento
- della funzione di allocazione (\func{brk} o
- \func{sbrk}) con un errore di \errcode{ENOMEM}.\\
- \const{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
- può creare. Se il processo cerca di scrivere
- oltre questa dimensione riceverà un segnale di
- \signal{SIGXFSZ}, che di norma termina il
- processo; se questo viene intercettato la
- system call che ha causato l'errore fallirà con
- un errore di \errcode{EFBIG}.\\
- \const{RLIMIT\_LOCKS}& È un limite presente solo nelle prime versioni
- del kernel 2.4 sul numero massimo di
- \itindex{file~locking} \textit{file lock} (vedi
- sez.~\ref{sec:file_locking}) che un
- processo poteva effettuare.\\
- \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
- bloccata in RAM da un processo (vedi
- sez.~\ref{sec:proc_mem_lock}). Dal kernel 2.6.9
- questo limite comprende anche la memoria che può
- essere bloccata da ciascun utente nell'uso della
- memoria condivisa (vedi
- sez.~\ref{sec:ipc_sysv_shm}) che viene
- contabilizzata separatamente ma sulla quale
- viene applicato questo stesso limite.\\
+ \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\_MSGQUEUE}& Il numero massimo di \\
-% \const{RLIMIT\_NICE}& Il numero massimo di \\
% \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
- \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
- aprire. L'apertura di un ulteriore file farà
- fallire la funzione (\func{open}, \func{dup} o
- \func{pipe}) con un errore \errcode{EMFILE}.\\
- \const{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
- creati sullo stesso user id real. Se il limite
- viene raggiunto \func{fork} fallirà con un
- \errcode{EAGAIN}.\\
- \const{RLIMIT\_SIGPENDING}& Il numero massimo di segnali che possono
- essere mantenuti in coda per ciascun utente,
- considerando sia i segnali normali che real-time
- (vedi sez.~\ref{sec:sig_real_time}). Il limite è
- attivo solo per \func{sigqueue}, con \func{kill}
- si potrà sempre inviare un segnale che non sia
- già presente su una coda.\footnotemark\\
- \const{RLIMIT\_STACK} & La massima dimensione dello \itindex{stack}
- \textit{stack} del processo. Se il processo
- esegue operazioni che estendano lo
- \textit{stack} oltre questa dimensione
- riceverà un segnale di \signal{SIGSEGV}.\\
+
+
+\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
- \const{RLIMIT\_RSS} & L'ammontare massimo di pagine di memoria dato al
- \index{segmento!testo} testo del processo. Il
- limite è solo una indicazione per il kernel,
- qualora ci fosse un surplus di memoria questa
- verrebbe assegnata.\\
+
% TODO: 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
% TODO integrare con la roba di madvise
% TODO integrare con le ultime aggiunte, vedi pagina di manuale
- \hline
- \end{tabular}
- \caption{Valori possibili dell'argomento \param{resource} delle funzioni
- \func{getrlimit} e \func{setrlimit}.}
- \label{tab:sys_rlimit_values}
-\end{table}
-
-\footnotetext[18]{questo è quanto avviene per i kernel dalla serie 2.2 fino ad
- oggi (la 2.6.x); altri kernel possono avere comportamenti diversi per quanto
- avviene quando viene superato il \textit{soft limit}; perciò per avere
- operazioni portabili è sempre opportuno intercettare il primo
- \signal{SIGXCPU} e terminare in maniera ordinata il processo.}
-
-\footnotetext{il limite su questa risorsa è stato introdotto con il kernel
- 2.6.8.}
% TODO trattare prlimit64 introdotta con il 2.6.36 che dovrebbe sostituire
% setrlimit
+\end{basedescript}
-In generale il superamento di un limite corrente\footnote{di norma quanto
- riportato in tab.~\ref{tab:sys_rlimit_values} fa riferimento a quanto
- avviene al superamento del limite corrente, con l'eccezione
- \const{RLIMIT\_CPU} in cui si ha in comportamento diverso per il superamento
- dei due limiti.} comporta o l'emissione di un segnale o il fallimento della
-system call che lo ha provocato;\footnote{si nuovo c'è una eccezione per
- \const{RLIMIT\_CORE} che influenza soltanto la dimensione (o l'eventuale
- creazione) dei file di \itindex{core~dump} \textit{core dump}.} per
-permettere di leggere e di impostare i limiti di utilizzo delle risorse da
-parte di un processo sono previste due funzioni, \funcd{getrlimit} e
-\funcd{setrlimit}, i cui prototipi sono:
-\begin{functions}
- \headdecl{sys/time.h}
- \headdecl{sys/resource.h}
- \headdecl{unistd.h}
-
- \funcdecl{int getrlimit(int resource, struct rlimit *rlim)}
-
- Legge il limite corrente per la risorsa \param{resource}.
-
- \funcdecl{int setrlimit(int resource, const struct rlimit *rlim)}
-
- Imposta il limite per la risorsa \param{resource}.
-
- \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} assumerà uno dei valori:
- \begin{errlist}
- \item[\errcode{EINVAL}] i valori per \param{resource} non sono validi.
- \item[\errcode{EPERM}] un processo senza i privilegi di amministratore ha
- cercato di innalzare i propri limiti.
- \end{errlist}
- ed \errval{EFAULT}.}
-\end{functions}
-
-
-Entrambe le funzioni permettono di specificare, attraverso l'argomento
-\param{resource}, su quale risorsa si vuole operare: i possibili valori di
-questo argomento sono elencati in tab.~\ref{tab:sys_rlimit_values}. L'acceso
-(rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
-poi effettuato attraverso la struttura \struct{rlimit} puntata da
-\param{rlim}, la cui definizione è riportata in
-fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
-limite corrente e limite massimo.
-
-
-\begin{figure}[!htb]
- \footnotesize
- \centering
- \begin{minipage}[c]{\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}
-
-
-Nello specificare un limite, oltre a fornire dei valori specifici, si può
-anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
-di una risorsa; ma si ricordi che solo un processo con i privilegi di
-amministratore\footnote{per essere precisi in questo caso quello che serve è
- la \itindex{capabilities} \textit{capability} \const{CAP\_SYS\_RESOURCE}
- (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. 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
+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}).
La funzione è prevista in SVr4, BSD 4.4 e SUSv2, anche se questo ultimo
standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
-ha eliminata. In Linux è implementata come una system call nelle architetture
-in cui essa è necessaria, ed in genere restituisce il valore del simbolo
-\const{PAGE\_SIZE} del kernel, che dipende dalla architettura hardware, anche
-se le versioni delle librerie del C precedenti le \acr{glibc} 2.1
-implementavano questa funzione restituendo sempre un valore statico.
+ha eliminata. In Linux è implementata come una \textit{system call} nelle
+architetture in cui essa è necessaria, ed in genere restituisce il valore del
+simbolo \const{PAGE\_SIZE} del kernel, che dipende dalla architettura
+hardware, anche se le versioni delle librerie del C precedenti le \acr{glibc}
+2.1 implementavano questa funzione restituendo sempre un valore statico.
% TODO verificare meglio la faccenda di const{PAGE\_SIZE}
costante \const{HZ}.} Il dato primitivo usato per questo tempo è
\type{clock\_t}, che ha quindi una risoluzione del microsecondo. Il numero
di \itindex{clock~tick} \textit{tick} al secondo può essere ricavato anche
- attraverso \func{sysconf} (vedi sez.~\ref{sec:sys_sysconf}). Il vecchio
+ attraverso \func{sysconf} (vedi sez.~\ref{sec:sys_limits}). Il vecchio
simbolo \const{CLK\_TCK} definito in \headfile{time.h} è ormai considerato
obsoleto.
\end{basedescript}
sez.~\ref{sec:sys_resource_use}.
\item[\textit{system time}] il tempo effettivo che il processore ha impiegato
- per eseguire codice delle system call nel kernel per conto del processo. È
- quello riportato nella risorsa \var{ru\_stime} di \struct{rusage} vista in
- sez.~\ref{sec:sys_resource_use}.
+ per eseguire codice delle \textit{system call} nel kernel per conto del
+ processo. È quello riportato nella risorsa \var{ru\_stime} di
+ \struct{rusage} vista in sez.~\ref{sec:sys_resource_use}.
\end{basedescript}
In genere la somma di \textit{user time} e \textit{system time} indica il
% LocalWords: perror string errnum MESSAGES error message ErrCode strtol log
% LocalWords: program invocation argv printf print progname exit count fname
% LocalWords: lineno one standardese Di page Wed Wednesday Apr April PM AM
+% LocalWords: CEST
%%% mode: latex
%%% TeX-master: "gapil"
%%% End:
-% LocalWords: CEST
projects / gapil.git / blobdiff