perkamon - en to fr translation catalogue (73 entries)

note: type: TH
en: 2023-02-05
fr: 5 février 2023

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: loop, loop-control - loop devices
fr: loop, loop-control — Périphériques boucle

note: type: Plain text
en: The loop device is a block device that maps its data blocks not to a physical device such as a hard disk or optical disk drive, but to the blocks of a regular file in a filesystem or to another block device.  This can be useful for example to provide a block device for a filesystem image stored in a file, so that it can be mounted with the B<mount>(8)  command.  You could do
fr: Un périphérique boucle est un périphérique bloc qui mappe ses blocs de données non sur un périphérique physique tel qu’un disque dur ou un support optique, mais sur les blocs d’un fichier normal dans un système de fichiers ou sur ceux d’un autre périphérique bloc. Cela peut être utile pour fournir un périphérique bloc pour un stockage d’image de système de fichiers, de façon à pouvoir le monter avec la commande B<mount>(8). Il est possible de faire :

note: type: Plain text
en: $ B<dd if=/dev/zero of=file.img bs=1MiB count=10>
    $ B<sudo losetup /dev/loop4 file.img>
    $ B<sudo mkfs -t ext4 /dev/loop4>
    $ B<sudo mkdir /myloopdev>
    $ B<sudo mount /dev/loop4 /myloopdev>
fr: $ B<dd if=/dev/zero of=fich.img bs=1MiB count=10>
    $ B<sudo losetup /dev/loop4 fich.img>
    $ B<sudo mkfs -t ext4 /dev/loop4>
    $ B<sudo mkdir /monperboucle>
    $ B<sudo mount /dev/loop4 /monperboucle>

note: type: Plain text
en: See B<losetup>(8)  for another example.
fr: Consulter B<losetup>(8) pour un autre exemple.

note: type: Plain text
en: A transfer function can be specified for each loop device for encryption and decryption purposes.
fr: Une fonction de transfert peut être spécifiée pour chaque périphérique boucle dans un but de chiffrement et de déchiffrement.

note: type: Plain text
en: The following B<ioctl>(2)  operations are provided by the loop block device:
fr: Les opérations B<ioctl>(2) suivantes sont fournies par le périphérique boucle :

note: type: Plain text
en: Associate the loop device with the open file whose file descriptor is passed as the (third)  B<ioctl>(2)  argument.
fr: Associer le périphérique boucle avec le fichier ouvert dont le descripteur de fichier est passé comme (troisième) argument d’B<ioctl>(2).

note: type: Plain text
en: Disassociate the loop device from any file descriptor.
fr: Dissocier le périphérique boucle de n’importe quel descripteur de fichier.

note: type: Plain text
en: Set the status of the loop device using the (third)  B<ioctl>(2)  argument.  This argument is a pointer to a I<loop_info> structure, defined in I<E<lt>linux/loop.hE<gt>> as:
fr: Régler l’état du périphérique boucle en utilisant le (troisième) argument d’B<ioctl>(2). Cet argument est un pointeur vers une structure I<loop_info>, définie dans I<E<lt>linux/loop.hE<gt>> ainsi :

note: type: Plain text
en: struct loop_info {
        int           lo_number;      /* ioctl r/o */
        dev_t         lo_device;      /* ioctl r/o */
        unsigned long lo_inode;       /* ioctl r/o */
        dev_t         lo_rdevice;     /* ioctl r/o */
        int           lo_offset;
        int           lo_encrypt_type;
        int           lo_encrypt_key_size;  /* ioctl w/o */
        int           lo_flags;       /* ioctl r/w (r/o before
                                         Linux 2.6.25) */
        char          lo_name[LO_NAME_SIZE];
        unsigned char lo_encrypt_key[LO_KEY_SIZE];
                                      /* ioctl w/o */
        unsigned long lo_init[2];
        char          reserved[4];
    };
