manpages.fr - en to fr translation catalogue (48 entries)

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

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

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: pkeys - overview of Memory Protection Keys
fr: pkeys – Aperçu des clés de protection de la mémoire

note: type: Plain text
en: Memory Protection Keys (pkeys) are an extension to existing page-based memory permissions.  Normal page permissions using page tables require expensive system calls and TLB invalidations when changing permissions.  Memory Protection Keys provide a mechanism for changing protections without requiring modification of the page tables on every permission change.
fr: Les clés de protection de la mémoire (Memory Protection Keys — pkeys) sont une extension des permissions de la mémoire basées sur les pages. Les permissions normales de page nécessitent des appels système coûteux et des invalidations du TLB (Translation Lookaside Buffer) lors de modifications de permission. Les clés de protection de la mémoire fournissent un mécanisme pour changer les protections sans avoir besoin de modifier la table des pages lors de chaque modification de permission.

note: type: Plain text
en: To use pkeys, software must first "tag" a page in the page tables with a pkey.  After this tag is in place, an application only has to change the contents of a register in order to remove write access, or all access to a tagged page.
fr: Pour utiliser B<pkeys>, le logiciel doit d’abord « étiqueter » une page dans la table des pages avec une pkey. Une fois cette étiquette posée, une application a seulement à changer le contenu d’un registre pour retirer l’accès en écriture ou tous les accès à une page étiquetée.

note: type: Plain text
en: Protection keys work in conjunction with the existing B<PROT_READ>, B<PROT_WRITE>, and B<PROT_EXEC> permissions passed to system calls such as B<mprotect>(2)  and B<mmap>(2), but always act to further restrict these traditional permission mechanisms.
fr: Les clés de protection de la mémoire fonctionnent en conjonction avec les permissions B<PROT_READ>, B<PROT_WRITE> et B<PROT_EXEC> existantes passées aux appels système tels que B<mprotect>(2) et B<mmap>(2), mais agissent toujours pour restreindre encore plus ces mécanismes de permission traditionnels.

note: type: Plain text
en: If a process performs an access that violates pkey restrictions, it receives a B<SIGSEGV> signal.  See B<sigaction>(2)  for details of the information available with that signal.
fr: Si un processus réalise un accès qui enfreint les restrictions de pkey, il reçoit un signal B<SIGSEGV>. Consultez B<sigaction>(2) pour des détails sur l’information disponible avec ce signal.

note: type: Plain text
en: To use the pkeys feature, the processor must support it, and the kernel must contain support for the feature on a given processor.  As of early 2016 only future Intel x86 processors are supported, and this hardware supports 16 protection keys in each process.  However, pkey 0 is used as the default key, so a maximum of 15 are available for actual application use.  The default key is assigned to any memory region for which a pkey has not been explicitly assigned via B<pkey_mprotect>(2).
fr: Pour utiliser la fonctionnalité de B<pkeys>, le processeur doit la prendre en charge et le noyau doit contenir une prise en charge pour la fonctionnalité d’un processeur donné. Au tout début de 2016, seuls les processeurs x86 d’Intel à venir étaient pris en charge et ceux-ci géraient 16 clés de protection de la mémoire pour chaque processus. Cependant, la pkey 0 est utilisée comme clé par défaut, donc un maximum de 15 sont disponibles pour une utilisation effective d’application. La clé par défaut est affectée à n’importe quelle région de la mémoire pour laquelle une pkey n’a pas été assignée explicitement à l’aide de B<pkey_mprotect>(2).

note: type: Plain text
en: Protection keys have the potential to add a layer of security and reliability to applications.  But they have not been primarily designed as a security feature.  For instance, WRPKRU is a completely unprivileged instruction, so pkeys are useless in any case that an attacker controls the PKRU register or can execute arbitrary instructions.
fr: Les clés de protection ont la capacité d’ajouter une couche de sécurité et de fiabilité aux applications, mais elles n’ont pas été conçues principalement pour une fonctionnalité de sécurité. Par exemple, WRPKRU est une instruction entièrement non privilégiée, aussi les pkeys sont inutiles dans tous les cas où un attaquant contrôle le registre PKRU ou peut exécuter des instructions arbitraires.

