Correzione ai limiti, aggiustate referenze e iniziato le funzioni per

le informazioni sulla memoria.

diff --git a/process.tex b/process.tex
index 79cf7ae06bf9fab4683fbd074990342a87fb43d6..4d02cbc0a461530b5660a29ed210a13ceb5da0fa 100644 (file)
--- a/process.tex
+++ b/process.tex
@@ -253,11 +253,12 @@ esecuzione, e le varie funzioni utilizzabili per la sua gestione.
 Ci sono vari modi in cui i vari sistemi organizzano la memoria (ed i dettagli
 di basso livello dipendono spesso in maniera diretta dall'architettura
 dell'hardware), ma quello più tipico, usato dai sistemi unix-like come Linux è
 Ci sono vari modi in cui i vari sistemi organizzano la memoria (ed i dettagli
 di basso livello dipendono spesso in maniera diretta dall'architettura
 dell'hardware), ma quello più tipico, usato dai sistemi unix-like come Linux è

-la cosiddetta \textsl{memoria virtuale} che consiste nell'assegnare ad ogni
-processo uno spazio virtuale di indirizzamento lineare, in cui gli indirizzi
-vanno da zero ad un qualche valore massimo.\footnote{nel caso di Linux fino al
-  kernel 2.2 detto massimo era, per macchine a 32bit, di 2Gb, con il kernel
-  2.4 ed il supporto per la \textit{high-memory} il limite è stato esteso.}
+la cosiddetta \textsl{memoria virtuale}\index{memoria virtuale} che consiste
+nell'assegnare ad ogni processo uno spazio virtuale di indirizzamento lineare,
+in cui gli indirizzi vanno da zero ad un qualche valore massimo.\footnote{nel
+  caso di Linux fino al kernel 2.2 detto massimo era, per macchine a 32bit, di
+  2Gb, con il kernel 2.4 ed il supporto per la \textit{high-memory} il limite
+  è stato esteso.}

 
 Come accennato in \capref{cha:intro_unix} questo spazio di indirizzi è
 virtuale e non corrisponde all'effettiva posizione dei dati nella RAM del
 
 Come accennato in \capref{cha:intro_unix} questo spazio di indirizzi è
 virtuale e non corrisponde all'effettiva posizione dei dati nella RAM del


@@ -286,8 +287,8 @@ gestione della memoria (la \textit{Memory Management Unit} del processore).
 Poiché in genere la memoria fisica è solo una piccola frazione della memoria
 virtuale, è necessario un meccanismo che permetta di trasferire le pagine che
 servono dal supporto su cui si trovano in memoria, eliminando quelle che non
 Poiché in genere la memoria fisica è solo una piccola frazione della memoria
 virtuale, è necessario un meccanismo che permetta di trasferire le pagine che
 servono dal supporto su cui si trovano in memoria, eliminando quelle che non

-servono. Questo meccanismo è detto \textit{paging}, ed è uno dei compiti
-principali del kernel.
+servono. Questo meccanismo è detto \textsl{paginazione}\index{paginazione} (o
+\textit{paging}), ed è uno dei compiti 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}\index{page
 
 Quando un processo cerca di accedere ad una pagina che non è nella memoria
 reale, avviene quello che viene chiamato un \textit{page fault}\index{page


@@ -305,8 +306,8 @@ a tempi molto pi
 Normalmente questo è il prezzo da pagare per avere un multitasking reale, ed
 in genere il sistema è molto efficiente in questo lavoro; quando però ci siano
 esigenze specifiche di prestazioni è possibile usare delle funzioni che
 Normalmente questo è il prezzo da pagare per avere un multitasking reale, ed
 in genere il sistema è molto efficiente in questo lavoro; quando però ci siano
 esigenze specifiche di prestazioni è possibile usare delle funzioni che

-permettono di bloccare il meccanismo del paging e mantenere fisse delle pagine
-in memoria (vedi \ref{sec:proc_mem_lock}).
+permettono di bloccare il meccanismo della paginazione e mantenere fisse delle
+pagine in memoria (vedi \ref{sec:proc_mem_lock}).

 
 
 \subsection{La struttura della memoria di un processo}
 
 
 \subsection{La struttura della memoria di un processo}


@@ -662,10 +663,10 @@ memoria per metterle nello swap, sulla base dell'utilizzo corrente da parte
 dei vari processi.
 
 Nell'uso comune un processo non deve preoccuparsi di tutto ciò, in quanto il
 dei vari processi.
 
 Nell'uso comune un processo non deve preoccuparsi di tutto ciò, in quanto il

-meccanismo della paginazione riporta in RAM, ed in maniera trasparente, tutte
-le pagine che gli occorrono; esistono però esigenze particolari in cui non si
-vuole che questo meccanismo si attivi. In generale i motivi per cui si possono
-avere di queste necessità sono due:
+meccanismo della paginazione\index{paginazione} riporta in RAM, ed in maniera
+trasparente, tutte le pagine che gli occorrono; esistono però esigenze
+particolari in cui non si vuole che questo meccanismo si attivi. In generale i
+motivi per cui si possono avere di queste necessità sono due:

 \begin{itemize}
 \item \textsl{La velocità}. Il processo della paginazione è trasparente solo
   se il programma in esecuzione non è sensibile al tempo che occorre a
 \begin{itemize}
 \item \textsl{La velocità}. Il processo della paginazione è trasparente solo
   se il programma in esecuzione non è sensibile al tempo che occorre a

diff --git a/prochand.tex b/prochand.tex
index a526c5f15f9a9ba41fd43a284d3c591cd455d7c4..98a07883b31341efba1a9245828d1c3ea730cd98 100644 (file)
--- a/prochand.tex
+++ b/prochand.tex
@@ -1035,8 +1035,6 @@ utilizzata anche dalla funzione \func{getrusage} (vedi
 processo; la sua definizione è riportata in \figref{fig:sys_rusage_struct}.
 
 
 processo; la sua definizione è riportata in \figref{fig:sys_rusage_struct}.
 
 

-
-

 \subsection{Le funzioni \func{exec}}
 \label{sec:proc_exec}
 
 \subsection{Le funzioni \func{exec}}
 \label{sec:proc_exec}
 


@@ -1211,9 +1209,9 @@ la lista completa 
   \secref{sec:file_locking}).
 \item i segnali sospesi (\textit{pending}) e la maschera dei segnali (si veda
   \secref{sec:sig_sigmask}).
   \secref{sec:file_locking}).
 \item i segnali sospesi (\textit{pending}) e la maschera dei segnali (si veda
   \secref{sec:sig_sigmask}).

-\item i limiti sulle risorse (vedi \secref{sec:sys_limits}).
+\item i limiti sulle risorse (vedi \secref{sec:sys_resource_limits}).

 \item i valori delle variabili \var{tms\_utime}, \var{tms\_stime},
 \item i valori delle variabili \var{tms\_utime}, \var{tms\_stime},

-  \var{tms\_cutime}, \var{tms\_ustime} (vedi \secref{sec:xxx_xxx}).
+  \var{tms\_cutime}, \var{tms\_ustime} (vedi \secref{sec:sys_xxx}).

 \end{itemize*}
 
 Inoltre i segnali che sono stati settati per essere ignorati nel processo
 \end{itemize*}
 
 Inoltre i segnali che sono stati settati per essere ignorati nel processo

diff --git a/system.tex b/system.tex
index 38a7abcce10b0ec20e3319552cb7285321a2c75c..40ec611f1ab333141f99d5893149cba116a13fee 100644 (file)
--- a/system.tex
+++ b/system.tex
@@ -1467,10 +1467,11 @@ corrente e massimo.
   \label{fig:sys_rlimit_struct}
 \end{figure}
 
   \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:
+In genere il superamento di un limite comporta o l'emissione di un segnale o
+il fallimento della system call che lo ha provocato; per far leggere o settare
+i limiti di 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} 
 \begin{functions}
   \headdecl{sys/time.h} 
   \headdecl{sys/resource.h} 


@@ -1502,21 +1503,47 @@ specificarne i valori.
 \begin{table}[htb]
   \footnotesize
   \centering
 \begin{table}[htb]
   \footnotesize
   \centering

-  \begin{tabular}[c]{|l|p{8cm}|}
+  \begin{tabular}[c]{|l|p{12cm}|}

     \hline
     \textbf{Valore} & \textbf{Significato}\\
     \hline
     \hline
     \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}     &  \\
