1 \chapter{La gestione avanzata dei file}
2 \label{cha:file_advanced}
4 In questo capitolo affronteremo le tematiche relative alla gestione avanzata
5 dei file, che non sono state trattate in \capref{cha:file_unix_interface},
6 dove ci si è limitati ad una panoramica delle funzioni base. In particolare
7 tratteremo delle funzioni di input/output avanzato e del \textit{file
11 \section{Le funzioni di I/O avanzato}
12 \label{sec:file_advanced_io}
14 In questa sezione esamineremo le funzioni che permettono una gestione più
15 sofisticata dell'I/O su file, a partire da quelle che permettono di gestire
16 l'accesso contemporaneo a più file, per concludere con la gestione dell'I/O
20 \subsection{La modalità di I/O \textsl{non-bloccante}}
21 \label{sec:file_noblocking}
23 Abbiamo visto in \secref{sec:sig_gen_beha}, affrontando la suddivisione fra
24 \textit{fast} e \textit{slow} system call, che in certi casi le funzioni di
25 I/O possono bloccarsi indefinitamente.\footnote{si ricordi però che questo può
26 accadere solo per le pipe, i socket ed alcuni file di dispositivo; sui file
27 normali le funzioni di lettura e scrittura ritornano sempre subito.} Ad
28 esempio le operazioni di lettura possono bloccarsi quando non ci sono dati
29 disponibili sul descrittore su cui si sta operando.
31 Questo comportamento causa uno dei problemi più comuni che ci si trova ad
32 affrontare nelle operazioni di I/O, che è quello che si verifica quando si
33 devono eseguire operazioni che possono bloccarsi su più file descriptor:
34 mentre si è bloccati su uno di essi su di un'altro potrebbero essere presenti
35 dei dati; così che nel migliore dei casi si avrebbe una lettura ritardata
36 inutilmente, e nel peggiore si potrebbe addirittura arrivare ad un deadlock.
38 Abbiamo già accennato in \secref{sec:file_open} che è possibile prevenire
39 questo tipo di comportamento aprendo un file in modalità
40 \textsl{non-bloccante}, attraverso l'uso del flag \macro{O\_NONBLOCK} nella
41 chiamata di \func{open}. In questo caso le funzioni di input/output che
42 altrimenti si sarebbero bloccate ritornano immediatamente, restituendo
43 l'errore \macro{EAGAIN}.
45 L'utilizzo di questa modalità di I/O permette di risolvere il problema
46 controllando a turno i vari file descriptor, in un ciclo in cui si ripete
47 l'accesso fintanto che esso non viene garantito. Ovviamente questa tecnica,
48 detta \textit{polling}, è estremamente inefficiente: si tiene costantemente
49 impiegata la CPU solo per eseguire in continuazione delle system call che
50 nella gran parte dei casi falliranno. Per evitare questo, come vedremo in
51 \secref{sec:file_multiplexing}, è stata introdotta una nuova interfaccia di
52 programmazione, che comporta comunque l'uso della modalità di I/O non
57 \subsection{L'I/O multiplexing}
58 \label{sec:file_multiplexing}
60 Per superare il problema di dover usare il \textit{polling} per controllare la
61 possibilità di effettuare operazioni su un file aperto in modalità non
62 bloccante, sia BSD che System V hanno introdotto delle nuove funzioni in grado
63 di sospendere l'esecuzione di un processo in attesa che l'accesso diventi
64 possibile. Il primo ad introdurre questa modalità di operazione, chiamata
65 usualmente \textit{I/O multiplexing}, è stato BSD,\footnote{la funzione è
66 apparsa in BSD4.2 e standardizzata in BSD4.4, ma è stata portata su tutti i
67 sistemi che supportano i \textit{socket}, compreso le varianti di System V.}
68 con la funzione \func{select}, il cui prototipo è:
71 \headdecl{sys/types.h}
73 \funcdecl{int select(int n, fd\_set *readfds, fd\_set *writefds, fd\_set
74 *exceptfds, struct timeval *timeout)}
76 Attende che uno dei file descriptor degli insiemi specificati diventi
79 \bodydesc{La funzione in caso di successo restituisce il numero di file
80 descriptor (anche nullo) che sono attivi, e -1 in caso di errore, nel qual
81 caso \var{errno} viene settata ai valori:
83 \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
85 \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
86 \item[\macro{EINVAL}] Si è specificato per \param{n} un valore negativo.
88 ed inoltre \macro{ENOMEM}.
92 La funzione mette il processo in stato di \textit{sleep} (vedi
93 \tabref{tab:proc_proc_states}) fintanto che almeno uno dei file descriptor
94 degli insiemi specificati (\param{readfds}, \param{writefds} e
95 \param{exceptfds}), non diventa attivo, per un tempo massimo specificato da
98 Per specificare quali file descriptor si intende \textsl{selezionare}, la
99 funzione usa un particolare oggetto, il \textit{file descriptor set},
100 identificato dal tipo \type{fd\_set}, che serve ad identificare un insieme di
101 file descriptor, (in maniera analoga a come un \textit{signal set}, vedi
102 \secref{sec:sig_sigset}, identifica un insieme di segnali). Per la
103 manipolazione di questi \textit{file descriptor set} si possono usare delle
104 opportune macro di preprocessore:
106 \headdecl{sys/time.h}
107 \headdecl{sys/types.h}
109 \funcdecl{FD\_ZERO(fd\_set *set)}
110 Inizializza l'insieme (vuoto).
112 \funcdecl{FD\_SET(int fd, fd\_set *set)}
113 Inserisce il file descriptor \param{fd} nell'insieme.
115 \funcdecl{FD\_CLR(int fd, fd\_set *set)}
116 Rimuove il file descriptor \param{fd} nell'insieme.
118 \funcdecl{FD\_ISSET(int fd, fd\_set *set)}
119 Controlla se il file descriptor \param{fd} è nell'insieme.
122 In genere un \textit{file descriptor set} può contenere fino ad un massimo di
123 \macro{FD\_SETSIZE} file descriptor. Questo valore in origine corrispondeva
124 al limite per il numero massimo di file aperti\footnote{ad esempio in Linux,
125 fino alla serie 2.0.x, c'era un limite di 256 file per processo.}, ma
126 quando, come nelle versioni più recenti del kernel, non c'è più un limite
127 massimo, esso indica le dimensioni massime dei numeri usati nei \textit{file
130 La funzione richiede di specificare tre insiemi distinti di file descriptor;
131 il primo, \param{readfds}, verrà osservato per rilevare la disponibilità di
132 effettuare una lettura, il secondo, \param{writefds}, per verificare la
133 possibilità effettuare una scrittura ed il terzo, \param{exceptfds}, per
134 verificare l'esistenza di condizioni eccezionali (come i messaggi urgenti su
135 un \textit{socket}\index{socket}, vedi \secref{sec:xxx_urgent}).
137 La funzione inoltre richiede anche di specificare, tramite l'argomento
138 \param{n}, un valore massimo del numero dei file descriptor usati
139 nell'insieme; si può usare il già citato \macro{FD\_SETSIZE}, oppure il numero
140 più alto dei file descriptor usati nei tre insiemi, aumentato di uno.
142 Infine l'argomento \param{timeout}, specifica un tempo massimo di
143 attesa\footnote{il tempo è valutato come \textit{elapsed time}.} prima che la
144 funzione ritorni; se settato a \macro{NULL} la funzione attende
145 indefinitamente. Si può specificare anche un tempo nullo (cioè una \var{struct
146 timeval} con i campi settati a zero), qualora si voglia semplicemente
147 controllare lo stato corrente dei file descriptor.
149 La funzione restituisce il totale dei file descriptor pronti nei tre insiemi,
150 il valore zero indica sempre che si è raggiunto un timeout. Ciascuno dei tre
151 insiemi viene sovrascritto per indicare quale file descriptor è pronto per le
152 operazioni ad esso relative, in modo da poterlo controllare con la macro
153 \macro{FD\_ISSET}. In caso di errore la funzione restituisce -1 e gli insiemi
156 In Linux \func{select} modifica anche il valore di \param{timeout}, settandolo
157 al tempo restante; questo è utile quando la funzione viene interrotta da un
158 segnale, in tal caso infatti si ha un errore di \macro{EINTR}, ed occorre
159 rilanciare la funzione; in questo modo non è necessario ricalcolare tutte le
160 volte il tempo rimanente.\footnote{questo può causare problemi di portabilità
161 sia quando si trasporta codice scritto su Linux che legge questo valore, sia
162 quando si usano programmi scritti per altri sistemi che non dispongono di
163 questa caratteristica e ricalcolano \param{timeout} tutte le volte. In
164 genere la caratteristica è disponibile nei sistemi che derivano da System V
165 e non disponibile per quelli che derivano da BSD.}
167 Come accennato l'interfaccia di \func{select} è una estensione di BSD; anche
168 System V ha introdotto una sua interfaccia per gestire l'\textit{I/O
169 multiplexing}, basata sulla funzione \func{poll},\footnote{la funzione è
170 prevista dallo standard XPG4, ed è stata introdotta in Linux come system
171 call a partire dal kernel 2.1.23 e dalle \acr{libc} 5.4.28.} il cui prototipo è:
172 \begin{prototype}{sys/poll.h}
173 {int poll(struct pollfd *ufds, unsigned int nfds, int timeout)}
175 La funzione attente un cambiamento di stato per uno dei file descriptor
176 specificati da \param{ufds}.
178 \bodydesc{La funzione restituisce il numero di file descriptor con attività in
179 caso di successo, o 0 se c'è stato un timeout; in caso di errore viene
180 restituito -1 ed \var{errno} viene settata ai valori:
182 \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
184 \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
186 ed inoltre \macro{EFAULT} e \macro{ENOMEM}.}
189 La funzione tiene sotto controllo un numero \param{ndfs} di file descriptor
190 specificati attraverso un vettore di puntatori a strutture di tipo
191 \type{pollfd}, la cui definizione è riportata in \figref{fig:file_pollfd}.
192 Come \func{select} anche \func{poll} permette di interrompere l'attesa dopo un
193 certo tempo, che va specificato attraverso \param{timeout} in numero di
194 millisecondi (un valore negativo indica un'attesa indefinita).
197 \footnotesize \centering
198 \begin{minipage}[c]{15cm}
199 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
201 int fd; /* file descriptor */
202 short events; /* requested events */
203 short revents; /* returned events */
208 \caption{La struttura \type{pollfd}, utilizzata per specificare le modalità
209 di controllo di un file descriptor alla funzione \func{poll}.}
210 \label{fig:file_pollfd}
213 Per ciascun file da controllare deve essere opportunamente predisposta una
214 struttura \type{pollfd}; nel campo \var{fd} deve essere specificato il file
215 descriptor, mentre nel campo \var{events} il tipo di evento su cui si vuole
216 attendere; quest'ultimo deve essere specificato come maschera binaria dei
217 primi tre valori riportati in \tabref{tab:file_pollfd_flags} (gli altri
218 vengono utilizzati solo per \var{revents} come valori in uscita).
223 \begin{tabular}[c]{|l|c|l|}
225 \textbf{Flag} & \textbf{Valore} & \textbf{Significato} \\
228 \macro{POLLIN} & 0x001 & È possibile la lettura immediata.\\
229 \macro{POLLPRI} & 0x002 & Sono presenti dati urgenti.\\
230 \macro{POLLOUT} & 0x004 & È possibile la scrittura immediata.\\
232 \macro{POLLERR} & 0x008 & C'è una condizione di errore.\\
233 \macro{POLLHUP} & 0x010 & Si è verificato un hung-up.\\
234 \macro{POLLNVAL} & 0x020 & Il file descriptor non è aperto.\\
236 \macro{POLLRDNORM}& 0x040 & Sono disponibili in lettura dati normali.\\
237 \macro{POLLRDBAND}& 0x080 & Sono disponibili in lettura dati ad alta
239 \macro{POLLWRNORM}& 0x100 & È possibile la scrittura di dati normali. \\
240 \macro{POLLWRBAND}& 0x200 & È possibile la scrittura di dati ad
242 \macro{POLLMSG} & 0x400 & Estensione propria di Linux.\\
245 \caption{Costanti per l'identificazione dei vari bit dei campi
246 \var{events} e \var{revents} di \type{pollfd}.}
247 \label{tab:file_pollfd_flags}
250 La funzione ritorna, restituendo il numero di file per i quali si è verificata
251 una delle condizioni di attesa richieste o un errore. Lo stato dei file
252 all'uscita della funzione viene restituito nel campo \var{revents} della
253 relativa struttura \type{pollfd}, che viene settato alla maschera binaria dei
254 valori riportati in \tabref{tab:file_pollfd_flags}, ed oltre alle tre
255 condizioni specificate tramite \var{events} può riportare anche l'occorrere di
256 una condizione di errore.
258 Lo standard POSIX è rimasto a lungo senza primitive per l'\textit{I/O
259 multiplexing}, che è stata introdotto con le ultime revisioni dello standard
260 (POSIX 1003.1g-2000 e POSIX 1003.1-2001). Esso prevede che tutte le funzioni
261 ad esso relative vengano dichiarate nell'header \file{sys/select.h}, che
262 sostituisce i precedenti, ed aggiunge a \func{select} una nuova funzione
263 \func{pselect},\footnote{il supporto per lo standard POSIX 1003.1-2001, ed
264 l'header \file{sys/select.h}, compaiono in Linux a partire dalle \acr{glibc}
265 2.1. Le \acr{libc4} e \acr{libc5} non contengono questo header, le
266 \acr{glibc} 2.0 contengono una definizione sbagliata di \func{psignal},
267 senza l'argomento \param{sigmask}, la definizione corretta è presente dalle
268 \acr{glibc} 2.1-2.2.1 se si è definito \macro{\_GNU\_SOURCE} e nelle
269 \acr{glibc} 2.2.2-2.2.4 se si è definito \macro{\_XOPEN\_SOURCE} con valore
270 maggiore di 600.} il cui prototipo è:
271 \begin{prototype}{sys/select.h}
272 {int pselect(int n, fd\_set *readfds, fd\_set *writefds, fd\_set *exceptfds,
273 struct timespec *timeout, sigset\_t *sigmask)}
275 Attende che uno dei file descriptor degli insiemi specificati diventi
278 \bodydesc{La funzione in caso di successo restituisce il numero di file
279 descriptor (anche nullo) che sono attivi, e -1 in caso di errore, nel qual
280 caso \var{errno} viene settata ai valori:
282 \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
284 \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
285 \item[\macro{EINVAL}] Si è specificato per \param{n} un valore negativo.
287 ed inoltre \macro{ENOMEM}.}
290 La funzione è sostanzialmente identica a \func{select}, solo che usa una
291 struttura \type{timespec} per indicare con maggiore precisione il timeout e
292 non ne aggiorna il valore in caso di interruzione, inoltre prende un argomento
293 aggiuntivo \param{sigmask} che è il puntatore ad una maschera di segnali (si
294 veda \secref{sec:sig_sigmask}). La maschera corrente viene sostituita da
295 questa immediatamente prima di eseguire l'attesa, e ripristinata al ritorno
298 L'uso di \param{sigmask} è stato introdotto allo scopo di prevenire possibili
299 race condition\footnote{in Linux però, non esistendo una system call apposita,
300 la funzione è implementata nelle \acr{glibc} usando \func{select}, e la
301 possibilità di una race condition resta.} quando si deve eseguire un test su
302 una variabile settata da un manipolatore sulla base dell'occorrenza di un
303 segnale per decidere se lanciare \func{select}. Fra il test e l'esecuzione è
304 presente una finestra in cui potrebbe arrivare il segnale che non sarebbe
305 rilevato; la race condition diventa superabile disabilitando il segnale prima
306 del test e riabilitandolo poi grazie all'uso di \param{sigmask}.
310 \subsection{L'\textsl{I/O asincrono}}
311 \label{sec:file_asyncronous_io}
313 Una modalità alternativa all'uso dell'\textit{I/O multiplexing} è quella di
314 fare ricorso al cosiddetto \textsl{I/O asincrono}. Il concetto base
315 dell'\textsl{I/O asincrono} è che le funzioni di I/O non attendono il
316 completamento delle operazioni prima di ritornare, così che il processo non
317 viene bloccato. In questo modo diventa ad esempio possibile effettuare una
318 richiesta preventiva di dati, in modo da poter effettuare in contemporanea le
319 operazioni di calcolo e quelle di I/O.
321 Abbiamo accennato in \secref{sec:file_open} che è possibile, attraverso l'uso
322 del flag \macro{O\_ASYNC},\footnote{l'uso del flag di \macro{O\_ASYNC} e dei
323 comandi \macro{F\_SETOWN} e \macro{F\_GETOWN} per \func{fcntl} è specifico
324 di Linux e BSD.} aprire un file in modalità asincrona, così come è possibile
325 attivare in un secondo tempo questa modalità settando questo flag attraverso
326 l'uso di \func{fcntl} con il comando \macro{F\_SETFL} (vedi
327 \secref{sec:file_fcntl}).
329 In realtà in questo caso non si tratta di I/O asincrono vero e proprio, quanto
330 di un meccanismo asincrono di notifica delle variazione dello stato del file
331 descriptor; quello che succede è che il sistema genera un segnale (normalmente
332 \macro{SIGIO}, ma è possibile usarne altri) tutte le volte che diventa
333 possibile leggere o scrivere dal file descriptor che si è posto in questa
334 modalità. Si può inoltre selezionare, con il comando \macro{F\_SETOWN} di
335 \func{fcntl}, quale processo (o gruppo di processi) riceverà il segnale.
337 In questo modo si può evitare l'uso delle funzioni \func{poll} o \func{select}
338 che, quando vengono usate con un numero molto grande di file descriptor, non
339 hanno buone prestazioni. In tal caso infatti la maggior parte del loro tempo
340 di esecuzione è impegnato ad eseguire una scansione su tutti i file descriptor
341 tenuti sotto controllo per determinare quali di essi (in genere una piccola
342 percentuale) sono diventati attivi.
344 Tuttavia con l'implementazione classica dei segnali questa modalità di I/O
345 presenta notevoli problemi, dato che non è possibile determinare, quando sono
346 più di uno, qual'è il file descriptor responsabile dell'emissione del segnale.
347 Linux però supporta le estensioni POSIX.1b dei segnali che permettono di
348 superare il problema facendo ricorso alle informazioni aggiuntive restituite
349 attraverso la struttura \type{siginfo\_t}, utilizzando la forma estesa
350 \var{sa\_sigaction} del manipolatore (si riveda quanto illustrato in
351 \secref{sec:sig_sigaction}).
353 Per far questo però occorre utilizzare le funzionalità dei segnali real-time
354 (vedi \secref{sec:sig_real_time}) settando esplicitamente con il comando
355 \macro{F\_SETSIG} di \func{fcntl} un segnale real-time da inviare in caso di
356 I/O asincrono (il segnale di default è \macro{SIGIO}). In questo caso il
357 manipolatore tutte le volte che riceverà \macro{SI\_SIGIO} come valore del
358 campo \var{si\_code}\footnote{il valore resta \macro{SI\_SIGIO} qualunque sia
359 il segnale che si è associato all'I/O asincrono, ed indica appunto che il
360 segnale è stato generato a causa di attività nell'I/O asincrono.} di
361 \type{siginfo\_t}, troverà nel campo \var{si\_fd} il valore del file
362 descriptor che ha generato il segnale.
364 Un secondo vantaggio dell'uso dei segnali real-time è che essendo dotati di
365 una coda di consegna ogni segnale sarà associato ad uno solo file descriptor;
366 inoltre sarà possibile stabilire delle priorità nella risposta a seconda del
367 segnale usato. In questo modo si può identificare immediatamente un file su
368 cui l'accesso è diventato possibile evitando completamente l'uso di funzioni
369 come \func{poll} e \func{select}, almeno fintanto che non si satura la coda;
370 si eccedono le dimensioni di quest'ultima; in tal caso infatti il kernel, non
371 potendo più assicurare il comportamento corretto per un segnale real-time,
372 invierà al suo posto un \var{SIGIO}, su cui si accumuleranno tutti i segnali
373 in eccesso, e si dovrà determinare al solito modo quali sono i file diventati
376 Benché la modalità di apertura asincrona di un file possa risultare utile in
377 varie occasioni (in particolar modo con i socket e gli altri file per i quali
378 le funzioni di I/O sono system call lente), essa è comunque limitata alla
379 notifica della disponibilità del file descriptor per le operazioni di I/O, e
380 non ad uno svolgimento asincrono delle medesime. Lo standard POSIX.1b
381 definisce anche una interfaccia apposita per l'I/O asincrono, che prevede un
382 insieme di funzioni dedicate, completamente separate rispetto a quelle usate
385 In generale questa interfaccia è completamente astratta e può essere
386 implementata sia direttamente nel kernel, che in user space attraverso l'uso
387 di thread. Al momento\footnote{fino ai kernel della serie 2.4.x, nella serie
388 2.5.x è però iniziato un lavoro completo di riscrittura di tutto il sistema
389 di I/O, che prevede anche l'introduzione di un nuovo layer per l'I/O
390 asincrono.} esiste una sola versione stabile di questa interfaccia, quella
391 delle \acr{glibc}, che è realizzata completamente in user space. Esistono
392 comunque vari progetti sperimentali (come il KAIO della SGI, o i patch di
393 Benjamin La Haise) che prevedono un supporto diretto da parte del kernel.
395 Lo standard prevede che tutte le operazioni di I/O asincrono siano controllate
396 attraverso l'uso di una apposita struttura \type{aiocb} (il cui nome sta per
397 \textit{asyncronous I/O control block}), che viene passata come argomento a
398 tutte le funzioni dell'interfaccia. La sua definizione, come effettuata in
399 \file{aio.h}, è riportata in \figref{fig:file_aiocb}. Nello steso file è
400 definita la macro \macro{\_POSIX\_ASYNCHRONOUS\_IO}, che dichiara la
401 disponibilità dell'interfaccia per l'I/O asincrono.
404 \footnotesize \centering
405 \begin{minipage}[c]{15cm}
406 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
409 int aio_fildes; /* File descriptor. */
410 off_t aio_offset; /* File offset */
411 int aio_lio_opcode; /* Operation to be performed. */
412 int aio_reqprio; /* Request priority offset. */
413 volatile void *aio_buf; /* Location of buffer. */
414 size_t aio_nbytes; /* Length of transfer. */
415 struct sigevent aio_sigevent; /* Signal number and value. */
420 \caption{La struttura \type{aiocb}, usata per il controllo dell'I/O
422 \label{fig:file_aiocb}
425 Le operazioni di I/O asincrono possono essere effettuate solo su un file già
426 aperto; il file deve inoltre supportare la funzione \func{lseek},
427 pertanto terminali e pipe sono esclusi. Non c'è limite al numero di operazioni
428 contemporanee effettuabili su un singolo file.
430 Ogni operazione deve inizializzare opportunamente un \textit{control block}.
431 Il file descriptor su cui operare deve essere specificato tramite il campo
432 \var{aio\_fildes}; dato che più operazioni possono essere eseguita in maniera
433 asincrona, il concetto di posizione corrente sul file viene a mancare;
434 pertanto si deve sempre specificare nel campo \var{aio\_offset} la posizione
435 sul file da cui i dati saranno letti o scritti. Nel campo \var{aio\_buf} deve
436 essere specificato l'indirizzo del buffer usato per l'I/O, ed in
437 \var{aio\_nbytes} la lunghezza del blocco di dati da trasferire.
439 Il campo \var{aio\_reqprio} permette di settare la priorità delle operazioni
440 di I/O.\footnote{in generale perché ciò sia possibile occorre che la
441 piattaforma supporti questa caratteristica, questo viene indicato definendo
442 le macro \macro{\_POSIX\_PRIORITIZED\_IO}, e
443 \macro{\_POSIX\_PRIORITY\_SCHEDULING}.} La priorità viene settata a partire
444 da quella del processo chiamante (vedi \secref{sec:proc_priority}), cui viene
445 sottratto il valore di questo campo.
447 Il campo \var{aio\_lio\_opcode} è usato soltanto dalla funzione
448 \func{lio\_listio}, che, come vedremo più avanti, permette di eseguire con una
449 sola chiamanta una serie di operazioni, usando un vettore di \textit{control
450 block}. Tramite questo campo si specifica quale è la natura di ciascuna di
454 \footnotesize \centering
455 \begin{minipage}[c]{15cm}
456 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
459 sigval_t sigev_value;
462 sigev_notify_function;
463 sigev_notify_attributes;
468 \caption{La struttura \type{sigevent}, usata per specificare le modailtà di
469 notifica degli eventi relativi alle operazioni di I/O asincrono.}
470 \label{fig:file_sigevent}
473 Infine il campo \var{aio\_sigevent} è una struttura di tipo \type{sigevent}
474 che serve a specificare il modo in cui si vuole che venga effettuata la
475 notifica del completamento delle operazioni richieste. La struttura è
476 riportata in \secref{fig:file_sigevent}; il campo \var{sigev\_notify} è quello
477 che indica le modalità della notifica, esso può assumere i tre valori:
478 \begin{basedescript}{\desclabelwidth{3.0cm}}
479 \item[\macro{SIGEV\_NONE}] Non viene inviata nessuna notifica.
480 \item[\macro{SIGEV\_SIGNAL}] La notifica viene effettuata inviando al processo
481 chiamante il segnale specificato nel campo \var{sigev\_signo}, se il
482 manipolatore è installato con \macro{SA\_SIGINFO}, il gli verrà restituito
483 il valore di \var{sigev\_value} in come valore del campo \var{si\_value} per
485 \item[\macro{SIGEV\_THREAD}] La notifica viene effettuata creando un nuovo
486 thread che esegue la funzione specificata da \var{sigev\_notify\_function},
487 con gli attributi specificati da \var{sigev\_notify\_attribute}.
490 Le due funzioni base dell'interfaccia per l'I/O asincrono sono
491 \func{aio\_read} ed \func{aio\_write}. Esse permettono di richiedere una
492 lettura od una scrittura asincrona di dati, usando la struttura \type{aiocb}
493 appena descritta; i rispettivi prototipi sono:
497 \funcdecl{int aio\_read(struct aiocb *aiocbp)}
498 Richiede una lettura asincrona secondo quanto specificato con \param{aiocbp}.
500 \funcdecl{int aio\_write(struct aiocb *aiocbp)}
501 Richiede una scrittura asincrona secondo quanto specificato con
504 \bodydesc{Le funzioni restituiscono 0 in caso di successo, e -1 in caso di
505 errore, nel qual caso \var{errno} viene settata ai valori:
507 \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato.
508 \item[\macro{ENOSYS}] La funzione non è implementata.
509 \item[\macro{EINVAL}] Si è specificato un valore non valido per i campi
510 \var{aio\_offset} o \var{aio\_reqprio} di \param{aiocbp}.
511 \item[\macro{EAGAIN}] La coda delle richieste è momentaneamente piena.
516 Entrambe le funzioni ritornano immediatamente dopo aver messo in coda la
517 richiesta, o in caso di errore. Non è detto che gli errori \macro{EBADF} ed
518 \macro{EINVAL} siano rilevati immediatamente al momento della chiamata,
519 potrebbero anche emergere nelle fasi successive delle operazioni. Lettura e
520 scrittura avvengono alla posizione indicata da \var{aio\_offset}, a meno che
521 il file non sia stato aperto in \textit{append mode} (vedi
522 \secref{sec:file_open}), nel qual caso le scritture vengono effettuate
523 comunque alla fine de file, nell'ordine delle chiamate a \func{aio\_write}.
525 Si tenga inoltre presente che deallocare la memoria indirizzata da
526 \param{aiocbp} o modificarne i valori prima della conclusione di una
527 operazione può dar luogo a risultati impredicibili, perché l'accesso ai vari
528 campi per eseguire l'operazione può avvenire in un momento qualsiasi dopo la
529 richiesta. Questo comporta che occorre evitare di usare per \param{aiocbp}
530 variabili automatiche e che non si deve riutilizzare la stessa struttura per
531 un'ulteriore operazione fintanto che la precedente non sia stata ultimata. In
532 generale per ogni operazione di I/O asincrono si deve utilizzare una diversa
533 struttura \type{aiocb}.
535 Dato che si opera in modalità asincrona, il successo di \func{aio\_read} o
536 \func{aio\_write} non implica che le operazioni siano state effettivamente
537 eseguite in maniera corretta; per verificarne l'esito l'interfaccia prevede
538 altre due funzioni, che permettono di controllare lo stato di esecuzione. La
539 prima è \func{aio\_error}, che serve a determinare un eventuale stato di
540 errore; il suo prototipo è:
541 \begin{prototype}{aio.h}
542 {int aio\_error(const struct aiocb *aiocbp)}
544 Determina lo stato di errore delle operazioni di I/O associate a
547 \bodydesc{La funzione restituisce 0 se le operazioni si sono concluse con
548 successo, altrimenti restituisce il codice di errore.}
549 % }, che viene salvato
550 % anche in \var{errno}, i valori possibili sono:
552 % \item[\macro{ENOSYS}] La funzione non è implementata.
553 % \item[\macro{EINPROGRESS}] L'operazione è ancora in corso.
554 % \item[\macro{EINVAL}] Si è specificato un valore non valido per i campi
555 % \var{aio\_offset} o \var{aio\_reqprio} di \param{aiocbp}.
556 % \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato.
558 % più tutti quelli possibili per le sottostanti operazioni, .}
561 Se l'operazione non si è ancora completata viene restituito l'errore di
562 \macro{EINPROGRESS}. La funzione ritorna zero quando l'operazione si è
563 conclusa con successo, altrimenti restituisce il codice dell'errore
564 verificatosi, ed esegue il corrispondente settaggio di \var{errno}. Il codice
565 può essere sia \macro{EINVAL} ed \macro{EBADF}, dovuti ad un valore errato per
566 \param{aiocbp}, che uno degli errori possibili durante l'esecuzione
567 dell'operazione di I/O richiesta, nel qual caso saranno restituiti, a seconda
568 del caso, i codici di errore delle system call \func{read}, \func{write} e
571 Una volta che si sia certi che le operazioni siano state concluse (cioè dopo
572 che una chiamata ad \func{aio\_error} non ha restituito \macro{EINPROGRESS},
573 si potrà usare la seconda funzione dell'interfaccia, \func{aio\_return}, che
574 permette di verificare il completamento delle operazioni di I/O asincrono; il
576 \begin{prototype}{aio.h}
577 {ssize\_t aio\_return(const struct aiocb *aiocbp)}
579 Recupera il valore dello stato di ritorno delle operazioni di I/O associate a
582 \bodydesc{La funzione restituisce lo stato di uscita dell'operazione
586 La funzione deve essere chiamata una sola volte per ciascuna operazione
587 asincrona, essa infatti fa sì che il sistema rilasci le risorse ad essa
588 associate. É per questo motivo che occorre chiamare la funzione solo dopo che
589 l'operazione cui \param{aiocbp} fa riferimento si è completata. Una chiamata
590 precedente il completamento delle operazioni darebbe risultati indeterminati.
592 La funzione restituisce il valore di ritorno relativo all'operazione eseguita,
593 così come ricavato dalla sottostante system call (il numero di byte letti,
594 scritti o il valore di ritorno di \func{fsync}). É importante chiamare sempre
595 questa funzione, altrimenti le risorse disponibili per le operazioni di I/O
596 asincrono non verrebbero liberate, rischiando di arrivare ad un loro
599 Oltre alle operazioni di lettura e scrittura l'interfaccia POSIX.1b mette a
600 disposizione un'altra operazione, quella di sincronizzazione delll'I/O, essa è
601 compiuta dalla funzione \func{aio\_fsync}, che ha lo stesso effetto della
602 analoga \func{fsync}, ma viene esguita in maniera asincrona; il suo prototipo
604 \begin{prototype}{aio.h}
605 {ssize\_t aio\_return(int op, struct aiocb *aiocbp)}
607 Richiede la sincronizzazione dei dati per il file indicato da \param{aiocbp}.
609 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
610 errore, che può essere, con le stesse modalità di \func{aio\_read},
611 \macro{EAGAIN}, \macro{EBADF} o \macro{EINVAL}.}
614 La funzione richiede la sincronizzazione delle operazioni di I/O, ritornando
615 immediatamente. L'esecuzione effettiva della sincronizzazione dovrà essere
616 verificata con \func{aio\_error} e \func{aio\_return} come per le operazioni
617 di lettura e scrittura. L'argomento \param{op} permette di indicare la
618 modalità di esecuzione, se si specifica il valore \macro{O\_DSYNC} le
619 operazioni saranno completate con una chiamata a \func{fdatasync}, se si
620 specifica \macro{O\_SYNC} con una chiamata a \func{fsync} (per i dettagli vedi
621 \secref{sec:file_sync}).
623 Il successo della chiamata assicura la sincronizzazione delle operazioni fino
624 allora richieste, niente è garantito riguardo la sincronizzazione dei dati
625 relativi ad eventuali operazioni richieste successivamente. Se si è
626 specificato un meccanismo di notifica questo sarà innescato una volta che le
627 operazioni di sincronizzazione dei dati saranno completate.
629 In alcuni casi può essere necessario interrompere le operazioni (in genere
630 quando viene richiesta un'uscita immediata dal programam), per questo lo
631 standard POSIX.1b prevede una funzioni apposita, \func{aio\_cancel}, che
632 permette di cancellare una operazione richiesta in precedenza; il suo
634 \begin{prototype}{aio.h}
635 {int aio\_cancel(int fildes, struct aiocb *aiocbp)}
637 Richiede la cancellazione delle operazioni sul file \param{fildes} specificate
640 \bodydesc{La funzione restituisce il risultato dell'operazione con un codice
641 di positivo, e -1 in caso di errore, che avviene qualora si sia specificato
642 un valore non valido di \param{fildes}, setta \var{errno} al valore
646 La funzione permette di cancellare una operazione specifica sul file
647 \param{fildes}, o tutte le operazioni pendenti, specificando \macro{NULL} come
648 valore di \param{aiocbp}. Quando una operazione viene cancellata una
649 successiva chiamata ad \func{aio\_error} riporterà \macro{ECANCELED} come
650 codice di errore, ed il suo codice di ritorno sarà -1, inoltre il meccanismo
651 di notifica non verrà invocato. Se si specifica una operazione relativa ad un
652 altro file descriptor il risultato è indeterminato.
654 In caso di successo, i possibili valori di ritorno per \func{aio\_cancel} sono
655 tre (anch'essi definiti in \file{aio.h}):
656 \begin{basedescript}{\desclabelwidth{3.0cm}}
657 \item[\macro{AIO\_ALLDONE}] indica che le operazioni di cui si è richiesta la
658 cancellazione sono state già completate,
660 \item[\macro{AIO\_CANCELED}] indica che tutte le operazioni richieste sono
663 \item[\macro{AIO\_NOTCANCELED}] indica che alcune delle operazioni erano in
664 corso e non sono state cancellate.
667 Nel caso si abbia \macro{AIO\_NOTCANCELED} occorrerà chiamare
668 \func{aio\_error} per determinare quali sono le operazioni effettivamente
669 cancellate. Le operazioni che non sono state cancellate proseguiranno il loro
670 corso normale, compreso quanto richiesto riguardo al meccanismo di notifica
671 del loro avvenuto completamento.
673 Benché l'I/O asincrono preveda un meccanismo di notifica, l'interfaccia
674 fornisce anche una apposita funzione, \func{aio\_suspend}, che permette di
675 sospendere l'esecuzione del processo chiamante fino al completamento di una
676 specifica operazione; il suo prototipo è:
677 \begin{prototype}{aio.h}
678 {int aio\_suspend(const struct aiocb * const list[], int nent, const struct
681 Attende, per un massimo di \param{timeout}, il completamento di una delle
682 operazioni specificate da \param{list}.
684 \bodydesc{La funzione restituisce 0 se una (o più) operazioni sono state
685 completate, e -1 in caso di errorem nel qual caso \var{errno} viene
688 \item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
690 \item[\macro{ENOSYS}] La funzione non è implementata.
691 \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
696 La funzione permette di bloccare il processo fintanto che almeno una delle
697 \param{nent} operazioni specificate nella lista \param{list} è completata, per
698 un tempo massimo specificato da \param{timout}, o fintanto che non arrivi un
699 segnale.\footnote{si tenga conto che questo segnale può anche essere quello
700 utilizzato come meccanismo di notifica.} La lista deve essere inizializzata
701 con delle strutture \var{aiocb} relative ad operazioni effettivamente
702 richieste, ma può contenere puntatori nulli, che saranno ignorati. In caso si
703 siano specificati valori non validi l'effetto è indefinito. Un valore
704 \macro{NULL} per \param{timout} comporta l'assenza di timeout.
706 Lo standard POSIX.1b infine ha previsto pure una funzione, \func{lio\_listio},
707 che permette di effettuare la richiesta di una intera lista di operazioni di
708 lettura o scrittura; il suo prototipo è:
709 \begin{prototype}{aio.h}
710 {int lio\_listio(int mode, struct aiocb * const list[], int nent, struct
713 Richiede l'esecuzione delle operazioni di I/O elencata da \param{list},
714 secondo la modalità \param{mode}.
716 \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
717 errore, nel qual caso \var{errno} viene settata ai valori:
719 \item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
721 \item[\macro{ENOSYS}] La funzione non è implementata.
722 \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
727 La funzione esegue la richiesta delle \param{nent} operazioni indicate dalla
728 lista \param{list}; questa deve contenere gli indirizzi di altrettanti
729 \textit{control block}, opportunamente inizializzati; in particolare nel caso
730 dovrà essere specificato il tipo di operazione tramite il campo
731 \var{aio\_lio\_opcode}, che può prendere i tre valori:
732 \begin{basedescript}{\desclabelwidth{2.0cm}}
733 \item[\macro{LIO\_READ}] si richiede una operazione di lettura.
734 \item[\macro{LIO\_WRITE}] si richiede una operazione di scrittura.
735 \item[\macro{LIO\_NOP}] non si effettua nessuna operazione.
737 l'ultimo valore viene usato quando si ha a che fare con un vettore di
738 dimensione fissa, per poter specificare solo alcune operazioni, o quando si è
739 dovuto cancellare delle operazioni e si deve ripetere la richiesta per quelle
742 L'argomento \param{mode} permette di stabilire il comportamento della
743 funzione, se viene specificato il valore \macro{LIO\_WAIT} la funzione si
744 blocca fino al completamento di tutte le operazioni richieste; se invece si
745 spercifica \macro{LIO\_NOWAIT} la funzione ritorna immediatamente dopo aver
746 messo in coda tutte le richieste. In questo caso il chiamante può richiedere
747 la notifica del completamento di tutte le richieste, settando l'argomento
748 \param{sig} in maniera analoga a come si fa per il campo \var{aio\_sigevent}
753 \subsection{I/O vettorizzato}
754 \label{sec:file_multiple_io}
756 Un caso abbastanza comune è quello in cui ci si trova a dover eseguire una
757 serie multipla di operazioni di I/O, come una serie di letture o scritture di
758 vari buffer. Un esempio tipico è quando i dati sono strutturati nei campi di
759 una struttura ed essi devono essere caricati o salvati su un file. Benché
760 l'operazione sia facilmente eseguibile attraverso una serie multipla di
761 chiamate, ci sono casi in cui si vuole poter contare sulla atomicità delle
764 Per questo motivo BSD 4.2\footnote{Le due funzioni sono riprese da BSD4.4 ed
765 integrate anche dallo standard Unix 98; fino alle libc5 Linux usava
766 \type{size\_t} come tipo dell'argomento \param{count}, una scelta logica,
767 che è stata dismessa per restare aderenti allo standard.} ha introdotto due
768 nuove system call, \func{readv} e \func{writev}, che permettono di effettare
769 con una sola chiamata una lettura o una scrittura su una serie di buffer
770 (quello che viene chiamato \textsl{I/O vettorizzato}. I relativi prototipi
775 \funcdecl{int readv(int fd, const struct iovec *vector, int count)} Esegue
776 una lettura vettorizzata da \param{fd} nei \param{count} buffer specificati
779 \funcdecl{int writev(int fd, const struct iovec *vector, int count)} Esegue
780 una scrittura vettorizzata da \param{fd} nei \param{count} buffer
781 specificati da \param{vector}.
783 \bodydesc{Le funzioni restituiscono il numero di byte letti o scritti in
784 caso di successo, e -1 in caso di errore, nel qual caso \var{errno} viene
787 \item[\macro{EBADF}] si è specificato un file descriptor sbagliato.
788 \item[\macro{EINVAL}] si è specificato un valore non valido per uno degli
789 argomenti (ad esempio \param{count} è maggiore di \macro{MAX\_IOVEC}).
790 \item[\macro{EINTR}] la funzione è stata interrotta da un segnale prima di
791 di avere eseguito una qualunque lettura o scrittura.
792 \item[\macro{EAGAIN}] \param{fd} è stato aperto in modalità non bloccante e
793 non ci sono dati in lettura.
794 \item[\macro{EOPNOTSUPP}] La coda delle richieste è momentaneamente piena.
796 ed inoltre \macro{EISDIR}, \macro{ENOMEM}, \macro{EFAULT} (se non sono stato
797 allocati correttamente i buffer specificati nei campi \func{iov\_base}), più
798 tutti gli ulteriori errori che potrebbero avere le usuali funzioni di
799 lettura e scrittura eseguite su \param{fd}.}
802 Entrambe le funzioni usano una struttura \type{iovec}, definita in
803 \figref{fig:file_iovec}, che definisce dove i dati devono essere letti o
804 scritti. Il primo campo, \var{iov\_base}, contiene l'indirizzo del buffer ed
805 il secondo, \var{iov\_len}, la dimensione dello stesso.
808 \footnotesize \centering
809 \begin{minipage}[c]{15cm}
810 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
812 __ptr_t iov_base; /* Starting address */
813 size_t iov_len; /* Length in bytes */
818 \caption{La struttura \type{iovec}, usata dalle operazioni di I/O
820 \label{fig:file_iovec}
823 I buffer da utlizzare sono specificati attraverso l'argomento \var{vector} che
824 è un array di tale strutture, la cui lunghezza è specificata da \param{count}.
825 Essi verranno letti (o scritti) nell'ordine in cui li si sono specificati.
829 \subsection{File mappati in memoria}
830 \label{sec:file_memory_map}
832 Una modalità alternativa di I/O, che usa una interfaccia completamente diversa
833 rispetto a quella classica vista in \capref{cha:file_unix_interface}, è il
834 cosiddetto \textit{memory-mapped I/O}, che attraverso il meccanismo della
835 \textsl{paginazione}\index{paginazione} usato dalla memoria virtuale (vedi
836 \secref{sec:proc_mem_gen}) permette di \textsl{mappare} il contenuto di un
837 file in una sezione dello spazio di indirizzi del processo.
839 Tutto questo comporta una notevole semplificazione delle operazioni di I/O, in
840 quanto non sarà più necessario utilizzare dei buffer intermedi su cui
841 appoggiare i dati da traferire, ma questi potranno essere acceduti
842 direttamente dalla sezione di memoria; inoltre questa interfaccia
843 è più efficiente delle usuali funzioni di I/O, in quanto permette di caricare
844 in memoria solo le parti del file che sono effettivamente usate ad un dato
847 Infatti, dato che l'accesso è fatto direttamente attraverso la memoria
848 virtuale, la sezione di memoria mappata su cui si opera sarà a sua volta letta
849 o scritta sul file una pagina alla volta e solo per le parti effettivamente
850 usate, il tutto in maniera completamente trasparente al processo; l'acceso
851 alle pagine non ancora caricate avverrà allo stesso modo con cui vengono
852 caricate in memoria le pagine che sono state salvate sullo swap.
854 Infine in situazioni in cui la memoria è scarsa, le pagine che mappano un
855 file vengono salvate automaticamente, così come le pagine dei programmi
856 vengono scritte sulla swap; questo consente di accedere ai file su dimensioni
857 il cui solo limite è quello dello spazio di indirizzi disponibile, e non della
858 memoria su cui possono esserne lette delle porzioni.
860 L'interfaccia prevede varie funzioni per la gestione del \textit{memory
861 mapping}, la prima di queste è \func{mmap}, che esegue la mappatura in
862 memoria un file; il suo prototipo è:
866 \headdecl{sys/mman.h}
868 \funcdecl{void * mmap(void *start, size\_t length, int prot, int flags, int
871 Esegue la mappatura in memoria del file \param{fd}.
873 \bodydesc{La funzione restituisce il puntatore alla zona di memoria mappata
874 in caso di successo, e \macro{MAP\_FAILED} (-1) in caso di errore, nel
875 qual caso \var{errno} viene settata ai valori:
877 \item[\macro{EBADF}] Il file descriptor non è valido, e non si è usato
878 \macro{MAP\_ANONYMOUS}.
879 \item[\macro{EACCES}] Il file descriptor non si riferisce ad un file
880 normale, o si è richiesto \macro{MAP\_PRIVATE} ma \param{fd} non è
881 aperto in lettura, o si è richiesto \macro{MAP\_SHARED} e settato
882 \macro{PROT\_WRITE} ed \param{fd} non è aperto in lettura/scrittura, o
883 si è settato \macro{PROT\_WRITE} ed \param{fd} è in
884 \textit{append-only}.
885 \item[\macro{EINVAL}] I valori di \param{start}, \param{length} o
886 \param{offset} non sono validi (o troppo grandi o non allineati sulla
887 dimensione delle pagine).
888 \item[\macro{ETXTBSY}] Si è settato \macro{MAP\_DENYWRITE} ma \param{fd} è
890 \item[\macro{EAGAIN}] Il file è bloccato, o si è bloccata troppa memoria.
891 \item[\macro{ENOMEM}] Non c'è memoria o si è superato il limite sul numero
892 di mappature possibili.
893 \item[\macro{ENODEV}] Il filesystem di \param{fd} no supporta il memory
899 La funzione richiede di mappare in memoria la sezione del file \param{fd} a
900 partire da \param{offset} per \param{lenght} byte, preferibilmente
901 all'indirizzo \param{start}. Il valore di \param{offset} deve essere un
902 multiplo della dimensione di una pagina di memoria. Il valore dell'argomento
903 \param{prot} indica la protezione\footnote{in Linux la memoria reale è divisa
904 in pagine: ogni processo vede la sua memoria attraverso uno o più segmenti
905 lineari di memoria virtuale. Per ciascuno di questi segmenti il kernel
906 mantiene nella \textit{page table} la mappatura sulle pagine di memoria
907 reale, ed le modalità di accesso (lettura, esecuzione, scrittura); una loro
908 violazione causa quella che si chiama una \textit{segment violation}, e la
909 relativa emissione del segnale \macro{SIGSEGV}.} da applicare al segmento di
910 memoria e deve essere specificato come maschera binaria ottenuta dall'OR di
911 uno o più dei valori riportati in \tabref{tab:file_mmap_flag}; il valore
912 specificato deve essere compatibile con la modalità con cui si è aperto il
918 \begin{tabular}[c]{|l|l|}
920 \textbf{Valore} & \textbf{Significato} \\
923 \macro{PROT\_EXEC} & Le pagine possono essere eseguite.\\
924 \macro{PROT\_READ} & Le pagine possono essere lette.\\
925 \macro{PROT\_WRITE} & Le pagine possono essere scritte.\\
926 \macro{PROT\_NONE} & L'accesso alle pagine è vietato.\\
929 \caption{Valori dell'argomento \param{prot} di \func{mmap}, relativi alla
930 protezione applicate alle pagine del file mappate in memoria.}
931 \label{tab:file_mmap_prot}
934 L'argomento \param{flags} specifica qual'è il tipo di oggetto mappato, le
935 opzioni relative alle modalità con cui è effettuata la mappatura e alle
936 modalità con cui le modifiche alla memoria mappata vengono condivise o
937 mantenute private al processo che le ha effettuate. Deve essere specificato
938 come maschera binaria ottenuta dall'OR di uno o più dei valori riportati in
939 \tabref{tab:file_mmap_flag}.
944 \begin{tabular}[c]{|l|p{10cm}|}
946 \textbf{Valore} & \textbf{Significato} \\
949 \macro{MAP\_FIXED} & Non permette di restituire un indirizzo diverso
950 da \param{start}, se questo non può essere usato
951 \func{mmap} fallisce. Se si setta questo flag il
952 valore di \param{start} deve essere allineato
953 alle dimensioni di una pagina. \\
954 \macro{MAP\_SHARED} & I cambiamenti sulla memoria mappata vengono
955 riportati sul file e saranno immediatamente
956 visibili agli altri processi che mappano lo stesso
957 file.\footnotemark Il file su disco però non sarà
958 aggiornato fino alla chiamata di \func{rsync} o
959 \func{unmap}), e solo allora le modifiche saranno
960 visibili per l'I/O convenzionale. Incompatibile
961 con \macro{MAP\_PRIVATE}. \\
962 \macro{MAP\_PRIVATE} & I cambiamenti sulla memoria mappata non vengono
963 riportati sul file. Ne viene fatta una copia
964 privata cui solo il processo chiamante ha
965 accesso. Le modifiche sono mantenute attraverso
966 il meccanismo del \textit{copy on write} e
967 salvate su swap in caso di necessità. Non è
968 specificato se i cambiamenti sul file originale
969 vengano riportati sulla regione
970 mappata. Incompatibile con \macro{MAP\_SHARED}. \\
971 \macro{MAP\_DENYWRITE} & In Linux viene ignorato per evitare
972 \textit{DoS}\index{DoS} (veniva usato per
973 segnalare che tentativi di scrittura sul file
974 dovevano fallire con \macro{ETXTBUSY}).\\
975 \macro{MAP\_EXECUTABLE}& Ignorato. \\
976 \macro{MAP\_NORESERVE} & Si usa con \macro{MAP\_PRIVATE}. Non riserva
977 delle pagine di swap ad uso del meccanismo di
978 \textit{copy on write} per mantere le modifiche
979 fatte alla regione mappata, in
980 questo caso dopo una scrittura, se non c'è più
981 memoria disponibile, si ha l'emissione di
982 un \macro{SIGSEGV}. \\
983 \macro{MAP\_LOCKED} & Se settato impedisce lo swapping delle pagine
985 \macro{MAP\_GROWSDOWN} & Usato per gli stack. Indica alla virtual memory
986 che la mappatura deve essere effettuata .\\
987 \macro{MAP\_ANONYMOUS} & La mappatura non è associata a nessun file. Gli
988 argomenti \param{fd} e \param{offset} sono
989 ignorati.\footnotemark\\
990 \macro{MAP\_ANON} & Sinonimo di \macro{MAP\_ANONYMOUS}, deprecato.\\
991 \macro{MAP\_FILE} & Valore di compatibiità, deprecato.\\
994 \caption{Valori possibili dell'argomento \param{flag} di \func{mmap}.}
995 \label{tab:file_mmap_flag}
998 \footnotetext{Dato che tutti faranno riferimento alle stesse pagine di
1000 \footnotetext{L'uso di questo flag con \macro{MAP\_SHARED} è
1001 stato implementato in Linux a partire dai kernel della serie 2.4.x.}
1003 Un file viene sempre mappato su multipli delle dimensioni di una pagina,
1004 qualora esso sia più corto la parte restante è riempita con zeri; eventuali
1005 scritture in quella zona di memoria non vengono riportate sul file. Se le
1006 dimensioni del file cambiano (esso viene esteso o troncato), non è specificato
1007 quale effetto viene a aversi sulle pagine di memoria che corrispondono alle
1008 regioni aggiunte o tolte.
1010 Si tenga presente che non tutti i file possono venire mappati in memoria; ad
1011 esempio non è possibile mappare in memoria pipe, socket e fifo; lo stesso vale
1012 anche per alcuni file di dispositivo, che non dispongono dell'operazione
1013 relativa \var{mmap} (si ricordi quanto esposto in \secref{sec:file_vfs_work}).
1015 La memoria mappata viene mantenuta attraverso una \func{fork}; con gli stessi
1016 attributi. In particolare se la memoria è condivisa lo sarà anche fra padre e
1017 figlio, se è privata ognuno di essi manterrà una sua versione privata. Non c'è
1018 invece nessun passaggio attraverso una \func{exec}, dato che quest'ultima
1019 sostituisce tutto lo spazio degli indirizzo con quello del nuovo programma.
1021 Quando si effettua una mappatura di un file, i relativi tempi (vedi
1022 \secref{sec:file_file_times}) vengono pure modificati. Il valore di
1023 \var{st\_atime} può venir cambiato in un qualunque momento in cui la mappatura
1024 sia attiva: il primo riferimento ad una pagina mappata aggiorna questo tempo.
1025 I valori di \var{st\_ctime} e \var{st\_mtime} vengono cambiati solo quando è
1026 possibile una scrittura (cioè per un file mappato con \macro{PROT\_WRITE} e
1027 \macro{MAP\_SHARED}) e sono aggiornati dopo la scrittura e prima di una
1028 eventuale \func{msync}.
1030 Dato per i file mappati in memoria le operazioni di I/O sono gestite
1031 direttamente dalla memoria virtuale, occorre essere consapevoli delle
1032 interazioni che possono esserci con operazioni effettuate con l'interfaccia
1033 standard di \capref{sec:file_unix_interface}. Il problema è che una volta che
1034 si è mappato un file, le operazioni di lettura e scrittura saranno eseguite
1035 sulla memoria, e riportate su disco in maniera autonoma dal sistema della
1038 Pertanto se si modifica un file con l'interfaccia standard queste modifiche
1039 potranno essere visibili o meno a seconda del momento in cui la memoria
1040 virtuale leggerà dal disco in memoria quella sezione del file, ed è del tutto
1041 indefinito quale può essere il contenuto della memoria mappata. È però
1042 possibile usare la funzione \func{msync} per sincronizzare il contenuto della
1043 memoria con il file su disco; il suo prototipo è:
1046 \headdecl{sys/mman.h}
1048 \funcdecl{int msync(const void *start, size\_t length, int flags)}
1050 Sincronizza i contenuti di una sezione di un file mappato in memoria.
1052 \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
1053 errore nel qual caso \var{errno} viene settata ai valori:
1055 \item[\macro{EINVAL}] O \param{start} non è multiplo di \macro{PAGESIZE},
1056 o si è specificato un valore non valido per \param{flags}.
1057 \item[\macro{EFAULT}] Il range specificato non ricade in una zona
1058 precedentemente mappata.
1063 La funzione esegue la sincronizzazione su file di quanto scritto nella sezione
1064 di memoria indicata da \param{start} e \param{offset}. Provvede anche ad
1065 aggiornare i relativi tempi di modifica; in questo modo le funzioni
1066 dell'interfaccia standard potranno accedere al contenuto aggiornato.
1068 L'argomento \param{flag} è specificato come maschera binaria composta da un OR
1069 dei valori riportati in \tabref{tab:file_mmap_rsync}, di questi però
1070 \macro{MS\_ASYNC} e \macro{MS\_SYNC} sono incompatibili; con il primo valore
1071 infatti la funzione si limita ad inoltrare la richiesta di sincronizzazione al
1072 meccanismo della memoria virtuale, ritornando subito, mentre con il secondo
1073 attende che la sincronizzazione sia stata effettivamente eseguita. Il terzo
1074 flag fa invalidare le pagine di cui si richiede la sincronizzazione per tutte
1075 le mappature dello stesso file, così che esse possano essere immediatamente
1076 aggiornate ai nuovi valori.
1081 \begin{tabular}[c]{|l|l|}
1083 \textbf{Valore} & \textbf{Significato} \\
1086 \macro{MS\_ASYNC} & Richiede la sincronizzazione.\\
1087 \macro{MS\_SYNC} & Attende che la sincronizzazione si eseguita.\\
1088 \macro{MS\_INVALIDATE}& Richiede che le altre mappature dello stesso file
1092 \caption{Valori dell'argomento \param{flag} di \func{msync}.}
1093 \label{tab:file_mmap_rsync}
1096 Una volta completate le operazioni di I/O si può eliminare la mappatura della
1097 memoria usando la funzione \func{munmap}, il cui prototipo è:
1100 \headdecl{sys/mman.h}
1102 \funcdecl{int munmap(void *start, size\_t length)}
1104 Rilascia la mappatura sulla sezione di memoria specificata.
1106 \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
1107 errore nel qual caso \var{errno} viene settata ai valori:
1109 \item[\macro{EINVAL}] Il range specificato non ricade in una zona
1110 precedentemente mappata.
1118 \section{Il file locking}
1119 \label{sec:file_locking}
1121 In \secref{sec:file_sharing} abbiamo preso in esame le modalità in cui un
1122 sistema unix-like gestisce la condivisione dei file da parte di processi
1123 diversi. In quell'occasione si è visto come, con l'eccezione dei file aperti
1124 in \textit{append mode}, quando più processi scrivono contemporaneamente sullo
1125 stesso file non è possibile determinare la sequenza in cui essi opereranno.
1127 Questo causa la possibilità di race condition\index{race condition}; in
1128 generale le situazioni più comuni sono due: l'interazione fra un processo che
1129 scrive e altri che leggono, in cui questi ultimi possono leggere informazioni
1130 scritte solo in maniera parziale o incompleta; o quella in cui diversi
1131 processi scrivono, mescolando in maniera imprevedibile il loro output sul
1134 In tutti questi casi il \textit{file locking} è la tecnica che permette di
1135 evitare le race condition, attraverso una serie di funzioni che permettono di
1136 bloccare l'accesso al file da parte di altri processi, così da evitare le
1137 sovrapposizioni, e garantire la atomicità delle operazioni di scrittura.
1140 \subsection{L'\textit{advisory locking}}
1141 \label{sec:file_record_locking}
1143 La prima modalità di file locking che è stata implementata nei sistemi
1144 unix-like è quella che viene usualmente chiamata \textit{advisory locking}, in
1145 quanto è il processo, e non il sistema, che si incarica di verificare se
1146 esiste una condizione di blocco per l'accesso ai file.
1151 \subsection{Il \textit{mandatory locking}}
1152 \label{sec:file_mand_locking}
1154 Il \textit{mandatory locking} è una opzione introdotta inizialmente in SVr4,
1160 %%% Local Variables:
1162 %%% TeX-master: "gapil"