Ricominciato coi process group
[gapil.git] / fileadv.tex
1 \chapter{La gestione avanzata dei file}
2 \label{cha:file_advanced}
3
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
8   locking}.
9
10
11 \section{Le funzioni di I/O avanzato}
12 \label{sec:file_advanced_io}
13
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
17 mappato in memoria.
18
19
20 \subsection{La modalità di I/O \textsl{non-bloccante}}
21 \label{sec:file_noblocking}
22
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.
30
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.
37
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}.
44
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
53 bloccante.
54
55
56
57 \subsection{L'I/O multiplexing}
58 \label{sec:file_multiplexing}
59
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 è:
69 \begin{functions}
70   \headdecl{sys/time.h}
71   \headdecl{sys/types.h}
72   \headdecl{unistd.h}
73   \funcdecl{int select(int n, fd\_set *readfds, fd\_set *writefds, fd\_set
74     *exceptfds, struct timeval *timeout)}
75   
76   Attende che uno dei file descriptor degli insiemi specificati diventi
77   attivo.
78   
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 impostata ai valori:
82   \begin{errlist}
83   \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
84   degli insiemi.
85   \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
86   \item[\macro{EINVAL}] Si è specificato per \param{n} un valore negativo.
87   \end{errlist}
88   ed inoltre \macro{ENOMEM}.
89 }
90 \end{functions}
91
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
96 \param{timeout}.
97
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:
105 \begin{functions}
106   \headdecl{sys/time.h}
107   \headdecl{sys/types.h}
108   \headdecl{unistd.h}
109   \funcdecl{FD\_ZERO(fd\_set *set)}
110   Inizializza l'insieme (vuoto).
111
112   \funcdecl{FD\_SET(int fd, fd\_set *set)}
113   Inserisce il file descriptor \param{fd} nell'insieme.
114
115   \funcdecl{FD\_CLR(int fd, fd\_set *set)}
116   Rimuove il file descriptor \param{fd} nell'insieme.
117   
118   \funcdecl{FD\_ISSET(int fd, fd\_set *set)}
119   Controlla se il file descriptor \param{fd} è nell'insieme.
120 \end{functions}
121
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
128   descriptor set}.
129
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}).
136
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.
141
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 impostato a \macro{NULL} la funzione attende
145 indefinitamente. Si può specificare anche un tempo nullo (cioè una \var{struct
146   timeval} con i campi impostati a zero), qualora si voglia semplicemente
147 controllare lo stato corrente dei file descriptor.
148
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
154 non vengono toccati.
155
156 In Linux \func{select} modifica anche il valore di \param{timeout},
157 impostandolo al tempo restante; questo è utile quando la funzione viene
158 interrotta da un segnale, in tal caso infatti si ha un errore di
159 \macro{EINTR}, ed occorre rilanciare la funzione; in questo modo non è
160 necessario ricalcolare tutte le volte il tempo rimanente.\footnote{questo può
161   causare problemi di portabilità sia quando si trasporta codice scritto su
162   Linux che legge questo valore, sia quando si usano programmi scritti per
163   altri sistemi che non dispongono di questa caratteristica e ricalcolano
164   \param{timeout} tutte le volte. In genere la caratteristica è disponibile
165   nei sistemi che derivano da System V e non disponibile per quelli che
166   derivano da BSD.}
167
168 Come accennato l'interfaccia di \func{select} è una estensione di BSD; anche
169 System V ha introdotto una sua interfaccia per gestire l'\textit{I/O
170   multiplexing}, basata sulla funzione \func{poll},\footnote{la funzione è
171   prevista dallo standard XPG4, ed è stata introdotta in Linux come system
172   call a partire dal kernel 2.1.23 e dalle \acr{libc} 5.4.28.} il cui prototipo è:
173 \begin{prototype}{sys/poll.h}
174   {int poll(struct pollfd *ufds, unsigned int nfds, int timeout)}
175
176 La funzione attente un cambiamento di stato per uno dei file descriptor
177 specificati da \param{ufds}.
178   
179 \bodydesc{La funzione restituisce il numero di file descriptor con attività in
180   caso di successo, o 0 se c'è stato un timeout; in caso di errore viene
181   restituito  -1 ed \var{errno} viene impostata ai valori:
182   \begin{errlist}
183   \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
184   degli insiemi.
185   \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
186   \end{errlist}
187   ed inoltre \macro{EFAULT} e \macro{ENOMEM}.}
188 \end{prototype}
189
190 La funzione tiene sotto controllo un numero \param{ndfs} di file descriptor
191 specificati attraverso un vettore di puntatori a strutture di tipo
192 \type{pollfd}, la cui definizione è riportata in \figref{fig:file_pollfd}.
193 Come \func{select} anche \func{poll} permette di interrompere l'attesa dopo un
194 certo tempo, che va specificato attraverso \param{timeout} in numero di
195 millisecondi (un valore negativo indica un'attesa indefinita).
196
197 \begin{figure}[!htb]
198   \footnotesize \centering
199   \begin{minipage}[c]{15cm}
200     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
201 struct pollfd {
202         int fd;           /* file descriptor */
203         short events;     /* requested events */
204         short revents;    /* returned events */
205 };
206     \end{lstlisting}
207   \end{minipage} 
208   \normalsize 
209   \caption{La struttura \type{pollfd}, utilizzata per specificare le modalità
210     di controllo di un file descriptor alla funzione \func{poll}.}
211   \label{fig:file_pollfd}
212 \end{figure}
213
214 Per ciascun file da controllare deve essere opportunamente predisposta una
215 struttura \type{pollfd}; nel campo \var{fd} deve essere specificato il file
216 descriptor, mentre nel campo \var{events} il tipo di evento su cui si vuole
217 attendere; quest'ultimo deve essere specificato come maschera binaria dei
218 primi tre valori riportati in \tabref{tab:file_pollfd_flags} (gli altri
219 vengono utilizzati solo per \var{revents} come valori in uscita).
220
221 \begin{table}[htb]
222   \centering
223   \footnotesize
224   \begin{tabular}[c]{|l|c|l|}
225     \hline
226     \textbf{Flag} & \textbf{Valore} & \textbf{Significato} \\
227     \hline
228     \hline
229     \macro{POLLIN}    & 0x001 & È possibile la lettura immediata.\\
230     \macro{POLLPRI}   & 0x002 & Sono presenti dati urgenti.\\
231     \macro{POLLOUT}   & 0x004 & È possibile la scrittura immediata.\\
232     \hline
233     \macro{POLLERR}   & 0x008 & C'è una condizione di errore.\\
234     \macro{POLLHUP}   & 0x010 & Si è verificato un hung-up.\\
235     \macro{POLLNVAL}  & 0x020 & Il file descriptor non è aperto.\\
236     \hline
237     \macro{POLLRDNORM}& 0x040 & Sono disponibili in lettura dati normali.\\ 
238     \macro{POLLRDBAND}& 0x080 & Sono disponibili in lettura dati ad alta 
239                                 priorità. \\
240     \macro{POLLWRNORM}& 0x100 & È possibile la scrittura di dati normali.  \\ 
241     \macro{POLLWRBAND}& 0x200 & È possibile la scrittura di dati ad 
242                                 alta priorità. \\
243     \macro{POLLMSG}   & 0x400 & Estensione propria di Linux.\\
244     \hline    
245   \end{tabular}
246   \caption{Costanti per l'identificazione dei vari bit dei campi
247     \var{events} e \var{revents} di \type{pollfd}.}
248   \label{tab:file_pollfd_flags}
249 \end{table}
250
251 La funzione ritorna, restituendo il numero di file per i quali si è verificata
252 una delle condizioni di attesa richieste od un errore. Lo stato dei file
253 all'uscita della funzione viene restituito nel campo \var{revents} della
254 relativa struttura \type{pollfd}, che viene impostato alla maschera binaria
255 dei valori riportati in \tabref{tab:file_pollfd_flags}, ed oltre alle tre
256 condizioni specificate tramite \var{events} può riportare anche l'occorrere di
257 una condizione di errore.
258
259 Lo standard POSIX è rimasto a lungo senza primitive per l'\textit{I/O
260   multiplexing}, che è stata introdotto con le ultime revisioni dello standard
261 (POSIX 1003.1g-2000 e POSIX 1003.1-2001). Esso prevede che tutte le funzioni
262 ad esso relative vengano dichiarate nell'header \file{sys/select.h}, che
263 sostituisce i precedenti, ed aggiunge a \func{select} una nuova funzione
264 \func{pselect},\footnote{il supporto per lo standard POSIX 1003.1-2001, ed
265   l'header \file{sys/select.h}, compaiono in Linux a partire dalle \acr{glibc}
266   2.1. Le \acr{libc4} e \acr{libc5} non contengono questo header, le
267   \acr{glibc} 2.0 contengono una definizione sbagliata di \func{psignal},
268   senza l'argomento \param{sigmask}, la definizione corretta è presente dalle
269   \acr{glibc} 2.1-2.2.1 se si è definito \macro{\_GNU\_SOURCE} e nelle
270   \acr{glibc} 2.2.2-2.2.4 se si è definito \macro{\_XOPEN\_SOURCE} con valore
271   maggiore di 600.} il cui prototipo è:
272 \begin{prototype}{sys/select.h}
273   {int pselect(int n, fd\_set *readfds, fd\_set *writefds, fd\_set *exceptfds,
274     struct timespec *timeout, sigset\_t *sigmask)}
275   
276   Attende che uno dei file descriptor degli insiemi specificati diventi
277   attivo.
278   
279   \bodydesc{La funzione in caso di successo restituisce il numero di file
280     descriptor (anche nullo) che sono attivi, e -1 in caso di errore, nel qual
281     caso \var{errno} viene impostata ai valori:
282   \begin{errlist}
283   \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
284   degli insiemi.
285   \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
286   \item[\macro{EINVAL}] Si è specificato per \param{n} un valore negativo.
287   \end{errlist}
288   ed inoltre \macro{ENOMEM}.}
289 \end{prototype}
290
291 La funzione è sostanzialmente identica a \func{select}, solo che usa una
292 struttura \type{timespec} per indicare con maggiore precisione il timeout e
293 non ne aggiorna il valore in caso di interruzione, inoltre prende un argomento
294 aggiuntivo \param{sigmask} che è il puntatore ad una maschera di segnali (si
295 veda \secref{sec:sig_sigmask}). La maschera corrente viene sostituita da
296 questa immediatamente prima di eseguire l'attesa, e ripristinata al ritorno
297 della funzione.
298
299 L'uso di \param{sigmask} è stato introdotto allo scopo di prevenire possibili
300 race condition\footnote{in Linux però, non esistendo una system call apposita,
301   la funzione è implementata nelle \acr{glibc} usando \func{select}, e la
302   possibilità di una race condition resta.} quando si deve eseguire un test su
303 una variabile assegnata da un manipolatore sulla base dell'occorrenza di un
304 segnale per decidere se lanciare \func{select}. Fra il test e l'esecuzione è
305 presente una finestra in cui potrebbe arrivare il segnale che non sarebbe
306 rilevato; la race condition diventa superabile disabilitando il segnale prima
307 del test e riabilitandolo poi grazie all'uso di \param{sigmask}.
308
309
310
311 \subsection{L'\textsl{I/O asincrono}}
312 \label{sec:file_asyncronous_io}
313
314 Una modalità alternativa all'uso dell'\textit{I/O multiplexing} è quella di
315 fare ricorso al cosiddetto \textsl{I/O asincrono}. Il concetto base
316 dell'\textsl{I/O asincrono} è che le funzioni di I/O non attendono il
317 completamento delle operazioni prima di ritornare, così che il processo non
318 viene bloccato.  In questo modo diventa ad esempio possibile effettuare una
319 richiesta preventiva di dati, in modo da poter effettuare in contemporanea le
320 operazioni di calcolo e quelle di I/O.
321
322 Abbiamo accennato in \secref{sec:file_open} che è possibile, attraverso l'uso
323 del flag \macro{O\_ASYNC},\footnote{l'uso del flag di \macro{O\_ASYNC} e dei
324   comandi \macro{F\_SETOWN} e \macro{F\_GETOWN} per \func{fcntl} è specifico
325   di Linux e BSD.} aprire un file in modalità asincrona, così come è possibile
326 attivare in un secondo tempo questa modalità impostando questo flag attraverso
327 l'uso di \func{fcntl} con il comando \macro{F\_SETFL} (vedi
328 \secref{sec:file_fcntl}).
329
330 In realtà in questo caso non si tratta di I/O asincrono vero e proprio, quanto
331 di un meccanismo asincrono di notifica delle variazione dello stato del file
332 descriptor; quello che succede è che il sistema genera un segnale (normalmente
333 \macro{SIGIO}, ma è possibile usarne altri) tutte le volte che diventa
334 possibile leggere o scrivere dal file descriptor che si è posto in questa
335 modalità. Si può inoltre selezionare, con il comando \macro{F\_SETOWN} di
336 \func{fcntl}, quale processo (o gruppo di processi) riceverà il segnale. 
337
338 In questo modo si può evitare l'uso delle funzioni \func{poll} o \func{select}
339 che, quando vengono usate con un numero molto grande di file descriptor, non
340 hanno buone prestazioni. In tal caso infatti la maggior parte del loro tempo
341 di esecuzione è impegnato ad eseguire una scansione su tutti i file descriptor
342 tenuti sotto controllo per determinare quali di essi (in genere una piccola
343 percentuale) sono diventati attivi.
344
345 Tuttavia con l'implementazione classica dei segnali questa modalità di I/O
346 presenta notevoli problemi, dato che non è possibile determinare, quando sono
347 più di uno, qual'è il file descriptor responsabile dell'emissione del segnale.
348 Linux però supporta le estensioni POSIX.1b dei segnali che permettono di
349 superare il problema facendo ricorso alle informazioni aggiuntive restituite
350 attraverso la struttura \type{siginfo\_t}, utilizzando la forma estesa
351 \var{sa\_sigaction} del manipolatore (si riveda quanto illustrato in
352 \secref{sec:sig_sigaction}).
353
354 Per far questo però occorre utilizzare le funzionalità dei segnali real-time
355 (vedi \secref{sec:sig_real_time}) imopstando esplicitamente con il comando
356 \macro{F\_SETSIG} di \func{fcntl} un segnale real-time da inviare in caso di
357 I/O asincrono (il segnale predefinito è \macro{SIGIO}). In questo caso il
358 manipolatore tutte le volte che riceverà \macro{SI\_SIGIO} come valore del
359 campo \var{si\_code}\footnote{il valore resta \macro{SI\_SIGIO} qualunque sia
360   il segnale che si è associato all'I/O asincrono, ed indica appunto che il
361   segnale è stato generato a causa di attività nell'I/O asincrono.} di
362 \type{siginfo\_t}, troverà nel campo \var{si\_fd} il valore del file
363 descriptor che ha generato il segnale.
364
365 Un secondo vantaggio dell'uso dei segnali real-time è che essendo dotati di
366 una coda di consegna ogni segnale sarà associato ad uno solo file descriptor;
367 inoltre sarà possibile stabilire delle priorità nella risposta a seconda del
368 segnale usato. In questo modo si può identificare immediatamente un file su
369 cui l'accesso è diventato possibile evitando completamente l'uso di funzioni
370 come \func{poll} e \func{select}, almeno fintanto che non si satura la coda;
371 si eccedono le dimensioni di quest'ultima; in tal caso infatti il kernel, non
372 potendo più assicurare il comportamento corretto per un segnale real-time,
373 invierà al suo posto un \var{SIGIO}, su cui si accumuleranno tutti i segnali
374 in eccesso, e si dovrà determinare al solito modo quali sono i file diventati
375 attivi.
376
377 Benché la modalità di apertura asincrona di un file possa risultare utile in
378 varie occasioni (in particolar modo con i socket e gli altri file per i quali
379 le funzioni di I/O sono system call lente), essa è comunque limitata alla
380 notifica della disponibilità del file descriptor per le operazioni di I/O, e
381 non ad uno svolgimento asincrono delle medesime.  Lo standard POSIX.1b
382 definisce anche una interfaccia apposita per l'I/O asincrono, che prevede un
383 insieme di funzioni dedicate, completamente separate rispetto a quelle usate
384 normalmente.
385
386 In generale questa interfaccia è completamente astratta e può essere
387 implementata sia direttamente nel kernel, che in user space attraverso l'uso
388 di thread. Al momento\footnote{fino ai kernel della serie 2.4.x, nella serie
389   2.5.x è però iniziato un lavoro completo di riscrittura di tutto il sistema
390   di I/O, che prevede anche l'introduzione di un nuovo layer per l'I/O
391   asincrono (effettuato a partire dal 2.5.32).} esiste una sola versione
392 stabile di questa interfaccia, quella delle \acr{glibc}, che è realizzata
393 completamente in user space.  Esistono comunque vari progetti sperimentali
394 (come il KAIO della SGI, o i patch di Benjamin La Haise) che prevedono un
395 supporto diretto da parte del kernel.
396
397 Lo standard prevede che tutte le operazioni di I/O asincrono siano controllate
398 attraverso l'uso di una apposita struttura \type{aiocb} (il cui nome sta per
399 \textit{asyncronous I/O control block}), che viene passata come argomento a
400 tutte le funzioni dell'interfaccia. La sua definizione, come effettuata in
401 \file{aio.h}, è riportata in \figref{fig:file_aiocb}. Nello steso file è
402 definita la macro \macro{\_POSIX\_ASYNCHRONOUS\_IO}, che dichiara la
403 disponibilità dell'interfaccia per l'I/O asincrono.
404
405 \begin{figure}[!htb]
406   \footnotesize \centering
407   \begin{minipage}[c]{15cm}
408     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
409 struct aiocb
410 {
411     int aio_fildes;               /* File descriptor.  */
412     off_t aio_offset;             /* File offset */
413     int aio_lio_opcode;           /* Operation to be performed.  */
414     int aio_reqprio;              /* Request priority offset.  */
415     volatile void *aio_buf;       /* Location of buffer.  */
416     size_t aio_nbytes;            /* Length of transfer.  */
417     struct sigevent aio_sigevent; /* Signal number and value.  */
418 };
419     \end{lstlisting}
420   \end{minipage} 
421   \normalsize 
422   \caption{La struttura \type{aiocb}, usata per il controllo dell'I/O
423     asincrono.}
424   \label{fig:file_aiocb}
425 \end{figure}
426
427 Le operazioni di I/O asincrono possono essere effettuate solo su un file già
428 aperto; il file deve inoltre supportare la funzione \func{lseek},
429 pertanto terminali e pipe sono esclusi. Non c'è limite al numero di operazioni
430 contemporanee effettuabili su un singolo file.
431
432 Ogni operazione deve inizializzare opportunamente un \textit{control block}.
433 Il file descriptor su cui operare deve essere specificato tramite il campo
434 \var{aio\_fildes}; dato che più operazioni possono essere eseguita in maniera
435 asincrona, il concetto di posizione corrente sul file viene a mancare;
436 pertanto si deve sempre specificare nel campo \var{aio\_offset} la posizione
437 sul file da cui i dati saranno letti o scritti.  Nel campo \var{aio\_buf} deve
438 essere specificato l'indirizzo del buffer usato per l'I/O, ed in
439 \var{aio\_nbytes} la lunghezza del blocco di dati da trasferire.
440
441 Il campo \var{aio\_reqprio} permette di impostare la priorità delle operazioni
442 di I/O.\footnote{in generale perché ciò sia possibile occorre che la
443   piattaforma supporti questa caratteristica, questo viene indicato definendo
444   le macro \macro{\_POSIX\_PRIORITIZED\_IO}, e
445   \macro{\_POSIX\_PRIORITY\_SCHEDULING}.} La priorità viene impostata a
446 partire da quella del processo chiamante (vedi \secref{sec:proc_priority}),
447 cui viene sottratto il valore di questo campo.
448
449 Il campo \var{aio\_lio\_opcode} è usato soltanto dalla funzione
450 \func{lio\_listio}, che, come vedremo più avanti, permette di eseguire con una
451 sola chiamata una serie di operazioni, usando un vettore di \textit{control
452   block}. Tramite questo campo si specifica quale è la natura di ciascuna di
453 esse.
454
455 \begin{figure}[!htb]
456   \footnotesize \centering
457   \begin{minipage}[c]{15cm}
458     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
459 struct sigevent
460 {
461     sigval_t sigev_value;
462     int sigev_signo;
463     int sigev_notify;
464     sigev_notify_function;
465     sigev_notify_attributes;
466 };
467     \end{lstlisting}
468   \end{minipage} 
469   \normalsize 
470   \caption{La struttura \type{sigevent}, usata per specificare le modalità di
471     notifica degli eventi relativi alle operazioni di I/O asincrono.}
472   \label{fig:file_sigevent}
473 \end{figure}
474
475 Infine il campo \var{aio\_sigevent} è una struttura di tipo \type{sigevent}
476 che serve a specificare il modo in cui si vuole che venga effettuata la
477 notifica del completamento delle operazioni richieste. La struttura è
478 riportata in \secref{fig:file_sigevent}; il campo \var{sigev\_notify} è quello
479 che indica le modalità della notifica, esso può assumere i tre valori:
480 \begin{basedescript}{\desclabelwidth{3.0cm}}
481 \item[\macro{SIGEV\_NONE}]   Non viene inviata nessuna notifica.
482 \item[\macro{SIGEV\_SIGNAL}] La notifica viene effettuata inviando al processo
483   chiamante il segnale specificato nel campo \var{sigev\_signo}, se il
484   manipolatore è installato con \macro{SA\_SIGINFO}, il gli verrà restituito
485   il valore di \var{sigev\_value} in come valore del campo \var{si\_value} per
486   \type{siginfo\_t}.
487 \item[\macro{SIGEV\_THREAD}] La notifica viene effettuata creando un nuovo
488   thread che esegue la funzione specificata da \var{sigev\_notify\_function},
489   con gli attributi specificati da \var{sigev\_notify\_attribute}.
490 \end{basedescript}
491
492 Le due funzioni base dell'interfaccia per l'I/O asincrono sono
493 \func{aio\_read} ed \func{aio\_write}.  Esse permettono di richiedere una
494 lettura od una scrittura asincrona di dati, usando la struttura \type{aiocb}
495 appena descritta; i rispettivi prototipi sono:
496 \begin{functions}
497   \headdecl{aio.h}
498
499   \funcdecl{int aio\_read(struct aiocb *aiocbp)}
500   Richiede una lettura asincrona secondo quanto specificato con \param{aiocbp}.
501
502   \funcdecl{int aio\_write(struct aiocb *aiocbp)}
503   Richiede una scrittura asincrona secondo quanto specificato con
504   \param{aiocbp}.
505   
506   \bodydesc{Le funzioni restituiscono 0 in caso di successo, e -1 in caso di
507     errore, nel qual caso \var{errno} viene impostata ai valori:
508   \begin{errlist}
509   \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato.
510   \item[\macro{ENOSYS}] La funzione non è implementata.
511   \item[\macro{EINVAL}] Si è specificato un valore non valido per i campi
512     \var{aio\_offset} o \var{aio\_reqprio} di \param{aiocbp}.
513   \item[\macro{EAGAIN}] La coda delle richieste è momentaneamente piena.
514   \end{errlist}
515 }
516 \end{functions}
517
518 Entrambe le funzioni ritornano immediatamente dopo aver messo in coda la
519 richiesta, o in caso di errore. Non è detto che gli errori \macro{EBADF} ed
520 \macro{EINVAL} siano rilevati immediatamente al momento della chiamata,
521 potrebbero anche emergere nelle fasi successive delle operazioni. Lettura e
522 scrittura avvengono alla posizione indicata da \var{aio\_offset}, a meno che
523 il file non sia stato aperto in \textit{append mode} (vedi
524 \secref{sec:file_open}), nel qual caso le scritture vengono effettuate
525 comunque alla fine de file, nell'ordine delle chiamate a \func{aio\_write}.
526
527 Si tenga inoltre presente che deallocare la memoria indirizzata da
528 \param{aiocbp} o modificarne i valori prima della conclusione di una
529 operazione può dar luogo a risultati impredicibili, perché l'accesso ai vari
530 campi per eseguire l'operazione può avvenire in un momento qualsiasi dopo la
531 richiesta.  Questo comporta che occorre evitare di usare per \param{aiocbp}
532 variabili automatiche e che non si deve riutilizzare la stessa struttura per
533 un ulteriore operazione fintanto che la precedente non sia stata ultimata. In
534 generale per ogni operazione di I/O asincrono si deve utilizzare una diversa
535 struttura \type{aiocb}.
536
537 Dato che si opera in modalità asincrona, il successo di \func{aio\_read} o
538 \func{aio\_write} non implica che le operazioni siano state effettivamente
539 eseguite in maniera corretta; per verificarne l'esito l'interfaccia prevede
540 altre due funzioni, che permettono di controllare lo stato di esecuzione. La
541 prima è \func{aio\_error}, che serve a determinare un eventuale stato di
542 errore; il suo prototipo è:
543 \begin{prototype}{aio.h}
544   {int aio\_error(const struct aiocb *aiocbp)}  
545
546   Determina lo stato di errore delle operazioni di I/O associate a
547   \param{aiocbp}.
548   
549   \bodydesc{La funzione restituisce 0 se le operazioni si sono concluse con
550     successo, altrimenti restituisce il codice di errore relativo al loro
551     fallimento.}
552 \end{prototype}
553
554 Se l'operazione non si è ancora completata viene restituito l'errore di
555 \macro{EINPROGRESS}. La funzione ritorna zero quando l'operazione si è
556 conclusa con successo, altrimenti restituisce il codice dell'errore
557 verificatosi, ed esegue la corrispondente impostazione di \var{errno}. Il
558 codice può essere sia \macro{EINVAL} ed \macro{EBADF}, dovuti ad un valore
559 errato per \param{aiocbp}, che uno degli errori possibili durante l'esecuzione
560 dell'operazione di I/O richiesta, nel qual caso saranno restituiti, a seconda
561 del caso, i codici di errore delle system call \func{read}, \func{write} e
562 \func{fsync}.
563
564 Una volta che si sia certi che le operazioni siano state concluse (cioè dopo
565 che una chiamata ad \func{aio\_error} non ha restituito \macro{EINPROGRESS},
566 si potrà usare la seconda funzione dell'interfaccia, \func{aio\_return}, che
567 permette di verificare il completamento delle operazioni di I/O asincrono; il
568 suo prototipo è:
569 \begin{prototype}{aio.h}
570 {ssize\_t aio\_return(const struct aiocb *aiocbp)} 
571
572 Recupera il valore dello stato di ritorno delle operazioni di I/O associate a
573 \param{aiocbp}.
574   
575 \bodydesc{La funzione restituisce lo stato di uscita dell'operazione
576   eseguita.}
577 \end{prototype}
578
579 La funzione deve essere chiamata una sola volte per ciascuna operazione
580 asincrona, essa infatti fa sì che il sistema rilasci le risorse ad essa
581 associate. É per questo motivo che occorre chiamare la funzione solo dopo che
582 l'operazione cui \param{aiocbp} fa riferimento si è completata. Una chiamata
583 precedente il completamento delle operazioni darebbe risultati indeterminati.
584
585 La funzione restituisce il valore di ritorno relativo all'operazione eseguita,
586 così come ricavato dalla sottostante system call (il numero di byte letti,
587 scritti o il valore di ritorno di \func{fsync}).  É importante chiamare sempre
588 questa funzione, altrimenti le risorse disponibili per le operazioni di I/O
589 asincrono non verrebbero liberate, rischiando di arrivare ad un loro
590 esaurimento.
591
592 Oltre alle operazioni di lettura e scrittura l'interfaccia POSIX.1b mette a
593 disposizione un'altra operazione, quella di sincronizzazione dell'I/O, essa è
594 compiuta dalla funzione \func{aio\_fsync}, che ha lo stesso effetto della
595 analoga \func{fsync}, ma viene eseguita in maniera asincrona; il suo prototipo
596 è:
597 \begin{prototype}{aio.h}
598 {ssize\_t aio\_return(int op, struct aiocb *aiocbp)} 
599
600 Richiede la sincronizzazione dei dati per il file indicato da \param{aiocbp}.
601   
602 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
603   errore, che può essere, con le stesse modalità di \func{aio\_read},
604   \macro{EAGAIN}, \macro{EBADF} o \macro{EINVAL}.}
605 \end{prototype}
606
607 La funzione richiede la sincronizzazione delle operazioni di I/O, ritornando
608 immediatamente. L'esecuzione effettiva della sincronizzazione dovrà essere
609 verificata con \func{aio\_error} e \func{aio\_return} come per le operazioni
610 di lettura e scrittura. L'argomento \param{op} permette di indicare la
611 modalità di esecuzione, se si specifica il valore \macro{O\_DSYNC} le
612 operazioni saranno completate con una chiamata a \func{fdatasync}, se si
613 specifica \macro{O\_SYNC} con una chiamata a \func{fsync} (per i dettagli vedi
614 \secref{sec:file_sync}).
615
616 Il successo della chiamata assicura la sincronizzazione delle operazioni fino
617 allora richieste, niente è garantito riguardo la sincronizzazione dei dati
618 relativi ad eventuali operazioni richieste successivamente. Se si è
619 specificato un meccanismo di notifica questo sarà innescato una volta che le
620 operazioni di sincronizzazione dei dati saranno completate.
621
622 In alcuni casi può essere necessario interrompere le operazioni (in genere
623 quando viene richiesta un'uscita immediata dal programma), per questo lo
624 standard POSIX.1b prevede una funzioni apposita, \func{aio\_cancel}, che
625 permette di cancellare una operazione richiesta in precedenza; il suo
626 prototipo è:
627 \begin{prototype}{aio.h}
628 {int aio\_cancel(int fildes, struct aiocb *aiocbp)} 
629
630 Richiede la cancellazione delle operazioni sul file \param{fildes} specificate
631 da \param{aiocbp}.
632   
633 \bodydesc{La funzione restituisce il risultato dell'operazione con un codice
634   di positivo, e -1 in caso di errore, che avviene qualora si sia specificato
635   un valore non valido di \param{fildes}, imposta \var{errno} al valore
636   \macro{EBADF}.}
637 \end{prototype}
638
639 La funzione permette di cancellare una operazione specifica sul file
640 \param{fildes}, o tutte le operazioni pendenti, specificando \macro{NULL} come
641 valore di \param{aiocbp}.  Quando una operazione viene cancellata una
642 successiva chiamata ad \func{aio\_error} riporterà \macro{ECANCELED} come
643 codice di errore, ed il suo codice di ritorno sarà -1, inoltre il meccanismo
644 di notifica non verrà invocato. Se si specifica una operazione relativa ad un
645 altro file descriptor il risultato è indeterminato.
646
647 In caso di successo, i possibili valori di ritorno per \func{aio\_cancel} sono
648 tre (anch'essi definiti in \file{aio.h}):
649 \begin{basedescript}{\desclabelwidth{3.0cm}}
650 \item[\macro{AIO\_ALLDONE}] indica che le operazioni di cui si è richiesta la
651   cancellazione sono state già completate,
652   
653 \item[\macro{AIO\_CANCELED}] indica che tutte le operazioni richieste sono
654   state cancellate,  
655   
656 \item[\macro{AIO\_NOTCANCELED}] indica che alcune delle operazioni erano in
657   corso e non sono state cancellate.
658 \end{basedescript}
659
660 Nel caso si abbia \macro{AIO\_NOTCANCELED} occorrerà chiamare
661 \func{aio\_error} per determinare quali sono le operazioni effettivamente
662 cancellate. Le operazioni che non sono state cancellate proseguiranno il loro
663 corso normale, compreso quanto richiesto riguardo al meccanismo di notifica
664 del loro avvenuto completamento.
665
666 Benché l'I/O asincrono preveda un meccanismo di notifica, l'interfaccia
667 fornisce anche una apposita funzione, \func{aio\_suspend}, che permette di
668 sospendere l'esecuzione del processo chiamante fino al completamento di una
669 specifica operazione; il suo prototipo è:
670 \begin{prototype}{aio.h}
671 {int aio\_suspend(const struct aiocb * const list[], int nent, const struct
672     timespec *timeout)}
673   
674   Attende, per un massimo di \param{timeout}, il completamento di una delle
675   operazioni specificate da \param{list}.
676   
677   \bodydesc{La funzione restituisce 0 se una (o più) operazioni sono state
678     completate, e -1 in caso di errore nel qual caso \var{errno} viene
679     impostata ai valori:
680     \begin{errlist}
681     \item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
682       \param{timeout}.
683     \item[\macro{ENOSYS}] La funzione non è implementata.
684     \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
685     \end{errlist}
686   }
687 \end{prototype}
688
689 La funzione permette di bloccare il processo fintanto che almeno una delle
690 \param{nent} operazioni specificate nella lista \param{list} è completata, per
691 un tempo massimo specificato da \param{timout}, o fintanto che non arrivi un
692 segnale.\footnote{si tenga conto che questo segnale può anche essere quello
693   utilizzato come meccanismo di notifica.} La lista deve essere inizializzata
694 con delle strutture \var{aiocb} relative ad operazioni effettivamente
695 richieste, ma può contenere puntatori nulli, che saranno ignorati. In caso si
696 siano specificati valori non validi l'effetto è indefinito.  Un valore
697 \macro{NULL} per \param{timout} comporta l'assenza di timeout.
698
699 Lo standard POSIX.1b infine ha previsto pure una funzione, \func{lio\_listio},
700 che permette di effettuare la richiesta di una intera lista di operazioni di
701 lettura o scrittura; il suo prototipo è:
702 \begin{prototype}{aio.h}
703   {int lio\_listio(int mode, struct aiocb * const list[], int nent, struct
704     sigevent *sig)}
705   
706   Richiede l'esecuzione delle operazioni di I/O elencata da \param{list},
707   secondo la modalità \param{mode}.
708   
709   \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
710     errore, nel qual caso \var{errno} viene impostata ai valori:
711     \begin{errlist}
712     \item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
713       \param{timeout}.
714     \item[\macro{ENOSYS}] La funzione non è implementata.
715     \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
716     \end{errlist}
717   }
718 \end{prototype}
719
720 La funzione esegue la richiesta delle \param{nent} operazioni indicate dalla
721 lista \param{list}; questa deve contenere gli indirizzi di altrettanti
722 \textit{control block}, opportunamente inizializzati; in particolare nel caso
723 dovrà essere specificato il tipo di operazione tramite il campo
724 \var{aio\_lio\_opcode}, che può prendere i tre valori:
725 \begin{basedescript}{\desclabelwidth{2.0cm}}
726 \item[\macro{LIO\_READ}]  si richiede una operazione di lettura.
727 \item[\macro{LIO\_WRITE}] si richiede una operazione di scrittura.
728 \item[\macro{LIO\_NOP}] non si effettua nessuna operazione.
729 \end{basedescript}
730 l'ultimo valore viene usato quando si ha a che fare con un vettore di
731 dimensione fissa, per poter specificare solo alcune operazioni, o quando si è
732 dovuto cancellare delle operazioni e si deve ripetere la richiesta per quelle
733 non completate.
734
735 L'argomento \param{mode} permette di stabilire il comportamento della
736 funzione, se viene specificato il valore \macro{LIO\_WAIT} la funzione si
737 blocca fino al completamento di tutte le operazioni richieste; se invece si
738 specifica \macro{LIO\_NOWAIT} la funzione ritorna immediatamente dopo aver
739 messo in coda tutte le richieste. In questo caso il chiamante può richiedere
740 la notifica del completamento di tutte le richieste, impostando l'argomento
741 \param{sig} in maniera analoga a come si fa per il campo \var{aio\_sigevent}
742 di \type{aiocb}.
743
744
745
746 \subsection{I/O vettorizzato}
747 \label{sec:file_multiple_io}
748
749 Un caso abbastanza comune è quello in cui ci si trova a dover eseguire una
750 serie multipla di operazioni di I/O, come una serie di letture o scritture di
751 vari buffer. Un esempio tipico è quando i dati sono strutturati nei campi di
752 una struttura ed essi devono essere caricati o salvati su un file.  Benché
753 l'operazione sia facilmente eseguibile attraverso una serie multipla di
754 chiamate, ci sono casi in cui si vuole poter contare sulla atomicità delle
755 operazioni.
756
757 Per questo motivo BSD 4.2\footnote{Le due funzioni sono riprese da BSD4.4 ed
758   integrate anche dallo standard Unix 98; fino alle libc5 Linux usava
759   \type{size\_t} come tipo dell'argomento \param{count}, una scelta logica,
760   che però è stata dismessa per restare aderenti allo standard.} ha introdotto
761 due nuove system call, \func{readv} e \func{writev}, che permettono di
762 effettuare con una sola chiamata una lettura o una scrittura su una serie di
763 buffer (quello che viene chiamato \textsl{I/O vettorizzato}. I relativi
764 prototipi sono:
765 \begin{functions}
766   \headdecl{sys/uio.h}
767   
768   \funcdecl{int readv(int fd, const struct iovec *vector, int count)} Esegue
769   una lettura vettorizzata da \param{fd} nei \param{count} buffer specificati
770   da \param{vector}.
771   
772   \funcdecl{int writev(int fd, const struct iovec *vector, int count)} Esegue
773   una scrittura vettorizzata da \param{fd} nei \param{count} buffer
774   specificati da \param{vector}.
775   
776   \bodydesc{Le funzioni restituiscono il numero di byte letti o scritti in
777     caso di successo, e -1 in caso di errore, nel qual caso \var{errno} viene
778     impostata ai valori:
779   \begin{errlist}
780   \item[\macro{EBADF}] si è specificato un file descriptor sbagliato.
781   \item[\macro{EINVAL}] si è specificato un valore non valido per uno degli
782     argomenti (ad esempio \param{count} è maggiore di \macro{MAX\_IOVEC}).
783   \item[\macro{EINTR}] la funzione è stata interrotta da un segnale prima di
784     di avere eseguito una qualunque lettura o scrittura.
785   \item[\macro{EAGAIN}] \param{fd} è stato aperto in modalità non bloccante e
786   non ci sono dati in lettura.
787   \item[\macro{EOPNOTSUPP}] La coda delle richieste è momentaneamente piena.
788   \end{errlist}
789   ed inoltre \macro{EISDIR}, \macro{ENOMEM}, \macro{EFAULT} (se non sono stato
790   allocati correttamente i buffer specificati nei campi \func{iov\_base}), più
791   tutti gli ulteriori errori che potrebbero avere le usuali funzioni di
792   lettura e scrittura eseguite su \param{fd}.}
793 \end{functions}
794
795 Entrambe le funzioni usano una struttura \type{iovec}, definita in
796 \figref{fig:file_iovec}, che definisce dove i dati devono essere letti o
797 scritti. Il primo campo, \var{iov\_base}, contiene l'indirizzo del buffer ed
798 il secondo, \var{iov\_len}, la dimensione dello stesso. 
799
800 \begin{figure}[!htb]
801   \footnotesize \centering
802   \begin{minipage}[c]{15cm}
803     \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
804 struct iovec {
805     __ptr_t iov_base;    /* Starting address */
806     size_t iov_len;      /* Length in bytes  */
807 };
808     \end{lstlisting}
809   \end{minipage} 
810   \normalsize 
811   \caption{La struttura \type{iovec}, usata dalle operazioni di I/O
812     vettorizzato.} 
813   \label{fig:file_iovec}
814 \end{figure}
815
816 I buffer da utilizzare sono indicati attraverso l'argomento \param{vector} che
817 è un vettore di strutture \var{iovec}, la cui lunghezza è specificata da
818 \param{count}.  Ciascuna struttura dovrà essere inizializzata per
819 opportunamente per indicare i vari buffer da/verso i quali verrà eseguito il
820 trasferimento dei dati. Essi verranno letti (o scritti) nell'ordine in cui li
821 si sono specificati nel vattore \var{vector}.
822
823
824 \subsection{File mappati in memoria}
825 \label{sec:file_memory_map}
826
827 Una modalità alternativa di I/O, che usa una interfaccia completamente diversa
828 rispetto a quella classica vista in \capref{cha:file_unix_interface}, è il
829 cosiddetto \textit{memory-mapped I/O}, che, attraverso il meccanismo della
830 \textsl{paginazione}\index{paginazione} usato dalla memoria virtuale (vedi
831 \secref{sec:proc_mem_gen}), permette di \textsl{mappare} il contenuto di un
832 file in una sezione dello spazio di indirizzi del processo. Il meccanismo è
833 illustrato in \figref{fig:file_mmap_layout}, una sezione del file viene
834 riportata direttamente nello spazio degli indirizzi del programma. Tutte le
835 operazioni su questa zona verranno riportate indietro sul file dal meccanismo
836 della memoria virtuale che trasferirà il contenuto di quel segmento sul file
837 invece che nella swap, per cui si può parlare tanto di file mappato in
838 memoria, quanto di memoria mappata su file.
839
840 \begin{figure}[htb]
841   \centering
842   \includegraphics[width=9.5cm]{img/mmap_layout}
843   \caption{Disposizione della memoria di un processo quando si esegue la
844   mappatuara in memoria di un file.}
845   \label{fig:file_mmap_layout}
846 \end{figure}
847
848 Tutto questo comporta una notevole semplificazione delle operazioni di I/O, in
849 quanto non sarà più necessario utilizzare dei buffer intermedi su cui
850 appoggiare i dati da traferire, ma questi potranno essere acceduti
851 direttamente nella sezione di memoria mappata; inoltre questa interfaccia è
852 più efficiente delle usuali funzioni di I/O, in quanto permette di caricare in
853 memoria solo le parti del file che sono effettivamente usate ad un dato
854 istante.
855
856 Infatti, dato che l'accesso è fatto direttamente attraverso la memoria
857 virtuale, la sezione di memoria mappata su cui si opera sarà a sua volta letta
858 o scritta sul file una pagina alla volta e solo per le parti effettivamente
859 usate, il tutto in maniera completamente trasparente al processo; l'accesso
860 alle pagine non ancora caricate avverrà allo stesso modo con cui vengono
861 caricate in memoria le pagine che sono state salvate sullo swap.
862
863 Infine in situazioni in cui la memoria è scarsa, le pagine che mappano un
864 file vengono salvate automaticamente, così come le pagine dei programmi
865 vengono scritte sulla swap; questo consente di accedere ai file su dimensioni
866 il cui solo limite è quello dello spazio di indirizzi disponibile, e non della
867 memoria su cui possono esserne lette delle porzioni.
868
869 L'interfaccia prevede varie funzioni per la gestione del \textit{memory mapped
870   I/O}, la prima di queste è \func{mmap}, che serve ad eseguire la mappatura
871 in memoria di un file; il suo prototipo è:
872 \begin{functions}
873   
874   \headdecl{unistd.h}
875   \headdecl{sys/mman.h} 
876
877   \funcdecl{void * mmap(void * start, size\_t length, int prot, int flags, int
878     fd, off\_t offset)}
879   
880   Esegue la mappatura in memoria del file \param{fd}.
881   
882   \bodydesc{La funzione restituisce il puntatore alla zona di memoria mappata
883     in caso di successo, e \macro{MAP\_FAILED} (-1) in caso di errore, nel
884     qual caso \var{errno} viene impostata ai valori:
885     \begin{errlist}
886     \item[\macro{EBADF}] Il file descriptor non è valido, e non si è usato
887       \macro{MAP\_ANONYMOUS}.
888     \item[\macro{EACCES}] Il file descriptor non si riferisce ad un file
889       regolare, o si è richiesto \macro{MAP\_PRIVATE} ma \param{fd} non è
890       aperto in lettura, o si è richiesto \macro{MAP\_SHARED} e impostato
891       \macro{PROT\_WRITE} ed \param{fd} non è aperto in lettura/scrittura, o
892       si è impostato \macro{PROT\_WRITE} ed \param{fd} è in
893       \textit{append-only}.
894     \item[\macro{EINVAL}] I valori di \param{start}, \param{length} o
895       \param{offset} non sono validi (o troppo grandi o non allineati sulla
896       dimensione delle pagine).
897     \item[\macro{ETXTBSY}] Si è impostato \macro{MAP\_DENYWRITE} ma \param{fd}
898       è aperto in scrittura.
899     \item[\macro{EAGAIN}] Il file è bloccato, o si è bloccata troppa memoria.
900     \item[\macro{ENOMEM}] Non c'è memoria o si è superato il limite sul numero
901       di mappature possibili.
902     \item[\macro{ENODEV}] Il filesystem di \param{fd} non supporta il memory
903       mapping.
904     \end{errlist}
905   }
906 \end{functions}
907
908 La funzione richiede di mappare in memoria la sezione del file \param{fd} a
909 partire da \param{offset} per \param{lenght} byte, preferibilmente
910 all'indirizzo \param{start}. Il valore di \param{offset} deve essere un
911 multiplo della dimensione di una pagina di memoria. 
912
913
914 \begin{table}[htb]
915   \centering
916   \footnotesize
917   \begin{tabular}[c]{|l|l|}
918     \hline
919     \textbf{Valore} & \textbf{Significato} \\
920     \hline
921     \hline
922     \macro{PROT\_EXEC}  & Le pagine possono essere eseguite.\\
923     \macro{PROT\_READ}  & Le pagine possono essere lette.\\
924     \macro{PROT\_WRITE} & Le pagine possono essere scritte.\\
925     \macro{PROT\_NONE}  & L'accesso alle pagine è vietato.\\
926     \hline    
927   \end{tabular}
928   \caption{Valori dell'argomento \param{prot} di \func{mmap}, relativi alla
929     protezione applicate alle pagine del file mappate in memoria.}
930   \label{tab:file_mmap_prot}
931 \end{table}
932
933
934 Il valore dell'argomento \param{prot} indica la protezione\footnote{in Linux
935   la memoria reale è divisa in pagine: ogni processo vede la sua memoria
936   attraverso uno o più segmenti lineari di memoria virtuale.  Per ciascuno di
937   questi segmenti il kernel mantiene nella \textit{page table} la mappatura
938   sulle pagine di memoria reale, ed le modalità di accesso (lettura,
939   esecuzione, scrittura); una loro violazione causa quella che si chiama una
940   \textit{segment violation}, e la relativa emissione del segnale
941   \macro{SIGSEGV}.} da applicare al segmento di memoria e deve essere
942 specificato come maschera binaria ottenuta dall'OR di uno o più dei valori
943 riportati in \tabref{tab:file_mmap_flag}; il valore specificato deve essere
944 compatibile con la modalità di accesso con cui si è aperto il file.
945
946 L'argomento \param{flags} specifica infine qual'è il tipo di oggetto mappato,
947 le opzioni relative alle modalità con cui è effettuata la mappatura e alle
948 modalità con cui le modifiche alla memoria mappata vengono condivise o
949 mantenute private al processo che le ha effettuate. Deve essere specificato
950 come maschera binaria ottenuta dall'OR di uno o più dei valori riportati in
951 \tabref{tab:file_mmap_flag}.
952
953 \begin{table}[htb]
954   \centering
955   \footnotesize
956   \begin{tabular}[c]{|l|p{10cm}|}
957     \hline
958     \textbf{Valore} & \textbf{Significato} \\
959     \hline
960     \hline
961     \macro{MAP\_FIXED}     & Non permette di restituire un indirizzo diverso
962                              da \param{start}, se questo non può essere usato
963                              \func{mmap} fallisce. Se si imposta questo flag il
964                              valore di \param{start} deve essere allineato
965                              alle dimensioni di una pagina. \\
966     \macro{MAP\_SHARED}    & I cambiamenti sulla memoria mappata vengono
967                              riportati sul file e saranno immediatamente
968                              visibili agli altri processi che mappano lo stesso
969                              file.\footnotemark Il file su disco però non sarà
970                              aggiornato fino alla chiamata di \func{msync} o
971                              \func{unmap}), e solo allora le modifiche saranno
972                              visibili per l'I/O convenzionale. Incompatibile
973                              con \macro{MAP\_PRIVATE}. \\ 
974     \macro{MAP\_PRIVATE}   & I cambiamenti sulla memoria mappata non vengono
975                              riportati sul file. Ne viene fatta una copia
976                              privata cui solo il processo chiamante ha
977                              accesso.  Le modifiche sono mantenute attraverso
978                              il meccanismo del \textit{copy on write} e
979                              salvate su swap in caso di necessità. Non è
980                              specificato se i cambiamenti sul file originale
981                              vengano riportati sulla regione
982                              mappata. Incompatibile con \macro{MAP\_SHARED}. \\
983     \macro{MAP\_DENYWRITE} & In Linux viene ignorato per evitare
984                              \textit{DoS}\index{DoS} (veniva usato per
985                              segnalare che tentativi di scrittura sul file
986                              dovevano fallire con \macro{ETXTBUSY}).\\
987     \macro{MAP\_EXECUTABLE}& Ignorato. \\
988     \macro{MAP\_NORESERVE} & Si usa con \macro{MAP\_PRIVATE}. Non riserva
989                              delle pagine di swap ad uso del meccanismo di
990                              \textit{copy on write} per mantenere le
991                              modifiche fatte alla regione mappata, in
992                              questo caso dopo una scrittura, se non c'è più
993                              memoria disponibile, si ha l'emissione di
994                              un \macro{SIGSEGV}. \\
995     \macro{MAP\_LOCKED}    & Se impostato impedisce lo swapping delle pagine
996                              mappate. \\
997     \macro{MAP\_GROWSDOWN} & Usato per gli stack. Indica 
998                              che la mappatura deve essere effettuata con gli
999                              indirizzi crecenti verso il basso.\\
1000     \macro{MAP\_ANONYMOUS} & La mappatura non è associata a nessun file. Gli
1001                              argomenti \param{fd} e \param{offset} sono
1002                              ignorati.\footnotemark\\
1003     \macro{MAP\_ANON}      & Sinonimo di \macro{MAP\_ANONYMOUS}, deprecato.\\
1004     \macro{MAP\_FILE}      & Valore di compatibiità, deprecato.\\
1005     \hline
1006   \end{tabular}
1007   \caption{Valori possibili dell'argomento \param{flag} di \func{mmap}.}
1008   \label{tab:file_mmap_flag}
1009 \end{table}
1010
1011 \footnotetext{Dato che tutti faranno riferimento alle stesse pagine di
1012   memoria.}  
1013 \footnotetext{L'uso di questo flag con \macro{MAP\_SHARED} è
1014   stato implementato in Linux a partire dai kernel della serie 2.4.x.}
1015
1016 Gli effetti dell'accesso ad una zona di memoria mappata su file possono essere
1017 piuttosto complessi, essi si possono comprendere solo tenendo presente che
1018 tutto quanto è comunque basato sul basato sul meccanismo della memoria
1019 virtuale. Questo comporta allora una serie di conseguenze. La più ovvia è che
1020 se si cerca di scrivere su una zona mappata in sola lettura si avrà
1021 l'emissione di un segnale di violazione di accesso (\macro{SIGSEGV}), dato che
1022 i permessi sul segmento di memoria relativo non consentono questo tipo di
1023 accesso.
1024
1025 È invece assai diversa la questione relativa agli accessi al di fuori della
1026 regione di cui si è richiesta la mappatura. A prima vista infatti si potrebbe
1027 ritenere che anch'essi debbano generare un segnale di violazione di accesso;
1028 questo però non tiene conto del fatto che, essendo basata sul meccanismo della
1029 paginazione, la mappatura in memoria non può che essere eseguita su un
1030 segmento di dimensioni rigorosamente multiple di quelle di una pagina, ed in
1031 generale queste potranno non corrispondere alle dimensioni effettive del file
1032 o della sezione che si vuole mappare. Il caso più comune è quello illustrato
1033 in \figref{fig:file_mmap_boundary}, in cui la sezione di file non rientra nei
1034 confini di una pagina: in tal caso verrà il file sarà mappato su un segmento
1035 di memoria che si estende fino al bordo della pagina successiva.
1036
1037 \begin{figure}[htb]
1038   \centering
1039   \includegraphics[width=10cm]{img/mmap_boundary}
1040   \caption{Schema della mappatura in memoria di una sezione di file di
1041     dimensioni non corripondenti al bordo di una pagina.}
1042   \label{fig:file_mmap_boundary}
1043 \end{figure}
1044
1045
1046 In questo caso è possibile accedere a quella zona di memoria che eccede le
1047 dimensioni specificate da \param{lenght}, senza ottenere un \macro{SIGSEGV}
1048 poiché essa è presente nello spazio di indirizzi del processo, anche se non è
1049 mappata sul file. Il comportamento del sistema è quello di restituire un
1050 valore nullo per quanto viene letto, e di non riportare su file quanto viene
1051 scritto.
1052
1053 Un caso più complesso è quello che si viene a creare quando le dimensioni del
1054 file mappato sono più corte delle dimensioni della mappatura, oppure quando il
1055 file è stato troncato, dopo che è stato mappato, ad una dimensione inferiore a
1056 quella della mappatura in memoria.
1057
1058 \begin{figure}[htb]
1059   \centering
1060   \includegraphics[width=13cm]{img/mmap_exceed}
1061   \caption{Schema della mappatura in memoria di file di dimensioni inferiori
1062     alla lunghezza richiesta.}
1063   \label{fig:file_mmap_exceed}
1064 \end{figure}
1065
1066 In questa situazione, per la sezione di pagina parzialmente coperta dal
1067 contenuto del file, vale esattamente quanto visto in precedenza; invece per la
1068 parte che eccede, fino alle dimensioni date da \param{length}, l'accesso non
1069 sarà più possibile, ma il segnale emesso non sarà \macro{SIGSEGV}, ma
1070 \macro{SIGBUS}, come illustrato in \figref{fig:file_mmap_exceed}.
1071
1072 Non tutti i file possono venire mappati in memoria, dato che, come illustrato
1073 in \figref{fig:file_mmap_layout}, la mappatura introduce una corrispondenza
1074 biunivoca fra una sezione di un file ed una sezione di memoria. Questo
1075 comporta che ad esempio non è possibile mappare in memoria file descriptor
1076 relativi a pipe, socket e fifo, per i quali non ha senso parlare di
1077 \textsl{sezione}. Lo stesso vale anche per alcuni file di dispositivo, che non
1078 dispongono della relativa operazione \var{mmap} (si ricordi quanto esposto in
1079 \secref{sec:file_vfs_work}). Si tenga presente però che esistono anche casi di
1080 dispositivi (un esempio è l'interfaccia al ponte PCI-VME del chip Universe)
1081 che sono utilizzabili solo con questa interfaccia.
1082
1083 Dato che passando attraverso una \func{fork} lo spazio di indirizzi viene
1084 copiato integralmente, i file mappati in memoria verranno ereditati in maniera
1085 trasparente dal processo figlio, mantenendo gli stessi attributi avuti nel
1086 padre; così se si è usato \macro{MAP\_SHARED} padre e figlio accederanno allo
1087 stesso file in maniera condivisa, mentre se si è usato \macro{MAP\_PRIVATE}
1088 ciascuno di essi manterrà una sua versione privata indipendente. Non c'è
1089 invece nessun passaggio attraverso una \func{exec}, dato che quest'ultima
1090 sostituisce tutto lo spazio degli indirizzi di un processo con quello di un
1091 nuovo programma.
1092
1093 Quando si effettua la mappatura di un file vengono pure modificati i tempi ad
1094 esso associati (di cui si è trattato in \secref{sec:file_file_times}). Il
1095 valore di \var{st\_atime} può venir cambiato in qualunque istante a partire
1096 dal momento in cui la mappatura è stata effettuata: il primo riferimento ad
1097 una pagina mappata su un file aggiorna questo tempo.  I valori di
1098 \var{st\_ctime} e \var{st\_mtime} possono venir cambiati solo quando si è
1099 consentita la scrittura sul file (cioè per un file mappato con
1100 \macro{PROT\_WRITE} e \macro{MAP\_SHARED}) e sono aggiornati dopo la scrittura
1101 o in corrispondenza di una eventuale \func{msync}.
1102
1103 Dato per i file mappati in memoria le operazioni di I/O sono gestite
1104 direttamente dalla memoria virtuale, occorre essere consapevoli delle
1105 interazioni che possono esserci con operazioni effettuate con l'interfaccia
1106 standard dei file di \capref{cha:file_unix_interface}. Il problema è che una
1107 volta che si è mappato un file, le operazioni di lettura e scrittura saranno
1108 eseguite sulla memoria, e riportate su disco in maniera autonoma dal sistema
1109 della memoria virtuale.
1110
1111 Pertanto se si modifica un file con l'interfaccia standard queste modifiche
1112 potranno essere visibili o meno a seconda del momento in cui la memoria
1113 virtuale trasporterà dal disco in memoria quella sezione del file, perciò è
1114 del tutto imprevedibile il risultato della modifica di un file nei confronti
1115 del contenuto della memoria mappata su cui è mappato.
1116
1117 Per quanto appena visto, è sempre sconsigliabile eseguire scritture su file
1118 attraverso l'interfaccia standard, quando lo si è mappato in memoria, è invece
1119 possibile usare l'interfaccia standard per leggere un file mappato in memoria,
1120 purché si abbia una certa cura; infatti l'interfaccia dell'I/O mappato in
1121 memoria mette a disposizione la funzione \func{msync} per sincronizzare il
1122 contenuto della memoria mappata con il file su disco; il suo prototipo è:
1123 \begin{functions}  
1124   \headdecl{unistd.h}
1125   \headdecl{sys/mman.h} 
1126
1127   \funcdecl{int msync(const void *start, size\_t length, int flags)}
1128   
1129   Sincronizza i contenuti di una sezione di un file mappato in memoria.
1130   
1131   \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
1132     errore nel qual caso \var{errno} viene impostata ai valori:
1133     \begin{errlist}
1134     \item[\macro{EINVAL}] O \param{start} non è multiplo di \macro{PAGESIZE},
1135     o si è specificato un valore non valido per \param{flags}.
1136     \item[\macro{EFAULT}] L'intervallo specificato non ricade in una zona
1137       precedentemente mappata.
1138     \end{errlist}
1139   }
1140 \end{functions}
1141
1142 La funzione esegue la sincronizzazione di quanto scritto nella sezione di
1143 memoria indicata da \param{start} e \param{offset}, scrivendo le modifiche sul
1144 file (qualora questo non sia già stato fatto).  Provvede anche ad aggiornare i
1145 relativi tempi di modifica. In questo modo si è sicuri che dopo l'esecuzione
1146 di \func{msync} le funzioni dell'interfaccia standard troveranno un contenuto
1147 del file aggiornato.
1148
1149 \begin{table}[htb]
1150   \centering
1151   \footnotesize
1152   \begin{tabular}[c]{|l|l|}
1153     \hline
1154     \textbf{Valore} & \textbf{Significato} \\
1155     \hline
1156     \hline
1157     \macro{MS\_ASYNC}     & Richiede la sincronizzazione.\\
1158     \macro{MS\_SYNC}      & Attende che la sincronizzazione si eseguita.\\
1159     \macro{MS\_INVALIDATE}& Richiede che le altre mappature dello stesso file
1160                             siano invalidate.\\
1161     \hline    
1162   \end{tabular}
1163   \caption{Valori dell'argomento \param{flag} di \func{msync}.}
1164   \label{tab:file_mmap_rsync}
1165 \end{table}
1166
1167 L'argomento \param{flag} è specificato come maschera binaria composta da un OR
1168 dei valori riportati in \tabref{tab:file_mmap_rsync}, di questi però
1169 \macro{MS\_ASYNC} e \macro{MS\_SYNC} sono incompatibili; con il primo valore
1170 infatti la funzione si limita ad inoltrare la richiesta di sincronizzazione al
1171 meccanismo della memoria virtuale, ritornando subito, mentre con il secondo
1172 attende che la sincronizzazione sia stata effettivamente eseguita. Il terzo
1173 flag fa invalidare le pagine di cui si richiede la sincronizzazione per tutte
1174 le mappature dello stesso file, così che esse possano essere immediatamente
1175 aggiornate ai nuovi valori.
1176
1177 Una volta che si sono completate le operazioni di I/O si può eliminare la
1178 mappatura della memoria usando la funzione \func{munmap}, il suo prototipo è:
1179 \begin{functions}  
1180   \headdecl{unistd.h}
1181   \headdecl{sys/mman.h} 
1182
1183   \funcdecl{int munmap(void *start, size\_t length)}
1184   
1185   Rilascia la mappatura sulla sezione di memoria specificata.
1186
1187   \bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
1188     errore nel qual caso \var{errno} viene impostata ai valori:
1189     \begin{errlist}
1190     \item[\macro{EINVAL}] L'intervallo specificato non ricade in una zona
1191       precedentemente mappata.
1192     \end{errlist}
1193   }
1194 \end{functions}
1195
1196 La funzione cancella la mappatura per l'intervallo specificato attraverso
1197 \param{start} e \param{length}, ed ogni successivo accesso a tale regione
1198 causerà un errore di accesso in memoria. L'argomento \param{start} deve essere
1199 allineato alle dimensioni di una pagina di memoria, e la mappatura di tutte le
1200 pagine contenute (anche parzialmente) nell'intervallo indicato, verrà rimossa.
1201 Indicare un intervallo che non contiene pagine mappate non è un errore.
1202
1203 Alla conclusione del processo, ogni pagina mappata verrà automaticamente
1204 rilasciata, mentre la chiusura del file descriptor usato per effettuare la
1205 mappatura in memoria non ha alcun effetto sulla stessa.
1206
1207
1208 \section{Il file locking}
1209 \label{sec:file_locking}
1210
1211 In \secref{sec:file_sharing} abbiamo preso in esame le modalità in cui un
1212 sistema unix-like gestisce la condivisione dei file da parte di processi
1213 diversi. In quell'occasione si è visto come, con l'eccezione dei file aperti
1214 in \textit{append mode}, quando più processi scrivono contemporaneamente sullo
1215 stesso file non è possibile determinare la sequenza in cui essi opereranno.
1216
1217 Questo causa la possibilità di race condition\index{race condition}; in
1218 generale le situazioni più comuni sono due: l'interazione fra un processo che
1219 scrive e altri che leggono, in cui questi ultimi possono leggere informazioni
1220 scritte solo in maniera parziale o incompleta; o quella in cui diversi
1221 processi scrivono, mescolando in maniera imprevedibile il loro output sul
1222 file.
1223
1224 In tutti questi casi il \textit{file locking} è la tecnica che permette di
1225 evitare le race condition, attraverso una serie di funzioni che permettono di
1226 bloccare l'accesso al file da parte di altri processi, così da evitare le
1227 sovrapposizioni, e garantire la atomicità delle operazioni di scrittura.
1228
1229
1230 \subsection{L'\textit{advisory locking}}
1231 \label{sec:file_record_locking}
1232
1233 La prima modalità di file locking che è stata implementata nei sistemi
1234 unix-like è quella che viene usualmente chiamata \textit{advisory locking}, in
1235 quanto è il processo, e non il sistema, che si incarica di verificare se
1236 esiste una condizione di blocco per l'accesso ai file.
1237
1238
1239
1240
1241 \subsection{Il \textit{mandatory locking}}
1242 \label{sec:file_mand_locking}
1243
1244 Il \textit{mandatory locking} è una opzione introdotta inizialmente in SVr4,
1245 per introdurre un file locking che come dice il nome, fosse effettivo
1246 indipendentemente dai controlli eseguiti da un processo. Con il
1247 \textit{mandatory locking} infatti è possibile far eseguire il blocco del file
1248 direttamente al sistema, così che anche qualora non si predisponessero le
1249 opportune verifiche nei processi, questo verrebbe comunque rispettato.
1250
1251 Per poter utilizzare il \textit{mandatory locking} è stato introdotto un
1252 utilizzo particolare del bit \acr{suid}. Se si ricorda quanto esposto in
1253 \secref{sec:file_suid_sgid}), esso viene di norma utilizzato per cambiare
1254 l'userid effettivo con cui viene eseguito un programma, ed è pertanto sempre
1255 associato alla presenza del permesso di esecuzione. Impostando questo bit su
1256 un file senza permesso di esecuzione in un sistema che supporta il
1257 \textit{mandatory locking}, fa sì che quest'ultimo venga attivato per il file
1258 in questione. In questo modo una combinaizone dei permessi originariamente non
1259 contemplata, in quanto senza significato, diventa l'indicazione della presenza
1260 o meno del \textit{mandatory locking}.
1261
1262
1263
1264 %%% Local Variables: 
1265 %%% mode: latex
1266 %%% TeX-master: "gapil"
1267 %%% End: