From: Simone Piccardi Date: Sun, 30 Dec 2001 00:12:23 +0000 (+0000) Subject: Finito con la bufferizzazione degli stream e chroot, iniziato a riordinare X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=commitdiff_plain;h=89ab23ea8770a3b4c7a617acf1aae071ce87c8f1 Finito con la bufferizzazione degli stream e chroot, iniziato a riordinare il capitolo sul sistema --- diff --git a/filedir.tex b/filedir.tex index 835e350..24f331b 100644 --- a/filedir.tex +++ b/filedir.tex @@ -1933,7 +1933,7 @@ potrebbe restare fuori dalla \textit{chroot jail}. Un caso tipico di uso di \func{chroot} è quello di un server ftp, in questo caso infatti si vuole che il server veda solo i file che deve trasferire, per -cui in genere si una \textit{chroot jail} alla directory che contiene i file. +cui in genere si esegue una \func{chroot} sulla directory che contiene i file. Si tenga presente però che in questo caso occorrerà replicare all'interno della \textit{chroot jail} tutti i file (in genere programmi e librerie) di cui il server potrebbe avere bisogno. diff --git a/filestd.tex b/filestd.tex index 8a0f2c7..79931fc 100644 --- a/filestd.tex +++ b/filestd.tex @@ -107,8 +107,8 @@ effettivamente tre variabili di tipo \type{FILE *} che possono essere usate come tutte le altre, ad esempio si può effettuare una redirezione dell'output di un programma con il semplice codice: \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{} - fclose (stdout); - stdout = fopen ("standard-output-file", "w"); + fclose(stdout); + stdout = fopen("standard-output-file", "w"); \end{lstlisting} ma in altri sistemi queste variabili possono essere definite da macro, e se si hanno problemi di portabilità e si vuole essere sicuri, diventa @@ -436,8 +436,10 @@ la funzione \func{clearerr}, il cui prototipo Cancella i flag di errore ed end-of-file di \param{stream}. \end{prototype} \noindent in genere si usa questa funziona una volta che si sia identificata e -corretta la causa di un errore per evitare di mantenere i flag attivi, -così da poter rilevare una successiva ulteriore condizione di errore. +corretta la causa di un errore per evitare di mantenere i flag attivi, così da +poter rilevare una successiva ulteriore condizione di errore. Di questa +funzione esiste una analoga \func{clearerr\_unlocked} che non esegue il blocco +dello stream (vedi \secref{sec:file_stream_thread}). \subsection{Input/output binario} @@ -1304,17 +1306,31 @@ impliciti per la programmazione multi thread. \label{sec:file_stream_cntrl} Al contrario di quanto avviene con i file descriptor le librerie standard del -C non prevedono nessuna funzione come la \func{fcntl} per la lettura degli -attributi degli stream; le \acr{glibc} però supportano alcune estensioni -derivate da Solaris, che permettono di ottenere informazioni utili. - -In certi casi può essere necessario sapere se un certo stream è accessibile in -lettura o scrittura. In genere questa informazione non è disponibile, e si -deve ricordare come il file è stato aperto. La cosa può essere complessa se le -operazioni vengono effettuate in una subroutine, che a questo punto -necessiterà di informazioni aggiuntive rispetto al semplice puntatore allo -stream; questo può essere evitato con le due funzioni \func{\_\_freadable} e -\func{\_\_fwritable} i cui prototipi sono: +C non prevedono nessuna funzione come la \func{fcntl} per il controllo degli +attributi dei file. Però siccome ogni stream si appoggia ad un file descriptor +si può usare la funzione \func{fileno} per ottenere quest'ultimo, il prototipo +della funzione è: +\begin{prototype}{stdio.h}{int fileno(FILE *stream)} + Legge il file descriptor sottostante lo stream \param{stream}. + + \bodydesc{Restituisce il numero del file descriptor in caso di successo, e + -1 qualora \param{stream} non sia valido, nel qual caso setta \var{errno} + a \macro{EBADF}.} +\end{prototype} +\noindent ed in questo modo diventa possibile usare direttamente \func{fcntl}. + +Questo permette di accedere agli attributi del file descriptor sottostante lo +stream, ma non ci da nessuna informazione riguardo alle proprietà dello stream +medesimo. Le \acr{glibc} però supportano alcune estensioni derivate da +Solaris, che permettono di ottenere informazioni utili. + +Ad esempio in certi casi può essere necessario sapere se un certo stream è +accessibile in lettura o scrittura. In genere questa informazione non è +disponibile, e si deve ricordare come il file è stato aperto. La cosa può +essere complessa se le operazioni vengono effettuate in una subroutine, che a +questo punto necessiterà di informazioni aggiuntive rispetto al semplice +puntatore allo stream; questo può essere evitato con le due funzioni +\func{\_\_freadable} e \func{\_\_fwritable} i cui prototipi sono: \begin{functions} \headdecl{stdio\_ext.h} \funcdecl{int \_\_freadable(FILE *stream)} @@ -1324,6 +1340,7 @@ stream; questo pu Restituisce un valore diverso da zero se \param{stream} consente la scrittura. \end{functions} +\noindent che permettono di ottenere questa informazione. Altre due funzioni, \func{\_\_freading} e \func{\_\_fwriting} servono ad un uso ancora più specialistico, il loro prototipo è: @@ -1381,20 +1398,28 @@ sistema passandone alla funzione l'indirizzo in \param{buf} e la dimensione in Ovviamente se si usa un buffer specificato dall'utente questo deve essere stato allocato e restare disponibile per tutto il tempo in cui si opera sullo stream. In genere conviene allocarlo con \func{malloc} e disallocarlo dopo la -chiusura del file, ma fintanto che il file è usato all'interno di una -funzione, può anche essere usata una variabile automatica; in genere è -definita una macro \macro{BUFSIZ} che indica le dimensioni ottimali del -buffer. Dato che la procedura è macchinosa e comporta dei rischi (come delle -scritture accidentali sul buffer) è sempre meglio lasciare allocare il buffer -alle funzioni di librerie, che sono in grado di farlo in maniera ottimale e -trasparente all'utente. - -Per evitare il settaggio del buffer basta passare un valore \macro{NULL} per -\param{buf} e la funzione ignorerà il parametro \param{size} usando il buffer -allocato automaticamente dal sistema. In questo modo si potrà comunque +chiusura del file; ma fintanto che il file è usato all'interno di una +funzione, può anche essere usata una variabile automatica. In \file{stdio.h} +definita la macro \macro{BUFSIZ}, che indica le dimensioni generiche del +buffer di uno stream; queste vengono usate dalla funzione \func{setbuf}, +questa però non è detto corrisponda in tutti i casi al valore ottimale (che +può variare a seconda del dispositivo). + +Dato che la procedura di allocazione manuale è macchinosa, comporta dei rischi +(come delle scritture accidentali sul buffer) e non assicura la scelta delle +dimensioni ottimali, è sempre meglio lasciare allocare il buffer alle funzioni +di librerie, che sono in grado di farlo in maniera ottimale e trasparente +all'utente (in quanto la disallocazione avviene automaticamente). Inoltre +siccome alcune implementazioni usano parte del buffer per mantenere delle +informazioni di controllo, non è detto che le dimensioni dello stesso +coincidano con le dimensioni con cui viene effettuato l'I/O. + +Per evitare che \func{setvbuf} setti il buffer basta passare un valore +\macro{NULL} per \param{buf} e la funzione ignorerà il parametro \param{size} +usando il buffer allocato automaticamente dal sistema. Si potrà comunque modificare la modalità di bufferizzazione, passando in \param{mode} uno degli -opportuni valori elencati in \ntab; qualora si specifiche la modalità non -bufferizzata i valori di \param{buf} e \param{size} vengono ignorati. +opportuni valori elencati in \ntab. Qualora si specifichi la modalità non +bufferizzata i valori di \param{buf} e \param{size} vengono sempre ignorati. \begin{table}[htb] \centering @@ -1432,11 +1457,10 @@ e \func{setlinebuf}, i loro prototipi sono: \end{functions} \noindent tutte queste funzioni sono realizzate con opportune chiamate a \func{setvbuf} e sono definite solo per compatibilità con le vecchie librerie -BSD. - -Sempre seguendo Solaris le \acr{glibc} provvedono alcune estensioni non -standard che permettono di leggere le proprietà di bufferizzazione di uno -stream; dette funzioni sono: +BSD. Infine le \acr{glibc} provvedono le funzioni non standard\footnote{anche + queste sono originarie di Solaris} \func{\_\_flbf} e \func{\_\_fbufsize} che +permettono di leggere le proprietà di bufferizzazione di uno stream; i cui +prototipi sono: \begin{functions} \headdecl{stdio\_ext.h} @@ -1447,6 +1471,52 @@ stream; dette funzioni sono: buffer di \param{stream}. \end{functions} +Come già accennato, indipendentemente dalla modalità di bufferizzazione +scelta, si può forzare lo scarico dei dati sul file con la funzione +\func{fflush}, il suo prototipo è: +\begin{prototype}{stdio.h}{int fflush(FILE *stream)} + + Forza la scrittura di tutti i dati bufferizzati dello stream \param{stream}. + + \bodydesc{Restituisce zero in caso di successo, ed \macro{EOF} in caso di + errore, settando \var{errno} a \macro{EBADF} se \param{stream} non è + aperto o non è aperto in scrittura, o ad uno degli errori di + \func{write}.} +\end{prototype} +\noindent anche di questa funzione esiste una analoga +\func{fflush\_unlocked}\footnote{accessibile definendo \macro{\_BSD\_SOURCE} o + \macro{\_SVID\_SOURCE} o \macro{\_GNU\_SOURCE}} che non effettua il blocco +dello stream. + +Se \param{stream} è \macro{NULL} lo scarico dei dati è forzato per tutti gli +stream aperti. Esistono però circostanze, ad esempio quando si vuole essere +sicuri che sia stato eseguito tutto l'output su terminale, in cui serve poter +effettuare lo scarico dei dati solo per gli stream in modalità line buffered; +per questo motivo le \acr{glibc} supportano una estensione di Solaris, la +funzione \func{\_flushlbf}, il cui prototipo è: +\begin{prototype}{stdio-ext.h}{void \_flushlbf(void)} + Forza la scrittura di tutti i dati bufferizzati degli stream in modalità + line buffered. +\end{prototype} + +Si ricordi comunque che lo scarico dei dati dai buffer effettuato da queste +funzioni non comporta la scrittura di questi su disco; se si vuole che il +kernel dia effettivamente avvio alle operazioni di scrittura su disco occorre +usare \func{sync} o \func{fsync} (si veda~\secref{sec:file_sync}). + +Infine esistono anche circostanze in cui si vuole scartare tutto l'output +pendente, per questo si può usare \func{fpurge}, il cui prototipo è: +\begin{prototype}{stdio.h}{int fpurge(FILE *stream)} + + Cancella i buffer di input e di output dello stream \param{stream}. + + \bodydesc{Restituisce zero in caso di successo, ed \macro{EOF} in caso di + errore.} +\end{prototype} + +La funzione scarta tutti i dati non ancora scritti (se il file è aperto in +scrittura), e tutto l'input non ancora letto (se è aperto in lettura), +compresi gli eventuali caratteri rimandati indietro con \func{ungetc}. \subsection{Gli stream e i thread} @@ -1489,26 +1559,26 @@ definendo \macro{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono: \noindent con queste funzioni diventa possibile acquisire un blocco ed eseguire tutte le operazioni volute, per poi rilasciarlo. -Ma vista la complessità delle strutture di dati coinvolte, le operazioni di +Ma, vista la complessità delle strutture di dati coinvolte, le operazioni di blocco non sono del tutto indolori, e quando il locking dello stream non è necessario (come in tutti i programmi che non usano i thread), tutta la -procedura può comportare dei pesanti costi in termini di prestazioni. Per -questo motivo abbiamo visto in come per tutte le funzioni di I/O non -formattato esistano delle versioni \code{\_unlocked} (alcune previste dallo -standard POSIX stesso, altre aggiunte come estensioni dalle \acr{glibc}) che -possono essere usate in tutti questi casi\footnote{in certi casi dette - funzioni possono essere usate, visto che sono molto più efficiente, anche in - caso di necessità di locking, una volta che questo sia stato acquisito - manualmente.} dato che in molti casi (come per esempio \func{getc} e -\func{putc}) queste versioni possono essere realizzate come macro, e sono -pertanto in grado di garantire prestazione enormemente più elevate. +procedura può comportare dei costi pesanti in termini di prestazioni. Per +questo motivo abbiamo visto come alle usuali funzioni di I/O non formattato +siano associate delle versioni \code{\_unlocked} (alcune previste dallo stesso +standard POSIX, altre aggiunte come estensioni dalle \acr{glibc}) che possono +essere usate quando il locking non serve\footnote{in certi casi dette funzioni + possono essere usate, visto che sono molto più efficienti, anche in caso di + necessità di locking, una volta che questo sia stato acquisito manualmente.} +con prestazioni molto più elevate, dato che spesso queste versioni (come +accade per \func{getc} e \func{putc}) sono realizzate come macro. La sostituzione di tutte le funzioni di I/O con le relative versioni \code{\_unlocked} in un programma che non usa i thread è però un lavoro -abbastanza noioso, e che appesantisce il codice; per questo motivo le -\acr{glibc} provvedono un'altra via per poter utilizzare disabilitare il -locking, anch'essa mutuata da estensioni introdotte in Solaris, cioè l'uso -della funzione \func{\_\_fsetlocking}, il cui prototipo è: +abbastanza noioso; per questo motivo le \acr{glibc} provvedono al +programmatore pigro un'altra via\footnote{anche questa mutuata da estensioni + introdotte in Solaris.} da poter utilizzare per disabilitare in blocco il +locking degli stream: l'uso della funzione \func{\_\_fsetlocking}, il cui +prototipo è: \begin{prototype}{stdio\_ext.h}{int \_\_fsetlocking (FILE *stream, int type)} Specifica o richiede a seconda del valore di \param{type} la modalità in cui le operazioni di I/O su \param{stream} vengono effettuate rispetto @@ -1517,7 +1587,10 @@ della funzione \func{\_\_fsetlocking}, il cui prototipo \bodydesc{Restituisce lo stato di locking interno dello stream con uno dei valori \macro{FSETLOCKING\_INTERNAL} o \macro{FSETLOCKING\_BYCALLER}.} \end{prototype} -\noindent ed i valori possibili per \param{type} sono i seguenti: + +La funzione setta o legge lo stato della modalità di operazione di uno stream +nei confronti del locking a seconda del valore specificato con \param{type}, +che può essere uno dei seguenti: \begin{basedescript}{\desclabelwidth{4.0cm}} \item[\macro{FSETLOCKING\_INTERNAL}] Lo stream userà da ora in poi il blocco implicito di default. diff --git a/system.tex b/system.tex index fca6545..d2382b4 100644 --- a/system.tex +++ b/system.tex @@ -1,4 +1,4 @@ -\chapter{La gestione del sistema} +\chapter{La gestione del sistema, delle risorse, e degli errori} \label{cha:system} In questo capitolo si è raccolta le trattazione delle varie funzioni @@ -8,16 +8,22 @@ tempi, degli errori e degli utenti ed in generale la gestione dei vari parametri di configurazione dei vari componenti del sistema. -\section{La gestione della configurazione del sistema} + +\section{La configurazione del sistema} \label{sec:sys_config} -\subsection{Opzioni e configurazione del systema} +\subsection{Opzioni e configurazione del sistema} \label{sec:sys_sys_config} La funzione \func{sysconf} ... -\subsection{La configurazione dei file} + +\subsection{Limiti e parametri di sistema} +\label{sec:sys_sys_limits} + + +\subsection{La configurazione dei filesystem} \label{sec:sys_file_config} La funzione \func{statfs} ... @@ -25,12 +31,31 @@ La funzione \func{statfs} ... La funzione \func{pathconf} ... -\section{La gestione delle risorse e dei limiti di sistema} + + +\section{Limitazione ed uso delle risorse} \label{sec:sys_limits} In questa sezione esamimeremo le funzioni che permettono di gestire le varie -risorse associate ad un processo ed i relativi limiti, e quelle relatica al -sistema in quanto tale. +risorse associate ad un processo ed i relativi limiti. + + + +\subsection{L'uso delle risorse} +\label{sec:sys_resource_use} + + +\subsection{Limiti sulle risorse} +\label{sec:sys_resource_limit} + + +\subsection{Le risorse di memoria} +\label{sec:sys_memory_res} + + +\subsection{Le risorse di processore} +\label{sec:sys_cpu_load} + \begin{figure}[!htb]