fr: struct loop_info {
        int           lo_number;      /* ioctl r/o */
        dev_t         lo_device;      /* ioctl r/o */
        unsigned long lo_inode;       /* ioctl r/o */
        dev_t         lo_rdevice;     /* ioctl r/o */
        int           lo_offset;
        int           lo_encrypt_type;
        int           lo_encrypt_key_size;  /* ioctl w/o */
        int           lo_flags;       /* ioctl r/w (r/o avant
                                         Linux 2.6.25) */
        char          lo_name[LO_NAME_SIZE];
        unsigned char lo_encrypt_key[LO_KEY_SIZE];
                                      /* ioctl w/o */
        unsigned long lo_init[2];
        char          reserved[4];
    };

note: type: Plain text
en: The encryption type (I<lo_encrypt_type>)  should be one of B<LO_CRYPT_NONE>, B<LO_CRYPT_XOR>, B<LO_CRYPT_DES>, B<LO_CRYPT_FISH2>, B<LO_CRYPT_BLOW>, B<LO_CRYPT_CAST128>, B<LO_CRYPT_IDEA>, B<LO_CRYPT_DUMMY>, B<LO_CRYPT_SKIPJACK>, or (since Linux 2.6.0)  B<LO_CRYPT_CRYPTOAPI>.
fr: Le type de chiffrement (I<lo_encrypt_type>) devrait être soit B<LO_CRYPT_NONE>, B<LO_CRYPT_XOR>, B<LO_CRYPT_DES>, B<LO_CRYPT_FISH2>, B<LO_CRYPT_BLOW>, B<LO_CRYPT_CAST128>, B<LO_CRYPT_IDEA>, B<LO_CRYPT_DUMMY>, B<LO_CRYPT_SKIPJACK> ou (depuis Linux 2.6.0) B<LO_CRYPT_CRYPTOAPI>.

note: type: Plain text
en: The I<lo_flags> field is a bit mask that can include zero or more of the following:
fr: Le champ I<lo_flags> est un masque de bits qui peut inclure zéro ou plus des drapeaux suivants :

note: type: Plain text
en: The loopback device is read-only.
fr: Le périphérique boucle est en lecture seule.

note: type: TP
en: B<LO_FLAGS_AUTOCLEAR> (since Linux 2.6.25)
fr: B<LO_FLAGS_AUTOCLEAR> (depuis Linux 2.6.25)

note: commit 96c5865559cee0f9cbc5173f3c949f6ce3525581 type: Plain text
en: The loopback device will autodestruct on last close.
fr: Le périphérique boucle s’autodétruira lors de la dernière fermeture.

note: type: TP
en: B<LO_FLAGS_PARTSCAN> (since Linux 3.2)
fr: B<LO_FLAGS_PARTSCAN> (depuis Linux 3.2)

note: commit e03c8dd14915fabc101aa495828d58598dc5af98 type: Plain text
en: Allow automatic partition scanning.
fr: Permission de l’analyse automatique des partitions.

note: type: TP
en: B<LO_FLAGS_DIRECT_IO> (since Linux 4.10)
fr: B<LO_FLAGS_DIRECT_IO> (depuis Linux 4.10)

note: commit 2e5ab5f379f96a6207c45be40c357ebb1beb8ef3 type: Plain text
en: Use direct I/O mode to access the backing file.
fr: Utilisation du mode E/S direct pour accéder au fichier de sauvegarde.

note: type: Plain text
en: The only I<lo_flags> that can be modified by B<LOOP_SET_STATUS> are B<LO_FLAGS_AUTOCLEAR> and B<LO_FLAGS_PARTSCAN>.
fr: Les seuls I<lo_flags> pouvant être modifiés par B<LOOP_SET_STATUS> sont B<LO_FLAGS_AUTOCLEAR> et B<LO_FLAGS_PARTSCAN>.

note: type: Plain text
en: Get the status of the loop device.  The (third)  B<ioctl>(2)  argument must be a pointer to a I<struct loop_info>.
fr: Obtention de l’état du périphérique boucle ; le (troisième) argument d’B<ioctl>(2) doit être un pointeur vers une I<struct loop_info>.

note: type: TP
en: B<LOOP_CHANGE_FD> (since Linux 2.6.5)
fr: B<LOOP_CHANGE_FD> (depuis Linux 2.6.5)

