Sistemate referenze e contenuti di getrusage e setrlimit

diff --git a/process.tex b/process.tex
index 943924e0f851dc1385d2fef6f6db0816fb5ca3f6..79cf7ae06bf9fab4683fbd074990342a87fb43d6 100644 (file)
--- a/process.tex
+++ b/process.tex
@@ -290,11 +290,11 @@ servono. Questo meccanismo 
 principali del kernel.
 
 Quando un processo cerca di accedere ad una pagina che non è nella memoria
-reale, avviene quello che viene chiamato un \textit{page fault}; l'hardware di
-gestione della memoria genera un'interruzione e passa il controllo al kernel
-il quale sospende il processo e si incarica di mettere in RAM la pagina
-richiesta (effettuando tutte le operazioni necessarie per reperire lo spazio
-necessario), per poi restituire il controllo al processo.
+reale, avviene quello che viene chiamato un \textit{page fault}\index{page
+  fault}; l'hardware di gestione della memoria genera un'interruzione e passa
+il controllo al kernel il quale sospende il processo e si incarica di mettere
+in RAM la pagina richiesta (effettuando tutte le operazioni necessarie per
+reperire lo spazio necessario), per poi restituire il controllo al processo.
 
 Dal punto di vista di un processo questo meccanismo è completamente
 trasparente, e tutto avviene come se tutte le pagine fossero sempre
@@ -318,9 +318,9 @@ tentativo di accedere ad un indirizzo non allocato 
 commette quando si è manipolato male un puntatore e genera quello che viene
 chiamato un \textit{segmentation fault}. Se si tenta cioè di leggere o
 scrivere da un indirizzo per il quale non esiste un'associazione della pagina
-virtuale, il kernel risponde al relativo \textit{page fault} mandando un
-segnale \macro{SIGSEGV} al processo, che normalmente ne causa la terminazione
-immediata.
+virtuale, il kernel risponde al relativo \textit{page fault}
+mandando un segnale \macro{SIGSEGV} al processo, che normalmente ne causa la
+terminazione immediata.
 
 È pertanto importante capire come viene strutturata la memoria virtuale di un
 processo. Essa viene divisa in \textsl{segmenti}, cioè un insieme contiguo di

diff --git a/prochand.tex b/prochand.tex
index 63b5ca8c6a004d9d11375bfd60a4b4cf1892f0a2..a526c5f15f9a9ba41fd43a284d3c591cd455d7c4 100644 (file)
--- a/prochand.tex
+++ b/prochand.tex
@@ -610,7 +610,7 @@ comune dopo l'esecuzione di una \func{fork} 
   azioni installate (vedi \secref{sec:sig_gen_beha}).
 \item i segmenti di memoria condivisa agganciati al processo (vedi
 \secref{sec:ipc_xxx}). 
-\item i limiti sulle risorse (vedi \secref{sec:sys_xxx}).
+\item i limiti sulle risorse (vedi \secref{sec:sys_resource_limit}).
 \item le variabili di ambiente (vedi \secref{sec:proc_environ}).
 \end{itemize*}
 le differenze fra padre e figlio dopo la \func{fork} invece sono:
@@ -1015,15 +1015,14 @@ sulle risorse usate dal processo terminato e dai vari figli.  I prototipi di
 queste funzioni, che diventano accessibili definendo la costante
 \macro{\_USE\_BSD}, sono:
 \begin{functions}
-  \headdecl{sys/times.h} 
-  \headdecl{sys/types.h} 
-  \headdecl{sys/wait.h}        
-  \headdecl{sys/resource.h}
+  \headdecl{sys/times.h} \headdecl{sys/types.h} \headdecl{sys/wait.h}
+  \headdecl{sys/resource.h} 
+  
   \funcdecl{pid\_t wait4(pid\_t pid, int * status, int options, struct rusage
-    * rusage)} 
-  È identica a \func{waitpid} sia per comportamento che per i
-  valori dei parametri, ma restituisce in \param{rusage} un sommario delle
-  risorse usate dal processo (per i dettagli vedi \secref{sec:sys_xxx})
+    * rusage)}   
+  È identica a \func{waitpid} sia per comportamento che per i valori dei
+  parametri, ma restituisce in \param{rusage} un sommario delle risorse usate
+  dal processo.
 
   \funcdecl{pid\_t wait3(int *status, int options, struct rusage *rusage)}
   Prima versione, equivalente a \code{wait4(-1, \&status, opt, rusage)} è