note: type: Plain text
en: Applications should be very careful to ensure that they do not "leak" protection keys.  For instance, before calling B<pkey_free>(2), the application should be sure that no memory has that pkey assigned.  If the application left the freed pkey assigned, a future user of that pkey might inadvertently change the permissions of an unrelated data structure, which could impact security or stability.  The kernel currently allows in-use pkeys to have B<pkey_free>(2)  called on them because it would have processor or memory performance implications to perform the additional checks needed to disallow it.  Implementation of the necessary checks is left up to applications.  Applications may implement these checks by searching the I</proc/>pidI</smaps> file for memory regions with the pkey assigned.  Further details can be found in B<proc>(5).
fr: Les applications doivent être très précautionneuses pour assurer de ne pas faire « fuiter » leurs clés de protection. Par exemple, avant d’appeler B<pkey_free>(2), l’application doit être sûre qu’aucune mémoire a cette pkey assignée. Si l’application laisse la pkey libérée assignée, un prochain utilisateur de cette pkey peut par inadvertance modifier les permissions d’une structure de données étrangère, pouvant impacter la sécurité ou la stabilité. Le noyau permet actuellement aux pkeys en cours d’avoir B<pkey_free>(2) appelée sur elles car cela pourrait avoir des implications de performance de processeur ou de mémoire pour réaliser des vérifications supplémentaires nécessaires pour désactiver cet appel. L’implémentation des vérifications nécessaires est laissée aux applications. Celles-ci peuvent mettre en œuvre ces vérifications en parcourant le fichier I</proc/>pidI</smaps> pour des régions de la mémoire ayant la pkey assignée. Plus de détails sont fournis dans B<proc>(5).

note: type: Plain text
en: Any application wanting to use protection keys needs to be able to function without them.  They might be unavailable because the hardware that the application runs on does not support them, the kernel code does not contain support, the kernel support has been disabled, or because the keys have all been allocated, perhaps by a library the application is using.  It is recommended that applications wanting to use protection keys should simply call B<pkey_alloc>(2)  and test whether the call succeeds, instead of attempting to detect support for the feature in any other way.
fr: Toute application voulant utiliser les clés de protection doivent être capables de fonctionner sans elles. Elles peuvent être indisponibles parce que le matériel exécutant cette application ne les prennent pas en charge, le code du noyau ne fournit aucune prise en charge ou cette prise en charge a été désactivée, ou parce que les clés ont été allouées, peut être par une bibliothèque utilisée par l’application. Il est recommandé aux applications voulant utiliser les clés de protection de simplement appeler B<pkey_alloc>(2) et de tester si l’appel réussit au lieu d’essayer de détecter une prise en charge de la fonctionnalité par tout autre moyen.

note: type: Plain text
en: Although unnecessary, hardware support for protection keys may be enumerated with the I<cpuid> instruction.  Details of how to do this can be found in the Intel Software Developers Manual.  The kernel performs this enumeration and exposes the information in I</proc/cpuinfo> under the "flags" field.  The string "pku" in this field indicates hardware support for protection keys and the string "ospke" indicates that the kernel contains and has enabled protection keys support.
fr: Quoique non nécessaire, la prise en charge matérielle des clés de protection peut être déterminée à l’aide de l’instruction I<cpuid>. La manière de réaliser cela est décrite dans le manuel pour les développeurs de logiciels pour Intel. Le noyau réalise ce dénombrement et expose cette information dans le champ « flags » de I</proc/cpuinfo>. La chaîne « pku » dans ce champ indique la prise en charge matérielle des clés de protection et la chaîne « ospke » indique que le noyau gère et active la prise en charge des clés de protection.

