preadv() e pwritev()

La chiamata di sistema preadv() combina le funzionalità di readv() e di pread(2). Realizza lo stesso compito di readv(), ma aggiunge un quarto argomento, offset, che specifica la posizione nel file (offset) alla quale dev'essere effettuata l'operazione di input.

La chiamata di sistema pwritev() combina le funzionalità di writev() e di pwrite(2). Realizza lo stesso compito di writev(), ma aggiunge un quarto argomento, offset, che specifica la posizione nel file (offset) alla quale dev'essere effettuata l'operazione di input.

L'offset nel file non viene modificato da queste chiamate di sistema. Il file al quale fa riferimento fd deve poter permettere il posizionamento a un offset.

preadv2() e pwritev2()

Queste chiamate di sistema sono simili alle chiamate preadv() e pwritev(), ma aggiungono un quinto argomento, flags, che modifica il comportamento a seconda del tipo di chiamata.

A differenza di preadv() e pwritev(), se l'argomento offset è -1, viene usato e aggiornato l'offset del file corrente.

L'argomento flags contiene un OR binario di zero o più dei seguenti flag:

RWF_DSYNC (da Linux 4.7)

Equivale a richiedere a livello di una singola scrittura la funzione richiesta dal flag O_DSYNC di open(2). Questo flag è significativo solo per pwritev2(), e il suo risultato si applica solo all'intervallo di dati scritto dalla chiamata di sistema.

RWF_HIPRI (da Linux 4.6)

Lettura/scrittura ad alta priorità. Permette ai filesystem basati su blocchi di usare la funzione di polling (interrogazione periodica) del dispositivo, il che permette di abbreviare il periodo di latenza, ma può implicare il consumo di ulteriori risorse. (Attualmente, questa funzionalità è usabile solo su un descrittore di fileaperto usando il flag O_DIRECT.)

RWF_SYNC (da Linux 4.7)

Costituisce un equivalente per ogni singola scrittura (per-write) del flag O_SYNC di open(2). Questo flag è significativo solo per pwritev2(), e il suo risultato si applica solo all'intervallo di dati scritto dalla chiamata di sistema.

RWF_NOWAIT (da Linux 4.14)

Non attende i dati che non sono immediatamente disponibili. Se è stato specificato questo flag, la chiamata di sistema preadv2() torna al chiamante senza fare nulla se i dati da leggere devono essere rintracciati da disco o se occorre attendere per un lock Se qualche dato è stato letto con successo, restituisce il numero di byte letti. Se non è stato letto nessun byte, restituisce -1 e imposta errno a EAGAIN (però si veda BUGS). Attualmente, questo flag è significativo solo per preadv2().

RWF_APPEND (da Linux 4.16)

Costituisce un equivalente per ogni singola scrittura (per-write) del flag O_APPEND open(2) flag. Questo flag è significativo solo per pwritev2(), e il suo risultato si applica solo all'intervallo di dati scritto dalla chiamata di sistema. L'argomento offset non influisce sull'operazione di scrittura; i dati sono sempre accodati alla fine del file. Comunque, se l'argomento offset è -1, si usa e si aggiorna il file all'offset corrente.

RWF_NOAPPEND (since Linux 6.9)

Do not honor the O_APPEND open(2) flag. This flag is meaningful only for pwritev2(). Historically, Linux honored O_APPEND flag if set and ignored the offset argument, which is a bug. For pwritev2(), the offset argument is honored as expected if RWF_NOAPPEND flag is set, the same as if O_APPEND flag were not set.

RWF_ATOMIC (since Linux 6.11)

Requires that writes to regular files in block-based filesystems be issued with torn-write protection. Torn-write protection means that for a power or any other hardware failure, all or none of the data from the write will be stored, but never a mix of old and new data. This flag is meaningful only for pwritev2(), and its effect applies only to the data range written by the system call. The total write length must be power-of-2 and must be sized in the range [stx_atomic_write_unit_min, stx_atomic_write_unit_max]. The write must be at a naturally-aligned offset within the file with respect to the total write length. For example, a write of length 32KiB at a file offset of 32KiB is permitted, however a write of length 32KiB at a file offset of 48KiB is not permitted. The upper limit of iovcnt for pwritev2() is given by the value in stx_atomic_write_segments_max. Torn-write protection only works with O_DIRECT flag, i.e. buffered writes are not supported. To guarantee consistency from the write between a file's in-core state with the storage device, O_SYNC or O_DSYNC must be specified for open(2). The same synchronized I/O guarantees as described in open(2) are provided when these flags or their equivalent flags and system calls are used (e.g., if RWF_SYNC is specified for pwritev2()).

Differenze tra la libreria C e il kernel

Le chiamate di sistema dirette preadv() e pwritev() hanno firme che differiscono leggermente da quelle delle corrispondenti funzioni wrapper della libreria GNU C viste nella SINTASSI. L'argomento finale, offset, è spacchettato dalle funzioni wrapper in due argomenti nelle chiamate di sistema:

unsigned long pos_l, unsigned long pos

Questi argomenti contengono, rispettivamente, i 32 bit meno significativi e i 32 bit più significativi di offset.

Precedenti differenze tra la libreria C e il kernel

Per affrontare il fatto che IOV_MAX era così basso nelle prime versioni di Linux, le funzioni wrapper di glibc per readv() e writev() facevano un lavoro aggiuntivo se rilevavano che la sottostante chiamata di sistema al kernel falliva perché era stato superato questo limite. Nel caso di readv() la funzione wrapper allocava un buffer temporaneo abbastanza grande per tutti gli elementi specificati da iov, passava questo buffer in una chiamata a read(2), copiava i dati dal buffer alle posizioni specificate dai campi iov_base degli elementi di iov, e infine liberava il buffer. La funzione wrapper per writev() eseguiva l'attività analoga usando un buffer temporaneo e una chiamata a write(2).

La necessità di questo sforzo aggiuntivo nelle funzioni wrappr glibc venne meno con le versioni di Linux 2.2 e superiori. Comunque, glibc continuò con questo comportamento fino alla versione 2.10. A partire da glibc versione 2.9, le funzioni wrapper prevedono questo comportamento solo se la libreria rileva che il sistema sta eseguendo un kernel Linux più vecchio della versione 2.6.18 (una versione del kernel scelta arbitrariamente). E da glibc 2.20 (che richiede una versione del kernel Linux superiore alla 2.6.32), le funzioni wrapper di glibc invocano sempre direttamente le chiamate di sistema.