\chapter{L'interfaccia unix di I/O con i file}
\label{cha:file_unix_interface}

Esamineremo in questo capitolo la prima delle due interfacce di programmazione
per i file, quella dei \textit{file descriptor}, nativa di unix. Questa è
l'interfaccia di basso livello, che non prevede funzioni evolute come la
bufferizzazione o funzioni di lettura o scrittura formattata, ma è su questa
che è costruita anche l'interfaccia standard dei file definita dallo standard
ANSI C.



\section{L'architettura di base}
\label{sec:file_base_arch}

In questa sezione faremo una breve introduzione sulla architettura su cui è
basata dell'interfaccia dei \textit{file descriptor}, che, sia pure con
differenze di implementazione, è comune ad ogni implementazione di unix.
Vedremo cosa comporti questa architettura in caso di accesso contemporaneo ai
file da parte di più processi.


\subsection{L'architettura dei \textit{file descriptors}}
\label{sec:file_fd}

Per poter accedere al contenuto di un file occorre creare un canale di
comunicazione con il kernel che renda possibile operare su di esso (si ricordi
quanto visto in \secref{sec:file_vfs_work}). Questo si fa aprendo il file con
la funzione \func{open} che provvederà a localizzare l'inode del file e
inizializzare le funzioni che il VFS mette a disposizione (riportate in
\tabref{tab:file_file_operations}). Una volta terminate le operazioni, il file
dovrà essere chiuso, e questo chiuderà il canale di comunicazione impedendo
ogni ulteriore operazione.

All'interno di ogni processo i file aperti sono identificati da un intero non
negativo, chiamato appunto \textit{file descriptors}, quando un file viene
aperto la funzione restituisce il file descriptor, e tutte le successive
operazioni devono passare il \textit{file descriptors} come argomento.

Per capire come funziona il meccanismo occorre spiegare a grandi linee come è
che il kernel gestisce l'interazione fra processi e file.  Il kernel mantiene
sempre un elenco dei processi attivi nella cosiddetta \textit{process table}
ed un elenco dei file aperti nella \textit{file table}.

La \textit{process table} è una tabella che contiene una voce per ciascun
processo attivo nel sistema. In Linux la tabella è costituita da strutture di
tipo \var{task\_struct} nelle quali sono raccolte tutte le informazioni
relative ad un singolo processo; fra queste informazioni c'è anche il
puntatore ad una ulteriore struttura di tipo \var{files\_struct} in cui sono
contenute le informazioni relative ai file che il processo ha aperto, ed in
particolare:
\begin{itemize*}
\item i flag relativi ai file descriptor.
\item il numero di file aperti.
\item una tabella che contiene un puntatore alla relativa voce nella
  \textit{file table} per ogni file aperto.
\end{itemize*}
il \textit{file descriptor} in sostanza è l'intero positivo che indicizza
questa tabella.

La \textit{file table} è una tabella che contiene una voce per ciascun file
che è stato aperto nel sistema. In Linux è costituita da strutture di tipo
\var{file}; in ciascuna di esse sono tenute varie informazioni relative al
file, fra cui:
\begin{itemize*}
\item lo stato del file (nel campo \var{f\_flags}).
\item il valore della posizione corrente (l'\textit{offset}) nel file.
\item un puntatore all'inode\footnote{nel kernel 2.4.x si è in realtà passati
    ad un puntatore ad una struttura \var{dentry} che punta a sua volta
    all'inode passando per la nuova struttura del VFS} del file.
%\item un puntatore alla tabella delle funzioni \footnote{la struttura
%    \var{f\_op} descritta in \secref{sec:file_vfs_work}} che si possono usare
%  sul file.
\end{itemize*}

In \figref{fig:file_proc_file} si è riportato uno schema in cui è illustrata
questa architettura, in cui si sono evidenziate le interrelazioni fra le varie
strutture di dati sulla quale essa è basata. 
\begin{figure}[htb]
  \centering
  \includegraphics[width=14cm]{img/procfile.eps}
  \caption{Schema della architettura dell'accesso ai file attraverso
  l'interfaccia dei \textit{file descroptor}}
  \label{fig:file_proc_file}
\end{figure}
Ritorneremo su questo schema più volte, dato che esso è fondamentale per
capire i dettagli del funzionamento delle dell'interfaccia dei \textit{file
  descriptor}.


\subsection{I file standard}
\label{sec:file_std_descr}

Come accennato i \textit{file descriptor} non sono altro che un indice nella
tabella dei file aperti di ciascun processo; per questo motivo essi vengono
assegnati in successione tutte le volte che si apre un nuovo file (se non se
ne è chiuso nessuno in precedenza).

In tutti i sistemi unix-like esiste una convenzione generale per cui ogni
processo viene lanciato con almeno tre file aperti. Questi, per quanto
dicevamo prima, avranno come \textit{file descriptor} i valori 0, 1 e 2.
Benché questa sia soltanto una convenzione, essa è seguita dalla gran parte
delle applicazioni, e non aderirvi potrebbe portare a gravi problemi di
interoperabilità.

Il primo file è sempre associato a quello che viene chiamato \textit{standard
  input}, è cioè il file da cui il processo si aspetta di ricevere i dati in
ingresso (nel caso della shell, è associato alla lettura della tastiera); il
secondo file è il cosiddetto \textit{standard output}, cioè il file su cui ci
si aspetta debbano essere inviati i dati in uscita (sempre nel caso della
shell, è il terminale su cui si sta scrivendo), il terzo è lo \textit{standard
  error}, su cui viene inviato l'output relativo agli errori.
Lo standard POSIX.1 provvede tre costanti simboliche, definite nell'header
\file{unistd.h}, al posto di questi valori numerici: 
\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}[c]{|l|l|}
    \hline
    \textbf{Costante} & \textbf{Significato} \\
    \hline
    \hline
    \macro{STDIN\_FILENO}  & \textit{file descriptor} dello \textit{standard
      input} \\
    \macro{STDOUT\_FILENO} & \textit{file descriptor} dello \textit{standard
      output} \\
    \macro{STDERR\_FILENO} & \textit{file descriptor} dello \textit{standard
      error}\\
    \hline
  \end{tabular}
  \caption{Costanti definite in \file{unistd.h} per i file standard aperti 
    alla creazione di ogni processo.}
  \label{tab:file_std_files}
\end{table}

In \curfig\ si è utilizzata questa situazione come esempio, facendo
riferimento ad un programma in cui lo \textit{standard input} è associato ad
un file mentre lo \textit{standard output} e lo \textit{standard error} sono
entrambi associati ad un altro file (e quindi utilizzano lo stesso inode).

Nelle vecchie versioni di unix (ed anche in Linux fino al kernel 2.0.x) il
numero di file aperti era anche soggetto ad un limite massimo dato dalle
dimensioni del vettore di puntatori con cui era realizzata la tabella dei file
descriptor dentro \var{file\_struct}; questo limite intrinseco non sussiste
più, dato che si è passati ad una linked list, restano i limiti imposti
dall'amministratore (vedi \secref{sec:sys_limits}).



\section{Le funzioni base}
\label{sec:file_base_func}

L'interfaccia standard unix per l'input/output sui file è basata su cinque
funzioni fondamentali \func{open}, \func{read}, \func{write}, \func{lseek} e
\func{close}, usate rispettivamente per aprire, leggere, scrivere, spostarsi e
chiudere un file. 

La gran parte delle operazioni sui file si effettua attraverso queste cinque
funzioni, esse vengono chiamate anche funzioni di I/O non bufferizzato dato
che effettuano le operazioni di lettura e scrittura usando direttamente le
system call del kernel.


\subsection{La funzione \func{open}}
\label{sec:file_open}

La funzione \func{open} è la funzione fondamentale per accedere ai file, ed è
quella che crea l'associazione fra un pathname ed un file descriptor; il suo
prototipo è:

\begin{functions}
  \headdecl{sys/types.h}
  \headdecl{sys/stat.h}
  \headdecl{fcntl.h}
  \funcdecl{int open(const char *pathname, int flags)}
  \funcdecl{int open(const char *pathname, int flags, mode\_t mode)}
  Apre il file indicato da \var{pathname} nella modalità indicata da
  \var{flags}, e, nel caso il file sia creato, con gli eventuali permessi
  specificati da \var{mode}.
  
  La funzione ritorna il file descriptor in caso di successo e -1 in caso di
  errore. In questo caso la variabile \var{errno} viene settata ad uno dei
  valori:

  \begin{errlist}
  \item \macro{EEXIST} \var{pathname} esiste e si è specificato
    \macro{O\_CREAT} e \macro{O\_EXCL}.  
  \item \macro{EISDIR} \var{pathname} indica una directory e si è tentato
    l'accesso in scrittura. 
  \item \macro{ENOTDIR} si è specificato \macro{O\_DIRECTORY} e \var{pathname}
    non è una directory.
  \item \macro{ENXIO} si sono settati \macro{O\_NOBLOCK} o \macro{O\_WRONLY}
    ed il file è una fifo che non viene letta da nessun processo o
    \var{pathname} è un file di dispositivo ma il dispositivo è assente.
  \item \macro{ENODEV} \var{pathname} si riferisce a un file di dispositivo
    che non esiste.  
  \item \macro{ETXTBSY} si è cercato di accedere in scrittura all'immagine di
    un programma in esecuzione.
  \item \macro{ELOOP} si sono incotrati troppi link simbolici nel risolvere
    pathname o si è indicato \macro{O\_NOFOLLOW} e \var{pathname} è un link
    simbolico.
  \end{errlist}
  ed inoltre \macro{EACCES}, \macro{ENAMETOOLONG}, \macro{ENOENT},
  \macro{EROFS}, \macro{EFAULT}, \macro{ENOSPC}, \macro{ENOMEM},
  \macro{EMFILE} e \macro{ENFILE}.
\end{functions}

La funzione apre il file, usando il primo file descriptor libero, e crea
l'opportuna voce (cioè la struttura \var{file}) nella file table.  Viene usato
sempre il file descriptor con il valore più basso, questa caratteritica
permette di prevedere qual'è il valore che si otterrà e viene talvolta usata
da alcune applicazioni per sostituire i file corrispondenti ai file standard
di \secref{sec:file_std_descr}: se ad esempio si chiude lo standard input e si
apre subito dopo un nuovo file questo diventerà il nuovo standard input (avrà
cioè il file descriptor 0).

Il nuovo file descriptor non è condiviso con nessun altro processo, (torneremo
sulla condivisione dei file, in genere accessibile dopo una \func{fork}, in
\secref{sec:file_sharing}). Il nuovo file descriptor è settato di default per
restare aperto attraverso una \func{exec} (come accennato in
\secref{sec:proc_exec}) ed l'offset è settato all'inizio del file.

La funzione prevede diverse modalità di apertura di un file, che vengono
specificate dal parametro \var{flags}, questo parametro viene settato come
maschera binaria attraverso OR aritmetico delle costanti che identificano i
vari flag. Questi ultimi sono poi divisibili in tre categorie principali:
\begin{itemize}
\item \textsl{le modalità di accesso}, che specificano con quale modalità si
  accede al file: lettura, scrittura o lettura/scrittura.  Uno di questi
  valori deve essere sempre specificato, vengono settati alla chiamata da
  \func{open}, e possono essere riletti con una \func{fcntl}, ma non
  modificati.
\item \textsl{le modalità di apertura}, che permettono di specificare alcuni
  dei modi di funzionamento di \func{open}. Hanno effetto solo al momento
  della chiamata e non sono memorizzati nè possono essere riletti.
\item \textsl{le modalità di operazione}, che permettono di specificare alcuni
  effetti del comportamento delle operazioni sul file (come la \func{read} o
  la \func{write}). Sono settati alla chiamata da \func{open}, ma possono
  essere riletti e modificati con una una \func{fcntl}.
\end{itemize}

In \ntab\ si sono riportate, come definite in \file{fcntl.h}, le costanti che
identificano i vari flag di stato (ed i relativi valori numerici), da usare
per specificare il valore di \var{flags}, alcuni di questi poi andranno a
costituire lo stato del file (il cosiddetto \textit{file status flag}), tenuto
nel campo \var{f\_flags} di \var{file}.  

\begin{table}[htb]
  \centering
  \begin{tabular}[c]{|l|p{10cm}|}
    \hline
    \textbf{Flag} & \textbf{Descrizione} \\
    \hline
    \hline % modailtà di accesso
    \macro{O_RDONLY} & apre il file in sola lettura\\
    \macro{O_WRONLY} & apre il file in sola scrittura\\
    \macro{O_RDWR} & apre il file lettura/scrittura\\
    \hline % modalita di apertura
    \macro{O_CREAT} & \\
    \macro{O_EXCL} & \\
    \macro{O_NOCTTY} & \\
    \macro{O_NONBLOCK} & \\
    \macro{O_SHLOCK} & \\
    \macro{O_EXLOCK} & \\
    \macro{O_TRUNC} & \\
    \macro{O_NOFOLLOW} & \\
    \macro{O_DIRECTORY} & \\
    \macro{O_LARGEFILE} & \\
    \hline  % modalità di operazione
    \macro{O_APPEND} & \\
    \macro{O_NONBLOCK} & \\
    \macro{O_NDELAY} & sinonimo di \macro{O_NONBLOCK}\\
    \macro{O_ASYNC} & \\
    \macro{O_FSYNC} & \\
    \macro{O_SYNC} & \\
    \macro{O_NOATIME} & \\
    \hline
  \end{tabular}
  \caption{Costanti che identificano i vari flag di stato del file specificati
    alla sua aprertura tramite il parametro \var{flags} di \func{open}.}
  \label{tab:file_open_flags}
\end{table}


\subsection{La funzione \func{creat}}
\label{sec:file_creat}

\subsection{La funzione \func{close}}
\label{sec:file_close}

\subsection{La funzione \func{lseek}}
\label{sec:file_lseek}

\subsection{La funzione \func{read}}
\label{sec:file_read}

\subsection{La funzione \func{write}}
\label{sec:file_write}


\section{Funzioni avanzate}
\label{sec:file_adv_func}

\subsection{La condivisione dei files}
\label{sec:file_sharing}


Si noti che i flag di stato del file, quelli settati dal parametro \var{flag}
di \func{open}, essendo tenuti nella vode sulla file table, vengono condivisi,
ai file sono però associati anche altri flag, (tenuti invece nella struttura
\var{file\_struct} interna alla process table) che sono unici per ciascun file
descriptor, e sono pertanto detti \textit{file descriptor flags} (l'unico
usato al momento è \macro{FD\_CLOEXEC}).


\subsection{Operazioni atomiche coi file}
\label{sec:file_atomic}


\subsection{La funzioni \func{dup} e \func{dup2}}
\label{sec:file_dup}

\subsection{La funzione \func{fcntl}}
\label{sec:file_fcntl}

\subsection{La funzione \func{ioctl}}
\label{sec:file_ioctl}