note: type: Plain text
en: Applications using threads and protection keys should be especially careful.  Threads inherit the protection key rights of the parent at the time of the B<clone>(2), system call.  Applications should either ensure that their own permissions are appropriate for child threads at the time when B<clone>(2)  is called, or ensure that each child thread can perform its own initialization of protection key rights.
fr: Les applications utilisant les threads et les clés de protection doivent être particulièrement attentives. Les threads héritent des droits des clés de protection de leur parent au moment de l’appel système B<clone>(2). Les applications doivent aussi s’assurer que leurs propres permissions sont appropriées pour les threads enfant au moment de l’appel B<clone>(2) ou de s’assurer que chaque thread enfant peut réaliser sa propre initialisation des droits de clés de protection.

note: type: SS
en: Signal Handler Behavior
fr: Comportement du gestionnaire de signal

note: type: Plain text
en: Each time a signal handler is invoked (including nested signals), the thread is temporarily given a new, default set of protection key rights that override the rights from the interrupted context.  This means that applications must re-establish their desired protection key rights upon entering a signal handler if the desired rights differ from the defaults.  The rights of any interrupted context are restored when the signal handler returns.
fr: Chaque fois qu’un gestionnaire de signal est invoqué (y compris pour les signaux imbriqués), le thread obtient temporairement un nouvel ensemble par défaut de droits de clés de protection qui outrepasse les droits du contexte interrompu. Cela signifie que les applications doivent rétablir les droits désirés des clés de protection lors de l’utilisation d’un gestionnaire de signal si ces droits différent de ceux par défaut. Les droits de n’importe quel contexte sont restaurés lors du renvoi du gestionnaire de signal.

note: type: Plain text
en: This signal behavior is unusual and is due to the fact that the x86 PKRU register (which stores protection key access rights) is managed with the same hardware mechanism (XSAVE) that manages floating-point registers.  The signal behavior is the same as that of floating-point registers.
fr: Ce comportement de signal est inhabituel et est dû au fait que le registre PKRU x86 (qui stocke les droits d’accès des clés de protection) est géré avec le même mécanisme matériel (XSAVE) qui gère les registres de virgule flottante. Le comportement du signal est le même que celui des registres de virgule flottante.

note: type: SS
en: Protection Keys system calls
fr: Appels système des clés de protection

note: type: Plain text
en: The Linux kernel implements the following pkey-related system calls: B<pkey_mprotect>(2), B<pkey_alloc>(2), and B<pkey_free>(2).
fr: Le noyau Linux met en œuvre les appels système suivants relatifs aux clés de protection : B<pkey_mprotect>(2), B<pkey_alloc>(2) et B<pkey_free>(2).

note: type: Plain text
en: The Linux pkey system calls are available only if the kernel was configured and built with the B<CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS> option.
fr: Les appels système de Linux pour pkey sont disponibles uniquement si le noyau a été configuré et construit avec l’option B<CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS>.

note: type: SH
en: EXAMPLES
fr: EXEMPLES

note: type: Plain text
en: The program below allocates a page of memory with read and write permissions.  It then writes some data to the memory and successfully reads it back.  After that, it attempts to allocate a protection key and disallows access to the page by using the WRPKRU instruction.  It then tries to access the page, which we now expect to cause a fatal signal to the application.
fr: Le programme ci-dessous alloue une page de mémoire avec les permissions en lecture et écriture. Puis il écrit quelques données dans la mémoire et les relit avec succès. Après cela, il essaie d’allouer une clé de protection et désactive l’accès à la page en utilisant l’instruction WRPKRU. Il essaie alors d’accéder à la page qui est supposée provoquer un signal fatal pour l’application.

note: type: Plain text
en: $B< ./a.out>
    buffer contains: 73
    about to read buffer again...
    Segmentation fault (core dumped)