note: type: Plain text
en: Switch the backing store of the loop device to the new file identified file descriptor specified in the (third)  B<ioctl>(2)  argument, which is an integer.  This operation is possible only if the loop device is read-only and the new backing store is the same size and type as the old backing store.
fr: Basculement du stockage de sauvegarde du périphérique boucle vers le nouveau fichier identifié par le descripteur de fichier spécifié dans le (troisième) argument d’B<ioctl>(2), qui est un entier. Cette opération est possible si le périphérique boucle est en lecture seule et que le nouveau stockage de sauvegarde est de la même taille et du même type que l’ancien stockage de sauvegarde.

note: type: TP
en: B<LOOP_SET_CAPACITY> (since Linux 2.6.30)
fr: B<LOOP_SET_CAPACITY> (depuis Linux 2.6.30)

note: commit 53d6660836f233df66490707365ab177e5fb2bb4 type: Plain text
en: Resize a live loop device.  One can change the size of the underlying backing store and then use this operation so that the loop driver learns about the new size.  This operation takes no argument.
fr: Redimensionnement d’un périphérique boucle actif. Il est possible de changer la taille du stockage de sauvegarde sous-jacent et puis d’utiliser cette opération de façon que le pilote de boucle connaisse la nouvelle taille. Cette opération ne prend pas d’argument.

note: type: TP
en: B<LOOP_SET_DIRECT_IO> (since Linux 4.10)
fr: B<LOOP_SET_DIRECT_IO> (depuis Linux 4.10)

note: commit ab1cb278bc7027663adbfb0b81404f8398437e11 type: Plain text
en: Set DIRECT I/O mode on the loop device, so that it can be used to open backing file.  The (third)  B<ioctl>(2)  argument is an unsigned long value.  A nonzero represents direct I/O mode.
fr: Régler le mode E/S direct sur le périphérique boucle, de façon à ce qu’il puisse être utilisé pour ouvrir un fichier de sauvegarde. Le (troisième) argument d’B<ioctl>(2) est une valeur « unsigned long ». Une valeur différente de zéro représente le mode E/S direct.

note: type: TP
en: B<LOOP_SET_BLOCK_SIZE> (since Linux 4.14)
fr: B<LOOP_SET_BLOCK_SIZE> (depuis Linux 4.14)

note: commit 89e4fdecb51cf5535867026274bc97de9480ade5 type: Plain text
en: Set the block size of the loop device.  The (third)  B<ioctl>(2)  argument is an unsigned long value.  This value must be a power of two in the range [512,pagesize]; otherwise, an B<EINVAL> error results.
fr: Régler la taille de bloc de périphérique boucle. Le (troisième) argument d’B<ioctl>(2) est une valeur « unsigned long ». Cette valeur doit être une puissance de deux dans l’intervalle [512,taille_page], sinon une erreur B<EINVAL> en résultera.

note: type: TP
en: B<LOOP_CONFIGURE> (since Linux 5.8)
fr: B<LOOP_CONFIGURE> (depuis Linux 5.8)

note: commit 3448914e8cc550ba792d4ccc74471d1ca4293aae type: Plain text
en: Setup and configure all loop device parameters in a single step using the (third)  B<ioctl>(2)  argument.  This argument is a pointer to a I<loop_config> structure, defined in I<E<lt>linux/loop.hE<gt>> as:
fr: Régler et configurer tous les paramètres du périphérique boucle en une seule étape en utilisant le (troisième) argument d’B<ioctl>(2). Cet argument est un pointeur vers une structure I<loop_config>, définie dans I<E<lt>linux/loop.hE<gt>> ainsi :

note: type: Plain text
en: In addition to doing what B<LOOP_SET_STATUS> can do, B<LOOP_CONFIGURE> can also be used to do the following:
fr: En plus de faire ce que B<LOOP_SET_STATUS> peut faire, B<LOOP_CONFIGURE> peut aussi être utilisé pour faire les choses suivantes :

note: type: IP
en: \[bu]
fr: —

note: type: Plain text
en: set the correct block size immediately by setting I<loop_config.block_size>;
fr: régler la taille correcte de bloc immédiatement en réglant I<loop_config.block_size> ;