@@ -1031,16 +1030,11 @@ queste funzioni, che diventano accessibili definendo la costante
 \end{functions}
 \noindent 
 la struttura \type{rusage} è definita in \file{sys/resource.h}, e viene
-utilizzata anche dalla funzione \func{getrusage} (vedi \secref{sec:sys_xxx})
-per ottenere le risorse di sistema usate da un processo; la sua definizione è
-riportata in \figref{fig:sys_rusage_struct}.
-
-In genere includere esplicitamente \file{<sys/time.h>} non è più
-necessario, ma aumenta la portabilità, e serve in caso si debba accedere
-ai campi di \var{rusage} definiti come \type{struct timeval}. La
-struttura è ripresa da BSD 4.3, attualmente (con il kernel 2.4.x) i soli
-campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime},
-\var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}.
+utilizzata anche dalla funzione \func{getrusage} (vedi
+\secref{sec:sys_resource_use}) per ottenere le risorse di sistema usate da un
+processo; la sua definizione è riportata in \figref{fig:sys_rusage_struct}.
+
+
 
 
 \subsection{Le funzioni \func{exec}}

diff --git a/system.tex b/system.tex
index 657c0d645cc5bada0c1e7b00bf16aa52ef387ce4..38a7abcce10b0ec20e3319552cb7285321a2c75c 100644 (file)
--- a/system.tex
+++ b/system.tex
@@ -1,4 +1,4 @@
-\chapter{La gestione del sistema, delle risorse, e degli errori}
+fo \chapter{La gestione del sistema, delle risorse, e degli errori}
 \label{cha:system}
 
 In questo capitolo tratteremo varie interfacce che attengono agli aspetti più
@@ -1225,18 +1225,18 @@ eseguire una ricerca.
     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
 struct utmp
 {
-  short int ut_type;            /* Type of login.  */
-  pid_t ut_pid;                 /* Process ID of login process.  */
-  char ut_line[UT_LINESIZE];    /* Devicename.  */
-  char ut_id[4];                /* Inittab ID.  */
-  char ut_user[UT_NAMESIZE];    /* Username.  */
-  char ut_host[UT_HOSTSIZE];    /* Hostname for remote login.  */
-  struct exit_status ut_exit;   /* Exit status of a process marked
-                                   as DEAD_PROCESS.  */
-  long int ut_session;          /* Session ID, used for windowing.  */
-  struct timeval ut_tv;         /* Time entry was made.  */
-  int32_t ut_addr_v6[4];        /* Internet address of remote host.  */
-  char __unused[20];            /* Reserved for future use.  */
+    short int ut_type;            /* Type of login.  */
+    pid_t ut_pid;                 /* Process ID of login process.  */
+    char ut_line[UT_LINESIZE];    /* Devicename.  */
+    char ut_id[4];                /* Inittab ID.  */
+    char ut_user[UT_NAMESIZE];    /* Username.  */
+    char ut_host[UT_HOSTSIZE];    /* Hostname for remote login.  */
+    struct exit_status ut_exit;   /* Exit status of a process marked
+                                     as DEAD_PROCESS.  */
+    long int ut_session;          /* Session ID, used for windowing.  */
+    struct timeval ut_tv;         /* Time entry was made.  */
+    int32_t ut_addr_v6[4];        /* Internet address of remote host.  */
+    char __unused[20];            /* Reserved for future use.  */
 };
     \end{lstlisting}
   \end{minipage} 
@@ -1340,63 +1340,209 @@ poi aggiunge chiamando \func{updwtmp}.
 \section{Limitazione ed uso delle risorse}
 \label{sec:sys_res_limits}
 
-In questa sezione esamineremo le funzioni che permettono di esaminare e
-controllare come le varie risorse del sistema (CPU, memoria, ecc.) vengono
-utilizzate dai singoli processi, e le modalità con cui è possibile imporre dei
-limiti sul loro utilizzo.
 