fr: $B< ./a.out>
    le buffer contient : 73
    sur le point de lire le buffer de nouveau...
    Segmentation fault (core dumped)

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

note: type: Plain text
en:     /*
         * Allocate one page of memory.
         */
        buffer = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
                      MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        if (buffer == MAP_FAILED)
            err(EXIT_FAILURE, "mmap");
fr:     /*
         * Allocation d’une page de mémoire.
         */
        buffer = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
                      MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        if (buffer == MAP_FAILED)
            err(EXIT_FAILURE, "mmap");

note: type: Plain text
en:     /*
         * Put some random data into the page (still OK to touch).
         */
        *buffer = __LINE__;
        printf("buffer contains: %d\en", *buffer);
fr:     /*
         * Mise de données aléatoires dans la page (toujours OK à affecter).
         */
        *buffer = __LINE__;
        printf("le buffer contient : %d\en", *buffer);

note: type: Plain text
en:     /*
         * Allocate a protection key:
         */
        pkey = pkey_alloc(0, 0);
        if (pkey == -1)
            err(EXIT_FAILURE, "pkey_alloc");
fr:     /*
         * Allocation d’une clé de protection :
         */
        pkey = pkey_alloc(0, 0);
        if (pkey == -1)
            err(EXIT_FAILURE, "pkey_alloc");

note: type: Plain text
en:     /*
         * Disable access to any memory with "pkey" set,
         * even though there is none right now.
         */
        status = pkey_set(pkey, PKEY_DISABLE_ACCESS);
        if (status)
            err(EXIT_FAILURE, "pkey_set");
fr:     /*
         * Désactivation de l’accès à toute mémoire avec l’ensemble
         * « pkey », même si aucun droit n’existe à ce moment.
         */
        status = pkey_set(pkey, PKEY_DISABLE_ACCESS);
        if (status)
            err(EXIT_FAILURE, "pkey_set");

note: type: Plain text
en:     /*
         * Set the protection key on "buffer".
         * Note that it is still read/write as far as mprotect() is
         * concerned and the previous pkey_set() overrides it.
         */
        status = pkey_mprotect(buffer, getpagesize(),
                               PROT_READ | PROT_WRITE, pkey);
        if (status == -1)
            err(EXIT_FAILURE, "pkey_mprotect");
fr:     /*
         * Mettre la clé de protection dans « buffer ».
         * Noter que c’est toujours lect./écrit. aussi longtemps que mprotect()
         * est concerné et que le pkey_set() précédent l’écrase.
         */
        status = pkey_mprotect(buffer, getpagesize(),
                               PROT_READ | PROT_WRITE, pkey);
        if (status == -1)
            err(EXIT_FAILURE, "pkey_mprotect");

note: type: Plain text
en:     printf("about to read buffer again...\en");
fr:     printf("sur le point de lire le buffer de nouveau...\en");

note: type: Plain text
en:     /*
         * This will crash, because we have disallowed access.
         */
        printf("buffer contains: %d\en", *buffer);
fr:     /*
         * Cela va planter car l’accès a été désactivé.
         */
        printf("le buffer contient : %d\en", *buffer);

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

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

note: type: TH
en: 2023-05-03
fr: 3 mai 2023

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

