Sempre correzioni di D. Masini
authorSimone Piccardi <piccardi@gnulinux.it>
Mon, 25 Nov 2002 23:21:16 +0000 (23:21 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Mon, 25 Nov 2002 23:21:16 +0000 (23:21 +0000)
filestd.tex
fileunix.tex

index 78a524c..aa4ecff 100644 (file)
@@ -26,7 +26,7 @@ costituire il nucleo\footnote{queste funzioni sono state implementate la prima
 \subsection{I \textit{file stream}}
 \label{sec:file_stream}
 
-Come più volte ribadito l'interfaccia dei file descriptor è un'interfaccia di
+Come più volte ribadito, l'interfaccia dei file descriptor è un'interfaccia di
 basso livello, che non provvede nessuna forma di formattazione dei dati e
 nessuna forma di bufferizzazione per ottimizzare le operazioni di I/O.
 
@@ -117,25 +117,23 @@ opportuno usare la funzione \func{freopen}.
 \subsection{Le modalità di bufferizzazione}
 \label{sec:file_buffering}
 
-La bufferizzazione è una delle caratteristiche principali della
-interfaccia degli stream; lo scopo è quello di ridurre al minimo il
-numero di system call (\func{read} o \func{write}) eseguite nelle
-operazioni di input/output. Questa funzionalità è assicurata
-automaticamente dalla libreria, ma costituisce anche uno degli aspetti
-più comunemente fraintesi, in particolare per quello che riguarda
-l'aspetto della scrittura dei dati sul file.
-
-I caratteri che vengono scritti su uno stream normalmente vengono
-accumulati in un buffer e poi trasmessi in blocco in maniera asincrona
-rispetto alla scrittura (quello che viene chiamato lo \textsl{scarico}
-dei dati, dall'inglese \textit{flush}) tutte le volte che il buffer
-viene riempito. Un comportamento analogo avviene anche in lettura (cioè
-dal file viene letto un blocco di dati, anche se se ne sono richiesti
-una quantità inferiore), ma la cosa ovviamente ha rilevanza inferiore,
-dato che i dati letti sono sempre gli stessi; in caso di scrittura
-invece, quando si ha un accesso contemporaneo allo stesso file (ad
-esempio da parte di un altro processo) si potranno vedere solo le parti
-effettivamente scritte, e non quelle ancora presenti nel buffer.
+La bufferizzazione è una delle caratteristiche principali dell'interfaccia
+degli stream; lo scopo è quello di ridurre al minimo il numero di system call
+(\func{read} o \func{write}) eseguite nelle operazioni di input/output. Questa
+funzionalità è assicurata automaticamente dalla libreria, ma costituisce anche
+uno degli aspetti più comunemente fraintesi, in particolare per quello che
+riguarda l'aspetto della scrittura dei dati sul file.
+
+I caratteri che vengono scritti su uno stream normalmente vengono accumulati
+in un buffer e poi trasmessi in blocco in maniera asincrona rispetto alla
+scrittura (quello che viene chiamato lo \textsl{scarico} dei dati,
+dall'inglese \textit{flush}) tutte le volte che il buffer viene riempito. Un
+comportamento analogo avviene anche in lettura (cioè dal file viene letto un
+blocco di dati, anche se ne sono richiesti una quantità inferiore), ma la cosa
+ovviamente ha rilevanza inferiore, dato che i dati letti sono sempre gli
+stessi; in caso di scrittura invece, quando si ha un accesso contemporaneo
+allo stesso file (ad esempio da parte di un altro processo) si potranno vedere
+solo le parti effettivamente scritte, e non quelle ancora presenti nel buffer.
 
 Allo stesso modo, se si sta facendo dell'input/output interattivo
 bisognerà tenere presente le caratteristiche delle operazioni di scarico
@@ -179,16 +177,16 @@ seconda del file o del dispositivo scelto.
 La modalità \textit{line buffered} è quella che necessita di maggiori
 chiarimenti e attenzioni per quel che concerne il suo funzionamento. Come già
 accennato nella descrizione, \emph{di norma} i dati vengono inviati al kernel
-alla ricezione di un carattere di a capo; questo non è vero in tutti i casi,
-infatti, dato che le dimensioni del buffer usato dalle librerie sono fisse, se
-le si eccedono si può avere uno scarico dei dati anche prima che sia stato
-inviato un carattere di \textit{newline}.
+alla ricezione di un carattere di \textsl{a capo} (\textit{newline}); questo
+non è vero in tutti i casi, infatti, dato che le dimensioni del buffer usato
+dalle librerie sono fisse, se le si eccedono si può avere uno scarico dei dati
+anche prima che sia stato inviato un carattere di \textit{newline}.
 
 Un secondo punto da tenere presente, particolarmente quando si ha a che fare
-con I/O interattivo, è che quando si effettua una lettura su uno stream che
-comporta l'accesso al kernel\footnote{questo vuol dire sempre se lo stream da
-  cui si legge è in modalità \textit{unbuffered}.} viene anche eseguito lo
-scarico di tutti i buffer degli stream in scrittura.
+con I/O interattivo, è che quando si effettua una lettura da uno stream che
+comporta l'accesso al kernel\footnote{questo vuol dire che lo stream da cui si
+  legge è in modalità \textit{unbuffered}.} viene anche eseguito lo scarico di
+tutti i buffer degli stream in scrittura.
 
 In \secref{sec:file_buffering_ctrl} vedremo come la libreria definisca delle
 opportune funzioni per controllare le modalità di bufferizzazione e lo scarico
@@ -275,7 +273,7 @@ possono essere aperti con le funzioni delle librerie standard del C.
     \textit{append mode}, l'accesso viene posto in lettura e scrittura. \\
     \hline
     \texttt{b} & specifica che il file è binario, non ha alcun effetto. \\
-    \texttt{x} & lapertura fallisce se il file esiste già. \\
+    \texttt{x} & l'apertura fallisce se il file esiste già. \\
     \hline
   \end{tabular}
   \caption{Modalità di apertura di uno stream dello standard ANSI C che
@@ -385,9 +383,8 @@ modalit
 \item\textsl{a caratteri} in cui si legge/scrive un carattere alla
   volta (con la bufferizzazione gestita automaticamente dalla libreria),
   vedi \secref{sec:file_char_io}.
-\item\textsl{di linea} in cui si legge/scrive una linea (terminata dal
-  carattere di newline \verb|\n|) alla volta, vedi
-  \secref{sec:file_line_io}.
+\item\textsl{di linea} in cui si legge/scrive una linea alla volta (terminata
+  dal carattere di newline \verb|'\n'|), vedi \secref{sec:file_line_io}.
 \end{enumerate*}
 ed inoltre la modalità di input/output formattato.
 
@@ -437,7 +434,7 @@ la funzione \func{clearerr}, il cui prototipo 
 \begin{prototype}{stdio.h}{void clearerr(FILE *stream)}
   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
+\noindent in genere si usa questa funzione 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. Di questa
 funzione esiste una analoga \func{clearerr\_unlocked} che non esegue il blocco
@@ -498,7 +495,7 @@ struct histogram {
     double *bin;
 } histo; 
 
-int WriteStruct(FILE *stream, struct histogram *histo, size_t nelem
+int WriteStruct(FILE *stream, struct histogram *histo) 
 {
     if ( fwrite(vec, sizeof(*histo), 1, stream) !=1) {
         perror("Write error");
index df4bfb9..056e3b4 100644 (file)
@@ -832,9 +832,9 @@ kernel.
 La funzione viene usata dal comando \cmd{sync} quando si vuole forzare
 esplicitamente lo scarico dei dati su disco, o dal demone di sistema
 \cmd{update} che esegue lo scarico dei dati ad intervalli di tempo fissi: il
-valore tradizionale per l'update dei dati è ogni 30 secondi, ma in Linux era
-di 5 secondi; con le nuove versioni poi, è il kernel che si occupa
-direttamente di tutto quanto.
+valore tradizionale, usato da BSD, per l'update dei dati è ogni 30 secondi, ma
+in Linux ilvalore utilizzato è di 5 secondi; con le nuove versioni poi, è il
+kernel che si occupa direttamente di tutto quanto.
 
 Quando si vogliono scaricare soltanto i dati di un file (ad esempio essere
 sicuri che i dati di un database sono stati registrati su disco) si possono
@@ -857,8 +857,10 @@ usare le due funzioni \func{fsync} e \func{fdatasync}, i cui prototipi sono:
 
 Entrambe le funzioni forzano la sincronizzazione col disco di tutti i dati del
 file specificato, ed attendono fino alla conclusione delle operazioni;
-\func{fsync} forza anche la sincronizzazione dei metadata dell'inode (i dati
-di \var{fstat} come i tempi del file). 
+\func{fsync} forza anche la sincronizzazione dei metadati del file (che
+riguardano sia le modifiche alle tabelle di allocazione dei settori, che gli
+altri dati contenuti nell'inode che si leggono con \var{fstat} come i tempi
+del file).
 
 Si tenga presente che questo non comporta la sincronizzazione della
 directory che contiene il file (e scrittura della relativa voce su