From: Simone Piccardi Date: Mon, 6 May 2002 22:45:51 +0000 (+0000) Subject: Correzione ai limiti, aggiustate referenze e iniziato le funzioni per X-Git-Url: https://gapil.gnulinux.it/gitweb/?a=commitdiff_plain;h=989ba37f5c3e6190b8f500db103529c3253ebb4d;p=gapil.git Correzione ai limiti, aggiustate referenze e iniziato le funzioni per le informazioni sulla memoria. --- diff --git a/process.tex b/process.tex index 79cf7ae..4d02cbc 100644 --- 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 è -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 diff --git a/prochand.tex b/prochand.tex index a526c5f..98a0788 100644 --- 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}. - - \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 diff --git a/system.tex b/system.tex index 38a7abc..40ec611 100644 --- a/system.tex +++ b/system.tex @@ -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}