note: type: Plain text
en: #define _GNU_SOURCE
    #include E<lt>err.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/mman.hE<gt>
    \&
    int
    main(void)
    {
        int status;
        int pkey;
        int *buffer;
    \&
        /*
         * Allocate one page of memory.
         */
        buffer = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
                      MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        if (buffer == MAP_FAILED)
            err(EXIT_FAILURE, "mmap");
    \&
        /*
         * Put some random data into the page (still OK to touch).
         */
        *buffer = __LINE__;
        printf("buffer contains: %d\en", *buffer);
    \&
        /*
         * Allocate a protection key:
         */
        pkey = pkey_alloc(0, 0);
        if (pkey == -1)
            err(EXIT_FAILURE, "pkey_alloc");
    \&
        /*
         * Disable access to any memory with "pkey" set,
         * even though there is none right now.
         */
        status = pkey_set(pkey, PKEY_DISABLE_ACCESS);
        if (status)
            err(EXIT_FAILURE, "pkey_set");
    \&
        /*
         * Set the protection key on "buffer".
         * Note that it is still read/write as far as mprotect() is
         * concerned and the previous pkey_set() overrides it.
         */
        status = pkey_mprotect(buffer, getpagesize(),
                               PROT_READ | PROT_WRITE, pkey);
        if (status == -1)
            err(EXIT_FAILURE, "pkey_mprotect");
    \&
        printf("about to read buffer again...\en");
    \&
        /*
         * This will crash, because we have disallowed access.
         */
        printf("buffer contains: %d\en", *buffer);
    \&
        status = pkey_free(pkey);
        if (status == -1)
            err(EXIT_FAILURE, "pkey_free");
    \&
        exit(EXIT_SUCCESS);
    }
fr: #define _GNU_SOURCE
    #include E<lt>err.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/mman.hE<gt>
    \&
    int
    main(void)
    {
        int status;
        int pkey;
        int *buffer;
    \&
        /*
         * Allocation d’une page de mémoire.
         */
        buffer = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
                      MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        if (buffer == MAP_FAILED)
            err(EXIT_FAILURE, "mmap");
    \&
        /*
         * Mise de données aléatoires dans la page (toujours OK à affecter).
         */
        *buffer = __LINE__;
        printf("le buffer contient : %d\en", *buffer);
    \&
        /*
         * Allocation d’une clé de protection :
         */
        pkey = pkey_alloc(0, 0);
        if (pkey == -1)
            err(EXIT_FAILURE, "pkey_alloc");
    \&
        /*
         * Désactivation de l’accès à toute mémoire avec l’ensemble
         * « pkey », même si aucun droit n’existe à ce moment.
         */
        status = pkey_set(pkey, PKEY_DISABLE_ACCESS);
        if (status)
            err(EXIT_FAILURE, "pkey_set");
    \&
        /*
         * Mettre la clé de protection dans « buffer ».
         * Noter que c’est toujours lect./écrit. aussi longtemps que mprotect()
         * est concerné et que le pkey_set() précédent l’écrase.
         */
        status = pkey_mprotect(buffer, getpagesize(),
                               PROT_READ | PROT_WRITE, pkey);
        if (status == -1)
            err(EXIT_FAILURE, "pkey_mprotect");
    \&
        printf("sur le point de lire le buffer de nouveau...\en");
    \&
        /*
         * Cela va planter car l’accès a été désactivé.
         */
        printf("le buffer contient : %d\en", *buffer);
    \&
        status = pkey_free(pkey);
        if (status == -1)
            err(EXIT_FAILURE, "pkey_free");
    \&
        exit(EXIT_SUCCESS);
    }

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

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

note: type: Plain text
en: Protection keys work in conjunction with the existing B<PROT_READ>/ B<PROT_WRITE>/ B<PROT_EXEC> permissions passed to system calls such as B<mprotect>(2)  and B<mmap>(2), but always act to further restrict these traditional permission mechanisms.
fr: Les clés de protection de la mémoire fonctionnent en conjonction avec les permissions B<PROT_READ>, B<PROT_WRITE> et B<PROT_EXEC> existantes passées aux appels système tels que B<mprotect>(2) et B<mmap>(2), mais agissent toujours pour restreindre encore plus ces mécanismes de permission traditionnels.

