Correzione ai limiti, aggiustate referenze e iniziato le funzioni per
authorSimone Piccardi <piccardi@gnulinux.it>
Mon, 6 May 2002 22:45:51 +0000 (22:45 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Mon, 6 May 2002 22:45:51 +0000 (22:45 +0000)
le informazioni sulla memoria.

process.tex
prochand.tex
system.tex

index 79cf7ae..4d02cbc 100644 (file)
@@ -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 è
-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
@@ -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
-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
@@ -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
-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}
@@ -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
-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
index a526c5f..98a0788 100644 (file)
@@ -1035,8 +1035,6 @@ utilizzata anche dalla funzione \func{getrusage} (vedi
 processo; la sua definizione è riportata in \figref{fig:sys_rusage_struct}.
 
 
-
-
 \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}).
-\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},
-  \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
index 38a7abc..40ec611 100644 (file)
@@ -1467,10 +1467,11 @@ corrente e massimo.
   \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} 
@@ -1502,21 +1503,47 @@ specificarne i valori.
 \begin{table}[htb]
   \footnotesize
   \centering
-  \begin{tabular}[c]{|l|p{8cm}|}
+  \begin{tabular}[c]{|l|p{12cm}|}
     \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
@@ -1524,18 +1551,75 @@ specificarne i valori.
   \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
-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}
@@ -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}
 
-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}
@@ -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}