+    \macro{RLIMIT\_CPU}    &  Il massimo tempo di CPU che il processo può
+                              usare. Il superamento del limite comporta
+                              l'emissione di un segnale di \macro{SIGXCPU}.\\
+    \macro{RLIMIT\_FSIZE}  &  La massima dimensione di un file che un processo
+                              può usare. Se il processo cerca di scrivere
+                              oltre questa dimensione riceverà un segnale di
+                              \macro{SIGXFSZ}.\\
+    \macro{RLIMIT\_DATA}   &  La massima dimensione della memoria dati di un
+                              processo. Il tentatico di allocare più memoria
+                              causa il fallimento della funzione di
+                              allocazione. \\
+    \macro{RLIMIT\_STACK}  &  La massima dimensione dello stack del
+                              processo. Se il processo esegue operazioni che
+                              estendano lo stack oltre questa dimensione
+                              riceverà un segnale di \macro{SIGSEGV}.\\
+    \macro{RLIMIT\_CORE}   &  La massima dimensione di un file di \textit{core
+                              dump} creato da un processo. Nel caso le 
+                              dimensioni dovessero essere maggiori il file non
+                              verrebbe generato.\footnotemark\\
+    \macro{RLIMIT\_RSS}    &  L'ammontare massimo di memoria fisica dato al
+                              processo. Il limite è solo una indicazione per
+                              il kernel, qualora ci fosse un surplus di
+                              memoria questa verrebbe assegnata.\\
+    \macro{RLIMIT\_NPROC}  &  Il numero massimo di processi che possono essere
+                              creati sullo stesso user id. Se il limite viene
+                              raggiunto \func{fork} fallirà con un
+                              \macro{EAGAIN}.\\
+    \macro{RLIMIT\_NOFILE} &  Il numero massimo di file che il processo può
+                              aprire. L'apertura di un ulteriore file fallirà
+                              con un errore \macro{EMFILE}.\\
+    \macro{RLIMIT\_MEMLOCK}&  L'ammontare massimo di memoria che può essere
+                              bloccata (vedi \secref{sec:proc_mem_lock}).\\
+    \macro{RLIMIT\_AS}     &  La dimensione massima di tutta la memoria che il
+                              processo può ottenere. Se il processo tenta di
+                              allocarne di più  funzioni come \func{brk},
+                              \func{malloc} o \func{mmap} falliranno. \\

     \hline
   \end{tabular}
   \caption{Valori possibili dell'argomento \param{resource} delle funzioni
     \hline
   \end{tabular}
   \caption{Valori possibili dell'argomento \param{resource} delle funzioni


@@ -1524,18 +1551,75 @@ specificarne i valori.
   \label{tab:sys_rlimit_values}
 \end{table}
 
   \label{tab:sys_rlimit_values}
 \end{table}
 

+\footnotetext{Settare questo limite a zero è la maniera più semplice per
+  evitare la creazione di \file{core} file.}
+

 È 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
 È 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}.
+limite massimo. Si tenga conto infine che tutti i limiti vengono ereditati dal
+processo padre attraverso una \func{fork} (vedi \secref{sec:proc_fork}) e
+mantenuti attraverso una \func{exec} (vedi \secref{sec:proc_exec}).
+

 
 

+\subsection{Le risorse relative alla memoria}
+\label{sec:sys_memory_res}

 
 

+La gestione della memoria è già stata affrontata in dettaglio in
+\secref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
+meccanismo della memoria virtuale attraverso la divisione della memoria fisica
+in pagine.
+
+In genere questo è del tutto trasparente al singolo processo, ma in certi
+casi, come per l'I/O mappato in memoria (vedi \ref{sec:file_memory_map}) che
+usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
+dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
+gestire in maniera ottimale l'interazione della memoria allocata con il
+meccanismo della paginazione.
+
+Di solito la dimensione delle pagine di memoria è fissata dall'architettura
+hardware, per cui in genere la dimensione delle pagine di memoria era una
+costante definita in fase di compilazione, ma oggi alcune architetture (ad
+esempio su Sun Sparc) permettono di variare questa dimensione, e non volendo
+dover fornire binari diversi per ogni possibile modello, è necessario poter
+utilizzare una funzione. 
+
+In genere questa dimensione può essere ottenuta attraverso una chiamata a
+\func{sysconf} come \func{sysconf(\_SC\_PAGESIZE)}, ma in BSD 4.2 è stata
+introdotta una apposita funzione, \func{getpagesize}, che restituisce la
+dimensione delle pagine di memoria; il suo prototipo è:
+\begin{prototype}{unistd.h}{int getpagesize(void)}
+  Legge le dimensioni delle pagine di memoria.
+  
+  \bodydesc{La funzione ritorna la dimensione di una pagina in byte, e non
+    sono previsti errori.}
+\end{prototype}

 
 

+La funzione è prevista in SVr4, 4.4BSD 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 serve, in genere restituisce il valore del simbolo
+\macro{PAGE\_SIZE} del kernel, anche se le versioni delle librerie del C
+precedenti le \acr{glibc} 2.1 implementavano questa funzione restituendo un
+valore statico.
+
+Le \acr{glibc} forniscono, come specifica estensione GNU, altre due funzioni,
+\func{get\_phys\_pages} e \func{get\_avphys\_pages} che permettono di ottenere
+informazioni riguardo la memoria; i loro prototipi sono:
+\begin{functions}
+  \headdecl{sys/sysinfo.h} 
+  
+  \funcdecl{long int get\_phys\_pages(void)} 
+
+  Legge il numero totale di pagine di memorie disponibili per il sistema.
+  
+  \funcdecl{long int get\_avphys\_pages(void)} 
+  
+  Legge il numero.
+  
+  \bodydesc{}
+\end{functions}

 
 

-\subsection{Le risorse di memoria}
-\label{sec:sys_memory_res}

 
 
 \subsection{Le risorse di processore}
 
 
 \subsection{Le risorse di processore}


@@ -1545,16 +1629,14 @@ limite massimo. I limiti vengono ereditati dal processo padre attraverso una
 
 
 
 
 
 

-\var{tms\_utime}, \var{tms\_stime}, \var{tms\_cutime}, \var{tms\_uetime}
-

 
 
 \section{La gestione dei tempi del sistema}
 \label{sec:sys_time}
 
 
 
 \section{La gestione dei tempi del sistema}
 \label{sec:sys_time}
 

-In questa sezione tratteremo le varie funzioni per la gestione delle
-date e del tempo in un sistema unix-like, e quelle per convertire i vari
-tempi nelle differenti rappresentazioni che vengono utilizzate.
+In questa sezione tratteremo le varie funzioni per la gestione delle date e
+del tempo in un sistema unix-like, e quelle per convertire i vari tempi nelle
+differenti rappresentazioni che vengono utilizzate.

 
 
 \subsection{La misura del tempo in Unix}
 
 
 \subsection{La misura del tempo in Unix}


@@ -1617,6 +1699,14 @@ nell'eseguire un certo processo e viene chiamato \textit{CPU time}.
 
 
 
 
 
 

+\subsection{I tempi di processore}
+\label{sec:sys_cpu_times}
+
+
+\var{tms\_utime}, \var{tms\_stime}, \var{tms\_cutime}, \var{tms\_uetime}
+
+
+

 
 \section{La gestione degli errori}
 \label{sec:sys_errors}
 
 \section{La gestione degli errori}
 \label{sec:sys_errors}