note: type: Plain text
en: explicitly request direct I/O mode by setting B<LO_FLAGS_DIRECT_IO> in I<loop_config.info.lo_flags>; and
fr: requérir explicitement le mode E/S direct en réglant B<LO_FLAGS_DIRECT_IO> dans I<loop_config.info.lo_flags> ;

note: type: Plain text
en: explicitly request read-only mode by setting B<LO_FLAGS_READ_ONLY> in I<loop_config.info.lo_flags>.
fr: requérir explicitement le mode lecture seule en réglant B<LO_FLAGS_READ_ONLY> dans I<loop_config.info.lo_flags>.

note: type: Plain text
en: Since Linux 2.6, there are two new B<ioctl>(2)  operations:
fr: Depuis Linux 2.6, deux nouvelles opérations B<ioctl>(2) existent :

note: type: Plain text
en: These are similar to B<LOOP_SET_STATUS> and B<LOOP_GET_STATUS> described above but use the I<loop_info64> structure, which has some additional fields and a larger range for some other fields:
fr: Elles sont similaires à B<LOOP_SET_STATUS> et B<LOOP_GET_STATUS> décrites ci-dessus, mais utilisent la structure I<loop_info64> qui a quelques champs supplémentaires et des intervalles plus grands pour quelques autres champs :

note: type: Plain text
en: struct loop_info64 {
        uint64_t lo_device;           /* ioctl r/o */
        uint64_t lo_inode;            /* ioctl r/o */
        uint64_t lo_rdevice;          /* ioctl r/o */
        uint64_t lo_offset;
        uint64_t lo_sizelimit;  /* bytes, 0 == max available */
        uint32_t lo_number;           /* ioctl r/o */
        uint32_t lo_encrypt_type;
        uint32_t lo_encrypt_key_size; /* ioctl w/o */
        uint32_t lo_flags; i          /* ioctl r/w (r/o before
                                         Linux 2.6.25) */
        uint8_t  lo_file_name[LO_NAME_SIZE];
        uint8_t  lo_crypt_name[LO_NAME_SIZE];
        uint8_t  lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
        uint64_t lo_init[2];
    };
fr: struct loop_info64 {
        uint64_t lo_device;           /* ioctl r/o */
        uint64_t lo_inode;            /* ioctl r/o */
        uint64_t lo_rdevice;          /* ioctl r/o */
        uint64_t lo_offset;
        uint64_t lo_sizelimit;  /* octets, 0 == max dispo. */
        uint32_t lo_number;           /* ioctl r/o */
        uint32_t lo_encrypt_type;
        uint32_t lo_encrypt_key_size; /* ioctl w/o */
        uint32_t lo_flags; i          /* ioctl r/w (r/o avant
                                         Linux 2.6.25) */
        uint8_t  lo_file_name[LO_NAME_SIZE];
        uint8_t  lo_crypt_name[LO_NAME_SIZE];
        uint8_t  lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
        uint64_t lo_init[2];
    };

note: commit 770fe30a46a12b6fb6b63fbe1737654d28e84844 type: Plain text
en: Since Linux 3.1, the kernel provides the I</dev/loop-control> device, which permits an application to dynamically find a free device, and to add and remove loop devices from the system.  To perform these operations, one first opens I</dev/loop-control> and then employs one of the following B<ioctl>(2)  operations:
fr: Depuis Linux 3.1, le noyau fournit le périphérique I</dev/loop-control> qui permet à une application de trouver de manière dynamique un périphérique libre et d’ajouter ou de retirer des périphériques boucle du système. Pour réaliser ces opérations, l’utilisateur doit d’abord ouvrir I</dev/loop-control>, puis employer une des opérations B<ioctl>(2) suivantes :

note: type: Plain text
en: Allocate or find a free loop device for use.  On success, the device number is returned as the result of the call.  This operation takes no argument.
fr: Allocation ou récupération d’un périphérique boucle libre pour une utilisation. En cas de succès, le numéro du périphérique est renvoyé comme résultat de l’appel. Cette opération ne nécessite aucun argument.