note: type: Plain text
en: Applications should be very careful to ensure that they do not "leak" protection keys.  For instance, before calling B<pkey_free>(2), the application should be sure that no memory has that pkey assigned.  If the application left the freed pkey assigned, a future user of that pkey might inadvertently change the permissions of an unrelated data structure, which could impact security or stability.  The kernel currently allows in-use pkeys to have B<pkey_free>(2)  called on them because it would have processor or memory performance implications to perform the additional checks needed to disallow it.  Implementation of the necessary checks is left up to applications.  Applications may implement these checks by searching the I</proc/[pid]/smaps> file for memory regions with the pkey assigned.  Further details can be found in B<proc>(5).
fr: Les applications doivent être très précautionneuses pour assurer de ne pas faire « fuiter » leurs clés de protection. Par exemple, avant d’appeler B<pkey_free>(2), l’application doit être sûre qu’aucune mémoire a cette pkey assignée. Si l’application laisse la pkey libérée assignée, un prochain utilisateur de cette pkey peut par inadvertance modifier les permissions d’une structure de données étrangère, pouvant impacter la sécurité ou la stabilité. Le noyau permet actuellement aux pkeys en cours d’avoir B<pkey_free>(2) appelée sur elles car cela pourrait avoir des implications de performance de processeur ou de mémoire pour réaliser des vérifications supplémentaires nécessaires pour désactiver cet appel. L’implémentation des vérifications nécessaires est laissée aux applications. Celles-ci peuvent mettre en œuvre ces vérifications en parcourant le fichier I</proc/[pid]/smaps> pour des régions de la mémoire ayant la pkey assignée. Plus de détails sont fournis dans B<proc>(5).

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en:     /*
         *Allocate one page of memory
         */
        buffer = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
                      MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        if (buffer == MAP_FAILED)
            errExit("mmap");
fr:     /*
         *Allocation d’une page de mémoire
         */
        buffer = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
                      MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        if (buffer == MAP_FAILED)
            errExit("mmap");

note: type: Plain text
en:     /*
         * Put some random data into the page (still OK to touch)
         */
        *buffer = __LINE__;
        printf("buffer contains: %d\en", *buffer);
fr:     /*
         * Mise de données aléatoires dans la page (toujours OK à affecter).
         */
        *buffer = __LINE__;
        printf("le buffer contient : %d\en", *buffer);

note: type: Plain text
en:     /*
         * Allocate a protection key:
         */
        pkey = pkey_alloc();
        if (pkey == -1)
            errExit("pkey_alloc");
fr:     /*
         * Allocation d’une clé de protection :
         */
        pkey = pkey_alloc();
        if (pkey == -1)
            errExit("pkey_alloc");

note: type: Plain text
en:     /*
         * Disable access to any memory with "pkey" set,
         * even though there is none right now
         */
        status = pkey_set(pkey, PKEY_DISABLE_ACCESS, 0);
        if (status)
            errExit("pkey_set");
fr:     /*
         * Désactivation de l’accès à toute mémoire avec l’ensemble
         * « pkey », même si aucun droit n’existe à ce moment.
         */
        status = pkey_set(pkey, PKEY_DISABLE_ACCESS, 0);
        if (status)
            errExit("pkey_set");

note: type: Plain text
en:     /*
         * Set the protection key on "buffer".
         * Note that it is still read/write as far as mprotect() is
         * concerned and the previous pkey_set() overrides it.
         */
        status = pkey_mprotect(buffer, getpagesize(),
                               PROT_READ | PROT_WRITE, pkey);
        if (status == -1)
            errExit("pkey_mprotect");
fr:     /*
         * Mettre la clé de protection dans « buffer ».
         * Noter que c’est toujours lect./écrit. aussi longtemps que mprotect()
         * est concerné et que le pkey_set() précédent l’écrase.
         */
        status = pkey_mprotect(buffer, getpagesize(),
                               PROT_READ | PROT_WRITE, pkey);
        if (status == -1)
            errExit("pkey_mprotect");

note: type: Plain text
en:     /*
         * This will crash, because we have disallowed access
         */
        printf("buffer contains: %d\en", *buffer);
fr:     /*
         * Ceci va planter car l’accès a été désactivé.
         */
        printf("le buffer contient : %d\en", *buffer);

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/.
