X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=filestd.tex;h=a20d207aea09d97e4b69dfb9fd73ef0715b80d83;hp=e5ea8fdd48b7baf8618a18fc9f4c91fa75dfdd45;hb=ac964a03457cfe43aff04b65e4e6a08a470dedae;hpb=4200529d613212e34c8cd8afd1628aedc20d74f2 diff --git a/filestd.tex b/filestd.tex index e5ea8fd..a20d207 100644 --- a/filestd.tex +++ b/filestd.tex @@ -1,4 +1,4 @@ -\chapter{I file: l'interfaccia standard ANSI C} + \chapter{I file: l'interfaccia standard ANSI C} \label{cha:files_std_interface} Esamineremo in questo capitolo l'interfaccia standard ANSI C per i file, @@ -83,81 +83,87 @@ file \file{stdio.h}. \subsection{Gli stream standard} \label{sec:file_std_stream} -Ai tre file descriptor standard (vedi \secref{sec:file_std_descr}) aperti per -ogni processo, corrispondono altrettanti stream, che rappresentano i canali -standard di input/output prestabiliti; anche questi tre stream sono -identificabili attraverso dei nomi simbolici definiti nell'header -\file{stdio.h} che sono: +Ai tre file descriptor standard (vedi \secref{sec:file_std_descr}) +aperti per ogni processo, corrispondono altrettanti stream, che +rappresentano i canali standard di input/output prestabiliti; anche +questi tre stream sono identificabili attraverso dei nomi simbolici +definiti nell'header \file{stdio.h} che sono: \begin{itemize} -\item \var{FILE * stdin} Lo \textit{standard input} cioè lo stream da cui - il processo riceve ordinariamente i dati in ingresso. Normalmente è associato - dalla shell all'input del terminale e prende i caratteri dalla tastiera. -\item \var{FILE * stdout} Lo \textit{standard input} cioè lo stream su cui - il processo invia ordinariamente i dati in uscita. Normalmente è associato - dalla shell all'output del terminale e scrive sullo schermo. -\item \var{FILE * stderr} Lo \textit{standard input} cioè lo stream su cui - il processo è supposto inviare i messaggi di errore. Normalmente anch'esso - è associato dalla shell all'output del terminale e scrive sullo schermo. +\item \var{FILE * stdin} Lo \textit{standard input} cioè lo stream da + cui il processo riceve ordinariamente i dati in ingresso. Normalmente + è associato dalla shell all'input del terminale e prende i caratteri + dalla tastiera. +\item \var{FILE * stdout} Lo \textit{standard input} cioè lo stream su + cui il processo invia ordinariamente i dati in uscita. Normalmente è + associato dalla shell all'output del terminale e scrive sullo schermo. +\item \var{FILE * stderr} Lo \textit{standard input} cioè lo stream su + cui il processo è supposto inviare i messaggi di errore. Normalmente + anch'esso è associato dalla shell all'output del terminale e scrive + sullo schermo. \end{itemize} -Nelle \acr{glibc} \var{stdin}, \var{stdout} e \var{stderr} sono 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: +Nelle \acr{glibc} \var{stdin}, \var{stdout} e \var{stderr} sono +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"); \end{lstlisting} -ma in altri sistemi possono essere definite come macro, se si hanno problemi -di portabilità e si vuole essere sicuri, diventa opportuno usare la funzione -\func{freopen}. +ma in altri sistemi possono essere definite come macro, se si hanno +problemi di portabilità e si vuole essere sicuri, diventa 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 -una 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}, dall'ingelese -\textit{flush}, dei dati) 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. - -Allo stesso modo, se si sta facendo dell'input/output interattivo bisognerà -tenere presente le caratteristiche delle operazioni di scarico dei dati, -poiché non è detto che ad una scrittura sullo stream corrisponda una immediata -scrittura sul dispositivo. - -Per rispondere ad esigenze diverse, lo standard definisce tre distinte modalità -in cui può essere eseguita la bufferizzazione, delle quali occorre essere ben -consapevoli, specie in caso di lettura e scrittura da dispositivi interattivi: +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 una 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. + +Allo stesso modo, se si sta facendo dell'input/output interattivo +bisognerà tenere presente le caratteristiche delle operazioni di scarico +dei dati, poiché non è detto che ad una scrittura sullo stream +corrisponda una immediata scrittura sul dispositivo. + +Per rispondere ad esigenze diverse, lo standard definisce tre distinte +modalità in cui può essere eseguita la bufferizzazione, delle quali +occorre essere ben consapevoli, specie in caso di lettura e scrittura da +dispositivi interattivi: \begin{itemize} \item \textit{unbuffered}: in questo caso non c'è bufferizzazione ed i caratteri vengono trasmessi direttamente al file non appena possibile (effettuando immediatamente una \func{write}). -\item \textit{line buffered}: in questo caso i caratteri vengono normalmente - trasmessi al file in blocco ogni volta che viene incontrato un carattere di - \textit{newline} (il carattere ASCII \verb|\n|). -\item \textit{fully buffered}: in questo caso i caratteri vengono trasmessi da - e verso il file in blocchi di dimensione opportuna. +\item \textit{line buffered}: in questo caso i caratteri vengono + normalmente trasmessi al file in blocco ogni volta che viene + incontrato un carattere di \textit{newline} (il carattere ASCII + \verb|\n|). +\item \textit{fully buffered}: in questo caso i caratteri vengono + trasmessi da e verso il file in blocchi di dimensione opportuna. \end{itemize} -Lo standard ANSI C specifica inoltre che lo standard output e lo standard -input siano aperti in modalità \textit{fully buffered} quando non fanno -riferimento ad un dispositivo interattivo, e che lo standard error non sia mai -aperto in modalità \textit{fully buffered}. +Lo standard ANSI C specifica inoltre che lo standard output e lo +standard input siano aperti in modalità \textit{fully buffered} quando +non fanno riferimento ad un dispositivo interattivo, e che lo standard +error non sia mai aperto in modalità \textit{fully buffered}. Linux, come BSD e SVr4, specifica il comportamento di default in maniera ancora più precisa, e cioè impone che lo standard error sia sempre @@ -183,7 +189,7 @@ 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 + 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 @@ -207,7 +213,6 @@ corrente in uno stream. Le funzioni che permettono di aprire uno stream sono tre\footnote{\func{fopen} e \func{freopen} fanno parte dello standard ANSI C, \func{fdopen} è parte dello standard POSIX.1.}, i loro prototipi sono: - \begin{functions} \headdecl{stdio.h} \funcdecl{FILE * fopen(const char * path, const char *mode)} @@ -272,33 +277,35 @@ funzioni delle librerie standard del C. \label{tab:file_fopen_mode} \end{table} -In realtà lo standard ANSI C prevede un totale di 15 possibili valori diversi -per \param{mode}, ma in \tabref{tab:file_fopen_mode} si sono riportati solo i -sei valori effettivi, ad essi può essere aggiunto pure il carattere \func{b} -(come ultimo carattere o nel mezzo agli altri per le stringhe di due -caratteri) che in altri sistemi operativi serve a distinguere i file binari -dai file di testo; in un sistema POSIX questa distinzione non esiste e il -valore viene accettato solo per compatibilità, ma non ha alcun effetto. - -Inoltre nel caso si usi \func{fdopen} i valori specificati da \param{mode} -devono essere compatibili con quelli con cui il file descriptor è stato -aperto. Inoltre i modi \cmd{w} e \cmd{w+} non troncano il file. La posizione -nello stream viene settata a quella corrente nel file descriptor, e le -variabili di errore e di fine del file sono cancellate. Il file non viene -duplicato e verrà chiuso alla chiusura dello stream. +In realtà lo standard ANSI C prevede un totale di 15 possibili valori +diversi per \param{mode}, ma in \tabref{tab:file_fopen_mode} si sono +riportati solo i sei valori effettivi, ad essi può essere aggiunto pure +il carattere \func{b} (come ultimo carattere o nel mezzo agli altri per +le stringhe di due caratteri) che in altri sistemi operativi serve a +distinguere i file binari dai file di testo; in un sistema POSIX questa +distinzione non esiste e il valore viene accettato solo per +compatibilità, ma non ha alcun effetto. + +Inoltre nel caso si usi \func{fdopen} i valori specificati da +\param{mode} devono essere compatibili con quelli con cui il file +descriptor è stato aperto. Inoltre i modi \cmd{w} e \cmd{w+} non +troncano il file. La posizione nello stream viene settata a quella +corrente nel file descriptor, e le variabili di errore e di fine del +file sono cancellate. Il file non viene duplicato e verrà chiuso alla +chiusura dello stream. I nuovi file saranno creati secondo quanto visto in -\secref{sec:file_ownership} ed avranno i permessi di accesso settati al valore -\macro{S\_IRUSR|S\_IWUSR|S\_IRGRP|S\_IWGRP|S\_IROTH|S\_IWOTH} (pari a -\macro{0666}) modificato secondo il valore di \acr{umask} per il processo (si -veda \secref{sec:file_umask}). - -In caso di file aperti in lettura e scrittura occorre ricordarsi che c'è di -messo una bufferizzazione; per questo motivo lo standard ANSI C richiede che -ci sia una operazione di posizionamento fra una operazione di output ed una di -input o viceversa (eccetto il caso in cui l'input ha incontrato la fine del -file), altrimenti una lettura può ritornare anche il risultato di scritture -precedenti l'ultima effettuata. +\secref{sec:file_ownership} ed avranno i permessi di accesso settati al +valore \macro{S\_IRUSR|S\_IWUSR|S\_IRGRP|S\_IWGRP|S\_IROTH|S\_IWOTH} +(pari a \macro{0666}) modificato secondo il valore di \acr{umask} per il +processo (si veda \secref{sec:file_umask}). + +In caso di file aperti in lettura e scrittura occorre ricordarsi che c'è +di messo una bufferizzazione; per questo motivo lo standard ANSI C +richiede che ci sia una operazione di posizionamento fra una operazione +di output ed una di input o viceversa (eccetto il caso in cui l'input ha +incontrato la fine del file), altrimenti una lettura può ritornare anche +il risultato di scritture precedenti l'ultima effettuata. Per questo motivo è una buona pratica (e talvolta necessario) far seguire ad una scrittura una delle funzioni \func{fflush}, \func{fseek}, \func{fsetpos} o @@ -309,8 +316,8 @@ una operazione nominalmente nulla come \func{fseek(file, 0, SEEK\_CUR)} sufficiente a garantire la sincronizzazione. Una volta aperto lo stream, si può cambiare la modalità di bufferizzazione -fintanto che non si è effettuat - +(vedi \secref{sec:file_buffering_ctrl}) fintanto che non si è effettuato +alcuna operazione di I/O sul file. Uno stream viene chiuso con la funzione \func{fclose} il cui prototipo è: \begin{prototype}{stdio.h}{int fclose(FILE * stream)} @@ -326,20 +333,170 @@ La funzione effettua uno scarico di tutti i dati presenti nei buffer di uscita e scarta tutti i dati in ingresso, se era stato allocato un buffer per lo stream questo verrà rilasciato. La funzione effettua lo scarico solo per i dati presenti nei buffer in user space usati dalle \acr{glibc}; se si essere -sicuri che il kernel forzi la scrittura su disco occorrà effettuare . +sicuri che il kernel forzi la scrittura su disco occorrerà effettuare . + +Linux supporta, come estensione implementata dalle \acr{glibc}, anche una +altra funzione, \func{fcloseall}, che serve a chiudere tutti i file, il suo +prototipo è: +\begin{prototype}{stdio.h}{int fcloseall(void)} + Chiude tutti gli stream. + + Restituisce 0 se non ci sono errori ed \macro{EOF} altrimenti. +\end{prototype} +la funzione esegue lo scarico dei dati bufferizzati in uscita e scarta quelli +in ingresso, chiudendo tutti i file. Questa funzione è provvista solo per i +casi di emergenza, quando si è verificato un errore ed il programma deve +essere abortito, ma si vuole compiere qualche altra operazione dopo aver +chiuso i file e prima di uscire (si ricordi quanto visto in +\secref{sec:proc_exit}). \subsection{Lettura e scrittura su uno stream} \label{sec:file_io} +Una delle caratteristiche più utili dell'interfaccia degli stream è la +ricchezza delle funzioni disponibili per le operazioni di lettura e +scrittura sui file. Sono infatti previste ben tre diverse modalità +modalità di input/output non formattato: +\begin{enumerate} +\item\textsl{binario} in cui legge/scrive un blocco di dati alla + volta, vedi \secref{sec:file_binary_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{a caratteri} in cui si legge/scrive un carattere alla + volta (con la bufferizzazione gestita automaticamente dalla libreria), + vedi \secref{sec:file_char_io}. +\end{enumerate} +ed inoltre la modalità di input/output formattato. + +A differenza dell'interfaccia dei file descriptor il raggiungimento della fine +del file è considerato un errore, e viene notificato come tale dai valori di +uscita delle varie funzioni; nella maggior parte dei casi questo avviene con +la restituzione del valore intero (di tipo \type{int}) \macro{EOF}\footnote{la + costante deve essere negativa, le \acr{glibc} usano -1, altre + implementazioni possono avere valori diversi.} definito anch'esso +nell'header \func{stdlib.h}. + +Dato che le funzioni dell'interfaccia degli stream sono funzioni di libreria +che si appoggiano a delle system call, esse non settano direttamente la +variabile \var{errno}, che mantiene il valore settato dalla system call che ha +riportato l'errore. + +Siccome la condizione di end-of-file è anch'essa segnalata come errore, nasce +il problema di come distinguerla da un errore effettivo; basarsi solo sul +valore di ritorno della funzione e controllare il valore di \var{errno} +infatti non basta, dato che quest'ultimo potrebbe essere stato settato in una +altra occasione, (si veda \secref{sec:sys_errno} per i dettagli del +funzionamento di \var{errno}). + +Per questo motivo tutte le implementazioni delle librerie standard +mantengono per ogni stream almeno due flag all'interno dell'oggetto +\type{FILE}, il flag di \textit{end-of-file}, che segnala che si è +raggiunta la fine del file in lettura, e quello di errore, che segnala +la presenza di un qualche errore nelle operazioni di input/output; +questi flag possono essere riletti dalle funzioni: +\begin{functions} + \headdecl{stdio.h} + \funcdecl{int feof(FILE *stream)} + Controlla il flag di end-of-file di \param{stream}. + \funcdecl{int ferror(FILE *stream)} + Controlla il flag di errore di \param{stream}. -\subsection{Posizionamento su uno stream} -\label{sec:file_fseek} + Entrambe le funzioni ritornano un valore diverso da zero se i relativi + flag sono settati. +\end{functions} +\noindent si tenga presente comunque che la lettura di questi flag segnala +soltanto che c'è stato un errore, o che si è raggiunta la fine del file in una +qualunque operazione sullo stream, il controllo quindi deve essere effettuato +ogni volta che si chiama una funzione di libreria. + +Entrambi i flag (di errore e di end-of-file) possono essere cancellati usando +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 +corretta la causa di un errore per evitare di mantenere i flag attivi, +così da poter rilevare una successiva ulteriore condizione di errore. \subsection{Input/output binario} \label{sec:file_binary_io} +La prima modalità di input/output non formattato ricalca quella della +intefaccia dei file descriptor, e provvede semplicemente la scrittura e +la lettura dei dati da un buffer verso un file e vicecersa. In generale +questa è la modalità che si usa quando si ha a che fare con dati non +formattati. Le due funzioni che si usano per l'I/O binario sono: +\begin{functions} + \headdecl{stdio.h} + \funcdecl{size\_t fread(void * ptr, size\_t size, + size\_t nmemb, FILE * stream)} + \funcdecl{size\_t fwrite(const void * + ptr, size\_t size, size\_t nmemb, FILE * stream)} + + Le funzioni rispettivamente leggono e scrivono \param{nmemb} elementi + di dimensione \param{size} dal buffer \param{ptr} al file \param{stream}. + + Entrambe le funzioni ritornano il numero di elementi letti o scritti, + in caso di errore o fine del file viene restituito un numero di + elementi inferiore al richiesto. +\end{functions} + +In genere si usano queste funzioni quando si devono trasferire su file +blocchi di dati binari in maniera compatta e veloce; un primo caso di uso +tipico è quello in cui si salva un vettore (o un certo numero dei suoi +elementi) con una chiamata del tipo: +\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{} +int WriteVect(FILE * stream, double * vec, size_t nelem) +{ + int size, nread; + size = sizeof(*vec); + if ( (nread = fwrite(vec, size, nelem, stream)) != nelem) { + perror("Write error"); + } + return nread; +} +\end{lstlisting} +in questo caso devono essere specificate le dimensioni di ciascun +elemento ed il numero di quelli che si vogliono scrivere. Un secondo +caso è invece quello in cui si vuole trasferire su file una struttura; +si avrà allora una chiamata tipo: +\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{} +struct histogram { + int nbins; + double max, min; + double * bin; +} histo; + +int WriteStruct(FILE * stream, struct histogram * histo, size_t nelem) +{ + if ( fwrite(vec, sizeof(*histo), 1, stream) !=1) { + perror("Write error"); + } + return nread; +} +\end{lstlisting} +in cui si specifica la dimensione dell'intera struttura ed un solo +elemento. In realtà quello che conta nel trasferimento dei dati sono le +dimensioni totali, che sono sempre pari al prodotto \func{size * nelem}, +la sola differenza è che le funzioni non ritornano il numero di bytes +scritti, ma il numero di elementi. + +La funzione \func{fread} legge sempre un numero intero di elementi, se +si ha un errore o si incontra la fine del file l'oggetto letto +parzialmente viene scartato + + +Benché queste funzioni assicurino + + +\subsection{Input/output a caratteri singoli} +\label{sec:file_char_io} + + + \subsection{Input/output di linea} \label{sec:file_line_io} @@ -349,9 +506,68 @@ sicuri che il kernel forzi la scrittura su disco occorr \label{sec:file_formatted_io} +\subsection{Posizionamento su uno stream} +\label{sec:file_fseek} + + + \section{Funzioni avanzate} \label{sec:file_stream_adv_func} +In questa sezione esamineremo le funzioni che permettono di controllare alcune +caratteristiche più particolari degli stream, come la lettura degli attributi, +le modalità di bufferizzazione, etc. + + +\subsection{Le funzioni di controllo} +\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 un 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)} + Restituisce un valore diverso da zero se \param{stream} consente la lettura. + + \funcdecl{int \_\_fwritable(FILE * stream)} + Restituisce un valore diverso da zero se \param{stream} consente la + scrittura. +\end{functions} + +Altre due funzioni, \func{\_\_freading} e \func{\_\_fwriting} servono ad un +uso ancora più specialistico, il loro prototipo è: +\begin{functions} + \headdecl{stdio\_ext.h} + \funcdecl{int \_\_freading (FILE * stream)} + Restituisce un valore diverso da zero se \param{stream} è aperto in sola + lettura o se l'ultima operazione è stata di lettura. + + \funcdecl{int \_\_fwriting(FILE * stream)} + Restituisce un valore diverso da zero se \param{stream} è aperto in sola + scrittura o se l'ultima operazione è stata di scrittura. +\end{functions} + +Le due funzioni hanno lo scopo di determinare di che tipo è stata l'ultima +operazione eseguita su uno stream aperto in lettura/scrittura; ovviamente se +uno stream è aperto in sola lettura (o sola scrittura) la modalità dell'ultima +operazione è sempre determinata; l'unica ambiguità è quando non sono state +ancora eseguite operazioni, in questo caso le funzioni rispondono come se +una operazione ci fosse comunque stata. + +La conoscenza dell'ultima operazione effettuata su uno stream aperto in +lettura/scrittura è utile in quanto permette di trarre conclusioni sullo stato +del buffer e del suo contenuto. + \subsection{Il controllo della bufferizzazione} \label{sec:file_buffering_ctrl}