note: type: Plain text
en: Add the new loop device whose device number is specified as a long integer in the third B<ioctl>(2)  argument.  On success, the device index is returned as the result of the call.  If the device is already allocated, the call fails with the error B<EEXIST>.
fr: Ajout du nouveau périphérique boucle dont le numéro de périphérique est spécifié comme entier « long » dans le troisième argument d’B<ioctl>(2). En cas de succès, l’indice du périphérique est renvoyé comme résultat de l’appel. Si le périphérique est déjà alloué, l’appel échoue avec l’erreur B<EEXIST>.

note: type: Plain text
en: Remove the loop device whose device number is specified as a long integer in the third B<ioctl>(2)  argument.  On success, the device number is returned as the result of the call.  If the device is in use, the call fails with the error B<EBUSY>.
fr: Retrait du périphérique boucle dont le numéro de périphérique est spécifié comme entier « long » dans le troisième argument d’B<ioctl>(2). En cas de succès, le numéro du périphérique est renvoyé comme le résultat de l’appel. Si le périphérique est déjà utilisé, l’appel échoue avec l’erreur B<EBUSY>.

note: type: SH
en: FILES
fr: FICHIERS

note: type: Plain text
en: The loop block special device files.
fr: Les fichiers du périphérique bloc spécial de boucle.

note: type: SH
en: EXAMPLES
fr: EXEMPLES

note: type: Plain text
en: The program below uses the I</dev/loop-control> device to find a free loop device, opens the loop device, opens a file to be used as the underlying storage for the device, and then associates the loop device with the backing store.  The following shell session demonstrates the use of the program:
fr: Le programme ci-dessous utilise le périphérique I</dev/loop-control> pour trouver un périphérique boucle libre, ouvre le périphérique boucle, ouvre un fichier à utiliser comme stockage sous-jacent du périphérique et alors associe le périphérique boucle avec le stockage de sauvegarde. La session d’interpréteur suivante fait une démonstration de l’utilisation de ce programme :

note: type: Plain text
en: $ B<dd if=/dev/zero of=file.img bs=1MiB count=10>
    10+0 records in
    10+0 records out
    10485760 bytes (10 MB) copied, 0.00609385 s, 1.7 GB/s
    $ B<sudo ./mnt_loop file.img>
    loopname = /dev/loop5
fr: $ B<dd if=/dev/zero of=fich.img bs=1MiB count=10>
    10+0 enregistrements in
    10+0 enregistrement out
    10485760 octets (10 Mio) copiés, 0.00609385 s, 1.7 Gio/s
    $ B<sudo ./mnt_loop fich.img>
    nomboucle = /dev/loop5

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

