.\" -*- coding: UTF-8 -*- .\" Copyright 2010, Michael Kerrisk .\" Copyright, the authors of the Linux man-pages project .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH AIO 7 "8 février 2026" "Pages du manuel de Linux 6.18" .SH NOM aio \- Vue d'ensemble des entrées\-sorties (E/S) asynchrones POSIX .SH DESCRIPTION L'interface d'E/S asynchrones (AIO pour « asynchronous I/O ») POSIX permet aux applications de déclencher une ou plusieurs opérations d'E/S réalisées de façon asynchrone (c'est\-à\-dire en arrière\-plan). La fin d'une opération d'E/S peut être notifiée à l'application de différentes façons au choix : distribution d'un signal, instanciation d'un thread ou absence de notification. .P L'interface AIO POSIX est composée des fonctions suivantes : .TP \fBaio_read\fP(3) Placer en file d'attente une requête de lecture. C'est l'équivalent asynchrone de \fBread\fP(2). .TP \fBaio_write\fP(3) Placer en file d'attente une requête d'écriture. C'est l'équivalent asynchrone de \fBwrite\fP(2). .TP \fBaio_fsync\fP(3) Placer en file d'attente une requête de synchronisation pour des opérations d'E/S sur un descripteur de fichier. C'est l'équivalent asynchrone de \fBfsync\fP(2) et \fBfdatasync\fP(2). .TP \fBaio_error\fP(3) Obtenir l'état d'erreur d'une requête d'E/S placée en file d'attente. .TP \fBaio_return\fP(3) Obtenir l'état de retour d'une requête d'E/S terminée. .TP \fBaio_suspend\fP(3) Suspendre l'appelant jusqu'à la fin d'une ou plusieurs requêtes d'E/S d'un ensemble indiqué. .TP \fBaio_cancel\fP(3) Essayer d'annuler des requêtes d'E/S en cours sur un descripteur de fichier indiqué. .TP \fBlio_listio\fP(3) Placer en file d'attente plusieurs requêtes d'E/S à partir d'un seul appel de fonction. .P La structure \fIaiocb\fP (« asynchronous I/O control block », ou bloc de contrôle d'E/S asynchrones) définit les paramètres de contrôle d'une opération d'E/S. Un argument de ce type est utilisé avec toutes les fonctions précédentes. Cette structure est de la forme suivante : .P .in +4n .EX #include \& struct aiocb { /* L'ordre de ces champs dépend de l'implémentation */ \& int aio_fildes; /* Descripteur de fichier */ off_t aio_offset; /* Position dans le fichier */ volatile void *aio_buf; /* Emplacement du tampon */ size_t aio_nbytes; /* Longueur de transfert */ int aio_reqprio; /* Priorité de requête */ struct sigevent aio_sigevent; /* Méthode de notification */ int aio_lio_opcode; /* Opération à réaliser ; lio_listio() seulement */ \& /* Divers champs internes à l'implémentation ne sont pas montrés */ }; \& /* Codes opératoires pour « aio_lio_opcode » : */ \& enum { LIO_READ, LIO_WRITE, LIO_NOP }; .EE .in .P Les membres de cette structure sont les suivants : .TP \fIaio_fildes\fP Le descripteur du fichier sur lequel les opérations d'E/S sont à réaliser. .TP \fIaio_offset\fP La position dans le fichier où les opérations d'E/S sont à réaliser. .TP \fIaio_buf\fP Le tampon utilisé pour le transfert de données des opérations de lecture ou d'écriture. .TP \fIaio_nbytes\fP La taille du tampon pointé par \fIaio_buf\fP. .TP \fIaio_reqprio\fP Valeur à soustraire de la priorité temps\-réel du thread de l'appelant pour déterminer la priorité d'exécution de cette requête d'E/S (consultez \fBpthread_setschedparam\fP(3)). La valeur indiquée doit être entre 0 et la valeur renvoyée par \fIsysconf(_SC_AIO_PRIO_DELTA_MAX)\fP. Ce champ est ignoré lors des opérations de synchronisation de fichier. .TP \fIaio_sigevent\fP Structure indiquant comment l'appelant sera notifié de la fin d'une opération d'E/S asynchrone. Les valeurs de \fIaio_sigevent.sigev_notify\fP peuvent être \fBSIGEV_NONE\fP, \fBSIGEV_SIGNAL\fP et \fBSIGEV_THREAD\fP. Consultez \fBsigevent\fP(3type) pour plus de précisions. .TP \fIaio_lio_opcode\fP Le type d'opération à réaliser, utilisé seulement pour \fBlio_listio\fP(3). .P En plus des fonctions standard précédentes, la bibliothèque C du projet GNU fournit l'extension suivante à l'API AIO POSIX : .TP \fBaio_init\fP(3) Configurer les paramètres pour régler le comportement de l'implémentation AIO POSIX de la glibc. .SH ERREURS .TP \fBEINVAL\fP Le champ \fIaio_reqprio\fP de la structure \fIaiocb\fP était inférieur à 0 ou supérieur à la limite renvoyée par l'appel \fIsysconf(_SC_AIO_PRIO_DELTA_MAX)\fP. .SH NORMES POSIX.1\-2008. .SH HISTORIQUE POSIX.1\-2001. glibc 2.1. .SH NOTES Il est conseillé de mettre à zéro le tampon de bloc de contrôle avant utilisation (consultez \fBmemset\fP(3)). Le tampon de bloc de contrôle et le tampon pointé par \fIaio_buf\fP ne doivent pas être modifiés pendant l'exécution d'une opération d'E/S. Ces tampons doivent rester valables jusqu'à la fin de l'opération d'E/S. .P Les opérations de lecture ou d'écriture asynchrones simultanées qui utilisent la même structure \fIaiocb\fP produisent des résultats indéfinis. .P .\" http://lse.sourceforge.net/io/aio.html .\" http://lse.sourceforge.net/io/aionotes.txt .\" http://lwn.net/Articles/148755/ L'actuelle implémentation AIO POSIX de Linux est fournie en espace utilisateur par la glibc. De nombreuses limites existent, en particulier le maintien de plusieurs threads pour réaliser des opérations d'E/S est très coûteux et monte mal en charge. L'implémentation d'E/S asynchrones basée sur l'état de la machine est en travaux depuis un moment sur le noyau (consultez \fBio_submit\fP(2), \fBio_setup\fP(2), \fBio_cancel\fP(2), \fBio_destroy\fP(2), \fBio_getevents\fP(2)), mais cette implémentation n'a pas encore atteint le niveau où l'implémentation AIO POSIX peut être entièrement réimplémentée en utilisant les appels système du noyau. .SH EXEMPLES Le programme suivant ouvre chaque fichier nommé en argument de sa ligne de commande et place une requête sur le descripteur de fichier dans la file avec \fBaio_read\fP(3). Le programme boucle ensuite, en surveillant périodiquement toutes les opérations d'E/S en cours avec \fBaio_error\fP(3). Chaque requête d'E/S est configurée pour fournir une notification en distribuant un signal. Quand toutes les requêtes d'E/S sont terminées, le programme récupère leur état avec \fBaio_return\fP(3). .P Le signal \fBSIGQUIT\fP (créé en tapant Contrôle\-\[rs]) provoque la demande d'annulation de chaque requête en cours avec \fBaio_cancel\fP(3). .P Voici un exemple de ce qui pourrait être affiché lors de l'exécution de ce programme. Dans cet exemple, le programme place en file d'attente deux requêtes sur l'entrée standard et deux lignes de saisie contenant « abc » et « x » y répondent. .P .in +4n .EX $\fB ./a.out /dev/stdin /dev/stdin\fP; /dev/stdin ouvert sur le descripteur 3 /dev/stdin ouvert sur le descripteur 4 aio_error(): pour la requête 0 (descripteur 3) : En cours pour la requête 1 (descripteur 4) : En cours \fBabc\fP Signal de fin d'E/S reçu aio_error(): pour la requête 0 (descripteur 3) : E/S réussie pour la requête 1 (descripteur 4) : En cours aio_error(): pour la requête 1 (descripteur 4) : En cours \fBx\fP Signal de fin d'E/S reçu aio_error(): pour la requête 1 (descripteur 4) : E/S réussie Toutes les requêtes d'E/S sont terminées aio_return(): pour la requête 0 (descripteur 3) : 4 pour la requête 1 (descripteur 4) : 2 .EE .in .SS "Source du programme" \& .EX #include #include #include #include #include #include #include #include \& #define BUF_SIZE 20 /* Size of buffers for read operations */ \& struct ioRequest { /* Application\-defined structure for tracking I/O requests */ int reqNum; int status; struct aiocb *aiocbp; }; \& static volatile sig_atomic_t gotSIGQUIT = 0; /* On delivery of SIGQUIT, we attempt to cancel all outstanding I/O requests */ \& static void /* Handler for SIGQUIT */ quitHandler(int sig) { gotSIGQUIT = 1; } \& #define IO_SIGNAL SIGUSR1 /* Signal used to notify I/O completion */ \& static void /* Handler for I/O completion signal */ aioSigHandler(int sig, siginfo_t *si, void *ucontext) { if (si\->si_code == SI_ASYNCIO) { write(STDOUT_FILENO, "I/O completion signal received\[rs]n", 31); \& /* The corresponding ioRequest structure would be available as struct ioRequest *ioReq = si\->si_value.sival_ptr; and the file descriptor would then be available via ioReq\->aiocbp\->aio_fildes */ } } \& int main(int argc, char *argv[]) { struct sigaction sa; int s; int numReqs; /* Total number of queued I/O requests */ int openReqs; /* Number of I/O requests still in progress */ \& if (argc < 2) { fprintf(stderr, "Usage: %s ...\[rs]n", argv[0]); exit(EXIT_FAILURE); } \& numReqs = argc \- 1; \& /* Allocate our arrays. */ \& struct ioRequest *ioList = calloc(numReqs, sizeof(*ioList)); if (ioList == NULL) err(EXIT_FAILURE, "calloc"); \& struct aiocb *aiocbList = calloc(numReqs, sizeof(*aiocbList)); if (aiocbList == NULL) err(EXIT_FAILURE, "calloc"); \& /* Establish handlers for SIGQUIT and the I/O completion signal. */ \& sa.sa_flags = SA_RESTART; sigemptyset(&sa.sa_mask); \& sa.sa_handler = quitHandler; if (sigaction(SIGQUIT, &sa, NULL) == \-1) err(EXIT_FAILURE, "sigaction"); \& sa.sa_flags = SA_RESTART | SA_SIGINFO; sa.sa_sigaction = aioSigHandler; if (sigaction(IO_SIGNAL, &sa, NULL) == \-1) err(EXIT_FAILURE, "sigaction"); \& /* Open each file specified on the command line, and queue a read request on the resulting file descriptor. */ \& for (size_t j = 0; j < numReqs; j++) { ioList[j].reqNum = j; ioList[j].status = EINPROGRESS; ioList[j].aiocbp = &aiocbList[j]; \& ioList[j].aiocbp\->aio_fildes = open(argv[j + 1], O_RDONLY); if (ioList[j].aiocbp\->aio_fildes == \-1) err(EXIT_FAILURE, "open"); printf("opened %s on descriptor %d\[rs]n", argv[j + 1], ioList[j].aiocbp\->aio_fildes); \& ioList[j].aiocbp\->aio_buf = malloc(BUF_SIZE); if (ioList[j].aiocbp\->aio_buf == NULL) err(EXIT_FAILURE, "malloc"); \& ioList[j].aiocbp\->aio_nbytes = BUF_SIZE; ioList[j].aiocbp\->aio_reqprio = 0; ioList[j].aiocbp\->aio_offset = 0; ioList[j].aiocbp\->aio_sigevent.sigev_notify = SIGEV_SIGNAL; ioList[j].aiocbp\->aio_sigevent.sigev_signo = IO_SIGNAL; ioList[j].aiocbp\->aio_sigevent.sigev_value.sival_ptr = &ioList[j]; \& s = aio_read(ioList[j].aiocbp); if (s == \-1) err(EXIT_FAILURE, "aio_read"); } \& openReqs = numReqs; \& /* Loop, monitoring status of I/O requests. */ \& while (openReqs > 0) { sleep(3); /* Delay between each monitoring step */ \& if (gotSIGQUIT) { \& /* On receipt of SIGQUIT, attempt to cancel each of the outstanding I/O requests, and display status returned from the cancelation requests. */ \& printf("got SIGQUIT; canceling I/O requests: \[rs]n"); \& for (size_t j = 0; j < numReqs; j++) { if (ioList[j].status == EINPROGRESS) { printf(" Request %zu on descriptor %d:", j, ioList[j].aiocbp\->aio_fildes); s = aio_cancel(ioList[j].aiocbp\->aio_fildes, ioList[j].aiocbp); if (s == AIO_CANCELED) printf("I/O canceled\[rs]n"); else if (s == AIO_NOTCANCELED) printf("I/O not canceled\[rs]n"); else if (s == AIO_ALLDONE) printf("I/O all done\[rs]n"); else perror("aio_cancel"); } } \& gotSIGQUIT = 0; } \& /* Check the status of each I/O request that is still in progress. */ \& printf("aio_error():\[rs]n"); for (size_t j = 0; j < numReqs; j++) { if (ioList[j].status == EINPROGRESS) { printf(" for request %zu (descriptor %d): ", j, ioList[j].aiocbp\->aio_fildes); ioList[j].status = aio_error(ioList[j].aiocbp); \& switch (ioList[j].status) { case 0: printf("I/O succeeded\[rs]n"); break; case EINPROGRESS: printf("In progress\[rs]n"); break; case ECANCELED: printf("Canceled\[rs]n"); break; default: perror("aio_error"); break; } \& if (ioList[j].status != EINPROGRESS) openReqs\-\-; } } } \& printf("All I/O requests completed\[rs]n"); \& /* Check status return of all I/O requests. */ \& printf("aio_return():\[rs]n"); for (size_t j = 0; j < numReqs; j++) { ssize_t s; \& s = aio_return(ioList[j].aiocbp); printf(" for request %zu (descriptor %d): %zd\[rs]n", j, ioList[j].aiocbp\->aio_fildes, s); } \& exit(EXIT_SUCCESS); } .EE .SH "VOIR AUSSI" .ad l .nh \fBio_cancel\fP(2), \fBio_destroy\fP(2), \fBio_getevents\fP(2), \fBio_setup\fP(2), \fBio_submit\fP(2), \fBaio_cancel\fP(3), \fBaio_error\fP(3), \fBaio_init\fP(3), \fBaio_read\fP(3), \fBaio_return\fP(3), \fBaio_write\fP(3), \fBlio_listio\fP(3) .P "Asynchronous I/O Support in Linux 2.5", Bhattacharya, Pratt, Pulavarty, and Morgan, Proceedings of the Linux Symposium, 2003, .UR https:\://www.kernel.org/doc/ols/2003/ols2003\-pages\-351\-366.pdf .UE .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Christophe Blaess , Stéphan Rafin , Thierry Vignaud , François Micaux, Alain Portal , Jean-Philippe Guérard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas François , Florentin Duneau , Simon Paillard , Denis Barbier , David Prévot , Thomas Vincent et Jean-Pierre Giraud . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .