From: Simone Piccardi Date: Sun, 5 May 2002 22:16:06 +0000 (+0000) Subject: Sistemate referenze e contenuti di getrusage e setrlimit X-Git-Url: https://gapil.gnulinux.it/gitweb/?a=commitdiff_plain;h=9ed5353304ae9ef478fce673c5e0dbe873ee2ba8;p=gapil.git Sistemate referenze e contenuti di getrusage e setrlimit --- diff --git a/process.tex b/process.tex index 943924e..79cf7ae 100644 --- 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 63b5ca8..a526c5f 100644 --- 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{} 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 657c0d6..38a7abc 100644 --- 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{} 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}