note: type: Plain text
en: int
    main(int argc, char *argv[])
    {
        int loopctldf, loopdf, backingfile;
        long devnr;
        char loopname[4096];
fr: int
    main(int argc, char *argv[])
    {
        int ddfloopctl, ddfloop, fichsauv;
        long n°per;
        char nomboucle[4096];

note: type: Plain text
en:     if (argc != 2) {
            fprintf(stderr, "Usage: %s backing-file\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc != 2) {
            fprintf(stderr, "Usage : %s fichsauv\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     loopctlfd = open("/dev/loop-control", O_RDWR);
        if (loopctlfd == -1)
            errExit("open: /dev/loop-control");
fr:     ddfloopctl = open("/dev/loop-control", O_RDWR);
        if (ddfloopctl == -1)
            errExit("open: /dev/loop-control");

note: type: Plain text
en:     devnr = ioctl(loopctlfd, LOOP_CTL_GET_FREE);
        if (devnr == -1)
            errExit("ioctl-LOOP_CTL_GET_FREE");
fr:     n°per = ioctl(ddfloopctl, LOOP_CTL_GET_FREE);
        if (n°pr == -1)
            errExit("ioctl-LOOP_CTL_GET_FREE");

note: type: Plain text
en:     sprintf(loopname, "/dev/loop%ld", devnr);
        printf("loopname = %s\en", loopname);
fr:     sprintf(nomboucle, "/dev/loop%ld", n°per);
        printf("nomboucle = %s\en", nomboucle);

note: type: Plain text
en:     loopfd = open(loopname, O_RDWR);
        if (loopfd == -1)
            errExit("open: loopname");
fr:     loopfd = open(nomboucle, O_RDWR);
        if (ddfloop == -1)
            errExit("open: nomboucle");

note: type: Plain text
en:     backingfile = open(argv[1], O_RDWR);
        if (backingfile == -1)
            errExit("open: backing-file");
fr:     fichsauv = open(argv[1], O_RDWR);
        if (fichsauv == -1)
            errExit("open: fichsauv");

note: type: Plain text
en:     if (ioctl(loopfd, LOOP_SET_FD, backingfile) == -1)
            errExit("ioctl-LOOP_SET_FD");
fr:     if (ioctl(ddfloop, LOOP_SET_FD, fichsauv) == -1)
            errExit("ioctl-LOOP_SET_FD");

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

note: type: TH
en: 2020-11-01
fr: 1 novembre 2020

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

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

note: type: TH
en: Linux man-pages 6.03
fr: Pages du manuel de Linux 6.03

note: type: TH
en: 2017-09-15
fr: 15 septembre 2017

note: type: Plain text
en: $ B<dd if=/dev/zero of=file.img bs=1MiB count=10>
    $ B<sudo losetup /dev/loop4 file.img >
    $ B<sudo mkfs -t ext4 /dev/loop4>
    $ B<sudo mkdir /myloopdev>
    $ B<sudo mount /dev/loop4 /myloopdev>
fr: $ B<dd if=/dev/zero of=fich.img bs=1MiB count=10>
    $ B<sudo losetup /dev/loop4 fich.img >
    $ B<sudo mkfs -t ext4 /dev/loop4>
    $ B<sudo mkdir /monperboucle>
    $ B<sudo mount /dev/loop4 /monperboucle>

note: type: Plain text
en: Set the status of the loop device using the (third)  B<ioctl>(2)  argument.  This argument is a pointer to I<loop_info> structure, defined in I<E<lt>linux/loop.hE<gt>> as:
fr: Régler l’état du périphérique boucle en utilisant le (troisième) argument d’B<ioctl>(2). Cet argument est un pointeur vers une structure I<loop_info> définie dans I<E<lt>linux/loop.hE<gt>> comme :

note: type: Plain text
en: struct loop_info64 {
        uint64_t lo_device;                   /* ioctl r/o */
        uint64_t lo_inode;                    /* ioctl r/o */
        uint64_t lo_rdevice;                  /* ioctl r/o */
        uint64_t lo_offset;
        uint64_t lo_sizelimit;/* bytes, 0 == max available */
        uint32_t lo_number;                   /* ioctl r/o */
        uint32_t lo_encrypt_type;
        uint32_t lo_encrypt_key_size;         /* ioctl w/o */
        uint32_t lo_flags;                    /* ioctl r/o */
        uint8_t  lo_file_name[LO_NAME_SIZE];
        uint8_t  lo_crypt_name[LO_NAME_SIZE];
        uint8_t  lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
        uint64_t lo_init[2];
    };
fr: struct loop_info64 {
        uint64_t lo_device;                   /* ioctl r/o */
        uint64_t lo_inode;                    /* ioctl r/o */
        uint64_t lo_rdevice;                  /* ioctl r/o */
        uint64_t lo_offset;
        uint64_t lo_sizelimit;    * octets, 0 == max dispo.*/
        uint32_t lo_number;                   /* ioctl r/o */
        uint32_t lo_encrypt_type;
        uint32_t lo_encrypt_key_size;         /* ioctl w/o */
        uint32_t lo_flags;                    /* ioctl r/o */
        uint8_t  lo_file_name[LO_NAME_SIZE];
        uint8_t  lo_crypt_name[LO_NAME_SIZE];
        uint8_t  lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
        uint64_t lo_init[2];
    };

note: type: SH
en: EXAMPLE
fr: EXEMPLE

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

note: type: TH
en: 2022-10-30
fr: 30 octobre 2022

note: type: TH
en: Linux man-pages 6.02
fr: Pages du manuel de Linux 6.02

note: type: IP
en: \(bu
fr: —
