X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=fileadv.tex;h=40dc7a50fe7f6b7dba6cdea07f6ed4699de324ea;hp=9adbf64cdb73549d19952da805b78f96a2f1cc30;hb=486c2be2a052783e6dec09bc288c76ecaa4f21e6;hpb=f34bc210398c21e197ec81dc2acc1798330431fb diff --git a/fileadv.tex b/fileadv.tex index 9adbf64..40dc7a5 100644 --- a/fileadv.tex +++ b/fileadv.tex @@ -446,7 +446,7 @@ sottratto il valore di questo campo. Il campo \var{aio\_lio\_opcode} è usato soltanto dalla funzione \func{lio\_listio}, che, come vedremo più avanti, permette di eseguire con una -sola chiamanta una serie di operazioni, usando un vettore di \textit{control +sola chiamata una serie di operazioni, usando un vettore di \textit{control block}. Tramite questo campo si specifica quale è la natura di ciascuna di esse. @@ -465,7 +465,7 @@ struct sigevent \end{lstlisting} \end{minipage} \normalsize - \caption{La struttura \type{sigevent}, usata per specificare le modailtà di + \caption{La struttura \type{sigevent}, usata per specificare le modalità di notifica degli eventi relativi alle operazioni di I/O asincrono.} \label{fig:file_sigevent} \end{figure} @@ -528,7 +528,7 @@ operazione pu campi per eseguire l'operazione può avvenire in un momento qualsiasi dopo la richiesta. Questo comporta che occorre evitare di usare per \param{aiocbp} variabili automatiche e che non si deve riutilizzare la stessa struttura per -un'ulteriore operazione fintanto che la precedente non sia stata ultimata. In +un ulteriore operazione fintanto che la precedente non sia stata ultimata. In generale per ogni operazione di I/O asincrono si deve utilizzare una diversa struttura \type{aiocb}. @@ -597,9 +597,9 @@ asincrono non verrebbero liberate, rischiando di arrivare ad un loro esaurimento. Oltre alle operazioni di lettura e scrittura l'interfaccia POSIX.1b mette a -disposizione un'altra operazione, quella di sincronizzazione delll'I/O, essa è +disposizione un'altra operazione, quella di sincronizzazione dell'I/O, essa è compiuta dalla funzione \func{aio\_fsync}, che ha lo stesso effetto della -analoga \func{fsync}, ma viene esguita in maniera asincrona; il suo prototipo +analoga \func{fsync}, ma viene eseguita in maniera asincrona; il suo prototipo è: \begin{prototype}{aio.h} {ssize\_t aio\_return(int op, struct aiocb *aiocbp)} @@ -627,7 +627,7 @@ specificato un meccanismo di notifica questo sar operazioni di sincronizzazione dei dati saranno completate. In alcuni casi può essere necessario interrompere le operazioni (in genere -quando viene richiesta un'uscita immediata dal programam), per questo lo +quando viene richiesta un'uscita immediata dal programma), 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 è: @@ -682,7 +682,7 @@ specifica operazione; il suo prototipo 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 + completate, 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 @@ -714,7 +714,7 @@ lettura o scrittura; il suo prototipo secondo la modalità \param{mode}. \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di - errorem nel qual caso \var{errno} viene settata ai valori: + errore, nel qual caso \var{errno} viene settata ai valori: \begin{errlist} \item[\macro{EAGAIN}] Nessuna operazione è stata completata entro \param{timeout}. @@ -742,7 +742,7 @@ 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 +specifica \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} @@ -765,7 +765,7 @@ 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 +nuove system call, \func{readv} e \func{writev}, che permettono di effettuare 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: @@ -820,8 +820,8 @@ struct iovec { \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}. +I buffer da utilizzare sono specificati attraverso l'argomento \var{vector} che +è un vettore di tale strutture, la cui lunghezza è specificata da \param{count}. Essi verranno letti (o scritti) nell'ordine in cui li si sono specificati. @@ -830,31 +830,317 @@ Essi verranno letti (o scritti) nell'ordine in cui li si sono specificati. \label{sec:file_memory_map} Una modalità alternativa di I/O, che usa una interfaccia completamente diversa -rispetto a quella classica, è quella dei file \textsl{mappati in memoria}. In -sostanza quello che si fa è usare il meccanismo della -\textsl{paginazione}\index{paginazione} usato per la memoria virtuale (vedi -\secref{sec:proc_mem_gen}) vedere il file in una sezione dello spazio di -indirizzi del processo, in modo che l'accesso a quest'ultimo avvenga con le -normali operazioni di lettura e scrittura delle variabili in memoria. - -Questa interfaccia è più efficiente dell'uso 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, non è necessario trasferire in un -buffer tutti i dati che potrebbero servire, e poi riscrivere il tutto una -volta completate le operazioni, la scrittura e la lettura avverranno invece -direttamente sulla sezione di memoria mappata, che sarà a sua volta letta o -scritta sul file, una pagina alla volta (e solo per le parti effettivamente -usate) in maniera trasparente attraverso il meccanismo della paginazione. -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. - -Inoltre in situazioni in cui la memoria è scarsa, le pagine che mappano un +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, +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{msync} 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 mantenere 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 + che la mappatura deve essere effettuata con gli + indirizzi crecenti verso il basso.\\ + \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, la +mappatura infatti introduce una corrispondenza biunivoca fra una sezione di un +file ed una sezione di memoria, pertanto si può parlare tanto di file mappato +in memoria, quanto di memoria mappata su file. Questo comporta che ad esempio +non è possibile mappare in memoria pipe, socket e fifo, per le quali non ha +senso parlare di \textsl{sezione}. Lo stesso vale anche per alcuni file di +dispositivo, che non dispongono della relativa operazione \var{mmap} (si +ricordi quanto esposto in \secref{sec:file_vfs_work}), ma esistono anche casi +(un esempio è l'interfaccia ponte PCI-VME del chip Universe) di dispositivi +che sono utilizzabili praticamente solo con questa interfaccia. + +Passando attraverso una \func{fork} i file mappati in memoria vengono +ereditati in maniera trasparente dal processo figlio, mantenendo gli stessi +attributi avuti nel padre; così se si è usato \macro{MAP\_SHARED} padre e +figlio accederanno allo stesso file in maniera condivisa, mentre se si è usato +\macro{MAP\_PRIVATE} ciascuno di essi manterrà una sua versione privata +indipendente. Non c'è invece nessun passaggio attraverso una \func{exec}, dato +che quest'ultima sostituisce tutto lo spazio degli indirizzi di un processo +con quello di un nuovo programma. + +Quando si effettua la mappatura di un file vengono pure modificati i tempi ad +esso associati (si ricordi quanto esposto in \secref{sec:file_file_times}). Il +valore di \var{st\_atime} può venir cambiato in qualunque istante a partire +dal momento in cui la mappatura è stata effettuata: il primo riferimento ad +una pagina mappata su un file aggiorna questo tempo. I valori di +\var{st\_ctime} e \var{st\_mtime} possono venir cambiati solo quando si è +consentita la scrittura sul file (cioè per un file mappato con +\macro{PROT\_WRITE} e \macro{MAP\_SHARED}) e sono aggiornati dopo la scrittura +o in corrispondenza 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 dei file 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, perciò è del +tutto indefinito il risultato della modifica nei confronti del contenuto della +memoria mappata. + +Se è, per quanto appena visto, sconsigliabile eseguire scritture su file +attraverso l'interfaccia standard quando lo si è mappato in memoria, è invece +possibile usare l'interfaccia standard per leggere un file mappato in memoria, +purché si abbia una certa cura; infatti l'interfaccia dell'I/O mappato in +memoria mette a disposizione la funzione \func{msync} per sincronizzare il +contenuto della memoria mappata 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}] L'intervallo specificato non ricade in una zona + precedentemente mappata. + \end{errlist} + } +\end{functions} + +La funzione esegue la sincronizzazione di quanto scritto nella sezione di +memoria indicata da \param{start} e \param{offset}, scrivendo le modifiche sul +file (qualora questo non sia già stato fatto). Provvede anche ad aggiornare i +relativi tempi di modifica. In questo modo si è sicuri che dopo l'esecuzione +di \func{msync} le funzioni dell'interfaccia standard troveranno un contenuto +del file 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 che si sono completate le operazioni di I/O si può eliminare la +mappatura della memoria usando la funzione \func{munmap}, il suo 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}] L'intervallo specificato non ricade in una zona + precedentemente mappata. + \end{errlist} + } +\end{functions} + +La funzione cancella la mappatura per l'intervallo specificato attraverso +\param{start} e \param{length}, ed ogni successivo accesso a tale regione +causerà un errore di accesso in memoria. L'argomento \param{start} deve essere +allineato alle dimensioni di una pagina di memoria, e la mappatura di tutte le +pagine contenute (anche parzialmente) nell'intervallo indicato, verrà rimossa. +Indicare un intervallo che non contiene pagine mappate non è un errore. + +Alla conclusione del processo, ogni pagina mappata verrà automaticamente +rilasciata, mentre la chiusura del file descriptor non ha alcun effetto sulla +mappatura della memoria. \section{Il file locking} @@ -899,7 +1185,6 @@ Il \textit{mandatory locking} - %%% Local Variables: %%% mode: latex %%% TeX-master: "gapil"