+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.
 
 
 \subsection{L'uso delle risorse}
 \label{sec:sys_resource_use}
 
+Come abbiamo accennato in \secref{sec:proc_wait4} le informazioni riguardo
+l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
+di tipo \code{struct }\type{rusage}, la cui definizione (che si trova in
+\file{sys/resource.h}) è riportata in \figref{fig:sys_rusage_struct}.
 
+\begin{figure}[!htb]
+  \footnotesize
+  \centering
+  \begin{minipage}[c]{15cm}
+    \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
+struct rusage {
+    struct timeval ru_utime; /* user time used */
+    struct timeval ru_stime; /* system time used */
+    long ru_maxrss;          /* maximum resident set size */
+    long ru_ixrss;           /* integral shared memory size */
+    long ru_idrss;           /* integral unshared data size */
+    long ru_isrss;           /* integral unshared stack size */
+    long ru_minflt;          /* page reclaims */
+    long ru_majflt;          /* page faults */
+    long ru_nswap;           /* swaps */
+    long ru_inblock;         /* block input operations */
+    long ru_oublock;         /* block output operations */
+    long ru_msgsnd;          /* messages sent */
+    long ru_msgrcv;          /* messages received */
+    long ru_nsignals;   ;    /* signals received */
+    long ru_nvcsw;           /* voluntary context switches */
+    long ru_nivcsw;          /* involuntary context switches */
+};
+    \end{lstlisting}
+  \end{minipage} 
+  \normalsize 
+  \caption{La struttura \var{rusage} per la lettura delle informazioni dei 
+    delle risorse usate da un processo.}
+  \label{fig:sys_rusage_struct}
+\end{figure}
 
-\subsection{Limiti sulle risorse}
-\label{sec:sys_resource_limit}
+La struttura è ripresa da BSD 4.3, ma attualmente (con i kernel della serie
+2.4.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 virtuale e
+corrispondono rispettivamente al numero di \textit{page fault}\index{page
+  fault} (vedi \secref{sec:proc_mem_gen}) avvenuti senza richiedere I/O (i
+cosiddetti \textit{minor page fault}), a quelli che invece han richiesto I/O
+(detti invece \textit{major page fault}) ed al numero di volte che il processo
+è stato completamente tolto dalla memoria per essere inserito nello swap.
+
+In genere includere esplicitamente \file{<sys/time.h>} non è più necessario,
+ma aumenta la portabilità, e serve comunque quando, come nella maggior parte
+dei casi, si debba accedere ai campi di \var{rusage} relativi ai tempi di
+utilizzo del processore, che sono definiti come \code{struct }\type{timeval}.
+
+
+Questa è la stessa struttura utilizzata da \func{wait4}  per ricavare la
+quantità di risorse impiegato dal processo di cui si è letto lo stato di
+terminazione, ma essa può anche essere letta direttamente utilizzando la
+funzione \func{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.
 
 
-\subsection{Le risorse di memoria}
-\label{sec:sys_memory_res}
+  \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
+  nel qual caso \var{errno} può essere \macro{EINVAL} o \macro{EFAULT}.}
+\end{functions}
 
+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
+\macro{RUSAGE\_SELF} per indicare il processo corrente e
+\macro{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
+ricevuto lo stato di terminazione. 
 
-\subsection{Le risorse di processore}
-\label{sec:sys_cpu_load}
 
+\subsection{Limiti sulle risorse}
+\label{sec:sys_resource_limit}
 
+Come accennato nell'introduzione oltre a leggere l'uso delle risorse da parte
+di un processo si possono anche imporre dei limiti sulle sue capacità. Ogni
+processo ha in generale due limiti associati ad ogni risorsa; questi sono
+detti il \textsl{limite corrente} (o \textit{current limit}) che esprime il
+valore che attualmente il processo non può superare, ed il \textsl{limite
+  massimo} (o \textit{maximum limit}) che esprime il valore massimo che può
+assumere il \textsl{limite corrente}.
+
+In generale il primo viene chiamato un limite \textsl{soffice} (o \textit{soft
+  limit}) dato che il suo valore può essere aumentato, mentre il secondo è
+detto \textsl{duro} (o \textit{hard limit}), in quanto un processo normale non
+può modificarne il valore. Il valore di questi limiti è mantenuto in una
+struttura \var{rlimit}, la cui definizione è riportata in
+\figref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a limite
+corrente e massimo.
 
 \begin{figure}[!htb]
   \footnotesize
   \centering
   \begin{minipage}[c]{15cm}
     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
-struct rusage {
-     struct timeval ru_utime; /* user time used */
-     struct timeval ru_stime; /* system time used */
-     long ru_maxrss;          /* maximum resident set size */
-     long ru_ixrss;           /* integral shared memory size */
-     long ru_idrss;           /* integral unshared data size */
-     long ru_isrss;           /* integral unshared stack size */
-     long ru_minflt;          /* page reclaims */
-     long ru_majflt;          /* page faults */
-     long ru_nswap;           /* swaps */
-     long ru_inblock;         /* block input operations */
-     long ru_oublock;         /* block output operations */
-     long ru_msgsnd;          /* messages sent */
-     long ru_msgrcv;          /* messages received */
-     long ru_nsignals;   ;    /* signals received */
-     long ru_nvcsw;           /* voluntary context switches */
-     long ru_nivcsw;          /* involuntary context switches */
-};
+    struct rlimit {
+         rlim_t    rlim_cur;
+         rlim_t    rlim_max;
+    };
     \end{lstlisting}
   \end{minipage} 
   \normalsize 
-  \caption{La struttura \var{rusage} per la lettura delle informazioni dei 
+  \caption{La struttura \var{rlimit} per impostare i limiti di utilizzo 
     delle risorse usate da un processo.}
-  \label{fig:sys_rusage_struct}
+  \label{fig:sys_rlimit_struct}
 \end{figure}
 
 
+Per far leggere o settare i limiti sdi utilizzo delle risorse da parte di un
+processo le \acr{glibc} prevedono due funzioni, \func{getrlimit} e
+\func{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)} 
+  
+  Setta 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} viene settata ai valori:
+    \begin{errlist}
+    \item[\macro{INVAL}] I valori per \param{resource} non sono validi.
+    \item[\macro{EPERM}] Un processo senza i privilegi di amministratore ha
+    cercato di innalzare i propri limiti.
+    \end{errlist}
+  ed \macro{EFAULT}.}
+\end{functions}
+
+Entrambe le funzioni permettono di specificare su quale risorsa si vuole
+operare attraverso \param{resource}, i cui possibili valori sono elencati in
+\secref{tab:sys_rlimit_values}, e utilizzano una struttura \var{rlimit} per
+specificarne i valori.
+
+\begin{table}[htb]
+  \footnotesize
+  \centering
+  \begin{tabular}[c]{|l|p{8cm}|}
+    \hline
+    \textbf{Valore} & \textbf{Significato}\\
+    \hline
+    \hline
+    \macro{RLIMIT\_CPU}    &  \\
+    \macro{RLIMIT\_FSIZE}  &  \\
+    \macro{RLIMIT\_DATA}   &  \\
+    \macro{RLIMIT\_STACK}  &  \\
+    \macro{RLIMIT\_CORE}   &  \\
+    \macro{RLIMIT\_RSS}    &  \\
+    \macro{RLIMIT\_NPROC}  &  \\
+    \macro{RLIMIT\_NOFILE} &  \\
+    \macro{RLIMIT\_MEMLOCK}&  \\
+    \macro{RLIMIT\_AS}     &  \\
+    \hline
+  \end{tabular}
+  \caption{Valori possibili dell'argomento \param{resource} delle funzioni
+    \func{getrlimit} e \func{setrlimit}.} 
+  \label{tab:sys_rlimit_values}
+\end{table}
+
+È inoltre definita la costante \macro{RLIM\_INFINITY} che permette di
+sbloccare l'uso di una risorsa, ma solo un processo con i privilegi di
+amministratore può innalzare un limite al di sopra del valore corrente del
+limite massimo. I limiti vengono ereditati dal processo padre attraverso una
+\func{fork} (vedi \secref{sec:proc_fork}) e mantenuti attraverso una
+\func{exec}.
+
+
+
+
+\subsection{Le risorse di memoria}
+\label{sec:sys_memory_res}
+
+
+\subsection{Le risorse di processore}
+\label{sec:sys_cpu_load}
+
+
+
 
 
 \var{tms\_utime}, \var{tms\_stime}, \var{tms\_cutime}, \var{tms\_uetime}