perkamon - en to fr translation catalogue (252 entries)

note: type: TH
en: 2014-04-06
fr: 6 avril 2014

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: aio - POSIX asynchronous I/O overview
fr: aio - Vue d'ensemble des entrées-sorties (E/S) asynchrones POSIX

note: type: Plain text
en: The POSIX asynchronous I/O (AIO) interface allows applications to initiate one or more I/O operations that are performed asynchronously (i.e., in the background).  The application can elect to be notified of completion of the I/O operation in a variety of ways: by delivery of a signal, by instantiation of a thread, or no notification at all.
fr: 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.

note: type: Plain text
en: The POSIX AIO interface consists of the following functions:
fr: L'interface AIO POSIX est composée des fonctions suivantes :

note: type: Plain text
en: Enqueue a read request.  This is the asynchronous analog of B<read>(2).
fr: Placer en file d'attente une requête de lecture. C'est l'équivalent asynchrone de B<read>(2).

note: type: Plain text
en: Enqueue a write request.  This is the asynchronous analog of B<write>(2).
fr: Placer en file d'attente une requête d'écriture. C'est l'équivalent asynchrone de B<write>(2).

note: type: Plain text
en: Enqueue a sync request for the I/O operations on a file descriptor.  This is the asynchronous analog of B<fsync>(2)  and B<fdatasync>(2).
fr: 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 B<fsync>(2) et B<fdatasync>(2).

note: type: Plain text
en: Obtain the error status of an enqueued I/O request.
fr: Obtenir l'état d'erreur d'une requête d'E/S placée en file d'attente.

note: type: Plain text
en: Obtain the return status of a completed I/O request.
fr: Obtenir l'état de retour d'une requête d'E/S terminée.

note: type: Plain text
en: Suspend the caller until one or more of a specified set of I/O requests completes.
fr: Suspendre l'appelant jusqu'à la fin d'une ou plusieurs requêtes d'E/S d'un ensemble indiqué.

note: type: Plain text
en: Attempt to cancel outstanding I/O requests on a specified file descriptor.
fr: Essayer d'annuler des requêtes d'E/S en cours sur un descripteur de fichier indiqué.

note: type: Plain text
en: Enqueue multiple I/O requests using a single function call.
fr: Placer en file d'attente plusieurs requêtes d'E/S à partir d'un seul appel de fonction.

note: type: Plain text
en: The I<aiocb> ("asynchronous I/O control block") structure defines parameters that control an I/O operation.  An argument of this type is employed with all of the functions listed above.  This structure has the following form:
fr: La structure I<aiocb> (« 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 :

note: type: Plain text
en: struct aiocb {
        /* The order of these fields is implementation-dependent */
fr: struct aiocb {
        /* L'ordre de ces champs dépend de l'implémentation */

note: type: Plain text
en:     int             aio_fildes;     /* File descriptor */
        off_t           aio_offset;     /* File offset */
        volatile void  *aio_buf;        /* Location of buffer */
        size_t          aio_nbytes;     /* Length of transfer */
        int             aio_reqprio;    /* Request priority */
        struct sigevent aio_sigevent;   /* Notification method */
        int             aio_lio_opcode; /* Operation to be performed;
                                           lio_listio() only */
fr:     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 */

note: type: Plain text
en:     /* Various implementation-internal fields not shown */
    };
fr:     /* Divers champs internes à l'implémentation ne sont pas montrés */
    };

note: type: Plain text
en: /* Operation codes for \(aqaio_lio_opcode\(aq: */
fr: /* Codes opératoires pour « aio_lio_opcode » : */

note: type: Plain text
en: The fields of this structure are as follows:
fr: Les champs de cette structure sont les suivants :

note: type: Plain text
en: The file descriptor on which the I/O operation is to be performed.
fr: Le descripteur de fichier sur lequel les opérations d'E/S sont à réaliser.

note: type: Plain text
en: This is the file offset at which the I/O operation is to be performed.
fr: La position dans le fichier où les opérations d'E/S sont à réaliser.

note: type: Plain text
en: This is the buffer used to transfer data for a read or write operation.
fr: Le tampon utilisé pour le transfert de données des opérations de lecture ou d'écriture.

note: type: Plain text
en: This is the size of the buffer pointed to by I<aio_buf>.
fr: La taille du tampon pointé par I<aio_buf>.

note: type: Plain text
en: This field specifies a value that is subtracted from the calling thread's real-time priority in order to determine the priority for execution of this I/O request (see B<pthread_setschedparam>(3)).  The specified value must be between 0 and the value returned by I<sysconf(_SC_AIO_PRIO_DELTA_MAX)>.  This field is ignored for file synchronization operations.
fr: 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 B<pthread_setschedparam>(3)). La valeur indiquée doit être entre 0 et la valeur renvoyée par I<sysconf(_SC_AIO_PRIO_DELTA_MAX)>. Ce champ est ignoré lors des opérations de synchronisation de fichier.

note: type: Plain text
en: This field is a structure that specifies how the caller is to be notified when the asynchronous I/O operation completes.  Possible values for I<aio_sigevent.sigev_notify> are B<SIGEV_NONE>, B<SIGEV_SIGNAL>, and B<SIGEV_THREAD>.  See B<sigevent>(7)  for further details.
fr: Structure indiquant comment l'appelant sera notifié de la fin d'une opération d'E/S asynchrone. Les valeurs de I<aio_sigevent.sigev_notify> peuvent être B<SIGEV_NONE>, B<SIGEV_SIGNAL> et B<SIGEV_THREAD>. Consultez B<sigevent>(7) pour plus de précisions.

note: type: Plain text
en: The type of operation to be performed; used only for B<lio_listio>(3).
fr: Le type d'opération à réaliser, utilisé seulement pour B<lio_listio>(3).

note: type: Plain text
en: In addition to the standard functions listed above, the GNU C library provides the following extension to the POSIX AIO API:
fr: En plus des fonctions standard précédentes, la bibliothèque C du projet GNU fournit les extensions suivantes à l'API AIO POSIX :

note: type: Plain text
en: Set parameters for tuning the behavior of the glibc POSIX AIO implementation.
fr: Configurer les paramètres pour régler le comportement de l'implémentation AIO POSIX de la glibc.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: The I<aio_reqprio> field of the I<aiocb> structure was less than 0, or was greater than the limit returned by the call I<sysconf(_SC_AIO_PRIO_DELTA_MAX)>.
fr: Le champ I<aio_reqprio> de la structure I<aiocb> était inférieur à 0, ou supérieur à la limite renvoyée par l'appel I<sysconf(_SC_AIO_PRIO_DELTA_MAX)>.

note: type: Plain text
en: The POSIX AIO interfaces are provided by glibc since version 2.1.
fr: Les interfaces AIO POSIX sont fournies par la glibc depuis la version 2.1.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: It is a good idea to zero out the control block buffer before use (see B<memset>(3)).  The control block buffer and the buffer pointed to by I<aio_buf> must not be changed while the I/O operation is in progress.  These buffers must remain valid until the I/O operation completes.
fr: Il est conseillé de mettre à zéro le tampon de bloc de contrôle avant utilisation (consultez B<memset>(3)). Le tampon de bloc de contrôle et le tampon pointé par I<aio_buf> 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.

note: type: Plain text
en: Simultaneous asynchronous read or write operations using the same I<aiocb> structure yield undefined results.
fr: Les opérations de lecture ou d'écriture asynchrones simultanées qui utilisent la même structure I<aiocb> produisent des résultats indéfinis.

