+In alcuni casi può essere necessario interrompere le operazioni (in genere
+quando viene richiesta un'uscita immediata dal programam), per questo lo
+standard POSIX.1b prevede una funzioni apposita, \func{aio\_cancel}, che
+permette di cancellare una operazione richiesta in precedenza; il suo
+prototipo è:
+\begin{prototype}{aio.h}
+{int aio\_cancel(int fildes, struct aiocb *aiocbp)}
+
+Richiede la cancellazione delle operazioni sul file \param{fildes} specificate
+da \param{aiocbp}.
+
+\bodydesc{La funzione restituisce il risultato dell'operazione con un codice
+ di positivo, e -1 in caso di errore, che avviene qualora si sia specificato
+ un valore non valido di \param{fildes}, setta \var{errno} al valore
+ \macro{EBADF}.}
+\end{prototype}
+
+La funzione permette di cancellare una operazione specifica sul file
+\param{fildes}, o tutte le operazioni pendenti, specificando \macro{NULL} come
+valore di \param{aiocbp}. Quando una operazione viene cancellata una
+successiva chiamata ad \func{aio\_error} riporterà \macro{ECANCELED} come
+codice di errore, ed il suo codice di ritorno sarà -1, inoltre il meccanismo
+di notifica non verrà invocato. Se si specifica una operazione relativa ad un
+altro file descriptor il risultato è indeterminato.
+
+In caso di successo, i possibili valori di ritorno per \func{aio\_cancel} sono
+tre (anch'essi definiti in \file{aio.h}):
+\begin{basedescript}{\desclabelwidth{3.0cm}}
+\item[\macro{AIO\_ALLDONE}] indica che le operazioni di cui si è richiesta la
+ cancellazione sono state già completate,
+
+\item[\macro{AIO\_CANCELED}] indica che tutte le operazioni richieste sono
+ state cancellate,
+
+\item[\macro{AIO\_NOTCANCELED}] indica che alcune delle operazioni erano in
+ corso e non sono state cancellate.
+\end{basedescript}
+
+Nel caso si abbia \macro{AIO\_NOTCANCELED} occorrerà chiamare
+\func{aio\_error} per determinare quali sono le operazioni effettivamente
+cancellate. Le operazioni che non sono state cancellate proseguiranno il loro
+corso normale, compreso quanto richiesto riguardo al meccanismo di notifica
+del loro avvenuto completamento.
+
+Benché l'I/O asincrono preveda un meccanismo di notifica, l'interfaccia
+fornisce anche una apposita funzione, \func{aio\_suspend}, che permette di
+sospendere l'esecuzione del processo chiamante fino al completamento di una
+specifica operazione; il suo prototipo è:
+\begin{prototype}{aio.h}
+{int aio\_suspend(const struct aiocb * const list[], int nent, const struct
+ timespec *timeout)}
+
+ Attende, per un massimo di \param{timeout}, il completamento di una delle
+ operazioni specificate da \param{list}.
+
+ \bodydesc{La funzione restituisce 0 se una (o più) operazioni sono state
+ completate, e -1 in caso di errorem nel qual caso \var{errno} viene
+ settata ai valori:
+ \begin{errlist}
+ \item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
+ \param{timeout}.
+ \item[\macro{ENOSYS}] La funzione non è implementata.
+ \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
+ \end{errlist}
+ }
+\end{prototype}
+
+La funzione permette di bloccare il processo fintanto che almeno una delle
+\param{nent} operazioni specificate nella lista \param{list} è completata, per
+un tempo massimo specificato da \param{timout}, o fintanto che non arrivi un
+segnale.\footnote{si tenga conto che questo segnale può anche essere quello
+ utilizzato come meccanismo di notifica.} La lista deve essere inizializzata
+con delle strutture \var{aiocb} relative ad operazioni effettivamente
+richieste, ma può contenere puntatori nulli, che saranno ignorati. In caso si
+siano specificati valori non validi l'effetto è indefinito. Un valore
+\macro{NULL} per \param{timout} comporta l'assenza di timeout.
+
+Lo standard POSIX.1b infine ha previsto pure una funzione, \func{lio\_listio},
+che permette di effettuare la richiesta di una intera lista di operazioni di
+lettura o scrittura; il suo prototipo è:
+\begin{prototype}{aio.h}
+ {int lio\_listio(int mode, struct aiocb * const list[], int nent, struct
+ sigevent *sig)}
+
+ Richiede l'esecuzione delle operazioni di I/O elencata da \param{list},
+ secondo la modalità \param{mode}.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
+ errore, nel qual caso \var{errno} viene settata ai valori:
+ \begin{errlist}
+ \item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
+ \param{timeout}.
+ \item[\macro{ENOSYS}] La funzione non è implementata.
+ \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
+ \end{errlist}
+ }
+\end{prototype}
+
+La funzione esegue la richiesta delle \param{nent} operazioni indicate dalla
+lista \param{list}; questa deve contenere gli indirizzi di altrettanti
+\textit{control block}, opportunamente inizializzati; in particolare nel caso
+dovrà essere specificato il tipo di operazione tramite il campo
+\var{aio\_lio\_opcode}, che può prendere i tre valori:
+\begin{basedescript}{\desclabelwidth{2.0cm}}
+\item[\macro{LIO\_READ}] si richiede una operazione di lettura.
+\item[\macro{LIO\_WRITE}] si richiede una operazione di scrittura.
+\item[\macro{LIO\_NOP}] non si effettua nessuna operazione.
+\end{basedescript}
+l'ultimo valore viene usato quando si ha a che fare con un vettore di
+dimensione fissa, per poter specificare solo alcune operazioni, o quando si è
+dovuto cancellare delle operazioni e si deve ripetere la richiesta per quelle
+non completate.
+
+L'argomento \param{mode} permette di stabilire il comportamento della
+funzione, se viene specificato il valore \macro{LIO\_WAIT} la funzione si
+blocca fino al completamento di tutte le operazioni richieste; se invece si
+spercifica \macro{LIO\_NOWAIT} la funzione ritorna immediatamente dopo aver
+messo in coda tutte le richieste. In questo caso il chiamante può richiedere
+la notifica del completamento di tutte le richieste, settando l'argomento
+\param{sig} in maniera analoga a come si fa per il campo \var{aio\_sigevent}
+di \type{aiocb}.
+
+
+
+\subsection{I/O vettorizzato}
+\label{sec:file_multiple_io}
+
+Un caso abbastanza comune è quello in cui ci si trova a dover eseguire una
+serie multipla di operazioni di I/O, come una serie di letture o scritture di
+vari buffer. Un esempio tipico è quando i dati sono strutturati nei campi di
+una struttura ed essi devono essere caricati o salvati su un file. Benché
+l'operazione sia facilmente eseguibile attraverso una serie multipla di
+chiamate, ci sono casi in cui si vuole poter contare sulla atomicità delle
+operazioni.
+
+Per questo motivo BSD 4.2\footnote{Le due funzioni sono riprese da BSD4.4 ed
+ integrate anche dallo standard Unix 98; fino alle libc5 Linux usava
+ \type{size\_t} come tipo dell'argomento \param{count}, una scelta logica,
+ che è stata dismessa per restare aderenti allo standard.} ha introdotto due
+nuove system call, \func{readv} e \func{writev}, che permettono di effettare
+con una sola chiamata una lettura o una scrittura su una serie di buffer
+(quello che viene chiamato \textsl{I/O vettorizzato}. I relativi prototipi
+sono:
+\begin{functions}
+ \headdecl{sys/uio.h}
+
+ \funcdecl{int readv(int fd, const struct iovec *vector, int count)} Esegue
+ una lettura vettorizzata da \param{fd} nei \param{count} buffer specificati
+ da \param{vector}.
+
+ \funcdecl{int writev(int fd, const struct iovec *vector, int count)} Esegue
+ una scrittura vettorizzata da \param{fd} nei \param{count} buffer
+ specificati da \param{vector}.
+
+ \bodydesc{Le funzioni restituiscono il numero di byte letti o scritti in
+ caso di successo, e -1 in caso di errore, nel qual caso \var{errno} viene
+ settata ai valori:
+ \begin{errlist}
+ \item[\macro{EBADF}] si è specificato un file descriptor sbagliato.
+ \item[\macro{EINVAL}] si è specificato un valore non valido per uno degli
+ argomenti (ad esempio \param{count} è maggiore di \macro{MAX\_IOVEC}).
+ \item[\macro{EINTR}] la funzione è stata interrotta da un segnale prima di
+ di avere eseguito una qualunque lettura o scrittura.
+ \item[\macro{EAGAIN}] \param{fd} è stato aperto in modalità non bloccante e
+ non ci sono dati in lettura.
+ \item[\macro{EOPNOTSUPP}] La coda delle richieste è momentaneamente piena.
+ \end{errlist}
+ ed inoltre \macro{EISDIR}, \macro{ENOMEM}, \macro{EFAULT} (se non sono stato
+ allocati correttamente i buffer specificati nei campi \func{iov\_base}), più
+ tutti gli ulteriori errori che potrebbero avere le usuali funzioni di
+ lettura e scrittura eseguite su \param{fd}.}
+\end{functions}
+
+Entrambe le funzioni usano una struttura \type{iovec}, definita in
+\figref{fig:file_iovec}, che definisce dove i dati devono essere letti o
+scritti. Il primo campo, \var{iov\_base}, contiene l'indirizzo del buffer ed
+il secondo, \var{iov\_len}, la dimensione dello stesso.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
+struct iovec {
+ __ptr_t iov_base; /* Starting address */
+ size_t iov_len; /* Length in bytes */
+};
+ \end{lstlisting}
+ \end{minipage}
+ \normalsize
+ \caption{La struttura \type{iovec}, usata dalle operazioni di I/O
+ vettorizzato.}
+ \label{fig:file_iovec}
+\end{figure}
+
+I buffer da utlizzare sono specificati attraverso l'argomento \var{vector} che
+è un array di tale strutture, la cui lunghezza è specificata da \param{count}.
+Essi verranno letti (o scritti) nell'ordine in cui li si sono specificati.
+
+
+
+\subsection{File mappati in memoria}
+\label{sec:file_memory_map}
+
+Una modalità alternativa di I/O, che usa una interfaccia completamente diversa
+rispetto a quella classica vista in \capref{cha:file_unix_interface}, è il
+cosiddetto \textit{memory-mapped I/O}, che attraverso il meccanismo della
+\textsl{paginazione}\index{paginazione} usato dalla memoria virtuale (vedi
+\secref{sec:proc_mem_gen}) permette di \textsl{mappare} il contenuto di un
+file in una sezione dello spazio di indirizzi del processo.
+
+Tutto questo comporta una notevole semplificazione delle operazioni di I/O, in
+quanto non sarà più necessario utilizzare dei buffer intermedi su cui
+appoggiare i dati da traferire, ma questi potranno essere acceduti
+direttamente dalla sezione di memoria; inoltre questa interfaccia
+è più efficiente delle usuali funzioni di I/O, in quanto permette di caricare
+in memoria solo le parti del file che sono effettivamente usate ad un dato
+istante.
+
+Infatti, dato che l'accesso è fatto direttamente attraverso la memoria
+virtuale, la sezione di memoria mappata su cui si opera sarà a sua volta letta
+o scritta sul file una pagina alla volta e solo per le parti effettivamente
+usate, il tutto in maniera completamente trasparente al processo; l'acceso
+alle pagine non ancora caricate avverrà allo stesso modo con cui vengono
+caricate in memoria le pagine che sono state salvate sullo swap.
+
+Infine in situazioni in cui la memoria è scarsa, le pagine che mappano un
+file vengono salvate automaticamente, così come le pagine dei programmi
+vengono scritte sulla swap; questo consente di accedere ai file su dimensioni
+il cui solo limite è quello dello spazio di indirizzi disponibile, e non della
+memoria su cui possono esserne lette delle porzioni.
+
+L'interfaccia prevede varie funzioni per la gestione del \textit{memory
+ mapping}, la prima di queste è \func{mmap}, che esegue la mappatura in
+memoria un file; il suo prototipo è:
+\begin{functions}
+
+ \headdecl{unistd.h}
+ \headdecl{sys/mman.h}
+
+ \funcdecl{void * mmap(void *start, size\_t length, int prot, int flags, int
+ fd, off\_t offset)}
+
+ Esegue la mappatura in memoria del file \param{fd}.
+
+ \bodydesc{La funzione restituisce il puntatore alla zona di memoria mappata
+ in caso di successo, e \macro{MAP\_FAILED} (-1) in caso di errore, nel
+ qual caso \var{errno} viene settata ai valori:
+ \begin{errlist}
+ \item[\macro{EBADF}] Il file descriptor non è valido, e non si è usato
+ \macro{MAP\_ANONYMOUS}.
+ \item[\macro{EACCES}] Il file descriptor non si riferisce ad un file
+ normale, o si è richiesto \macro{MAP\_PRIVATE} ma \param{fd} non è
+ aperto in lettura, o si è richiesto \macro{MAP\_SHARED} e settato
+ \macro{PROT\_WRITE} ed \param{fd} non è aperto in lettura/scrittura, o
+ si è settato \macro{PROT\_WRITE} ed \param{fd} è in
+ \textit{append-only}.
+ \item[\macro{EINVAL}] I valori di \param{start}, \param{length} o
+ \param{offset} non sono validi (o troppo grandi o non allineati sulla
+ dimensione delle pagine).
+ \item[\macro{ETXTBSY}] Si è settato \macro{MAP\_DENYWRITE} ma \param{fd} è
+ aperto in scrittura.
+ \item[\macro{EAGAIN}] Il file è bloccato, o si è bloccata troppa memoria.
+ \item[\macro{ENOMEM}] Non c'è memoria o si è superato il limite sul numero
+ di mappature possibili.
+ \item[\macro{ENODEV}] Il filesystem di \param{fd} no supporta il memory
+ mapping.
+ \end{errlist}
+ }
+\end{functions}
+
+La funzione richiede di mappare in memoria la sezione del file \param{fd} a
+partire da \param{offset} per \param{lenght} byte, preferibilmente
+all'indirizzo \param{start}. Il valore di \param{offset} deve essere un
+multiplo della dimensione di una pagina di memoria. Il valore dell'argomento
+\param{prot} indica la protezione\footnote{in Linux la memoria reale è divisa
+ in pagine: ogni processo vede la sua memoria attraverso uno o più segmenti
+ lineari di memoria virtuale. Per ciascuno di questi segmenti il kernel
+ mantiene nella \textit{page table} la mappatura sulle pagine di memoria
+ reale, ed le modalità di accesso (lettura, esecuzione, scrittura); una loro
+ violazione causa quella che si chiama una \textit{segment violation}, e la
+ relativa emissione del segnale \macro{SIGSEGV}.} da applicare al segmento di
+memoria e deve essere specificato come maschera binaria ottenuta dall'OR di
+uno o più dei valori riportati in \tabref{tab:file_mmap_flag}; il valore
+specificato deve essere compatibile con la modalità con cui si è aperto il
+file.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|l|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \macro{PROT\_EXEC} & Le pagine possono essere eseguite.\\
+ \macro{PROT\_READ} & Le pagine possono essere lette.\\
+ \macro{PROT\_WRITE} & Le pagine possono essere scritte.\\
+ \macro{PROT\_NONE} & L'accesso alle pagine è vietato.\\
+ \hline
+ \end{tabular}
+ \caption{Valori dell'argomento \param{prot} di \func{mmap}, relativi alla
+ protezione applicate alle pagine del file mappate in memoria.}
+ \label{tab:file_mmap_prot}
+\end{table}
+
+L'argomento \param{flags} specifica qual'è il tipo di oggetto mappato, le
+opzioni relative alle modalità con cui è effettuata la mappatura e alle
+modalità con cui le modifiche alla memoria mappata vengono condivise o
+mantenute private al processo che le ha effettuate. Deve essere specificato
+come maschera binaria ottenuta dall'OR di uno o più dei valori riportati in
+\tabref{tab:file_mmap_flag}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|p{10cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \macro{MAP\_FIXED} & Non permette di restituire un indirizzo diverso
+ da \param{start}, se questo non può essere usato
+ \func{mmap} fallisce. Se si setta questo flag il
+ valore di \param{start} deve essere allineato
+ alle dimensioni di una pagina. \\
+ \macro{MAP\_SHARED} & I cambiamenti sulla memoria mappata vengono
+ riportati sul file e saranno immediatamente
+ visibili agli altri processi che mappano lo stesso
+ file.\footnotemark Il file su disco però non sarà
+ aggiornato fino alla chiamata di \func{rsync} o
+ \func{unmap}), e solo allora le modifiche saranno
+ visibili per l'I/O convenzionale. Incompatibile
+ con \macro{MAP\_PRIVATE}. \\
+ \macro{MAP\_PRIVATE} & I cambiamenti sulla memoria mappata non vengono
+ riportati sul file. Ne viene fatta una copia
+ privata cui solo il processo chiamante ha
+ accesso. Le modifiche sono mantenute attraverso
+ il meccanismo del \textit{copy on write} e
+ salvate su swap in caso di necessità. Non è
+ specificato se i cambiamenti sul file originale
+ vengano riportati sulla regione
+ mappata. Incompatibile con \macro{MAP\_SHARED}. \\
+ \macro{MAP\_DENYWRITE} & In Linux viene ignorato per evitare
+ \textit{DoS}\index{DoS} (veniva usato per
+ segnalare che tentativi di scrittura sul file
+ dovevano fallire con \macro{ETXTBUSY}).\\
+ \macro{MAP\_EXECUTABLE}& Ignorato. \\
+ \macro{MAP\_NORESERVE} & Si usa con \macro{MAP\_PRIVATE}. Non riserva
+ delle pagine di swap ad uso del meccanismo di
+ \textit{copy on write} per mantere le modifiche
+ fatte alla regione mappata, in
+ questo caso dopo una scrittura, se non c'è più
+ memoria disponibile, si ha l'emissione di
+ un \macro{SIGSEGV}. \\
+ \macro{MAP\_LOCKED} & Se settato impedisce lo swapping delle pagine
+ mappate. \\
+ \macro{MAP\_GROWSDOWN} & Usato per gli stack. Indica alla virtual memory
+ che la mappatura deve essere effettuata .\\
+ \macro{MAP\_ANONYMOUS} & La mappatura non è associata a nessun file. Gli
+ argomenti \param{fd} e \param{offset} sono
+ ignorati.\footnotemark\\
+ \macro{MAP\_ANON} & Sinonimo di \macro{MAP\_ANONYMOUS}, deprecato.\\
+ \macro{MAP\_FILE} & Valore di compatibiità, deprecato.\\
+ \hline
+ \end{tabular}
+ \caption{Valori possibili dell'argomento \param{flag} di \func{mmap}.}
+ \label{tab:file_mmap_flag}
+\end{table}
+
+\footnotetext{Dato che tutti faranno riferimento alle stesse pagine di
+ memoria.}
+\footnotetext{L'uso di questo flag con \macro{MAP\_SHARED} è
+ stato implementato in Linux a partire dai kernel della serie 2.4.x.}
+
+Un file viene sempre mappato su multipli delle dimensioni di una pagina,
+qualora esso sia più corto la parte restante è riempita con zeri; eventuali
+scritture in quella zona di memoria non vengono riportate sul file. Se le
+dimensioni del file cambiano (esso viene esteso o troncato), non è specificato
+quale effetto viene a aversi sulle pagine di memoria che corrispondono alle
+regioni aggiunte o tolte.
+
+Si tenga presente che non tutti i file possono venire mappati in memoria; ad
+esempio non è possibile mappare in memoria pipe, socket e fifo; lo stesso vale
+anche per alcuni file di dispositivo, che non dispongono dell'operazione
+relativa \var{mmap} (si ricordi quanto esposto in \secref{sec:file_vfs_work}).
+
+La memoria mappata viene mantenuta attraverso una \func{fork}; con gli stessi
+attributi. In particolare se la memoria è condivisa lo sarà anche fra padre e
+figlio, se è privata ognuno di essi manterrà una sua versione privata. Non c'è
+invece nessun passaggio attraverso una \func{exec}, dato che quest'ultima
+sostituisce tutto lo spazio degli indirizzo con quello del nuovo programma.
+
+Quando si effettua una mappatura di un file, i relativi tempi (vedi
+\secref{sec:file_file_times}) vengono pure modificati. Il valore di
+\var{st\_atime} può venir cambiato in un qualunque momento in cui la mappatura
+sia attiva: il primo riferimento ad una pagina mappata aggiorna questo tempo.
+I valori di \var{st\_ctime} e \var{st\_mtime} vengono cambiati solo quando è
+possibile una scrittura (cioè per un file mappato con \macro{PROT\_WRITE} e
+\macro{MAP\_SHARED}) e sono aggiornati dopo la scrittura e prima di una
+eventuale \func{msync}.
+
+Dato per i file mappati in memoria le operazioni di I/O sono gestite
+direttamente dalla memoria virtuale, occorre essere consapevoli delle
+interazioni che possono esserci con operazioni effettuate con l'interfaccia
+standard di \capref{sec:file_unix_interface}. Il problema è che una volta che
+si è mappato un file, le operazioni di lettura e scrittura saranno eseguite
+sulla memoria, e riportate su disco in maniera autonoma dal sistema della
+memoria virtuale.
+
+Pertanto se si modifica un file con l'interfaccia standard queste modifiche
+potranno essere visibili o meno a seconda del momento in cui la memoria
+virtuale leggerà dal disco in memoria quella sezione del file, ed è del tutto
+indefinito quale può essere il contenuto della memoria mappata. È però
+possibile usare la funzione \func{msync} per sincronizzare il contenuto della
+memoria con il file su disco; il suo prototipo è:
+\begin{functions}
+ \headdecl{unistd.h}
+ \headdecl{sys/mman.h}
+
+ \funcdecl{int msync(const void *start, size\_t length, int flags)}
+
+ Sincronizza i contenuti di una sezione di un file mappato in memoria.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
+ errore nel qual caso \var{errno} viene settata ai valori:
+ \begin{errlist}
+ \item[\macro{EINVAL}] O \param{start} non è multiplo di \macro{PAGESIZE},
+ o si è specificato un valore non valido per \param{flags}.
+ \item[\macro{EFAULT}] Il range specificato non ricade in una zona
+ precedentemente mappata.
+ \end{errlist}
+ }
+\end{functions}
+
+La funzione esegue la sincronizzazione su file di quanto scritto nella sezione
+di memoria indicata da \param{start} e \param{offset}. Provvede anche ad
+aggiornare i relativi tempi di modifica; in questo modo le funzioni
+dell'interfaccia standard potranno accedere al contenuto aggiornato.
+
+L'argomento \param{flag} è specificato come maschera binaria composta da un OR
+dei valori riportati in \tabref{tab:file_mmap_rsync}, di questi però
+\macro{MS\_ASYNC} e \macro{MS\_SYNC} sono incompatibili; con il primo valore
+infatti la funzione si limita ad inoltrare la richiesta di sincronizzazione al
+meccanismo della memoria virtuale, ritornando subito, mentre con il secondo
+attende che la sincronizzazione sia stata effettivamente eseguita. Il terzo
+flag fa invalidare le pagine di cui si richiede la sincronizzazione per tutte
+le mappature dello stesso file, così che esse possano essere immediatamente
+aggiornate ai nuovi valori.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|l|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \macro{MS\_ASYNC} & Richiede la sincronizzazione.\\
+ \macro{MS\_SYNC} & Attende che la sincronizzazione si eseguita.\\
+ \macro{MS\_INVALIDATE}& Richiede che le altre mappature dello stesso file
+ siano invalidate.\\
+ \hline
+ \end{tabular}
+ \caption{Valori dell'argomento \param{flag} di \func{msync}.}
+ \label{tab:file_mmap_rsync}
+\end{table}
+
+Una volta completate le operazioni di I/O si può eliminare la mappatura della
+memoria usando la funzione \func{munmap}, il cui prototipo è:
+\begin{functions}
+ \headdecl{unistd.h}
+ \headdecl{sys/mman.h}
+
+ \funcdecl{int munmap(void *start, size\_t length)}
+
+ Rilascia la mappatura sulla sezione di memoria specificata.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
+ errore nel qual caso \var{errno} viene settata ai valori:
+ \begin{errlist}
+ \item[\macro{EINVAL}] Il range specificato non ricade in una zona
+ precedentemente mappata.
+ \end{errlist}
+ }
+\end{functions}
+
+La funzione
+
+
+\section{Il file locking}