note: http://lse.sourceforge.net/io/aio.html http://lse.sourceforge.net/io/aionotes.txt http://lwn.net/Articles/148755/ type: Plain text
en: The current Linux POSIX AIO implementation is provided in user space by glibc.  This has a number of limitations, most notably that maintaining multiple threads to perform I/O operations is expensive and scales poorly.  Work has been in progress for some time on a kernel state-machine-based implementation of asynchronous I/O (see B<io_submit>(2), B<io_setup>(2), B<io_cancel>(2), B<io_destroy>(2), B<io_getevents>(2)), but this implementation hasn't yet matured to the point where the POSIX AIO implementation can be completely reimplemented using the kernel system calls.
fr: 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 B<io_submit>(2), B<io_setup>(2), B<io_cancel>(2), B<io_destroy>(2), B<io_getevents>(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.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The program below opens each of the files named in its command-line arguments and queues a request on the resulting file descriptor using B<aio_read>(3).  The program then loops, periodically monitoring each of the I/O operations that is still in progress using B<aio_error>(3).  Each of the I/O requests is set up to provide notification by delivery of a signal.  After all I/O requests have completed, the program retrieves their status using B<aio_return>(3).
fr: 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 B<aio_read>(3). Le programme boucle ensuite, en surveillant périodiquement toutes les opérations d'E/S en cours avec B<aio_error>(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 B<aio_return>(3).

note: type: Plain text
en: The B<SIGQUIT> signal (generated by typing control-\e) causes the program to request cancellation of each of the outstanding requests using B<aio_cancel>(3).
fr: Le signal B<SIGQUIT> (créé en tapant Contrôle-\e) provoque la demande d'annulation de chaque requête en cours avec B<aio_cancel>(3).

note: type: Plain text
en: Here is an example of what we might see when running this program.  In this example, the program queues two requests to standard input, and these are satisfied by two lines of input containing "abc" and "x".
fr: 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.

note: type: Plain text
en: $ B<./a.out /dev/stdin /dev/stdin>
    opened /dev/stdin on descriptor 3
    opened /dev/stdin on descriptor 4
    aio_error():
        for request 0 (descriptor 3): In progress
        for request 1 (descriptor 4): In progress
    B<abc>
    I/O completion signal received
    aio_error():
        for request 0 (descriptor 3): I/O succeeded
        for request 1 (descriptor 4): In progress
    aio_error():
        for request 1 (descriptor 4): In progress
    B<x>
    I/O completion signal received
    aio_error():
        for request 1 (descriptor 4): I/O succeeded
    All I/O requests completed
    aio_return():
        for request 0 (descriptor 3): 4
        for request 1 (descriptor 4): 2
fr: $ B<./a.out /dev/stdin /dev/stdin>
    /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
    B<abc>
    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
    B<x>
    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

note: type: SS
en: Program source
fr: Source du programme

note: type: Plain text
en: #define BUF_SIZE 20     /* Size of buffers for read operations */
fr: #define BUF_SIZE 20     /* Taille des tampons pour les opérations de lecture */

note: type: Plain text
en: struct ioRequest {      /* Application-defined structure for tracking
                               I/O requests */
        int           reqNum;
        int           status;
        struct aiocb *aiocbp;
    };
fr: struct ioRequest {      /* Structure spécifique à l'application
                               pour suivre les requêtes d'E/S */
        int           reqNum;
        int           status;
        struct aiocb *aiocbp;
    };

note: type: Plain text
en: static volatile sig_atomic_t gotSIGQUIT = 0;
                            /* On delivery of SIGQUIT, we attempt to
                               cancel all outstanding I/O requests */
fr: static volatile sig_atomic_t gotSIGQUIT = 0;
                            /* Essayer d'annuler toutes les requêtes d'E/S
                               en cours lors de la réception d'un SIGQUIT */

note: type: Plain text
en: static void             /* Handler for SIGQUIT */
    quitHandler(int sig)
    {
        gotSIGQUIT = 1;
    }
fr: static void             /* Gestionnaire pour SIGQUIT */
    quitHandler(int sig)
    {
        gotSIGQUIT = 1;
    }

note: type: Plain text
en: #define IO_SIGNAL SIGUSR1   /* Signal used to notify I/O completion */
fr: #define IO_SIGNAL SIGUSR1   /* Signal pour notifier la fin d'E/S */

note: type: Plain text
en: static void                 /* Handler for I/O completion signal */
    aioSigHandler(int sig, siginfo_t *si, void *ucontext)
    {
        write(STDOUT_FILENO, "I/O completion signal received\en", 31);
fr: static void                 /* Gestionnaire pour le signal de fin d'E/S */
    aioSigHandler(int sig, siginfo_t *si, void *ucontext)
    {
        write(STDOUT_FILENO, "Signal de fin d'E/S reçu\en", 31);

note: type: Plain text
en:     /* The corresponding ioRequest structure would be available as
               struct ioRequest *ioReq = si-E<gt>si_value.sival_ptr;
           and the file descriptor would then be available via
               ioReq-E<gt>aiocbp-E<gt>aio_fildes */
    }
fr:     /* La structure ioRequest correspondante serait disponible en
               struct ioRequest *ioReq = si-E<gt>si_value.sival_ptr;
           et le descripteur de fichier serait alors disponible via
               ioReq-E<gt>aiocbp-E<gt>aio_fildes */
    }

note: type: Plain text
en: int
    main(int argc, char *argv[])
    {
        struct ioRequest *ioList;
        struct aiocb *aiocbList;
        struct sigaction sa;
        int s, j;
        int numReqs;        /* Total number of queued I/O requests */
        int openReqs;       /* Number of I/O requests still in progress */
fr: int
    main(int argc, char *argv[])
    {
        struct ioRequest *ioList;
        struct aiocb *aiocbList;
        struct sigaction sa;
        int s, j;
        int numReqs;        /* Nombre total de requêtes d'E/S dans la file */
        int openReqs;       /* Nombre de requêtes d'E/S encore en cours */

note: type: Plain text
en:     if (argc E<lt> 2) {
            fprintf(stderr, "Usage: %s E<lt>pathnameE<gt> E<lt>pathnameE<gt>...\en",
                    argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc E<lt> 2) {
            fprintf(stderr, "Utilisation : %s E<lt>cheminE<gt> E<lt>cheminE<gt>...\en",
                    argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Allocate our arrays */
fr:     /* Allocation des tableaux */

note: type: Plain text
en:     /* Establish handlers for SIGQUIT and the I/O completion signal */
fr:     /* Mise en place des gestionnaires pour SIGQUIT et le signal de fin d'E/S */

note: type: Plain text
en:     /* Open each file specified on the command line, and queue
           a read request on the resulting file descriptor */
fr:     /* Ouverture de chaque fichier indiqué sur la ligne de commande, et mise en file
           d'attente d'une requête de lecture sur le descripteur de fichier correspondant */

note: type: Plain text
en:         ioList[j].aiocbp-E<gt>aio_fildes = open(argv[j + 1], O_RDONLY);
            if (ioList[j].aiocbp-E<gt>aio_fildes == -1)
                errExit("open");
            printf("opened %s on descriptor %d\en", argv[j + 1],
                    ioList[j].aiocbp-E<gt>aio_fildes);
fr:         ioList[j].aiocbp-E<gt>aio_fildes = open(argv[j + 1], O_RDONLY);
            if (ioList[j].aiocbp-E<gt>aio_fildes == -1)
                errExit("open");
            printf("%s ouvert sur le descripteur %d\en", argv[j + 1],
                    ioList[j].aiocbp-E<gt>aio_fildes);

note: type: Plain text
en:     /* Loop, monitoring status of I/O requests */
fr:     /* Boucle, surveillance de l'état des requêtes d'E/S */

note: type: Plain text
en:     while (openReqs E<gt> 0) {
            sleep(3);       /* Delay between each monitoring step */
fr:     while (openReqs E<gt> 0) {
            sleep(3);       /* Délai entre chaque étape de surveillance */

note: type: Plain text
en:             /* On receipt of SIGQUIT, attempt to cancel each of the
                   outstanding I/O requests, and display status returned
                   from the cancellation requests */
fr:             /* Lors de la réception de SIGQUIT, essayer d'annuler
                   toutes les requêtes d'E/S en cours, et afficher
                   l'état renvoyé par les requêtes d'annulation */

note: type: Plain text
en:             printf("got SIGQUIT; canceling I/O requests: \en");
fr:             printf("réception de SIGQUIT ; annulation des requêtes d'E/S : \en");

note: type: Plain text
en:             for (j = 0; j E<lt> numReqs; j++) {
                    if (ioList[j].status == EINPROGRESS) {
                        printf("    Request %d on descriptor %d:", j,
                                ioList[j].aiocbp-E<gt>aio_fildes);
                        s = aio_cancel(ioList[j].aiocbp-E<gt>aio_fildes,
                                ioList[j].aiocbp);
                        if (s == AIO_CANCELED)
                            printf("I/O canceled\en");
                        else if (s == AIO_NOTCANCELED)
                                printf("I/O not canceled\en");
                        else if (s == AIO_ALLDONE)
                            printf("I/O all done\en");
                        else
                            errMsg("aio_cancel");
                    }
                }
fr:             for (j = 0; j E<lt> numReqs; j++) {
                    if (ioList[j].status == EINPROGRESS) {
                        printf("    Requête %d sur le descripteur %d :", j,
                                ioList[j].aiocbp-E<gt>aio_fildes);
                        s = aio_cancel(ioList[j].aiocbp-E<gt>aio_fildes,
                                ioList[j].aiocbp);
                        if (s == AIO_CANCELED)
                            printf("E/S annulée\en");
                        else if (s == AIO_NOTCANCELED)
                                printf("E/S non annulée\en");
                        else if (s == AIO_ALLDONE)
                            printf("E/S terminée\en");
                        else
                            errMsg("aio_cancel");
                    }
                }

note: type: Plain text
en:         /* Check the status of each I/O request that is still
               in progress */
fr:         /* Vérification de l'état de toutes les
               requêtes d'E/S encore en cours */

note: type: Plain text
en:         printf("aio_error():\en");
            for (j = 0; j E<lt> numReqs; j++) {
                if (ioList[j].status == EINPROGRESS) {
                    printf("    for request %d (descriptor %d): ",
                            j, ioList[j].aiocbp-E<gt>aio_fildes);
                    ioList[j].status = aio_error(ioList[j].aiocbp);
fr:         printf("aio_error():\en");
            for (j = 0; j E<lt> numReqs; j++) {
                if (ioList[j].status == EINPROGRESS) {
                    printf("    pour la requête %d (descripteur %d) : ",
                            j, ioList[j].aiocbp-E<gt>aio_fildes);
                    ioList[j].status = aio_error(ioList[j].aiocbp);

note: type: Plain text
en:                 switch (ioList[j].status) {
                    case 0:
                        printf("I/O succeeded\en");
                        break;
                    case EINPROGRESS:
                        printf("In progress\en");
                        break;
                    case ECANCELED:
                        printf("Canceled\en");
                        break;
                    default:
                        errMsg("aio_error");
                        break;
                    }
fr:                 switch (ioList[j].status) {
                    case 0:
                        printf("E/S réussie\en");
                        break;
                    case EINPROGRESS:
                        printf("En cours\en");
                        break;
                    case ECANCELED:
                        printf("Annulée\en");
                        break;
                    default:
                        errMsg("aio_error");
                        break;
                    }

note: type: Plain text
en:     printf("All I/O requests completed\en");
fr:     printf("Toutes les requêtes d'E/S sont terminées\en");

note: type: Plain text
en:     /* Check status return of all I/O requests */
fr:     /* Vérification de l'état de retour de toutes les requêtes d'E/S */

note: type: Plain text
en:         s = aio_return(ioList[j].aiocbp);
            printf("    for request %d (descriptor %d): %zd\en",
                    j, ioList[j].aiocbp-E<gt>aio_fildes, s);
        }
fr:         s = aio_return(ioList[j].aiocbp);
            printf("    pour la requête %d (descripteur %d) : %zd\en",
                    j, ioList[j].aiocbp-E<gt>aio_fildes, s);
        }

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2012-05-08
fr: 8 mai 2012

note: type: Plain text
en: aio_cancel - cancel an outstanding asynchronous I/O request
fr: aio_cancel - Annuler une requête d'E/S asynchrone en cours

note: type: Plain text
en: Link with I<-lrt>.
fr: Effectuez l'édition des liens avec l'option I<-lrt>.

note: type: Plain text
en: The B<aio_cancel>()  function attempts to cancel outstanding asynchronous I/O requests for the file descriptor I<fd>.  If I<aiocbp> is NULL, all such requests are canceled.  Otherwise, only the request described by the control block pointed to by I<aiocbp> is canceled.  (See B<aio>(7)  for a description of the I<aiocb> structure.)
fr: La fonction B<aio_cancel>() tente d'annuler les requêtes d'E/S asynchrones en cours du descripteur de fichier I<fd>. Si I<aiocbp> est NULL, toutes ces requêtes sont annulées. Sinon, seule la requête décrite par le bloc de contrôle pointé par I<aiocbp> est annulée. Consultez B<aio>(7) pour une description de la structure I<aiocb>.

note: type: Plain text
en: Normal asynchronous notification occurs for canceled requests (see B<aio>(7)  and B<sigevent>(7)).  The request return status (B<aio_return>(3))  is set to -1, and the request error status (B<aio_error>(3))  is set to B<ECANCELED>.  The control block of requests that cannot be canceled is not changed.
fr: Une notification asynchrone normale survient pour les requêtes annulées (consultez B<aio>(7) et B<sigevent>(7)). L'état de retour de la requête (B<aio_return>(3)) est défini à -1 et l'état de l'erreur de la requête (B<aio_error>(3)) est défini à B<ECANCELED>. Le bloc de contrôle des requêtes qui n'ont pas été annulées n'est pas modifié.

note: type: Plain text
en: If the request could not be canceled, then it will terminate in the usual way after performing the I/O operation.  (In this case, B<aio_error>(3)  will return the status B<EINPROGRESSS>.)
fr: Si la requête n'a pas pu être annulée, elle se terminera comme d'habitude après avoir réalisé l'opération d'E/S (dans ce cas, B<aio_error>(3) renverra l'état B<EINPROGRESSS>).

note: type: Plain text
en: If I<aiocbp> is not NULL, and I<fd> differs from the file descriptor with which the asynchronous operation was initiated, unspecified results occur.
fr: Si I<aiocbp> n'est pas NULL et si I<fd> diffère du descripteur de fichier pour lequel l'opération asynchrone a été initiée, les résultats sont imprévisibles.

note: FreeBSD: not those on raw disk devices. type: Plain text
en: Which operations are cancelable is implementation-defined.
fr: Les opérations qui peuvent être annulées dépendent de l'implémentation.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: The B<aio_cancel>()  function returns one of the following values:
fr: La fonction B<aio_cancel>() renvoie une des valeurs suivantes :

note: type: Plain text
en: All requests were successfully canceled.
fr: Toutes les requêtes ont été annulées avec succès.

note: type: Plain text
en: At least one of the requests specified was not canceled because it was in progress.  In this case, one may check the status of individual requests using B<aio_error>(3).
fr: Au moins une des requêtes indiquées n'a pas été annulée parce qu'elle était en cours. Dans ce cas, l'état de chaque requête peut être vérifié en utilisant B<aio_error>(3).

note: type: Plain text
en: All requests had already been completed before the call.
fr: Toutes les requêtes étaient déjà achevées avant l'appel.

note: type: Plain text
en: An error occurred.  The cause of the error can be found by inspecting I<errno>.
fr: Une erreur est survenue. La raison de l'erreur est définie dans I<errno>.

note: type: Plain text
en: I<fd> is not a valid file descriptor.
fr: I<fd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: B<aio_cancel>()  is not implemented.
fr: B<aio_cancel>() n'est pas implémenté.

note: type: Plain text
en: The B<aio_cancel>()  function is available since glibc 2.1.
fr: La fonction B<aio_cancel>() est disponible depuis la glibc\ 2.1.

note: type: Plain text
en: See B<aio>(7).
fr: Consultez B<aio>(7).

note: type: TH
en: 2013-07-04
fr: 4 juillet 2013

note: type: Plain text
en: aio_error - get error status of asynchronous I/O operation
fr: aio_error - Récupérer l'état d'erreur d'une opération d'E/S asynchrone

note: type: Plain text
en: The B<aio_error>()  function returns the error status for the asynchronous I/O request with control block pointed to by I<aiocbp>.  (See B<aio>(7)  for a description of the I<aiocb> structure.)
fr: La fonction B<aio_error>() renvoie l'état d'erreur d'une requête d'E/S asynchrone dont le bloc de contrôle est pointé par I<aiocbp>. Consultez B<aio>(7) pour une description de la structure I<aiocb>.

note: type: Plain text
en: This function returns one of the following:
fr: Cette fonction renvoie une des valeurs suivantes :

note: type: Plain text
en: B<EINPROGRESS>, if the request has not been completed yet.
fr: B<EINPROGRESS>, si la requête n'est pas encore terminée.

note: type: Plain text
en: B<ECANCELED>, if the request was canceled.
fr: B<ECANCELED>, si la requête a été annulée.

note: type: Plain text
en: 0, if the request completed successfully.
fr: 0, si la requête s'est terminée avec succès.

note: type: Plain text
en: A positive error number, if the asynchronous I/O operation failed.  This is the same value that would have been stored in the I<errno> variable in the case of a synchronous B<read>(2), B<write>(2), B<fsync>(2), or B<fdatasync>(2)  call.
fr: Un numéro d'erreur positif si l'opération E/S asynchrone a échoué. La valeur renvoyée est la même que celle qui aurait été définie dans I<errno> dans le cas d'un appel synchrone à B<read>(2), B<write>(2), B<fsync>(2) ou B<fdatasync>(2).

note: type: Plain text
en: I<aiocbp> does not point at a control block for an asynchronous I/O request of which the return status (see B<aio_return>(3))  has not been retrieved yet.
fr: I<aiocbp> ne pointe pas vers un bloc de contrôle d'une requête d'E/S asynchrone pour laquelle l'état de retour (consultez B<aio_return>(3)) n'a pas encore été récupéré.

note: type: Plain text
en: B<aio_error>()  is not implemented.
fr: B<aio_error>() n'est pas implémenté.

note: type: Plain text
en: The B<aio_error>()  function is available since glibc 2.1.
fr: La fonction B<aio_error>() est disponible depuis la glibc\ 2.1.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<aio_error>()  function is thread-safe.
fr: La fonction B<aio_error>() est sûre dans un contexte multithread.

note: type: Plain text
en: aio_fsync - asynchronous file synchronization
fr: aio_fsync - Synchronisation de fichier asynchrone

note: type: Plain text
en: The B<aio_fsync>()  function does a sync on all outstanding asynchronous I/O operations associated with I<aiocbp-E<gt>aio_fildes>.  (See B<aio>(7)  for a description of the I<aiocb> structure.)
fr: La fonction B<aio_fsync>() effectue une synchronisation de toutes les opérations d'E/S asynchrones en cours associées à I<aiocbp-E<gt>aio_fildes>. Consultez B<aio>(7) pour une description de la structure I<aiocb>.

note: type: Plain text
en: More precisely, if I<op> is B<O_SYNC>, then all currently queued I/O operations shall be completed as if by a call of B<fsync>(2), and if I<op> is B<O_DSYNC>, this call is the asynchronous analog of B<fdatasync>(2).
fr: Plus précisément, si I<op> est défini à B<O_SYNC>, alors toutes les opérations d'E/S actuellement en file d'attente seront achevées comme avec un appel à B<fsync>(2), et si I<op> est défini à B<O_DSYNC>, cet appel est la version asynchrone de l'appel B<fdatasync>(2).

note: type: Plain text
en: Note that this is a request only; it does not wait for I/O completion.
fr: Veuillez noter qu'il ne s'agit que d'une requête ; cet appel n'attend pas la fin des E/S.

note: type: Plain text
en: Apart from I<aio_fildes>, the only field in the structure pointed to by I<aiocbp> that is used by this call is the I<aio_sigevent> field (a I<sigevent> structure, described in B<sigevent>(7)), which indicates the desired type of asynchronous notification at completion.  All other fields are ignored.
fr: À part I<aio_fildes>, le seul membre de la structure pointée par I<aiocbp> qui soit utilisé par cet appel est le membre I<aio_sigevent> (une structure I<sigevent> décrite dans B<sigevent>(7)) qui indique le type de notification asynchrone désiré à l'achèvement. Tous les autres membres sont ignorés.

note: type: Plain text
en: On success (the sync request was successfully queued)  this function returns 0.  On error, -1 is returned, and I<errno> is set appropriately.
fr: En cas de réussite (la requête de synchronisation a été mise avec succès dans la file d'attente), la fonction renvoie 0. En cas d'erreur, -1 est renvoyé et I<errno> est définie en conséquence.

note: type: Plain text
en: Out of resources.
fr: Ressources insuffisantes.

note: type: Plain text
en: I<aio_fildes> is not a valid file descriptor open for writing.
fr: I<aio_fildes> n'est pas un descripteur de fichier valable ouvert en écriture.

note: type: Plain text
en: Synchronized I/O is not supported for this file, or I<op> is not B<O_SYNC> or B<O_DSYNC>.
fr: Ce fichier ne gère pas les E/S synchronisées, ou I<op> n'est pas B<O_SYNC> ou B<O_DSYNC>.

note: type: Plain text
en: B<aio_fsync>()  is not implemented.
fr: B<aio_fsync>() n'est pas implémenté.

note: type: Plain text
en: The B<aio_fsync>()  function is available since glibc 2.1.
fr: La fonction B<aio_fsync>() est disponible depuis la glibc\ 2.1.

note: type: TH
en: 2012-04-26
fr: 26 avril 2012

note: type: Plain text
en: aio_init - asynchronous I/O initialization
fr: aio_init - Initialisation des E/S asynchrone

note: type: Plain text
en: B<#define _GNU_SOURCE>         /* See feature_test_macros(7) */
    B<#include E<lt>aio.hE<gt>>
fr: B<#define _GNU_SOURCE>         /* Consultez feature_test_macros(7) */
    B<#include E<lt>aio.hE<gt>>

note: type: Plain text
en: The GNU-specific B<aio_init>()  function allows the caller to provide tuning hints to the glibc POSIX AIO implementation.  Use of this function is optional, but to be effective, it must be called before employing any other functions in the POSIX AIO API.
fr: La fonction GNU spécifique B<aio_init>() permet à l'appelant de configurer plus finement l'implémentation AIO POSIX de la glibc. L'utilisation de cette fonction est optionnelle, mais elle doit être appelée avant tout emploi d'une autre fonction de l'API AIO POSIX pour être effective.

note: type: Plain text
en: The tuning information is provided in the buffer pointed to by the argument I<init>.  This buffer is a structure of the following form:
fr: Les informations de configuration fine sont fournies dans le tampon pointé par le paramètre I<init>. Ce tampon est une structure au format suivant\ :

note: type: Plain text
en: struct aioinit {
        int aio_threads;    /* Maximum number of threads */
        int aio_num;        /* Number of expected simultaneous
                               requests */
        int aio_locks;      /* Not used */
        int aio_usedba;     /* Not used */
        int aio_debug;      /* Not used */
        int aio_numusers;   /* Not used */
        int aio_idle_time;  /* Number of seconds before idle thread
                               terminates (since glibc 2.2) */
        int aio_reserved;
    };
fr: struct aioinit {
        int aio_threads;    /* Nombre maximal de processus légers */
        int aio_num;        /* Nombre de requêtes simultanées attendu */
        int aio_locks;      /* Pas utilisé */
        int aio_usedba;     /* Pas utilisé */
        int aio_debug;      /* Pas utilisé */
        int aio_numusers;   /* Pas utilisé */
        int aio_idle_time;  /* Nombre de secondes avant que le
                               processus léger idle se termine
                               (depuis la glibc 2.2) */
        int aio_reserved;
    };

note: type: Plain text
en: The following fields are used in the I<aioinit> structure:
fr: Les champs suivants sont utilisés dans la structure I<aioinit>\ :

note: type: Plain text
en: This field specifies the maximum number of worker threads that may be used by the implementation.  If the number of outstanding I/O operations exceeds this limit, then excess operations will be queued until a worker thread becomes free.  If this field is specified with a value less than 1, the value 1 is used.  The default value is 20.
fr: Ce champ spécifie le nombre maximal de processus légers de travail qui peuvent être utilisés par l'implémentation. Si le nombre d'opérations d'E/S en suspens dépasse cette limite, alors les opérations en trop seront mis en file d'attente jusqu'à la libération d'un processus léger de travail. Si la valeur de ce champ est inférieur à 1, la valeur 1 est utilisée. La valeur par défaut est 20.

note: FIXME But, if aio_num > 32, the behavior looks strange. See http://sourceware.org/bugzilla/show_bug.cgi?id=12083 type: Plain text
en: This field should specify the maximum number of simultaneous I/O requests that the caller expects to enqueue.  If a value less than 32 is specified for this field, it is rounded up to 32.  The default value is 64.
fr: Ce champ spécifie le nombre maximal de requêtes d'E/S simultanées que l'appelant s'attend à mettre en file d'attente. Si la valeur du champ est inférieure à 32, la valeur 32 est utilisée. La valeur par défaut est 64.

note: type: Plain text
en: This field specifies the amount of time in seconds that a worker thread should wait for further requests before terminating, after having completed a previous request.  The default value is 1.
fr: Ce champ spécifie le nombre de secondes d'attente d'autres requêtes du processus léger de travail avant de se terminer, après avoir terminer un précédente requête. La valeur par défaut est 1.

note: type: Plain text
en: The B<aio_init>()  function is available since glibc 2.1.
fr: La fonction B<aio_init>() est disponible depuis la glibc\ 2.1.

note: type: Plain text
en: This function is a GNU extension.
fr: Cette fonction est une extension GNU.

note: type: Plain text
en: aio_read - asynchronous read
fr: aio_read - Lecture asynchrone

note: type: Plain text
en: The B<aio_read>()  function queues the I/O request described by the buffer pointed to by I<aiocbp>.  This function is the asynchronous analog of B<read>(2).  The arguments of the call
fr: La fonction B<aio_read>() met en file d'attente les requêtes d'E/S décrites par le tampon pointé par I<aiocb>. Cette fonction est la version asynchrone de B<read>(2). Les arguments de l'appel

note: type: Plain text
en: correspond (in order) to the fields I<aio_fildes>, I<aio_buf>, and I<aio_nbytes> of the structure pointed to by I<aiocbp>.  (See B<aio>(7)  for a description of the I<aiocb> structure.)
fr: correspondent (dans l'ordre) au membre I<aio_fildes>, I<aio_buf> et I<aio_nbytes> de la structure pointée par I<aiocbp>. Consultez B<aio>(7) pour une description de la structure I<aiocb>.

note: type: Plain text
en: The data is read starting at the absolute file offset I<aiocbp-E<gt>aio_offset>, regardless of the current file offset.  After the call, the value of the current file offset is unspecified.
fr: La donnée est lue en commençant au décalage absolu du fichier I<aiocbp-E<gt>aio_offset>, quelle que soit la position actuelle du pointeur sur le fichier. Après cet appel, la valeur de la position courante du pointeur du fichier est indéfinie.

note: type: Plain text
en: The "asynchronous" means that this call returns as soon as the request has been enqueued; the read may or may not have completed when the call returns.  One tests for completion using B<aio_error>(3).  The return status of a completed I/O operation can be obtained by B<aio_return>(3).  Asynchronous notification of I/O completion can be obtained by setting I<aiocbp-E<gt>aio_sigevent> appropriately; see B<sigevent>(7)  for details.
fr: «\ Asynchrone\ » signifie que cet appel renvoie aussitôt que la requête a été mise dans la file d'attente\ ; la lecture peut être ou ne pas être achevée lorsque l'appel renvoie. On peut tester cet achèvement en utilisant B<aio_error>(3). La valeur de retour d'une opération d'E/S complétée peut être obtenue avec B<aio_return>(3). La notification asynchrone de la fin de l'E/S peut être obtenue en définissant I<aiocbp-E<gt>aio_sigevent> de façon appropriée. Consultez B<sigevent>(7) pour plus de détails.

note: type: Plain text
en: If B<_POSIX_PRIORITIZED_IO> is defined, and this file supports it, then the asynchronous operation is submitted at a priority equal to that of the calling process minus I<aiocbp-E<gt>aio_reqprio>.
fr: Si B<_POSIX_PRIORITIZED_IO> est définie et si le fichier le supporte, l'opération asynchrone est soumise à une priorité égale à celle du processus appelant moins I<aiocbp-E<gt>aio_reqprio>.

note: type: Plain text
en: The field I<aiocbp-E<gt>aio_lio_opcode> is ignored.
fr: Le membre I<aiocbp-E<gt>aio_lio_opcode> est ignoré.

note: type: Plain text
en: No data is read from a regular file beyond its maximum offset.
fr: Aucune donnée n'est lue dans un fichier régulier au-delà de son décalage maximum.

note: type: Plain text
en: On success, 0 is returned.  On error, the request is not enqueued, -1 is returned, and I<errno> is set appropriately.  If an error is detected only later, it will be reported via B<aio_return>(3)  (returns status -1) and B<aio_error>(3)  (error status\(emwhatever one would have gotten in I<errno>, such as B<EBADF>).
fr: En cas de réussite, 0 est renvoyé. En cas d'erreur, la requête n'est pas mise dans la file d'attente, -1 est renvoyé et I<errno> est définie en conséquence. Si une erreur est détectée plus tard, elle sera signalée via B<aio_return>(3) (état de retour -1) et B<aio_error>(3) (état d'erreur\ : tout ce qu'on veut, récupéré dans I<errno>, comme B<EBADF>).

note: type: Plain text
en: I<aio_fildes> is not a valid file descriptor open for reading.
fr: I<aio_fildes> n'est pas un descripteur de fichier valable ouvert en lecture.

note: type: Plain text
en: One or more of I<aio_offset>, I<aio_reqprio>, or I<aio_nbytes> are invalid.
fr: Une ou plusieurs valeurs parmi I<aio_offset>, I<aio_reqprio> ou I<aio_nbytes> ne sont pas valables.

note: type: Plain text
en: B<aio_read>()  is not implemented.
fr: B<aio_read>() n'est pas implémenté.

note: type: Plain text
en: The file is a regular file, we start reading before end-of-file and want at least one byte, but the starting position is past the maximum offset for this file.
fr: Le fichier est un fichier régulier, nous avons commencé la lecture avant la fin de fichier et voulons au moins un octet, mais la position de départ a dépassé le décalage maximum du fichier.

note: type: Plain text
en: The B<aio_read>()  function is available since glibc 2.1.
fr: La fonction B<aio_read>() est disponible depuis la glibc\ 2.1.

note: or the control block of the operation type: Plain text
en: It is a good idea to zero out the control block before use.  The control block must not be changed while the read operation is in progress.  The buffer area being read into must not be accessed during the operation or undefined results may occur.  The memory areas involved must remain valid.
fr: C'est une bonne idée de mettre à zéro le bloc de contrôle avant de l'utiliser. Ce bloc de contrôle ne doit pas être modifié pendant l'opération de lecture. Il ne faut pas accéder à la zone tampon à lire pendant l'opération, sinon des résultats indéfinis peuvent survenir. Les zones mémoires atteintes doivent rester valables.

note: type: Plain text
en: Simultaneous I/O operations specifying the same I<aiocb> structure produce undefined results.
fr: Des opérations d'E/S simultanées spécifiant la même structure I<aiocb> produisent des résultats indéfinis.

note: type: Plain text
en: aio_return - get return status of asynchronous I/O operation
fr: aio_return - Récupérer l'état de retour d'une opération d'E/S asynchrone

note: type: Plain text
en: The B<aio_return>()  function returns the final return status for the asynchronous I/O request with control block pointed to by I<aiocbp>.  (See B<aio>(7)  for a description of the I<aiocb> structure.)
fr: La fonction B<aio_return>() renvoie l'état de retour final d'une requête d'E/S asynchrone dont le bloc de contrôle est pointé par I<aiocbp>. Consultez B<aio>(7) pour une description de la structure I<aiocb>.

note: type: Plain text
en: This function should be called only once for any given request, after B<aio_error>(3)  returns something other than B<EINPROGRESS>.
fr: Cette fonction ne devrait être appelée qu'une seule fois pour une requête donnée, après que la fonction B<aio_error>(3) a renvoyé autre chose que B<EINPROGRESS>.

note: type: Plain text
en: If the asynchronous I/O operation has completed, this function returns the value that would have been returned in case of a synchronous B<read>(2), B<write>(2), B<fsync>(2)  or B<fdatasync>(2), call.
fr: Si l'opération d'E/S asynchrone s'est achevée, cette fonction renvoie la valeur qui aurait été retournée dans le cas d'un appel synchrone à B<read>(2), B<write>(2), B<fsync>(2) ou B<fdatasync>(2).

note: type: Plain text
en: If the asynchronous I/O operation has not yet completed, the return value and effect of B<aio_return>()  are undefined.
fr: Si l'opération asynchrone d'E/S n'est pas terminée, la valeur renvoyée et l'effet de B<aio_return>() est indéfini.

note: type: Plain text
en: I<aiocbp> does not point at a control block for an asynchronous I/O request of which the return status has not been retrieved yet.
fr: I<aiocbp> ne pointe pas vers un bloc de contrôle d'une une requête d'E/S asynchrone pour laquelle l'état de retour n'a pas encore été récupéré.

note: type: Plain text
en: B<aio_return>()  is not implemented.
fr: B<aio_return>() n'est pas implémenté.

note: type: Plain text
en: The B<aio_return>()  function is available since glibc 2.1.
fr: La fonction B<aio_return>() est disponible depuis la glibc\ 2.1.

note: type: Plain text
en: The B<aio_return>()  function is thread-safe.
fr: La fonction B<aio_return>() est sûre dans un contexte multithread.

note: type: Plain text
en: aio_suspend - wait for asynchronous I/O operation or timeout
fr: aio_suspend - Attendre une opération d'E/S asynchrone ou un délai

note: type: Plain text
en: Link with I<-lrt>.
fr: Effectuez l'édition des liens avec l'option I<-lrt>.

note: type: Plain text
en: The B<aio_suspend>()  function suspends the calling thread until one of the following occurs:
fr: La fonction B<aio_suspend>() suspend le processus léger appelant tant que l'un des événements suivants ne se produisent :

note: type: Plain text
en: One or more of the asynchronous I/O requests in the list I<aiocb_list> has completed.
fr: Une ou plusieurs requêtes asynchrones d'E/S de la liste I<aiocb_list> se sont terminées.

note: type: Plain text
en: A signal is delivered.
fr: Un signal est reçu.

note: type: Plain text
en: I<timeout> is not NULL and the specified time interval has passed.  (For details of the I<timespec> structure, see B<nanosleep>(2).)
fr: I<timeout> est non NULL et l'intervalle de temps spécifié a expiré. Consultez B<nanospleep>(2) pour plus de détails sur la structure I<timespec>.

note: type: Plain text
en: The I<nitems> argument specifies the number of items in I<aiocb_list>.  Each item in the list pointed to by I<aiocb_list> must be either NULL (and then is ignored), or a pointer to a control block on which I/O was initiated using B<aio_read>(3), B<aio_write>(3), or B<lio_listio>(3).  (See B<aio>(7)  for a description of the I<aiocb> structure.)
fr: Le paramètre I<nitems> spécifie le nombre d'éléments dans I<aiocb_list>. Chaque élément de la liste pointée par I<aiocb_list> doit être soit NULL (auquel cas il est ignoré), soit un pointeur vers un bloc de contrôle sur lequel a été initiée une E/S en utilisant B<aio_read>(3), B<aio_write>(3), ou B<lio_listio>(3). Consultez B<aio>(7) pour une description de la structure I<aiocb>.

note: type: Plain text
en: If B<CLOCK_MONOTONIC> is supported, this clock is used to measure the timeout interval (see B<clock_gettime>(3)).
fr: Si B<CLOCK_MONOTONIC> est géré, cette horloge est utilisée pour mesurer l'intervalle de dépassement du délai (consultez B<clock_gettime>(3)).

note: type: Plain text
en: If this function returns after completion of one of the I/O requests specified in I<aiocb_list>, 0 is returned.  Otherwise, -1 is returned, and I<errno> is set to indicate the error.
fr: Si cette fonction se termine après l'achèvement de l'une des requêtes d'E/S indiquées dans I<aiocb_list>, elle renvoie 0. Autrement, elle renvoie -1 et définit I<errno> en conséquence.

note: type: Plain text
en: The call timed out before any of the indicated operations had completed.
fr: L'appel s'est achevé par un dépassement de délai avant qu'au moins une des opérations indiquées ne soit terminée.

note: type: Plain text
en: The call was ended by signal (possibly the completion signal of one of the operations we were waiting for); see B<signal>(7).
fr: L'appel s'est achevé par un signal ; consultez B<signal>(7). (Il est possible que ce soit un signal d'achèvement de l'une des opérations que l'on attendait).

note: type: Plain text
en: B<aio_suspend>()  is not implemented.
fr: B<aio_suspend>() n'est pas implémenté.

note: type: Plain text
en: The B<aio_suspend>()  function is available since glibc 2.1.
fr: La fonction B<aio_suspend>() est disponible depuis la glibc\ 2.1.

note: type: Plain text
en: One can achieve polling by using a non-NULL I<timeout> that specifies a zero time interval.
fr: Il est possible d'effectuer une scrutation en utilisant un délai I<timeout> non nul qui spécifie un intervalle de temps nul.

note: type: Plain text
en: If one or more of the asynchronous I/O operations specified in I<aiocb_list> has already completed at the time of the call to B<aio_suspend>(), then the call returns immediately.
fr: Si une ou plusieurs opérations d'E/S asynchrones spécifiées dans I<aiocb_list> se sont déjà terminées au moment de l'appel à B<aio_suspend>(), alors l'appel renvoie immédiatement.

note: type: Plain text
en: To determine which I/O operations have completed after a successful return from B<aio_suspend>(), use B<aio_error>(3)  to scan the list of I<aiocb> structures pointed to by I<aiocb_list>.
fr: Pour déterminer quelles opérations d'E/S se sont terminées après un retour avec succès de B<aio_suspend>(), utilisez B<aio_error>(3) pour parcourir les structures I<aiocb> pointées par I<aiocb_list>.

note: type: Plain text
en: aio_write - asynchronous write
fr: aio_write - Écriture asynchrone

note: type: Plain text
en: The B<aio_write>()  function queues the I/O request described by the buffer pointed to by I<aiocbp>.  This function is the asynchronous analog of B<write>(2).  The arguments of the call
fr: La fonction B<aio_write>() met en file d'attente la requête d'E/S décrite par le tampon pointé par I<aiocbp>. Cette fonction est la version asynchrone de B<write>(2). Les paramètres de l'appel sont

note: type: Plain text
en: If B<O_APPEND> is not set, the data is written starting at the absolute file offset I<aiocbp-E<gt>aio_offset>, regardless of the current file offset.  If B<O_APPEND> is set, data is written at the end of the file in the same order as B<aio_write>()  calls are made.  After the call, the value of the current file offset is unspecified.
fr: Si B<O_APPEND> n'est pas défini, la donnée est écrite en commençant au décalage absolu du fichier I<aiocbp-E<gt>aio_offset>, quelle que soit la position actuelle dans le fichier. Si B<O_APPEND> est défini, les données sont écrites à la fin du fichier dans le même ordre que B<aio_write>(). Après cet appel, la valeur de la position «\ courante\ » dans le fichier est indéfinie.

note: type: Plain text
en: The "asynchronous" means that this call returns as soon as the request has been enqueued; the write may or may not have completed when the call returns.  One tests for completion using B<aio_error>(3).  The return status of a completed I/O operation can be obtained B<aio_return>(3).  Asynchronous notification of I/O completion can be obtained by setting I<aiocbp-E<gt>aio_sigevent> appropriately; see B<sigevent>(7)  for details.
fr: «\ Asynchrone\ » signifie que cet appel se termine aussitôt que la requête a été mise dans la file d'attente\ ; l'écriture peut être ou ne pas être achevée lorsque l'appel termine. On peut tester cet achèvement en utilisant B<aio_error>(3). La valeur de retour d'une opération d'E/S complétée peut être obtenue avec B<aio_return>(3). La notification asynchrone de la fin de l'E/S peut être obtenue en définissant I<aiocbp-E<gt>aio_sigevent> de façon  appropriée. Consultez B<sigevent>(7) pour plus de détails.

note: type: Plain text
en: No data is written to a regular file beyond its maximum offset.
fr: Aucune donnée n'est écrite dans un fichier régulier au-delà de son décalage maximum.

note: type: Plain text
en: The file is a regular file, we want to write at least one byte, but the starting position is at or beyond the maximum offset for this file.
fr: Le fichier est un fichier régulier, nous voulons écrire au moins un octet, mais la position de départ est égale, ou au-delà du décalage maximum du fichier.

note: type: Plain text
en: One or more of I<aio_offset>, I<aio_reqprio>, I<aio_nbytes> are invalid.
fr: Une ou plusieurs valeurs parmi I<aio_offset>, I<aio_reqprio>, I<aio_nbytes> ne sont pas valables.

note: type: Plain text
en: B<aio_write>()  is not implemented.
fr: B<aio_write>() n'est pas implémenté.

note: type: Plain text
en: The B<aio_write>()  function is available since glibc 2.1.
fr: La fonction B<aio_write>() est disponible depuis la glibc\ 2.1.

note: or the control block of the operation type: Plain text
en: It is a good idea to zero out the control block before use.  The control block must not be changed while the write operation is in progress.  The buffer area being written out must not be accessed during the operation or undefined results may occur.  The memory areas involved must remain valid.
fr: C'est une bonne idée de mettre à zéro le bloc de contrôle avant de l'utiliser. Ce bloc de contrôle ne doit pas être modifié pendant l'opération d'écriture. Il ne faut pas accéder à la zone tampon à écrire pendant l'opération car des résultats indéfinis peuvent survenir. Les zones mémoires atteintes doivent rester valables.

note: type: TH
en: 2013-04-10
fr: 10 avril 2013

note: type: Plain text
en: io_cancel - cancel an outstanding asynchronous I/O operation
fr: io_cancel - Annuler une opération d'entrée-sortie asynchrone en attente

note: type: Plain text
en: B<#include E<lt>linux/aio_abi.hE<gt>>          /* Defines needed types */
fr: B<#include E<lt>linux/aio_abi.hE<gt>>          /* Définit les types nécessaires */

note: type: Plain text
en: I<Note>: There is no glibc wrapper for this system call; see NOTES.
fr: I<Remarque> : il n'existe pas de fonction glibc autour de cet appel système ; consultez B<NOTES>.

note: type: Plain text
en: The B<io_cancel>()  system call attempts to cancel an asynchronous I/O operation previously submitted with B<io_submit>(2).  The I<iocb> argument describes the operation to be canceled and the I<ctx_id> argument is the AIO context to which the operation was submitted.  If the operation is successfully canceled, the event will be copied into the memory pointed to by I<result> without being placed into the completion queue.
fr: L'appel système B<io_cancel>() essaye d'annuler l'opération d'E/S asynchrone précédemment soumise par l'appel B<io_submit>(2). L'argument I<iocb> décrit l'opération à annuler et l'argument I<ctx_id> est le contexte d'E/S asynchrone auquel l'opération a été soumise. Si l'opération est correctement annulée, l'événement sera copié dans la zone pointée par I<result> sans être placé dans la file des événements terminés.

note: type: Plain text
en: On success, B<io_cancel>()  returns 0.  For the failure return, see NOTES.
fr: B<io_cancel>() renvoie zéro s'il réussit. Pour les valeurs de retour en cas d'échec, consultez la section NOTES.

note: type: Plain text
en: The I<iocb> specified was not canceled.
fr: L'opération I<iocb> n'a pas été annulée.

note: type: Plain text
en: One of the data structures points to invalid data.
fr: L'une des structures de données pointe sur une zone invalide.

note: type: Plain text
en: The AIO context specified by I<ctx_id> is invalid.
fr: Le contexte indiqué par I<ctx_id> est invalide.

note: type: Plain text
en: B<io_cancel>()  is not implemented on this architecture.
fr: L'appel système B<io_cancel>() n'est pas implémenté sur cette architecture.

note: type: Plain text
en: The asynchronous I/O system calls first appeared in Linux 2.5.
fr: Les appels système d'entrées-sorties asynchrones sont apparus dans Linux 2.5.

note: type: Plain text
en: B<io_cancel>()  is Linux-specific and should not be used in programs that are intended to be portable.
fr: B<io_cancel>() est spécifique à Linux et ne doit pas être utilisé dans des programmes destinés à être portables.

note: http://git.fedorahosted.org/git/?p=libaio.git type: Plain text
en: Glibc does not provide a wrapper function for this system call.  You could invoke it using B<syscall>(2).  But instead, you probably want to use the B<io_cancel>()  wrapper function provided by I<libaio>.
fr: La glibc ne fournit pas de fonction autour de cet appel système. Vous pourriez l'invoquer en utilisant B<syscall>(2), mais vous préférerez sans doute utiliser la fonction enveloppe B<io_cancel>() fournie par I<libaio>.

note: But glibc is confused, since <libaio.h> uses 'io_context_t' to declare the system call. type: Plain text
en: Note that the I<libaio> wrapper function uses a different type (I<io_context_t>)  for the I<ctx_id> argument.  Note also that the I<libaio> wrapper does not follow the usual C library conventions for indicating errors: on error it returns a negated error number (the negative of one of the values listed in ERRORS).  If the system call is invoked via B<syscall>(2), then the return value follows the usual conventions for indicating an error: -1, with I<errno> set to a (positive) value that indicates the error.
fr: Remarquez que la fonction enveloppe I<libaio> utilise un autre type (I<io_context_t>) pour l'argument I<ctx_id>. Remarquez également que l'enveloppe I<libaio> ne suit pas les conventions classiques de la bibliothèque C concernant l'indication des erreurs : en cas d'erreur, la fonction renvoie un nombre négatif (la valeur négative de l'une des valeurs indiquées dans la section B<ERREURS>). Si l'appel système est invoqué avec B<syscall>(2), la valeur de retour suit les conventions classiques pour indiquer l'erreur : -1 avec I<errno> contenant le code (positif) de l'erreur.

note: type: TH
en: 2013-04-08
fr: 8 avril 2013

note: type: Plain text
en: io_destroy - destroy an asynchronous I/O context
fr: io_destroy - Détruire un contexte d'entrées-sorties asynchrones

note: type: Plain text
en: The B<io_destroy>()  system call will attempt to cancel all outstanding asynchronous I/O operations against I<ctx_id>, will block on the completion of all operations that could not be canceled, and will destroy the I<ctx_id>.
fr: L'appel système B<io_destroy>() essayera d'annuler toutes les opérations d'E/S asynchrones en attente de I<ctx_id>, bloquera la fin de toutes les opérations qui ne pourraient pas être annulées et détruira le I<ctx_id>.

note: type: Plain text
en: On success, B<io_destroy>()  returns 0.  For the failure return, see NOTES.
fr: B<io_destroy>() renvoie zéro s'il réussit. Pour les valeurs de retour en cas d'échec, consultez la section NOTES.

note: type: Plain text
en: The context pointed to is invalid.
fr: Le contexte pointé est invalide.

note: type: Plain text
en: B<io_destroy>()  is not implemented on this architecture.
fr: B<io_destroy>() n'est pas implémenté sur ce noyau.

note: type: Plain text
en: B<io_destroy>()  is Linux-specific and should not be used in programs that are intended to be portable.
fr: B<io_destroy>() est spécifique à Linux et ne doit pas être utilisé dans des programmes destinés à être portables.

note: http://git.fedorahosted.org/git/?p=libaio.git type: Plain text
en: Glibc does not provide a wrapper function for this system call.  You could invoke it using B<syscall>(2).  But instead, you probably want to use the B<io_destroy>()  wrapper function provided by I<libaio>.
fr: La glibc ne fournit pas de fonction autour de cet appel système. Vous pourriez l'invoquer en utilisant B<syscall>(2), mais vous préférerez sans doute utiliser la fonction enveloppe B<io_destroy>() fournie par I<libaio>.

note: type: Plain text
en: io_getevents - read asynchronous I/O events from the completion queue
fr: io_getevents - Lire les événements d'E/S asynchrones terminés

note: type: Plain text
en: B<#include E<lt>linux/aio_abi.hE<gt>>         /* Defines needed types */
    B<#include E<lt>linux/time.hE<gt>>            /* Defines 'struct timespec' */
fr: B<#include E<lt>linux/aio_abi.hE<gt>>         /* Définit les types nécessaires */
    B<#include E<lt>linux/time.hE<gt>>            /* Définit « struct timespec » */

note: type: Plain text
en: The B<io_getevents>()  system call attempts to read at least I<min_nr> events and up to I<nr> events from the completion queue of the AIO context specified by I<ctx_id>.  The I<timeout> argument specifies the amount of time to wait for events, where a NULL timeout waits until at least I<min_nr> events have been seen.  Note that I<timeout> is relative.
fr: L'appel système B<io_getevents>() essaye de lire de I<min_nr> à I<nr> événements de la file des événements terminés du contexte d'entrées-sorties asynchrones I<ctx_id>. L'argument I<timeout> indique une durée maximale d'attente pour les événements. S'il est NULL, l'attente dure jusqu'à avoir au moins I<min_nr> événements. Remarquez que I<timeout> est relatif.

note: type: Plain text
en: On success, B<io_getevents>()  returns the number of events read: 0 if no events are available, or less than I<min_nr> if the I<timeout> has elapsed.  For the failure return, see NOTES.
fr: B<io_getevents>() renvoie le nombre d'événements lus, zéro s'il n'y en a aucun, et moins de I<min_nr> si le délai I<timeout> a expiré. Pour les valeurs de retour en cas d'échec, consultez la section NOTES.

note: type: Plain text
en: Either I<events> or I<timeout> is an invalid pointer.
fr: I<events> ou I<timeout> est un pointeur invalide.

note: type: Plain text
en: I<ctx_id> is invalid.  I<min_nr> is out of range or I<nr> is out of range.
fr: I<ctx_id> est invalide, I<min_nr> ou I<nr> est incorrect.

note: type: Plain text
en: Interrupted by a signal handler; see B<signal>(7).
fr: L'appel a été interrompu par un gestionnaire de signal ; consultez B<signal>(7).

note: type: Plain text
en: B<io_getevents>()  is not implemented on this architecture.
fr: B<io_getevents>() n'est pas implémenté sur cette architecture.

note: type: Plain text
en: B<io_getevents>()  is Linux-specific and should not be used in programs that are intended to be portable.
fr: B<io_getevents>() est spécifique à Linux et ne doit pas être utilisé dans des programmes destinés à être portables.

note: http://git.fedorahosted.org/git/?p=libaio.git type: Plain text
en: Glibc does not provide a wrapper function for this system call.  You could invoke it using B<syscall>(2).  But instead, you probably want to use the B<io_getevents>()  wrapper function provided by I<libaio>.
fr: La glibc ne fournit pas de fonction autour de cet appel système. Vous pourriez l'invoquer en utilisant B<syscall>(2), mais vous préférerez sans doute utiliser la fonction enveloppe B<io_getevents>() fournie par I<libaio>.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: An invalid I<ctx_id> may cause a segmentation fault instead of generating the error B<EINVAL>.
fr: Un I<ctx_id> invalide peut provoquer une erreur de segmentation au lieu de générer une erreur B<EINVAL>.

note: type: TH
en: 2013-06-21
fr: 21 juin 2013

note: type: Plain text
en: io_setup - create an asynchronous I/O context
fr: io_setup - Créer un contexte d'entrées-sorties asynchrones

note: type: Plain text
en: The B<io_setup>()  system call creates an asynchronous I/O context suitable for concurrently processing I<nr_events> operations.  The I<ctx_idp> argument must not point to an AIO context that already exists, and must be initialized to 0 prior to the call.  On successful creation of the AIO context, I<*ctx_idp> is filled in with the resulting handle.
fr: L'appel système B<io_setup>() crée un contexte d'E/S asynchrone capable de traiter simultanément I<nr_events>. L'argument I<ctx_idp> ne doit pas pointer sur un contexte déjà existant et doit être initialisé à zéro avant l'appel. Si la création de contexte réussit, I<*ctx_idp> est rempli avec le descripteur résultant.

note: type: Plain text
en: On success, B<io_setup>()  returns 0.  For the failure return, see NOTES.
fr: B<io_setup>() renvoie zéro s'il réussit. Pour les valeurs de retour en cas d'échec, consultez la section NOTES.

note: type: Plain text
en: The specified I<nr_events> exceeds the user's limit of available events, as defined in I</proc/sys/fs/aio-max-nr>.
fr: La valeur I<nr_events> dépasse la limite de l'utilisateur en événements disponibles, telle que définie par I</proc/sys/fs/aio-max-nr>.

note: type: Plain text
en: An invalid pointer is passed for I<ctx_idp>.
fr: Un pointeur invalide a été transmis comme I<ctx_idp>.

note: type: Plain text
en: I<ctx_idp> is not initialized, or the specified I<nr_events> exceeds internal limits.  I<nr_events> should be greater than 0.
fr: I<ctx_idp> n'est pas initialisé ou la valeur I<nr_events> dépasse les limites internes. I<nr_events> doit être supérieur à zéro.

note: type: Plain text
en: Insufficient kernel resources are available.
fr: Pas assez de mémoire pour le noyau.

note: type: Plain text
en: B<io_setup>()  is not implemented on this architecture.
fr: B<io_setup>() n'est pas implémenté sur cette architecture.

note: type: Plain text
en: B<io_setup>()  is Linux-specific and should not be used in programs that are intended to be portable.
fr: B<io_setup>() est spécifique à Linux et ne doit pas être utilisé dans des programmes destinés à être portables.

note: http://git.fedorahosted.org/git/?p=libaio.git type: Plain text
en: Glibc does not provide a wrapper function for this system call.  You could invoke it using B<syscall>(2).  But instead, you probably want to use the B<io_setup>()  wrapper function provided by I<libaio>.
fr: La glibc ne fournit pas de fonction autour de cet appel système. Vous pourriez l'invoquer en utilisant B<syscall>(2), mais vous préférerez sans doute utiliser la fonction enveloppe B<io_setup>() fournie par I<libaio>.

note: But glibc is confused, since <libaio.h> uses 'io_context_t' to declare the system call. type: Plain text
en: Note that the I<libaio> wrapper function uses a different type (I<io_context_t\ *>)  for the I<ctx_idp> argument.  Note also that the I<libaio> wrapper does not follow the usual C library conventions for indicating errors: on error it returns a negated error number (the negative of one of the values listed in ERRORS).  If the system call is invoked via B<syscall>(2), then the return value follows the usual conventions for indicating an error: -1, with I<errno> set to a (positive) value that indicates the error.
fr: Remarquez que la fonction enveloppe I<libaio> utilise un autre type (I<io_context_t\ *>) pour l'argument I<ctx_idp>. Remarquez également que l'enveloppe I<libaio> ne suit pas les conventions classiques de la bibliothèque C concernant l'indication des erreurs : en cas d'erreur, la fonction renvoie un nombre négatif (la valeur négative de l'une des valeurs indiquées dans la section B<ERREURS>). Si l'appel système est invoqué avec B<syscall>(2), la valeur de retour suit les conventions classiques pour indiquer l'erreur : -1 avec I<errno> contenant le code (positif) de l'erreur.

note: type: TH
en: 2012-07-13
fr: 13 juillet 2012

note: type: Plain text
en: io_submit - submit asynchronous I/O blocks for processing
fr: io_submit - Soumettre un bloc d'entrées-sorties asynchrones

note: type: Plain text
en: The B<io_submit>()  system call queues I<nr> I/O request blocks for processing in the AIO context I<ctx_id>.  The I<iocbpp> argument should be an array of I<nr> AIO control blocks, which will be submitted to context I<ctx_id>.
fr: L'appel système B<io_submit>() enregistre I<nr> requêtes d'entrées-sorties asynchrones pour être traitées dans le contexte I<ctx_id>. L'argument I<iocbpp> devrait être une table de I<nr> blocs de contrôle, qui seront soumis au contexte I<ctx_id>.

note: type: Plain text
en: On success, B<io_submit>()  returns the number of I<iocb>s submitted (which may be 0 if I<nr> is zero).  For the failure return, see NOTES.
fr: B<io_submit>() renvoie le nombre de blocs I<iocb> soumis (qui peut être nul si I<nr> vaut zéro). Pour les valeurs de retour en cas d'échec, consultez la section NOTES.

note: type: Plain text
en: Insufficient resources are available to queue any I<iocb>s.
fr: Pas assez de ressources pour enregistrer un I<iocb>.

note: type: Plain text
en: The file descriptor specified in the first I<iocb> is invalid.
fr: Le descripteur de fichier dans le premier I<iocb> est invalide.

note: type: Plain text
en: The AIO context specified by I<ctx_id> is invalid.  I<nr> is less than 0.  The I<iocb> at I<*iocbpp[0]> is not properly initialized, or the operation specified is invalid for the file descriptor in the I<iocb>.
fr: Le contexte indiqué par I<ctx_id> n'est pas valable, I<nr> est inférieur à zéro, l'I<iocb> à l'adresse I<*iocbpp[0]> n'est pas initialisé correctement ou l'opération précisée n'est pas valable pour le descripteur de fichier I<iocb>.

note: type: Plain text
en: B<io_submit>()  is not implemented on this architecture.
fr: B<io_submit>() n'est pas implémenté dans ce noyau.

note: type: Plain text
en: B<io_submit>()  is Linux-specific and should not be used in programs that are intended to be portable.
fr: B<io_submit>() est spécifique à Linux et ne doit pas être utilisé dans des programmes destinés à être portables.

note: http://git.fedorahosted.org/git/?p=libaio.git type: Plain text
en: Glibc does not provide a wrapper function for this system call.  You could invoke it using B<syscall>(2).  But instead, you probably want to use the B<io_submit>()  wrapper function provided by I<libaio>.
fr: La glibc ne fournit pas de fonction autour de cet appel système. Vous pourriez l'invoquer en utilisant B<syscall>(2), mais vous préférerez sans doute utiliser la fonction enveloppe B<io_submit>() fournie par I<libaio>.

note: type: Plain text
en: lio_listio - initiate a list of I/O requests
fr: lio_listio - Initier une liste de requêtes d'E/S

note: type: Plain text
en: The B<lio_listio>()  function initiates the list of I/O operations described by the array I<aiocb_list>.
fr: La fonction B<lio_listio> initie la liste des opérations E/S décrite par le tableau I<aiocb_list>.

note: type: Plain text
en: The I<mode> operation has one of the following values:
fr: Le champ I<mode> peut prendre une des valeurs suivantes :

note: type: Plain text
en: The call blocks until all operations are complete.  The I<sevp> argument is ignored.
fr: L'appel est bloquant tant que toutes les opérations ne sont pas complétées. L'argument I<sevp> est ignoré.

note: type: Plain text
en: The I/O operations are queued for processing and the call returns immediately.  When all of the I/O operations complete, asynchronous notification occurs, as specified by the I<sevp> argument; see B<sigevent>(7)  for details.  If I<sevp> is NULL, no asynchronous notification occurs.
fr: Les opérations d'E/S sont mises en file d'attente pour traitement et l'appel renvoie immédiatement. Lorsque toutes les opérations d'E/S se terminent, une notification asynchrone est émise, comme spécifié dans le paramètre I<sevp> ; consultez B<sigevent>(7) pour plus de détails. Si I<sevp> est NULL, aucune notification asynchrone n'est émise.

note: type: Plain text
en: The I<aiocb_list> argument is an array of pointers to I<aiocb> structures that describe I/O operations.  These operations are executed in an unspecified order.  The I<nitems> argument specifies the size of the array I<aiocb_list>.  null pointers in I<aiocb_list> are ignored.
fr: Le paramètre I<aiocb_list> est un tableau de pointeurs vers des structures I<aiocb> qui décrivent les opérations d'E/S. Ces opérations sont exécutées dans un ordre non spécifié. Le paramètre I<nitems> spécifie la taille du tableau I<aiocb_list>. Les pointeurs NULL dans I<aiocb_list> sont ignorés.

note: type: Plain text
en: In each control block in I<aiocb_list>, the I<aio_lio_opcode> field specifies the I/O operation to be initiated, as follows:
fr: Dans chaque bloc de contrôle d'I<aiocb_list>, le champ I<aio_lio_opcode> spécifie l'opération d'E/S à initier comme ci-dessous :

note: type: Plain text
en: Initiate a read operation.  The operation is queued as for a call to B<aio_read>(3)  specifying this control block.
fr: Initier une opération de lecture. L'opération est mise en file d'attente comme lors d'un appel à B<aio_read>(3) spécifiant ce bloc de contrôle.

note: type: Plain text
en: Initiate a write operation.  The operation is queued as for a call to B<aio_write>(3)  specifying this control block.
fr: Initier une opération d'écriture. L'opération est mise en file d'attente comme pour un appel à B<aio_write>(3) spécifiant ce bloc de contrôle.

note: type: Plain text
en: Ignore this control block.
fr: Ignorer ce bloc de contrôle.

note: type: Plain text
en: The remaining fields in each control block have the same meanings as for B<aio_read>(3)  and B<aio_write>(3).  The I<aio_sigevent> fields of each control block can be used to specify notifications for the individual I/O operations (see B<sigevent>(7)).
fr: Les champs restants dans chaque bloc de contrôle ont le même sens que pour B<aio_read>(3) et B<aio_write>(3). Les champs I<aio_sigevent> de chaque bloc de contrôle  peuvent être utilisés pour spécifier des notifications pour chaque opération d'E/S (consultez B<sigevent>(7)).

note: type: Plain text
en: If I<mode> is B<LIO_NOWAIT>, B<lio_listio>()  returns 0 if all I/O operations are successfully queued.  Otherwise, -1 is returned, and I<errno> is set to indicate the error.
fr: Si I<mode> vaut B<LIO_NOWAIT>, B<lio_listio>() renvoie 0 si toutes les opérations d'E/S ont été mises avec succès en file d'attente. Sinon, elle renvoie -1 et définit I<errno> en conséquence.

note: type: Plain text
en: If I<mode> is B<LIO_WAIT>, B<lio_listio>()  returns 0 when all of the I/O operations have completed successfully.  Otherwise, -1 is returned, and I<errno> is set to indicate the error.
fr: Si I<mode> vaut B<LIO_WAIT>, B<lio_listio>() renvoie 0 lorsque toutes les opérations d'E/S se sont terminées avec succès. Sinon, elle renvoie -1 et définit I<errno> en conséquence.

note: type: Plain text
en: The return status from B<lio_listio>()  provides information only about the call itself, not about the individual I/O operations.  One or more of the I/O operations may fail, but this does not prevent other operations completing.  The status of individual I/O operations in I<aiocb_list> can be determined using B<aio_error>(3).  When an operation has completed, its return status can be obtained using B<aio_return>(3).  Individual I/O operations can fail for the reasons described in B<aio_read>(3)  and B<aio_write>(3).
fr: La valeur de retour de B<lio_listio>() fournit seulement des informations à propos de l'appel lui-même, et non à propos de chaque opération d'E/S. Une ou plusieurs opérations peuvent échouer, mais cela n'empêche pas les autres opérations de se terminer. L'état de chaque opération d'E/S de I<aiocb_list> peut être obtenu avec B<aio_error>(3). Lorsqu'une opération s'est terminée, son code de retour peut être obtenu avec B<aio_return>(3). Chaque opération d'E/S peut échouer pour les raisons décrites dans B<aio_read>(3) et B<aio_write>(3).

note: type: Plain text
en: The B<lio_listio>()  function may fail for the following reasons:
fr: La fonction B<lio_listio>() peut échouer pour les raisons suivantes :

note: Doesn't happen in glibc(?) type: Plain text
en: The number of I/O operations specified by I<nitems> would cause the limit B<AIO_MAX> to be exceeded.
fr: Le nombre d'opérations d'E/S spécifié dans I<nitems> dépasse la valeur limite B<AIO_MAX>.

note: Doesn't happen in glibc(?) type: Plain text
en: I<mode> is invalid, or I<nitems> exceeds the limit B<AIO_LISTIO_MAX>.
fr: I<mode> est non valable, ou I<nitems> dépasse la valeur limite B<AIO_LISTIO_MAX>.

note: type: Plain text
en: I<mode> was B<LIO_WAIT> and a signal was caught before all I/O operations completed.  (This may even be one of the signals used for asynchronous I/O completion notification.)
fr: I<mode> valait B<LIO_WAIT> et un signal a été attrapé avant que toutes les opérations d'E/S ne soient terminées (il peut s'agir de l'un des signaux utilisés pour les notifications asynchrones de fin d'opération d'E/S).

note: e.g., ioa_reqprio or aio_lio_opcode was invalid type: Plain text
en: One of more of the operations specified by I<aiocb_list> failed.  The application can check the status of each operation using B<aio_return>(3).
fr: Une ou plusieurs opérations spécifiées dans I<aiocb_list> ont échoué. L'application peut vérifier l'état de chaque opération avec B<aio_return>(3).

note: type: Plain text
en: If B<lio_listio>()  fails with the error B<EAGAIN>, B<EINTR>, or B<EIO>, then some of the operations in I<aiocb_list> may have been initiated.  If B<lio_listio>()  fails for any other reason, then none of the I/O operations has been initiated.
fr: Si B<lio_listio>() échoue avec l'erreur B<EAGAIN>, B<EINTR> ou B<EIO>, alors certaines des opérations définies dans I<aiocb_list> peuvent avoir été initiées. Si B<lio_listio>() échoue pour tout autre raison, alors aucune des opérations d'E/S n'aura été initiée.

note: type: Plain text
en: The B<lio_listio>()  function is available since glibc 2.1.
fr: La fonction B<lio_listio>() est disponible depuis la glibc 2.1.

note: or the control block of the operation type: Plain text
en: It is a good idea to zero out the control blocks before use.  The control blocks must not be changed while the I/O operations are in progress.  The buffer areas being read into or written from must not be accessed during the operations or undefined results may occur.  The memory areas involved must remain valid.
fr: C'est une bonne idée de mettre à zéro le bloc de contrôle avant de l'utiliser. Les blocs de contrôle ne doivent pas être changés pendant que des opérations d'E/S sont en cours. Les tampons qui seront lus ou écrits ne doivent pas être accédés durant les opérations ou des résultats indéterminés peuvent se produire. Les zones mémoires utilisées doivent rester valables.
