perkamon - en to fr translation catalogue (960 entries)

note: type: TH
en: 2008-06-16
fr: 16 juin 2008

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: acct - switch process accounting on or off
fr: acct - Activer/désactiver la comptabilité des processus

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<acct>(): _BSD_SOURCE || (_XOPEN_SOURCE && _XOPEN_SOURCE\ E<lt>\ 500)
fr: B<acct>() : _BSD_SOURCE || (_XOPEN_SOURCE && _XOPEN_SOURCE\ E<lt>\ 500)

note: type: Plain text
en: The B<acct>()  system call enables or disables process accounting.  If called with the name of an existing file as its argument, accounting is turned on, and records for each terminating process are appended to I<filename> as it terminates.  An argument of NULL causes accounting to be turned off.
fr: L'appel système B<acct>() active ou désactive la comptabilité des processus. Lorsqu'il est appelé avec un nom de fichier existant comme argument, la comptabilité est mise en marche, un enregistrement étant ajouté à I<filename> à la fin de chaque processus. Un argument NULL arrête la comptabilité.

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

note: type: Plain text
en: On success, zero is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'il réussit, cet appel système renvoie 0. S'il échoue, il renvoie -1 et remplit I<errno> en conséquence.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: Write permission is denied for the specified file, or search permission is denied for one of the directories in the path prefix of I<filename> (see also B<path_resolution>(7)), or I<filename> is not a regular file.
fr: L'autorisation d'écrire est refusée pour le fichier indiqué, ou l'autorisation de parcours est refusée pour l'un des répertoires du chemin de I<filename> (consultez aussi B<path_resolution>(7)), ou I<filename> n'est pas un fichier ordinaire.

note: type: Plain text
en: I<filename> points outside your accessible address space.
fr: L'argument I<filename> pointe en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: Error writing to the file I<filename>.
fr: Impossible d'écrire dans le fichier I<filename>.

note: type: Plain text
en: I<filename> is a directory.
fr: I<filename> est un répertoire.

note: type: Plain text
en: Too many symbolic links were encountered in resolving I<filename>.
fr: Références symboliques circulaires dans le chemin d'accès à I<filename>.

note: type: Plain text
en: I<filename> was too long.
fr: I<filename> est une chaîne trop longue.

note: type: Plain text
en: The system limit on the total number of open files has been reached.
fr: La limite du nombre total de fichiers ouverts sur le système a été atteinte.

note: type: Plain text
en: The specified filename does not exist.
fr: Le nom de fichier indiqué n'existe pas.

note: type: Plain text
en: Out of memory.
fr: Plus de mémoire disponible.

note: type: Plain text
en: BSD process accounting has not been enabled when the operating system kernel was compiled.  The kernel configuration parameter controlling this feature is B<CONFIG_BSD_PROCESS_ACCT>.
fr: Le système de comptabilité BSD n'a pas été activé lors de la compilation du noyau. Le paramètre de configuration du noyau contrôlant cette option est B<CONFIG_BSD_PROCESS_ACCT>.

note: type: Plain text
en: A component used as a directory in I<filename> is not in fact a directory.
fr: Un élément du chemin d'accès I<filename> n'est pas un répertoire.

note: type: Plain text
en: The calling process has insufficient privilege to enable process accounting.  On Linux the B<CAP_SYS_PACCT> capability is required.
fr: L'appelant n'a pas de privilèges suffisants pour activer la comptabilité. Sous Linux, la capacité B<CAP_SYS_PACCT> est nécessaire.

note: type: Plain text
en: I<filename> refers to a file on a read-only filesystem.
fr: I<filename> se trouve sur un système de fichiers en lecture seule.

note: type: Plain text
en: There are no more free file structures or we ran out of memory.
fr: Il n'y a plus de structures de fichiers libres, ou pas assez de mémoire.

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

note: SVr4 documents an EBUSY error condition, but no EISDIR or ENOSYS. Also AIX and HP-UX document EBUSY (attempt is made to enable accounting when it is already enabled), as does Solaris (attempt is made to enable accounting using the same file that is currently being used). type: Plain text
en: SVr4, 4.3BSD (but not POSIX).
fr: SVr4, BSD\ 4.3 (mais pas POSIX).

note: type: Plain text
en: No accounting is produced for programs running when a system crash occurs.  In particular, nonterminating processes are never accounted for.
fr: Aucune comptabilisation n'est effectuée pour les programmes en cours d'exécution si un plantage système survient. En particulier les processus qui ne se terminent jamais ne sont pas comptabilisés.

note: type: Plain text
en: The structure of the records written to the accounting file is described in B<acct>(5).
fr: La structure des enregistrements écrits dans le fichier de comptabilité est décrite dans B<acct>(5).

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: 2008-06-15
fr: 15 juin 2008

note: type: Plain text
en: acct - process accounting file
fr: acct - Fichier de comptabilité des processus

note: type: Plain text
en: If the kernel is built with the process accounting option enabled (B<CONFIG_BSD_PROCESS_ACCT>), then calling B<acct>(2)  starts process accounting, for example:
fr: Si le noyau a été compilé avec l'option de comptabilité des processus activée (B<CONFIG_BSD_PROCESS_ACCT>), l'appel système B<acct>(2) démarre la comptabilité. Par exemple :

note: type: Plain text
en: When process accounting is enabled, the kernel writes a record to the accounting file as each process on the system terminates.  This record contains information about the terminated process, and is defined in I<E<lt>sys/acct.hE<gt>> as follows:
fr: Quand la comptabilité des processus est activée, le noyau écrit dans le fichier indiqué un enregistrement à chaque mort d'un processus. Cet enregistrement contient des informations concernant le processus terminé, décrites dans I<E<lt>sys/acct.hE<gt>> ainsi :

note: type: Plain text
en: struct acct {
        char ac_flag;           /* Accounting flags */
        u_int16_t ac_uid;       /* Accounting user ID */
        u_int16_t ac_gid;       /* Accounting group ID */
        u_int16_t ac_tty;       /* Controlling terminal */
        u_int32_t ac_btime;     /* Process creation time
                                   (seconds since the Epoch) */
        comp_t    ac_utime;     /* User CPU time */
        comp_t    ac_stime;     /* System CPU time */
        comp_t    ac_etime;     /* Elapsed time */
        comp_t    ac_mem;       /* Average memory usage (kB) */
        comp_t    ac_io;        /* Characters transferred (unused) */
        comp_t    ac_rw;        /* Blocks read or written (unused) */
        comp_t    ac_minflt;    /* Minor page faults */
        comp_t    ac_majflt;    /* Major page faults */
        comp_t    ac_swaps;     /* Number of swaps (unused) */
        u_int32_t ac_exitcode;  /* Process termination status
                                   (see wait(2)) */
        char      ac_comm[ACCT_COMM+1];
                                /* Command name (basename of last
                                   executed command; null-terminated) */
        char      ac_pad[I<X>];    /* padding bytes */
    };
fr: struct acct {
        char      ac_flag;      /* Attribut de comptabilité */
        u_int16_t ac_uid;       /* UID comptabilisé */
        u_int16_t ac_gid;       /* GID comptabilisé */
        u_int16_t ac_tty;       /* Terminal de contrôle */
        u_int32_t ac_btime;     /* Heure de création du processus */
                                   (secondes depuis 01/01/1970) */
        comp_t    ac_utime;     /* Temps CPU en mode utilisateur */
        comp_t    ac_stime;     /* Temps CPU en mode noyau */
        comp_t    ac_etime;     /* Temps écoulé */
        comp_t    ac_mem;       /* Moyenne mémoire utilisée (ko) */
        comp_t    ac_io;        /* Caractères transmis (inutilisé) */
        comp_t    ac_rw;        /* Blocs lus ou écrits (inutilisé) */
        comp_t    ac_minflt;    /* Nb fautes de pages mineures */
        comp_t    ac_majflt;    /* Nb fautes de pages majeures */
        comp_t    ac_swaps;     /* Nb de swaps (inutilisé) */
        u_int32_t ac_exitcode;  /* Code de retour - voir wait(2) */
        char      ac_comm[ACCT_COMM+1];
                                /* Nom de la commande (nom de base
                                   de la dernière commande exécutée
                                   terminé par zéro) */
        char      ac_pad[I<X>];    /* Remplissage */
    };

note: type: Plain text
en: enum {          /* Bits that may be set in ac_flag field */
        AFORK = 0x01,           /* Has executed fork, but no exec */
        ASU   = 0x02,           /* Used superuser privileges */
        ACORE = 0x08,           /* Dumped core */
        AXSIG = 0x10            /* Killed by a signal */
    };
fr: enum {          /* Bits qui peuvent se trouver dans ac_flag */
        AFORK = 0x01,           /* A exécuté fork mais pas exec */
        ASU   = 0x02,           /* A utilisé les privilèges superutilisateur */
        ACORE = 0x08,           /* A créé un fichier core */
        AXSIG = 0x10            /* Tué par un signal */
    };

note: type: Plain text
en: The I<comp_t> data type is a floating-point value consisting of a 3-bit, base-8 exponent, and a 13-bit mantissa.  A value, I<c>, of this type can be converted to a (long) integer as follows:
fr: Le type de donnée I<comp_t> est une valeur réelle constituée d'un exposant en base 8 sur 3 bits et d'une mantisse sur 13 bits. Une valeur I<c>, de ce type peut être convertie en entier (long) ainsi :

note: type: Plain text
en: The I<ac_utime>, I<ac_stime>, and I<ac_etime> fields measure time in "clock ticks"; divide these values by I<sysconf(_SC_CLK_TCK)> to convert them to seconds.
fr: Les champs I<ac_utime>, I<ac_stime>, et I<ac_etime> mesurent les temps en «\ tops d'horloge\ ». Divisez ces valeurs par I<sysconf(_SC_CLK_TCK)> pour obtenir des secondes.

note: type: SS
en: Version 3 accounting file format
fr: Format des fichiers de comptabilité version 3

note: type: Plain text
en: Since kernel 2.6.8, an optional alternative version of the accounting file can be produced if the B<CONFIG_BSD_PROCESS_ACCT_V3> option is set when building the kernel.  With this option is set, the records written to the accounting file contain additional fields, and the width of I<c_uid> and I<ac_gid> fields is widened from 16 to 32 bits (in line with the increased size of UID and GIDs in Linux 2.4 and later).  The records are defined as follows:
fr: Depuis le noyau 2.6.8, une autre version du fichier peut être éventuellement produite, si l'option B<CONFIG_BSD_PROCESS_ACCT_V3> est définie lors de la compilation du noyau. Lorsque cette option est active, les enregistrements écrits dans le fichier de comptabilité contiennent des champs supplémentaires et la longueur des champs I<c_uid> et I<ac_gid> est élargie de 16 à 32 bits (en accord avec l'élargissement des UID et GID dans les noyaux Linux 2.4 et ultérieur). Les enregistrements sont définis ainsi :

note: type: Plain text
en: struct acct_v3 {
        char      ac_flag;      /* Flags */
        char      ac_version;   /* Always set to ACCT_VERSION (3) */
        u_int16_t ac_tty;       /* Controlling terminal */
        u_int32_t ac_exitcode;  /* Process termination status */
        u_int32_t ac_uid;       /* Real user ID */
        u_int32_t ac_gid;       /* Real group ID */
        u_int32_t ac_pid;       /* Process ID */
        u_int32_t ac_ppid;      /* Parent process ID */
        u_int32_t ac_btime;     /* Process creation time */
        float     ac_etime;     /* Elapsed time */
        comp_t    ac_utime;     /* User CPU time */
        comp_t    ac_stime;     /* System time */
        comp_t    ac_mem;       /* Average memory usage (kB) */
        comp_t    ac_io;        /* Characters transferred (unused) */
        comp_t    ac_rw;        /* Blocks read or written
                                   (unused) */
        comp_t    ac_minflt;    /* Minor page faults */
        comp_t    ac_majflt;    /* Major page faults */
        comp_t    ac_swaps;     /* Number of swaps (unused) */
        char      ac_comm[ACCT_COMM]; /* Command name */
    };
fr: struct acct_v3 {
        char      ac_flag;      /* Attribut de comptabilité */
        char      ac_version;   /* Vaut toujours ACCT_VERSION (3) */
        u_int16_t ac_tty;       /* Terminal de contrôle */
        u_int32_t ac_exitcode;  /* Code de retour - voir wait(2) */
        u_int32_t ac_uid;       /* UID réel */
        u_int32_t ac_gid;       /* GID réel */
        u_int32_t ac_pid;       /* PID */
        u_int32_t ac_ppid;      /* PPID (PID du parent) */
        u_int32_t ac_btime;     /* Heure de création du processus */
                                   (secondes depuis 01/01/1970) */
        float     ac_etime;     /* Temps écoulé */
        comp_t    ac_utime;     /* Temps CPU en mode utilisateur */
        comp_t    ac_stime;     /* Temps CPU en mode noyau */
        comp_t    ac_mem;       /* Moyenne mémoire utilisée (ko) */
        comp_t    ac_io;        /* Caractères transmis (inutilisé) */
        comp_t    ac_rw;        /* Blocs lus ou écrits (inutilisé) */
        comp_t    ac_minflt;    /* Nb fautes de pages mineures */
        comp_t    ac_majflt;    /* Nb fautes de pages majeures */
        comp_t    ac_swaps;     /* Nb de swaps (inutilisé) */
        char      ac_comm[ACCT_COMM];
                                /* Nom de la commande */
    };

note: type: Plain text
en: The I<acct_v3> structure is defined in glibc since version 2.6.
fr: La structure I<acct_v3> est définie dans la glibc depuis la version 2.6.

note: type: Plain text
en: Process accounting originated on BSD.  Although it is present on most systems, it is not standardized, and the details vary somewhat between systems.
fr: La comptabilité des processus provient de BSD. Bien qu'elle soit implémentée sur la plupart des systèmes, elle n'est pas normalisée et varie parfois entre les systèmes.

note: type: Plain text
en: Records in the accounting file are ordered by termination time of the process.
fr: Les enregistrements dans le fichier de comptabilité sont classés en fonction de l'heure de fin des processus.

note: type: Plain text
en: In kernels up to and including 2.6.9, a separate accounting record is written for each thread created using the NPTL threading library; since Linux 2.6.10, a single accounting record is written for the entire process on termination of the last thread in the process.
fr: Dans les noyaux jusqu'au 2.6.9 (inclus), un enregistrement séparé était écrit pour chaque thread utilisant la bibliothèque NPTL. Depuis Linux 2.6.10, un enregistrement unique est écrit pour l'ensemble du processus à la fin de son dernier thread.

note: type: Plain text
en: The I<proc/sys/kernel/acct> file, described in B<proc>(5), defines settings that control the behavior of process accounting when disk space runs low.
fr: Le fichier I<proc/sys/kernel/acct> décrit dans B<proc>(5), configure le comportement de la comptabilité des processus lorsque l'espace disque commence à manquer.

note: type: TH
en: 2014-04-09
fr: 9 avril 2014

note: type: Plain text
en: capabilities - overview of Linux capabilities
fr: capabilities - Présentation des capacités Linux

note: type: Plain text
en: For the purpose of performing permission checks, traditional UNIX implementations distinguish two categories of processes: I<privileged> processes (whose effective user ID is 0, referred to as superuser or root), and I<unprivileged> processes (whose effective UID is nonzero).  Privileged processes bypass all kernel permission checks, while unprivileged processes are subject to full permission checking based on the process's credentials (usually: effective UID, effective GID, and supplementary group list).
fr: Pour vérifier les permissions, les implémentations UNIX traditionnelles distinguent deux catégories de processus\ : les processus I<privilégiés> (dont l'UID effectif est 0, appelé superutilisateur ou root), et les processus I<non privilégiés> (dont l'UID effectif est non-nul). Les processus privilégiés contournent les vérifications de permissions du noyau, alors que les processus non-privilégiés sont soumis à une vérification complète basée sur l'identification du processus (habituellement\ : UID effectif, GID effectif, et liste des groupes).

note: type: Plain text
en: Starting with kernel 2.2, Linux divides the privileges traditionally associated with superuser into distinct units, known as I<capabilities>, which can be independently enabled and disabled.  Capabilities are a per-thread attribute.
fr: À partir du noyau 2.2, Linux propose un mécanisme (encore incomplet) de I<capacités>, qui scinde les privilèges traditionnellement associés au superutilisateur en unités distinctes que l'on peut activer ou inhiber individuellement. Les capacités sont des attributs individuels à chaque thread.

note: type: SS
en: Capabilities list
fr: Liste des capacités

note: type: Plain text
en: The following list shows the capabilities implemented on Linux, and the operations or behaviors that each capability permits:
fr: La liste suivante indique les capacités implémentées sous Linux et les opérations ou comportements que chaque capacité permet :

note: type: TP
en: B<CAP_AUDIT_CONTROL> (since Linux 2.6.11)
fr: B<CAP_AUDIT_CONTROL> (depuis Linux 2.6.11)

note: type: Plain text
en: Enable and disable kernel auditing; change auditing filter rules; retrieve auditing status and filtering rules.
fr: Activer et désactiver l'audit du noyau\ ; changer les règles de filtrage d'audit\ ; accéder à l'état de l'audit, et aux règles de filtrage.

note: type: TP
en: B<CAP_AUDIT_WRITE> (since Linux 2.6.11)
fr: B<CAP_AUDIT_WRITE> (depuis Linux 2.6.11)

note: type: Plain text
en: Write records to kernel auditing log.
fr: Écrire des enregistrements dans le journal d'audit du noyau.

note: type: TP
en: B<CAP_BLOCK_SUSPEND> (since Linux 3.5)
fr: B<CAP_BLOCK_SUSPEND> (depuis Linux 3.5)

note: type: Plain text
en: Employ features that can block system suspend (B<epoll>(7)  B<EPOLLWAKEUP>, I</proc/sys/wake_lock>).
fr: Utiliser des fonctionnalités qui peuvent bloquer la mise en veille du système (B<epoll>(7) B<EPOLLWAKEUP>, I</proc/sys/wake_lock>).

note: type: Plain text
en: Make arbitrary changes to file UIDs and GIDs (see B<chown>(2)).
fr: Effectuer toute modification des UID et GID de fichiers (consultez B<chown>(2)).

note: type: Plain text
en: Bypass file read, write, and execute permission checks.  (DAC is an abbreviation of "discretionary access control".)
fr: Contourne les permissions de lecture, écriture et exécution. (DAC est l'abréviation de « discretionary access control », contrôle d'accès à volonté).

note: type: Plain text
en: Bypass file read permission checks and directory read and execute permission checks;
fr: Contourne les permissions de lecture de fichiers et celles de lecture et exécution des répertoires ;

note: type: Plain text
en: Invoke B<open_by_handle_at>(2).
fr: Invoque B<open_by_handle_at>(2).

note: type: Plain text
en: Bypass permission checks on operations that normally require the filesystem UID of the process to match the UID of the file (e.g., B<chmod>(2), B<utime>(2)), excluding those operations covered by B<CAP_DAC_OVERRIDE> and B<CAP_DAC_READ_SEARCH>;
fr: Contourne les vérifications pour les opérations qui demandent que le FS-UID du processus corresponde à l'UID du fichier (par exemple B<chmod>(2), B<utime>(2)), à l'exclusion des opérations couvertes par B<CAP_DAC_OVERRIDE> et B<CAP_DAC_READ_SEARCH>\ ;

note: type: Plain text
en: set extended file attributes (see B<chattr>(1))  on arbitrary files;
fr: positionner les attributs de fichier étendus (consultez B<chattr>(1)) pour n'importe quel fichier\ ;

note: type: Plain text
en: set Access Control Lists (ACLs) on arbitrary files;
fr: positionner les listes de contrôle d'accès ACL (« Access Control Lists ») pour n'importe quel fichier\ ;

note: type: Plain text
en: ignore directory sticky bit on file deletion;
fr: ignorer le bit sticky des répertoires pour les suppressions de fichier\ ;

note: type: Plain text
en: specify B<O_NOATIME> for arbitrary files in B<open>(2)  and B<fcntl>(2).
fr: spécifier B<O_NOATIME> dans B<open>(2) et B<fcntl>(2) pour n'importe quel fichier.

note: type: Plain text
en: Don't clear set-user-ID and set-group-ID permission bits when a file is modified; set the set-group-ID bit for a file whose GID does not match the filesystem or any of the supplementary GIDs of the calling process.
fr: Ne pas effacer les bits de permission Set-UID et Set-GID quand un fichier est modifié\ ; positionner le bit Set-GID sur un fichier dont le GID ne correspond à aucun GID du processus appelant.

note: FIXME As at Linux 3.2, there are some strange uses of this capability in other places; they probably should be replaced with something else. type: Plain text
en: Lock memory (B<mlock>(2), B<mlockall>(2), B<mmap>(2), B<shmctl>(2)).
fr: Verrouiller des pages mémoire (B<mlock>(2), B<mlockall>(2), B<mmap>(2), B<shmctl>(2)).

note: type: Plain text
en: Bypass permission checks for operations on System V IPC objects.
fr: Contourne les vérifications pour les opérations sur les IPC System V.

note: FIXME CAP_KILL also has an effect for threads + setting child termination signal to other than SIGCHLD: without this capability, the termination signal reverts to SIGCHLD if the child does an exec().  What is the rationale for this? type: Plain text
en: Bypass permission checks for sending signals (see B<kill>(2)).  This includes use of the B<ioctl>(2)  B<KDSIGACCEPT> operation.
fr: Contourne les vérifications pour l'émission de signaux (consultez B<kill>(2)). Cela inclut l'utilisation de l'B<ioctl>(2) B<KDSIGACCEPT>.

note: type: TP
en: B<CAP_LEASE> (since Linux 2.4)
fr: B<CAP_LEASE> (depuis Linux 2.4)

note: type: Plain text
en: Establish leases on arbitrary files (see B<fcntl>(2)).
fr: Demander des baux sur n'importe quel fichier (consultez B<fcntl>(2)).

note: These attributes are now available on ext2, ext3, Reiserfs, XFS, JFS type: Plain text
en: Set the B<FS_APPEND_FL> and B<FS_IMMUTABLE_FL> i-node flags (see B<chattr>(1)).
fr: Positionner les attributs d'inœuds B<FS_APPEND_FL> et B<FS_IMMUTABLE_FL> (consultez B<chattr>(1)).

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

note: type: Plain text
en: Override Mandatory Access Control (MAC).  Implemented for the Smack Linux Security Module (LSM).
fr: Surcharger les contrôles d'accès MAC (« Mandatory Access Control »). Implémentée pour le module de sécurité (LSM : « Linux Security Module ») Smack.

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

note: type: Plain text
en: Allow MAC configuration or state changes.  Implemented for the Smack LSM.
fr: Permettre les modifications de la configuration ou des états MAC. Implémentée pour le LSM Smack.

note: type: TP
en: B<CAP_MKNOD> (since Linux 2.4)
fr: B<CAP_MKNOD> (depuis Linux 2.4)

note: type: Plain text
en: Create special files using B<mknod>(2).
fr: Créer des fichiers spéciaux avec B<mknod>(2).

note: type: Plain text
en: Perform various network-related operations:
fr: Effectuer diverses opérations liées au réseau :

note: type: Plain text
en: interface configuration;
fr: configuration des interfaces ;

note: type: Plain text
en: administration of IP firewall, masquerading, and accounting;
fr: administration du pare-feu, de la traduction d'adresse IP (« masquerading ») et collection de données sur le trafic réseau (« accounting ») ;

note: type: Plain text
en: modify routing tables;
fr: modification des tables de routages ;

note: type: Plain text
en: bind to any address for transparent proxying;
fr: attachement à n'importe quelle adresse pour un service mandataire transparent ;

note: type: Plain text
en: set type-of-service (TOS)
fr: sélection du type de service (« TOS ») ;

note: type: Plain text
en: clear driver statistics;
fr: effacement des statistiques du pilote ;

note: type: Plain text
en: set promiscuous mode;
fr: sélection du mode « promiscuité » ;

note: type: Plain text
en: enabling multicasting;
fr: activation de la diffusion multipoint (« multicast ») ;

note: type: Plain text
en: use B<setsockopt>(2)  to set the following socket options: B<SO_DEBUG>, B<SO_MARK>, B<SO_PRIORITY> (for a priority outside the range 0 to 6), B<SO_RCVBUFFORCE>, and B<SO_SNDBUFFORCE>.
fr: utiliser B<setsockopt>(2) pour définir les options de sockets suivantes : B<SO_DEBUG>, B<SO_MARK>, B<SO_PRIORITY> (pour une priorité en dehors des valeurs de 0 à 6), B<SO_RCVBUFFORCE> et B<SO_SNDBUFFORCE>.

note: type: Plain text
en: Bind a socket to Internet domain privileged ports (port numbers less than 1024).
fr: Attacher une socket sur un port privilégié (numéro de port inférieur à 1024).

note: type: Plain text
en: (Unused)  Make socket broadcasts, and listen to multicasts.
fr: (Inutilisé) Broadcaster et écouter en multicast avec des sockets.

note: type: Plain text
en: use RAW and PACKET sockets;
fr: utiliser des sockets RAW et PACKET ;

note: type: Plain text
en: bind to any address for transparent proxying.
fr: attacher à n'importe quelle adresse pour un service mandataire transparent.

note: type: Plain text
en: Make arbitrary manipulations of process GIDs and supplementary GID list; forge GID when passing socket credentials via UNIX domain sockets.
fr: Effectuer toute manipulation des GID du processus et de la liste de groupes supplémentaires, utiliser de faux GID sur les socket UNIX.

note: type: TP
en: B<CAP_SETFCAP> (since Linux 2.6.24)
fr: B<CAP_SETFCAP> (depuis Linux 2.6.24)

note: type: Plain text
en: Set file capabilities.
fr: Définir des capacités de fichier

note: type: Plain text
en: If file capabilities are not supported: grant or remove any capability in the caller's permitted capability set to or from any other process.  (This property of B<CAP_SETPCAP> is not available when the kernel is configured to support file capabilities, since B<CAP_SETPCAP> has entirely different semantics for such kernels.)
fr: Si les capacités de fichier sont prises en charge : autoriser ou interdire toute capacité dans l'ensemble des capacités permises à l'appelant vers ou depuis tout autre processus. (Cette propriété de B<CAP_SETPCAP> n'est pas disponible quand le noyau est configuré pour prendre en charge les capacité de fichiers, puisque B<CAP_SETPCAP> a une toute autre sémantique pour ces noyaux)

note: type: Plain text
en: If file capabilities are supported: add any capability from the calling thread's bounding set to its inheritable set; drop capabilities from the bounding set (via B<prctl>(2)  B<PR_CAPBSET_DROP>); make changes to the I<securebits> flags.
fr: Si les capacités de fichier sont prises en charge : ajouter toute capacité de l'ensemble de limitation de capacités du thread appelant à son ensemble hérité ; supprimer les capacités de l'ensemble de limitation de capacités (avec B<prctl>(2) B<PR_CAPBSET_DROP>) ; modifier l'attribut I<securebits>.

note: FIXME CAP_SETUID also an effect in exec(); document this. type: Plain text
en: Make arbitrary manipulations of process UIDs (B<setuid>(2), B<setreuid>(2), B<setresuid>(2), B<setfsuid>(2)); make forged UID when passing socket credentials via UNIX domain sockets.
fr: Effectuer toute manipulation des UID de processus (B<setuid>(2), B<setreuid>(2), B<setresuid>(2), B<setfsuid>(2))\ ; transmettre un faux UID sur une socket dans le domaine UNIX.

note: type: Plain text
en: Perform a range of system administration operations including: B<quotactl>(2), B<mount>(2), B<umount>(2), B<swapon>(2), B<swapoff>(2), B<sethostname>(2), and B<setdomainname>(2);
fr: Effectuer certaines opérations d'administration comme : B<quotactl>(2), B<mount>(2), B<umount>(2), B<swapon>(2), B<swapoff>(2), B<sethostname>(2) et B<setdomainname>(2) ;

note: type: Plain text
en: perform privileged B<syslog>(2)  operations (since Linux 2.6.37, B<CAP_SYSLOG> should be used to permit such operations);
fr: effectuer des opérations B<syslog>(2) nécessitant des droits (depuis Linux 2.6.37, B<CAP_SYSLOG> doit être utilisée pour permettre de telles opérations) ;

note: type: Plain text
en: perform B<VM86_REQUEST_IRQ> B<vm86>(2)  command;
fr: effectuer une commande B<VM86_REQUEST_IRQ> B<vm86>(2) ;

note: type: Plain text
en: perform B<IPC_SET> and B<IPC_RMID> operations on arbitrary System V IPC objects;
fr: effectuer des opérations B<IPC_SET> et B<IPC_RMID> sur n'importe quel objet IPC System V ;

note: type: Plain text
en: perform operations on I<trusted> and I<security> Extended Attributes (see B<attr>(5));
fr: effectuer des opérations sur les attributs étendus I<trusted> et I<security> (consultez B<attr>(5)) ;

note: type: Plain text
en: use B<lookup_dcookie>(2);
fr: utiliser B<lookup_dcookie>(2) ;

note: type: Plain text
en: use B<ioprio_set>(2)  to assign B<IOPRIO_CLASS_RT> and (before Linux 2.6.25)  B<IOPRIO_CLASS_IDLE> I/O scheduling classes;
fr: utiliser B<ioprio_set>(2) pour configurer une classe d'ordonnancement B<IOPRIO_CLASS_RT> (avant Linux 2.6.25) et B<IOPRIO_CLASS_IDLE> ;

note: type: Plain text
en: forge UID when passing socket credentials;
fr: forger des identifiants d'utilisateur lors du passage de références de sockets ;

note: type: Plain text
en: exceed I</proc/sys/fs/file-max>, the system-wide limit on the number of open files, in system calls that open files (e.g., B<accept>(2), B<execve>(2), B<open>(2), B<pipe>(2));
fr: dépasser I</proc/sys/fs/file-max>, la limite système du nombre de fichiers ouverts, dans les appels système qui ouvrent des fichiers (c'est-à-dire B<accept>(2), B<execve>(2), B<open>(2) et B<pipe>(2)) ;

note: type: Plain text
en: employ B<CLONE_*> flags that create new namespaces with B<clone>(2)  and B<unshare>(2);
fr: utiliser les attributs B<CLONE_*> qui créent de nouveaux espaces de nom avec B<clone>(2) et B<unshare>(2) ;

note: type: Plain text
en: call B<perf_event_open>(2);
fr: appeler B<perf_event_open>(2) ;

note: type: Plain text
en: access privileged I<perf> event information;
fr: accéder aux informations d'événements I<perf> nécessitant des droits ;

note: type: Plain text
en: call B<setns>(2);
fr: appeler B<setns>(2) ;

note: type: Plain text
en: call B<fanotify_init>(2);
fr: appeler B<fanotify_init>(2) ;

note: type: Plain text
en: perform B<KEYCTL_CHOWN> and B<KEYCTL_SETPERM> B<keyctl>(2)  operations;
fr: effectuer des opérations B<keyctl>(2) B<KEYCTL_CHOWN> et B<KEYCTL_SETPERM> ;

note: type: Plain text
en: perform B<madvise>(2)  B<MADV_HWPOISON> operation;
fr: effectuer une opération B<madvise>(2) B<MADV_HWPOISON> ;

note: type: Plain text
en: employ the B<TIOCSTI> B<ioctl>(2)  to insert characters into the input queue of a terminal other than the caller's controlling terminal.
fr: utiliser la commande B<TIOCSTI> de B<ioctl>(2) pour insérer des caractère dans la file d'entrée d'un terminal autre que le terminal de contrôle de l'appelant ;

note: type: Plain text
en: employ the obsolete B<nfsservctl>(2)  system call;
fr: utiliser l'appel système obsolète B<nfsservctl>(2) ;

note: type: Plain text
en: employ the obsolete B<bdflush>(2)  system call;
fr: utiliser l'appel système obsolète B<bdflush>(2) ;

note: type: Plain text
en: perform various privileged block-device B<ioctl>(2)  operations;
fr: effectuer diverses opérations B<ioctl>(2) sur des périphériques bloc nécessitant des droits ;

note: type: Plain text
en: perform various privileged filesystem B<ioctl>(2)  operations;
fr: effectuer diverses opérations B<ioctl>(2) sur des systèmes de fichiers nécessitant des droits ;

note: type: Plain text
en: perform administrative operations on many device drivers.
fr: effectuer des opérations d'administration sur de nombreux pilotes de périphériques.

note: type: Plain text
en: Use B<reboot>(2)  and B<kexec_load>(2).
fr: Utiliser B<reboot>(2) et B<kexec_load>(2).

note: type: Plain text
en: Use B<chroot>(2).
fr: Utiliser B<chroot>(2).

note: type: Plain text
en: Load and unload kernel modules (see B<init_module>(2)  and B<delete_module>(2)); in kernels before 2.6.25: drop capabilities from the system-wide capability bounding set.
fr: Charger ou décharger des modules noyaux (consultez B<init_module>(2) et B<delete_module>(2)) ; dans les noyaux antérieurs à 2.6.25 : enlever des capacités de l'ensemble système de limitation de capacités.

note: type: Plain text
en: Raise process nice value (B<nice>(2), B<setpriority>(2))  and change the nice value for arbitrary processes;
fr: Augmenter la valeur de courtoisie (« nice ») (B<nice>(2), B<setpriority>(2)) et changer la courtoisie de n'importe quel processus ;

note: type: Plain text
en: set real-time scheduling policies for calling process, and set scheduling policies and priorities for arbitrary processes (B<sched_setscheduler>(2), B<sched_setparam>(2));
fr: utiliser des ordonnancements temps-réel pour le processus appelant, et la modification de l'ordonnancement de n'importe quel processus (B<sched_setscheduler>(2), B<sched_setparam>(2))\ ;

note: type: Plain text
en: set CPU affinity for arbitrary processes (B<sched_setaffinity>(2));
fr: définir l'affinité CPU pour n'importe quel processus (B<sched_setaffinity>(2)) ;

note: type: Plain text
en: set I/O scheduling class and priority for arbitrary processes (B<ioprio_set>(2));
fr: définir la classe et la priorité d'ordonnancement d'entrées/sorties pour n'importe quel processus (B<ioprio_set>(2)) ;

note: FIXME CAP_SYS_NICE also has the following effect for migrate_pages(2): do_migrate_pages(mm, &old, &new, capable(CAP_SYS_NICE) ? MPOL_MF_MOVE_ALL : MPOL_MF_MOVE); type: Plain text
en: apply B<migrate_pages>(2)  to arbitrary processes and allow processes to be migrated to arbitrary nodes;
fr: appliquer B<migrate_pages>(2) à n'importe quel processus et migrer un processus vers n'importe quel nœud\ ;

note: type: Plain text
en: apply B<move_pages>(2)  to arbitrary processes;
fr: appliquer B<move_pages>(2) pour n'importe quel processus ;

note: type: Plain text
en: use the B<MPOL_MF_MOVE_ALL> flag with B<mbind>(2)  and B<move_pages>(2).
fr: utiliser l'attribut B<MPOL_MF_MOVE_ALL> avec B<mbind>(2) et B<move_pages>(2).

note: type: Plain text
en: Use B<acct>(2).
fr: Utiliser B<acct>(2).

note: type: Plain text
en: Trace arbitrary processes using B<ptrace>(2); apply B<get_robust_list>(2)  to arbitrary processes; inspect processes using B<kcmp>(2).
fr: Suivre n'importe quel processus avec B<ptrace>(2) ; appliquer B<get_robust_list>(2)  à n'importe quel processus ; examiner les processus avec B<kcmp>(2).

note: type: Plain text
en: Perform I/O port operations (B<iopl>(2)  and B<ioperm>(2));
fr: Effectuer des opérations d'entrées-sorties (B<iopl>(2) et B<ioperm>(2)) ;

note: type: Plain text
en: access I</proc/kcore>;
fr: accéder à I</proc/kcore> ;

note: type: Plain text
en: employ the B<FIBMAP> B<ioctl>(2)  operation;
fr: utiliser l'opération B<FIBMAP> de B<ioctl>(2) ;

note: type: Plain text
en: open devices for accessing x86 model-specific registers (MSRs, see B<msr>(4))
fr: ouvrir les périphériques pour accéder aux registres spécifiques au modèle (MSR, consultez B<msr>(4)) d'un processeur x86 ;

note: type: Plain text
en: update I</proc/sys/vm/mmap_min_addr>;
fr: mettre à jour I</proc/sys/vm/mmap_min_addr> ;

note: type: Plain text
en: create memory mappings at addresses below the value specified by I</proc/sys/vm/mmap_min_addr>;
fr: créer des projections en mémoire aux adresses inférieures à la valeur indiquée par I</proc/sys/vm/mmap_min_addr> ;

note: type: Plain text
en: map files in I</proc/bus/pci>;
fr: projeter les fichiers dans I</proc/bus/pci> ;

note: type: Plain text
en: open I</dev/mem> and I</dev/kmem>;
fr: ouvrir I</dev/mem> et I</dev/kmem> ;

note: type: Plain text
en: perform various SCSI device commands;
fr: effectuer diverses commandes de périphérique SCSI ;

note: type: Plain text
en: perform certain operations on B<hpsa>(4)  and B<cciss>(4)  devices;
fr: effectuer certaines opérations sur les périphériques B<hpsa>(4) et B<cciss>(4) ;

note: type: Plain text
en: perform a range of device-specific operations on other devices.
fr: effectuer certaines opérations spécifiques à d'autres types de périphériques.

note: type: Plain text
en: Use reserved space on ext2 filesystems;
fr: Utiliser de l'espace réservé sur des systèmes de fichiers ext2 ;

note: type: Plain text
en: make B<ioctl>(2)  calls controlling ext3 journaling;
fr: effectuer des appels B<ioctl>(2) pour contrôler la journalisation ext3 ;

note: type: Plain text
en: override disk quota limits;
fr: ne pas tenir compte des limites définies par les quota disque ;

note: type: Plain text
en: increase resource limits (see B<setrlimit>(2));
fr: augmenter les limites de ressources (consultez B<setrlimit>(2))\ ;

note: type: Plain text
en: override B<RLIMIT_NPROC> resource limit;
fr: ne pas tenir compte de la limite de ressource B<RLIMIT_NPROC> ;

note: type: Plain text
en: override maximum number of consoles on console allocation;
fr: ne pas tenir compte du nombre maximal de consoles sur l'allocation de console ;

note: type: Plain text
en: override maximum number of keymaps;
fr: ne pas tenir compte du nombre maximal de dispositions de clavier ;

note: type: Plain text
en: allow more than 64hz interrupts from the real-time clock;
fr: permettre des interruptions à plus de 64 Hz depuis l'horloge temps réel ;

note: type: Plain text
en: raise I<msg_qbytes> limit for a System V message queue above the limit in I</proc/sys/kernel/msgmnb> (see B<msgop>(2)  and B<msgctl>(2));
fr: augmenter la limite I<msg_qbytes> pour la file de messages System V au dessus de la limite I</proc/sys/kernel/msgmnb> (consultez B<msgop>(2) et B<msgctl>(2)) ;

note: type: Plain text
en: override the I</proc/sys/fs/pipe-size-max> limit when setting the capacity of a pipe using the B<F_SETPIPE_SZ> B<fcntl>(2)  command.
fr: ne pas tenir compte la limite I</proc/sys/fs/pipe-size-max> lors du réglage de la capacité d'un tube avec la commande B<fcntl>(2) avec l'argument B<F_SETPIPE_SZ> ;

note: type: Plain text
en: use B<F_SETPIPE_SZ> to increase the capacity of a pipe above the limit specified by I</proc/sys/fs/pipe-max-size>;
fr: utiliser B<F_SETPIPE_SZ> pour augmenter la capacité d'un tube au-dessus de la limite spécifiée par I</proc/sys/fs/pipe-max-size> ;

note: type: Plain text
en: override I</proc/sys/fs/mqueue/queues_max> limit when creating POSIX message queues (see B<mq_overview>(7));
fr: ne pas tenir compte de la limite I</proc/sys/fs/mqueue/queues_max> lors de la création de files de messages POSIX (consultez B<mq_overview>(7)) ;

note: type: Plain text
en: employ B<prctl>(2)  B<PR_SET_MM> operation;
fr: utiliser l'opération B<PR_SET_MM> de B<prctl>(2) ;

note: type: Plain text
en: set I</proc/PID/oom_score_adj> to a value lower than the value last set by a process with B<CAP_SYS_RESOURCE>.
fr: affecter à I</proc/PID/oom_score_adj> une valeur inférieure à la dernière valeur affectée par un processus avec B<CAP_SYS_RESOURCE>.

note: type: Plain text
en: Set system clock (B<settimeofday>(2), B<stime>(2), B<adjtimex>(2)); set real-time (hardware) clock.
fr: Modifier l'heure système (B<settimeofday>(2), B<stime>(2), B<adjtimex>(2))\ ; modifier l'horloge temps réel (matérielle).

note: type: Plain text
en: Use B<vhangup>(2); employ various privileged B<ioctl>(2)  operations on virtual terminals.
fr: Utiliser B<vhangup>(2) ; employer diverses opérations B<ioctl>(2) nécessitant des droits sur des terminaux virtuels.

note: type: TP
en: B<CAP_SYSLOG> (since Linux 2.6.37)
fr: B<CAP_SYSLOG> (depuis Linux 2.6.37)

note: type: Plain text
en: Perform privileged B<syslog>(2)  operations.  See B<syslog>(2)  for information on which operations require privilege.
fr: Effectuer des opérations B<syslog>(2) nécessitant des droits. Consultez B<syslog>(2) pour savoir quelles opérations nécessitent des droits.

note: type: Plain text
en: View kernel addresses exposed via I</proc> and other interfaces when I</proc/sys/kernel/kptr_restrict> has the value 1.  (See the discussion of the I<kptr_restrict> in B<proc>(5).)
fr: Inspecter les adresses du noyau exposées par I</proc> et d'autres interfaces lorsque I</proc/sys/kernel/kptr_restrict> a la valeur 1. (Voir la discussion sur I<kptr_restrict> dans B<proc>(5).)

note: type: TP
en: B<CAP_WAKE_ALARM> (since Linux 3.0)
fr: B<CAP_WAKE_ALARM> (depuis Linux 3.0)

note: type: Plain text
en: Trigger something that will wake up the system (set B<CLOCK_REALTIME_ALARM> and B<CLOCK_BOOTTIME_ALARM> timers).
fr: Déclencher quelque chose qui réveillera le système (réglage des alarmes B<CLOCK_REALTIME_ALARM> et B<CLOCK_BOOTTIME_ALARM>).

note: type: SS
en: Past and current implementation
fr: Implémentations passées et actuelles

note: type: Plain text
en: A full implementation of capabilities requires that:
fr: Une implémentation complète des capacités nécessite que\ :

note: type: Plain text
en: For all privileged operations, the kernel must check whether the thread has the required capability in its effective set.
fr: Pour toutes les opérations privilégiées, le noyau doit vérifier si le thread a la capacité requise dans son ensemble effectif\ ;

note: type: Plain text
en: The kernel must provide system calls allowing a thread's capability sets to be changed and retrieved.
fr: Le noyau doit fournir des appels système permettant de changer et récupérer les ensembles de capacités d'un thread.

note: type: Plain text
en: The filesystem must support attaching capabilities to an executable file, so that a process gains those capabilities when the file is executed.
fr: Le système de fichiers doit permettre d'attacher des capacités aux fichiers exécutables, pour qu'un processus en dispose quand le fichier est exécuté.

note: type: Plain text
en: Before kernel 2.6.24, only the first two of these requirements are met; since kernel 2.6.24, all three requirements are met.
fr: Sous Linux 2.6.14, seules les deux premières clauses sont remplies.Avant le noyau 2.6.24, seules les deux premières exigences sont remplies ; depuis le noyau 2.6.24, ces trois exigences sont remplies.

note: type: SS
en: Thread capability sets
fr: Ensembles de capacités des threads

note: type: Plain text
en: Each thread has three capability sets containing zero or more of the above capabilities:
fr: Chaque thread a trois ensembles contenant zéro ou plus des capacités ci-dessus\ :

note: type: TP
en: I<Permitted>:
fr: I<Permises>\ :

note: type: Plain text
en: This is a limiting superset for the effective capabilities that the thread may assume.  It is also a limiting superset for the capabilities that may be added to the inheritable set by a thread that does not have the B<CAP_SETPCAP> capability in its effective set.
fr: Il s'agit d'un surensemble limitant les capacités effectives que le thread peut prendre. Il limite également les capacités qui peuvent être ajoutées à l'ensemble héritable par un thread qui n'a pas la capacité B<CAP_SETPCAP> dans son ensemble effectif.

note: type: Plain text
en: If a thread drops a capability from its permitted set, it can never reacquire that capability (unless it B<execve>(2)s either a set-user-ID-root program, or a program whose associated file capabilities grant that capability).
fr: Si un processus supprime une capacité de son ensemble de capacités permises, il ne peut plus jamais la récupérer (sauf s'il appelle B<execve>(2) sur un programme Set-UID root ou un programme dont les capacités associées au fichier permettent cette capacité).

note: type: TP
en: I<Inheritable>:
fr: I<Héritable>\ :

note: type: Plain text
en: This is a set of capabilities preserved across an B<execve>(2).  It provides a mechanism for a process to assign capabilities to the permitted set of the new program during an B<execve>(2).
fr: Il s'agit d'un ensemble de capacités préservées au travers d'un B<execve>(2). Il fournit à un processus un mécanisme pour assigner des capacités à l'ensemble des capacités permises du nouveau programme lors d'un B<execve>(2).

note: type: TP
en: I<Effective>:
fr: I<Effectif>\ :

note: type: Plain text
en: This is the set of capabilities used by the kernel to perform permission checks for the thread.
fr: Il s'agit de l'ensemble des capacités utilisées par le noyau pour vérifier les permissions du thread.

note: type: Plain text
en: A child created via B<fork>(2)  inherits copies of its parent's capability sets.  See below for a discussion of the treatment of capabilities during B<execve>(2).
fr: Un fils créé par B<fork>(2) hérite d'une copie des ensembles de capacité de son père. Le traitement des capacités lors d'un B<execve>(2) est décrit plus bas.

note: type: Plain text
en: Using B<capset>(2), a thread may manipulate its own capability sets (see below).
fr: En utilisant B<capset>(2), un thread peut manipuler ses propres ensembles de capacités (voir ci-dessous).

note: commit 73efc0394e148d0e15583e13712637831f926720 type: Plain text
en: Since Linux 3.2, the file I</proc/sys/kernel/cap_last_cap> exposes the numerical value of the highest capability supported by the running kernel; this can be used to determine the highest bit that may be set in a capability set.
fr: À partir de Linux 3.2, le fichier I</proc/sys/kernel/cap_last_cap> contient la valeur numérique de la capacité la plus élevée qui soit acceptée par le noyau en cours d'exécution ; cette valeur peut être utilisée pour déterminer le bit le plus élevé qui puisse être défini dans un ensemble de capacités.

note: type: SS
en: File capabilities
fr: Capacités de fichier

note: type: Plain text
en: Since kernel 2.6.24, the kernel supports associating capability sets with an executable file using B<setcap>(8).  The file capability sets are stored in an extended attribute (see B<setxattr>(2))  named I<security.capability>.  Writing to this extended attribute requires the B<CAP_SETFCAP> capability.  The file capability sets, in conjunction with the capability sets of the thread, determine the capabilities of a thread after an B<execve>(2).
fr: Depuis le noyau 2.6.24, le noyau prend en charge l'association d'ensembles de capacités avec un fichier exécutable à l'aide de B<setcap>(8). Les ensembles de capacités du fichier sont stockés dans un attribut étendu (consultez B<setxattr>(2)) appelé I<security.capability>. Écrire dans cet attribut étendu nécessite la capacité B<CAP_SETFCAP>. Les ensembles de capacités d'un fichier, combinés avec les ensembles de capacités du thread déterminent les capacités d'un thread après un B<execve>(2).

note: type: Plain text
en: The three file capability sets are:
fr: Les trois ensembles de capacités de fichier sont :

note: type: TP
en: I<Permitted> (formerly known as I<forced>):
fr: I<Permises> (anciennement I<forcées>)\ :

note: type: Plain text
en: These capabilities are automatically permitted to the thread, regardless of the thread's inheritable capabilities.
fr: Ces capacités sont automatiquement permises au thread, quelles que soient ses capacités héritables.

note: type: TP
en: I<Inheritable> (formerly known as I<allowed>):
fr: I<Héritables> (anciennement I<autorisées>)\ :

note: type: Plain text
en: This set is ANDed with the thread's inheritable set to determine which inheritable capabilities are enabled in the permitted set of the thread after the B<execve>(2).
fr: Cet ensemble est combiné par un ET avec l'ensemble héritable du thread pour savoir quelles capacités de l'ensemble des capacités permises sont permises pour le thread après l'appel à B<execve>(2).

note: type: Plain text
en: This is not a set, but rather just a single bit.  If this bit is set, then during an B<execve>(2)  all of the new permitted capabilities for the thread are also raised in the effective set.  If this bit is not set, then after an B<execve>(2), none of the new permitted capabilities is in the new effective set.
fr: Il ne s'agit pas d'un ensemble, mais plutôt d'un unique bit. Si le bit est positionné, alors, lors d'un B<execve>(2), toutes les nouvelles capacités permises pour le thread sont également positionnées dans l'ensemble effectif. Si ce bit n'est pas positionné, alors, après un B<execve>(2), aucune des nouvelles capacités permises ne se trouvera dans le nouvel ensemble effectif.

note: type: Plain text
en: Enabling the file effective capability bit implies that any file permitted or inheritable capability that causes a thread to acquire the corresponding permitted capability during an B<execve>(2)  (see the transformation rules described below) will also acquire that capability in its effective set.  Therefore, when assigning capabilities to a file (B<setcap>(8), B<cap_set_file>(3), B<cap_set_fd>(3)), if we specify the effective flag as being enabled for any capability, then the effective flag must also be specified as enabled for all other capabilities for which the corresponding permitted or inheritable flags is enabled.
fr: Activer le bit des capacités effectives d'un fichier implique que toute capacité de fichier permise ou héritable qui permet à un thread d'obtenir les capacité permises correspondantes lors d'un B<execve>(2) (consultez les règles de transformation décrites ci-dessous) fournira également cette capacité dans l'ensemble de capacités effectives du thread. Ainsi, lors de l'ajout de capacités à un fichier (B<setcap>(8), B<cap_set_file>(3), B<cap_set_fd>(3)), si le bit effectif pour une des capacités est activé, alors le bit effectif doit également être activé pour toutes les capacités dont le bit permis ou héritable correspondant est activé.

note: type: SS
en: Transformation of capabilities during execve()
fr: Transformation des capacités lors d'un appel execve()

note: type: Plain text
en: During an B<execve>(2), the kernel calculates the new capabilities of the process using the following algorithm:
fr: Durant un B<execve>(2), le noyau calcule les nouvelles capacités du processus en utilisant l'algorithme suivant\ :

note: type: Plain text
en: P'(permitted) = (P(inheritable) & F(inheritable)) |
                    (F(permitted) & cap_bset)
fr: P'(permises) = (P(héritables) & F(héritables) |
                   (F(permises) & cap_bset)

note: type: Plain text
en: P'(effective) = F(effective) ? P'(permitted) : 0
fr: P'(effectives) = F(effectives) ? P'(permises) : 0

note: type: Plain text
en: P'(inheritable) = P(inheritable)    [i.e., unchanged]
fr: P'(héritables) = P(héritables)    [inchangé]

note: type: Plain text
en: where:
fr: où :

note: type: Plain text
en: denotes the value of a thread capability set before the B<execve>(2)
fr: indique la valeur d'un ensemble de capacités du thread avant le B<execve>(2)

note: type: Plain text
en: denotes the value of a capability set after the B<execve>(2)
fr: indique la valeur d'un ensemble de capacités après le B<execve>(2)

note: type: Plain text
en: denotes a file capability set
fr: indique la valeur d'un ensemble de capacités du fichier

note: type: Plain text
en: is the value of the capability bounding set (described below).
fr: est la valeur de la limitation de capacités (décrit ci-dessous).

note: type: SS
en: Capabilities and execution of programs by root
fr: Capacités et exécution de programmes par root

note: type: Plain text
en: In order to provide an all-powerful I<root> using capability sets, during an B<execve>(2):
fr: Pour fournir un I<root> tout puissant en utilisant les ensembles de capacités, lors d'un B<execve>(2) :

note: type: Plain text
en: If a set-user-ID-root program is being executed, or the real user ID of the process is 0 (root)  then the file inheritable and permitted sets are defined to be all ones (i.e., all capabilities enabled).
fr: Si on exécute un programme Set-UID root, ou si l'UID réel est nul, alors les ensembles des capacités héritables et permises du fichier sont remplis de uns (toutes les capacités activées).

note: type: Plain text
en: If a set-user-ID-root program is being executed, then the file effective bit is defined to be one (enabled).
fr: Si un programme Set-UID root est exécuté, alors le bit des capacités effectives du fichier est défini à 1 (activé).

note: If a process with real UID 0, and nonzero effective UID does an exec(), then it gets all capabilities in its permitted set, and no effective capabilities type: Plain text
en: The upshot of the above rules, combined with the capabilities transformations described above, is that when a process B<execve>(2)s a set-user-ID-root program, or when a process with an effective UID of 0 B<execve>(2)s a program, it gains all capabilities in its permitted and effective capability sets, except those masked out by the capability bounding set.  This provides semantics that are the same as those provided by traditional UNIX systems.
fr: L'effet des règles ci-dessus combinées avec les transformations de capacités ci-dessus, est que lorsqu'un processus lance (avec B<execve>(2)) un programme Set-UID root, ou lorsqu'un processus d'UID effectif nul exécute un programme, il obtient toutes les capacités dans ses ensembles de capacités permises et effectives, sauf celles qui sont interdites par la limitation de capacités. Ceci fournit une sémantique identique à celle fournie par les systèmes UNIX traditionnels.

note: type: SS
en: Capability bounding set
fr: Limitation des capacités

note: type: Plain text
en: The capability bounding set is a security mechanism that can be used to limit the capabilities that can be gained during an B<execve>(2).  The bounding set is used in the following ways:
fr: La limitation des capacités (« capability bounding set ») est un mécanisme de sécurité qui peut être utilisé pour limiter les capacités qui peuvent être obtenues lors d'un B<execve>(2). La limitation de capacités est utilisée de cette façon :

note: type: Plain text
en: During an B<execve>(2), the capability bounding set is ANDed with the file permitted capability set, and the result of this operation is assigned to the thread's permitted capability set.  The capability bounding set thus places a limit on the permitted capabilities that may be granted by an executable file.
fr: Lors d'un B<execve>(2), la limitation de capacités (un ensemble de capacités) est combinée avec un ET binaire avec l'ensemble des capacités autorisées du fichier, et le résultat de cette opération est placé dans l'ensemble des capacités autorisées du thread. La limitation de capacités permet donc de limiter les capacités permises qui peuvent être accordées à un fichier exécutable.

note: type: Plain text
en: (Since Linux 2.6.25)  The capability bounding set acts as a limiting superset for the capabilities that a thread can add to its inheritable set using B<capset>(2).  This means that if a capability is not in the bounding set, then a thread can't add this capability to its inheritable set, even if it was in its permitted capabilities, and thereby cannot have this capability preserved in its permitted set when it B<execve>(2)s a file that has the capability in its inheritable set.
fr: (Depuis Linux 2.6.25) La limitation de capacités agit comme un surensemble limitant les capacités qu'un thread peut ajouter à son ensemble de capacités héritables en utilisant B<capset>(2). Ceci signifie que si une capacité ne se trouve pas dans l'ensemble de limitation des capacités, alors un thread ne peut ajouter cette capacité dans son ensemble de capacités héritables, même si elle se trouvait dans son ensemble de capacités permises, et ne peut donc pas conserver cette capacité dans son ensemble de capacités permises lorsqu'il exécute avec B<execve>(2) un fichier qui a cette capacité dans son ensemble de capacités héritables.

note: type: Plain text
en: Note that the bounding set masks the file permitted capabilities, but not the inherited capabilities.  If a thread maintains a capability in its inherited set that is not in its bounding set, then it can still gain that capability in its permitted set by executing a file that has the capability in its inherited set.
fr: Notez que la limitation de capacités masque les capacités permises du fichier, mais pas les capacités héritées. Si un thread conserve une capacité dans son ensemble de capacités héritées et que cette capacité ne se trouve pas dans l'ensemble de limitation des capacités, alors il peut toujours obtenir cette capacité dans son ensemble de capacités permises en exécutant un fichier qui a la capacité dans son ensemble de capacités héritées.

note: type: Plain text
en: Depending on the kernel version, the capability bounding set is either a system-wide attribute, or a per-process attribute.
fr: Suivant la version du noyau, la limitation de capacités est un attribut au niveau du système ou un attribut par processus.

note: type: Plain text
en: B<Capability bounding set prior to Linux 2.6.25>
fr: B<Limitation de capacités avant Linux 2.6.25>

note: type: Plain text
en: In kernels before 2.6.25, the capability bounding set is a system-wide attribute that affects all threads on the system.  The bounding set is accessible via the file I</proc/sys/kernel/cap-bound>.  (Confusingly, this bit mask parameter is expressed as a signed decimal number in I</proc/sys/kernel/cap-bound>.)
fr: Dans les noyaux antérieurs à 2.6.25, la limitation de capacités est un attribut au niveau du système qui affecte tous les threads. La limitation de capacités est accessible par le fichier I</proc/sys/kernel/cap-bound>. (Le masque de bits est exprimé comme un nombre décimal signé dans I</proc/sys/kernel/cap-bound>, ce qui entretient les confusions).

note: type: Plain text
en: Only the B<init> process may set capabilities in the capability bounding set; other than that, the superuser (more precisely: programs with the B<CAP_SYS_MODULE> capability) may only clear capabilities from this set.
fr: Seul le processus B<init> peut configurer des capacités dans l'ensemble de limitation de capacités\ ; sinon, le superutilisateur (plus précisément : les programmes avec la capacité B<CAP_SYS_MODULE>) peut uniquement supprimer des capacités de cet ensemble.

note: type: Plain text
en: On a standard system the capability bounding set always masks out the B<CAP_SETPCAP> capability.  To remove this restriction (dangerous!), modify the definition of B<CAP_INIT_EFF_SET> in I<include/linux/capability.h> and rebuild the kernel.
fr: Sur un système standard, la limitation élimine toujours la capacité B<CAP_SETPCAP>. Pour supprimer cette restriction (attention, c'est dangereux\ !), modifiez la définition de B<CAP_INIT_EFF_SET> dans I<include/linux/capability.h> et recompilez le noyau.

note: type: Plain text
en: The system-wide capability bounding set feature was added to Linux starting with kernel version 2.2.11.
fr: La limitation de capacités système a été ajoutée à Linux à partir du noyau 2.2.11.

note: type: Plain text
en: B<Capability bounding set from Linux 2.6.25 onward>
fr: B<Limitation de capacités après Linux 2.6.25>

note: type: Plain text
en: From Linux 2.6.25, the I<capability bounding set> is a per-thread attribute.  (There is no longer a system-wide capability bounding set.)
fr: Depuis Linux 2.6.25, la I<limitation de capacités> est un attribut par thread (il n'y a plus désormais de limitation de capacités au niveau du système).

note: type: Plain text
en: The bounding set is inherited at B<fork>(2)  from the thread's parent, and is preserved across an B<execve>(2).
fr: La limitation est héritée du parent du thread au travers d'un B<fork>(2) et est préservé au travers d'un B<execve>(2).

note: type: Plain text
en: A thread may remove capabilities from its capability bounding set using the B<prctl>(2)  B<PR_CAPBSET_DROP> operation, provided it has the B<CAP_SETPCAP> capability.  Once a capability has been dropped from the bounding set, it cannot be restored to that set.  A thread can determine if a capability is in its bounding set using the B<prctl>(2)  B<PR_CAPBSET_READ> operation.
fr: Un thread peut enlever des capacités de son ensemble de limitation de capacités en utilisant l'opération B<PR_CAPBSET_DROP> de B<prctl>(2), à condition qu'il possède la capacité B<CAP_SETPCAP>. Une fois qu'une capacité a été supprimée de l'ensemble de limitation, elle ne peut être y être remise. Un thread peut déterminer si une capacité est dans son ensemble de limitation de capacités en utilisant l'opération B<PR_CAPBSET_READ> de B<prctl>(2).

note: type: Plain text
en: Removing capabilities from the bounding set is supported only if file capabilities are compiled into the kernel.  In kernels before Linux 2.6.33, file capabilities were an optional feature configurable via the CONFIG_SECURITY_FILE_CAPABILITIES option.  Since Linux 2.6.33, the configuration option has been removed and file capabilities are always part of the kernel.  When file capabilities are compiled into the kernel, the B<init> process (the ancestor of all processes) begins with a full bounding set.  If file capabilities are not compiled into the kernel, then B<init> begins with a full bounding set minus B<CAP_SETPCAP>, because this capability has a different meaning when there are no file capabilities.
fr: La suppression de capacités dans l'ensemble de limitation des capacités n'est prise en charge que si les capacités de fichiers sont compilés dans le noyau. Dans les noyaux antérieurs à Linux 2.6.33, les capacités de fichiers étaient une fonctionnalité optionnelle configurable via l'option CONFIG_SECURITY_FILE_CAPABILITIES. Depuis Linux 2.6.33, l'option de configuration a été supprimée et les capacités de fichiers font maintenant toujours partie du noyau. Quand les capacités de fichiers sont compilées dans le noyau,  le processus B<init> (l'ancêtre de tous les processus) démarre avec ensemble de limitation complet. Si les capacités de fichiers ne sont pas compilées dans le noyau, B<init> démarre alors avec un ensemble de limitation complet, à l'exception de B<CAP_SETPCAP>, parce que cette capacité a une autre signification quand il n'y a pas de capacités de fichiers.

note: type: Plain text
en: Removing a capability from the bounding set does not remove it from the thread's inherited set.  However it does prevent the capability from being added back into the thread's inherited set in the future.
fr: Supprimer une capacité de la limitation de capacités ne la supprime pas de l'ensemble hérité d'un thread. Cependant il empêche de rajouter la capacité dans l'ensemble hérité du thread par la suite.

note: type: SS
en: Effect of user ID changes on capabilities
fr: Effet des modifications d'UID sur les capacités

note: type: Plain text
en: To preserve the traditional semantics for transitions between 0 and nonzero user IDs, the kernel makes the following changes to a thread's capability sets on changes to the thread's real, effective, saved set, and filesystem user IDs (using B<setuid>(2), B<setresuid>(2), or similar):
fr: Afin de préserver la sémantique traditionnelle pour les transitions entre des UID nul et non nul, le noyau modifie les ensembles de capacités d'un thread de la façon suivante lors de modifications des UID réel, effectif, sauvé et du système de fichiers (avec B<setuid>(2), B<setresuid>(2) et compagnie)\ :

note: type: Plain text
en: If one or more of the real, effective or saved set user IDs was previously 0, and as a result of the UID changes all of these IDs have a nonzero value, then all capabilities are cleared from the permitted and effective capability sets.
fr: Si l'UID réel, effectif ou sauvé était égal à 0, et qu'à la suite de la modification ils sont tous non nuls, toutes les capacités sont supprimés des ensembles de capacités permises et effectives.

note: type: Plain text
en: If the effective user ID is changed from 0 to nonzero, then all capabilities are cleared from the effective set.
fr: Si l'UID effectif était nul et devient non nul, toutes les capacités sont supprimées de l'ensemble effectif.

note: type: Plain text
en: If the effective user ID is changed from nonzero to 0, then the permitted set is copied to the effective set.
fr: Si l'UID effectif est modifié d'une valeur non nulle à 0, l'ensemble des capacités permises est copié dans l'ensemble des capacités effectives.

note: type: Plain text
en: If the filesystem user ID is changed from 0 to nonzero (see B<setfsuid>(2)), then the following capabilities are cleared from the effective set: B<CAP_CHOWN>, B<CAP_DAC_OVERRIDE>, B<CAP_DAC_READ_SEARCH>, B<CAP_FOWNER>, B<CAP_FSETID>, B<CAP_LINUX_IMMUTABLE> (since Linux 2.6.30), B<CAP_MAC_OVERRIDE>, and B<CAP_MKNOD> (since Linux 2.6.30).  If the filesystem UID is changed from nonzero to 0, then any of these capabilities that are enabled in the permitted set are enabled in the effective set.
fr: Si le I<fsuid> est modifié de 0 à une valeur non nulle (consultez B<setfsuid>(2)), les capacités suivantes sont supprimées de l'ensemble effectif\ : B<CAP_CHOWN>, B<CAP_DAC_OVERRIDE>, B<CAP_DAC_READ_SEARCH>, B<CAP_FOWNER>, B<CAP_FSETID>, B<CAP_LINUX_IMMUTABLE> (depuis Linux 2.6.30), B<CAP_MAC_OVERRIDE> et B<CAP_MKNOD> (depuis Linux 2.6.30). Si le I<fsuid> devient nul, chacune de ces capacités est activée dans l'ensemble des capacités effectives si elle faisait partie de l'ensemble des capacités permises.

note: type: Plain text
en: If a thread that has a 0 value for one or more of its user IDs wants to prevent its permitted capability set being cleared when it resets all of its user IDs to nonzero values, it can do so using the B<prctl>(2)  B<PR_SET_KEEPCAPS> operation.
fr: Si un thread dont l'un des UID vaut 0 ne veut pas que son ensemble de capacités permises soit vidé lorsqu'il redéfinit tous ses UID à des valeurs non nulles, il peut le faire avec l'opération B<PR_SET_KEEPCAPS> de l'appel système B<prctl>(2).

note: type: SS
en: Programmatically adjusting capability sets
fr: Ajuster les ensembles de capacités par programmation

note: type: Plain text
en: A thread can retrieve and change its capability sets using the B<capget>(2)  and B<capset>(2)  system calls.  However, the use of B<cap_get_proc>(3)  and B<cap_set_proc>(3), both provided in the I<libcap> package, is preferred for this purpose.  The following rules govern changes to the thread capability sets:
fr: Un thread peut obtenir ou modifier ses ensembles de capacités en utilisant les appels système B<capget>(2) et B<capset>(2). Cependant, il faut leur préférer l'utilisation de B<cap_get_proc>(3) et B<cap_set_proc>(3), toutes deux fournies par le paquet I<libcap>. Les règles suivantes gouvernent les modifications des ensembles de capacités d'un thread :

note: type: Plain text
en: If the caller does not have the B<CAP_SETPCAP> capability, the new inheritable set must be a subset of the combination of the existing inheritable and permitted sets.
fr: Si l'appelant n'a pas la capacité B<CAP_SETPCAP>, le nouvel ensemble des capacités héritables doit être un sous-ensemble de l'union des ensembles de capacités héritables et des capacités permises.

note: type: Plain text
en: (Since Linux 2.6.25)  The new inheritable set must be a subset of the combination of the existing inheritable set and the capability bounding set.
fr: (Depuis Linux 2.6.25) Le nouvel ensemble héritable doit être un sous-ensemble de l'ensemble héritable existant et de l'ensemble de limitation de capacités.

note: type: Plain text
en: The new permitted set must be a subset of the existing permitted set (i.e., it is not possible to acquire permitted capabilities that the thread does not currently have).
fr: Le nouvel ensemble des capacités permises doit être un sous-ensemble de l'ensemble des capacités permises existant (c'est-à-dire qu'il n'est pas possible d'obtenir des capacités permises que le thread n'a pas actuellement).

note: type: Plain text
en: The new effective set must be a subset of the new permitted set.
fr: Le nouvel ensemble effectif doit être un sous-ensemble du nouvel ensemble des capacités permises.

note: type: SS
en: The securebits flags: establishing a capabilities-only environment
fr: Les attributs « securebits » : configuration d'un environnement restreint aux capacités de fichiers.

note: For some background: see http://lwn.net/Articles/280279/ and http://article.gmane.org/gmane.linux.kernel.lsm/5476/ type: Plain text
en: Starting with kernel 2.6.26, and with a kernel in which file capabilities are enabled, Linux implements a set of per-thread I<securebits> flags that can be used to disable special handling of capabilities for UID 0 (I<root>).  These flags are as follows:
fr: À partir du noyau 2.6.26, si les capacités de fichiers sont activées, Linux implémente un ensemble d'attributs I<securebits> par thread qui peuvent être utilisés pour désactiver la gestion particulière des capacités pour l'UID 0 (I<root>). Ces attributs sont les suivants :

note: type: Plain text
en: Setting this flag allows a thread that has one or more 0 UIDs to retain its capabilities when it switches all of its UIDs to a nonzero value.  If this flag is not set, then such a UID switch causes the thread to lose all capabilities.  This flag is always cleared on an B<execve>(2).  (This flag provides the same functionality as the older B<prctl>(2)  B<PR_SET_KEEPCAPS> operation.)
fr: Activer cet attribut permet à un thread qui a un UID (ou plus) égal à 0 de conserver ses capacités quand il change ses UID et que plus aucun n'est nul. Si cet attribut est désactivé, alors ces changements d'UID feront perdre au thread toutes ses capacités. Cet attribut est toujours désactivé lors d'un B<execve>(2). Cet attribut fournit la même fonctionnalité que l'ancienne opération B<PR_SET_KEEPCAPS> de B<prctl>(2)).

note: type: Plain text
en: Setting this flag stops the kernel from adjusting capability sets when the threads's effective and filesystem UIDs are switched between zero and nonzero values.  (See the subsection I<Effect of User ID Changes on Capabilities>.)
fr: Activer cet attribut stoppe l'ajustement des ensembles de capacités par le noyau lorsque les UID effectifs et d'accès aux fichiers du thread passent d'une valeur nulle à une valeur non nulle. (Consultez la sous-section I<Effet des modifications d'UID sur les capacités>.)

note: type: Plain text
en: If this bit is set, then the kernel does not grant capabilities when a set-user-ID-root program is executed, or when a process with an effective or real UID of 0 calls B<execve>(2).  (See the subsection I<Capabilities and execution of programs by root>.)
fr: Si cet attribut est activé, alors le noyau n'autorise pas les capacités lorsqu'un programme Set-UID root est exécuté ou lorsqu'un processus dont l'identifiant effectif ou réel est nul appelle B<execve>(2). (Consultez la sous-section I<Capacités et exécution de programmes par root>.)

note: type: Plain text
en: Each of the above "base" flags has a companion "locked" flag.  Setting any of the "locked" flags is irreversible, and has the effect of preventing further changes to the corresponding "base" flag.  The locked flags are: B<SECBIT_KEEP_CAPS_LOCKED>, B<SECBIT_NO_SETUID_FIXUP_LOCKED>, and B<SECBIT_NOROOT_LOCKED>.
fr: Chacun des attributs de base ci-dessus a un attribut compagnon de verrouillage. L'activation d'un attribut de verrouillage est irréversible et permet d'éviter toute modification ultérieure de l'attribut de base. Les attributs de verrouillage sont : B<SECBIT_KEEP_CAPS_LOCKED>, B<SECBIT_NO_SETUID_FIXUP_LOCKED> et B<SECBIT_NOROOT_LOCKED>.

note: type: Plain text
en: The I<securebits> flags can be modified and retrieved using the B<prctl>(2)  B<PR_SET_SECUREBITS> and B<PR_GET_SECUREBITS> operations.  The B<CAP_SETPCAP> capability is required to modify the flags.
fr: Les attributs I<securebits> peuvent être modifiés et récupérés en utilisant les opérations B<PR_SET_SECUREBITS> et B<PR_GET_SECUREBITS> de B<prctl>(2). La capacité B<CAP_SETPCAP> est nécessaire pour modifier ces attributs.

note: type: Plain text
en: The I<securebits> flags are inherited by child processes.  During an B<execve>(2), all of the flags are preserved, except B<SECBIT_KEEP_CAPS> which is always cleared.
fr: Les attributs I<securebits> sont hérités par les processus fils. Lors d'un B<execve>(2), tous les attributs sont conservés, à l'exception de B<SECBIT_KEEP_CAPS> qui est toujours désactivé.

note: type: Plain text
en: An application can use the following call to lock itself, and all of its descendants, into an environment where the only way of gaining capabilities is by executing a program with associated file capabilities:
fr: Une application peut utiliser l'appel suivant pour se verrouiller elle-même, ainsi que tous ses descendant, dans un environnement où la seule façon d'obtenir des capacités est d'exécuter un programme avec les capacités de fichiers correspondantes :

note: type: Plain text
en: No standards govern capabilities, but the Linux capability implementation is based on the withdrawn POSIX.1e draft standard; see E<.UR http://wt.tuxomania.net\:/publications\:/posix.1e/> E<.UE .>
fr: Il n'y a pas de véritable norme pour les capacités, mais l'implémentation Linux est basé sur une interprétation de la norme (retirée) POSIX.1e ; consultez E<.UR http://wt.tuxomania.net\:/publications\:/posix.1e/> E<.UE .>

note: type: Plain text
en: Since kernel 2.5.27, capabilities are an optional kernel component, and can be enabled/disabled via the CONFIG_SECURITY_CAPABILITIES kernel configuration option.
fr: Depuis le noyau 2.5.27, les capacités sont optionnelles dans le noyau et peuvent être activées ou désactivées avec l'option de configuration CONFIG_SECURITY_CAPABILITIES du noyau.

note: 7b9a7ec565505699f503b4fcf61500dceb36e744 type: Plain text
en: The I</proc/PID/task/TID/status> file can be used to view the capability sets of a thread.  The I</proc/PID/status> file shows the capability sets of a process's main thread.  Before Linux 3.8, nonexistent capabilities were shown as being enabled (1) in these sets.  Since Linux 3.8, all nonexistent capabilities (above B<CAP_LAST_CAP>)  are shown as disabled (0).
fr: Le fichier I</proc/PID/task/TID/status> peut être utilisé pour voir les ensembles de capacités d'un thread. Le fichier I</proc/PID/status> indique les ensembles de capacités du thread principal d'un thread. Avant Linux 3.8, les capacités inexistantes étaient vues comme activées (1) dans ces ensembles. Depuis Linux 3.8, toutes les capacités inexistantes (au-délà de B<CAP_LAST_CAP>) sont vues comme désactivées (0).

note: type: Plain text
en: The I<libcap> package provides a suite of routines for setting and getting capabilities that is more comfortable and less likely to change than the interface provided by B<capset>(2)  and B<capget>(2).  This package also provides the B<setcap>(8)  and B<getcap>(8)  programs.  It can be found at
fr: Le paquet I<libcap> fournit un ensemble de routines pour écrire et lire les capacités d'un processus, de manière plus simple et moins susceptible de changer que l'interface fournie par B<capset>(2) et B<capget>(2). Ce paquet fournit également les programmes B<setcap>(8) et B<getcap>(8). Il peut être trouvé à l'adresse :

note: type: Plain text
en: Before kernel 2.6.24, and since kernel 2.6.24 if file capabilities are not enabled, a thread with the B<CAP_SETPCAP> capability can manipulate the capabilities of threads other than itself.  However, this is only theoretically possible, since no thread ever has B<CAP_SETPCAP> in either of these cases:
fr: Avant le noyau 2.6.24, et depuis le noyau 2.6.24 si les capacités de fichier ne sont pas activées, un thread avec la capacité B<CAP_SETPCAP> peut manipuler les capacités des autres threads. Cependant, ce n'est possible qu'en théorie puisqu'aucun thread n'a la capacité B<CAP_SETPCAP> dans un des cas suivants :

note: type: Plain text
en: In the pre-2.6.25 implementation the system-wide capability bounding set, I</proc/sys/kernel/cap-bound>, always masks out this capability, and this can not be changed without modifying the kernel source and rebuilding.
fr: Dans l'implémentation antérieure au noyau 2.6.25, l'ensemble de limitation de capacités du système, I</proc/sys/kernel/cap-bound>, masque toujours cette capacité et ceci ne peut pas être changé sans modifier les sources du noyau et le recompiler.

note: type: Plain text
en: If file capabilities are disabled in the current implementation, then B<init> starts out with this capability removed from its per-process bounding set, and that bounding set is inherited by all other processes created on the system.
fr: Si les capacités de fichiers sont désactivées dans l'implémentation actuelle, alors B<init> démarre sans cette capacité dans l'ensemble de limitation de capacité de son processus, et cet ensemble de limitation de capacité est hérité par tous les processus créés sur le système.

note: type: Plain text
en: I<include/linux/capability.h> in the Linux kernel source tree
fr: I<include/linux/capability.h> dans les sources du noyau Linux

note: type: TH
en: 2013-03-11
fr: 11 mars 2013

note: type: Plain text
en: capget, capset - set/get capabilities of thread(s)
fr: capget, capset - Configurer les capacités des threads

note: type: Plain text
en: As of Linux 2.2, the power of the superuser (root) has been partitioned into a set of discrete capabilities.  Each thread has a set of effective capabilities identifying which capabilities (if any) it may currently exercise.  Each thread also has a set of inheritable capabilities that may be passed through an B<execve>(2)  call, and a set of permitted capabilities that it can make effective or inheritable.
fr: Depuis Linux 2.2, la toute puissance du superutilisateur (root) a été scindée en plusieurs ensembles distincts. Chaque thread dispose d'un ensemble de capacités effectives permettant d'identifier ses droits de réaliser certaines actions. Chaque thread a aussi un ensemble de capacités héritables, qu'il peut transmettre au travers d'un B<execve>(2) et un ensemble de capacités éventuelles qu'il peut rendre effectives ou héritables.

note: type: Plain text
en: These two system calls are the raw kernel interface for getting and setting thread capabilities.  Not only are these system calls specific to Linux, but the kernel API is likely to change and use of these system calls (in particular the format of the I<cap_user_*_t> types) is subject to extension with each kernel revision, but old programs will keep working.
fr: Ces deux appels système constituent l'interface brute du noyau pour configurer ou lire les capacités d'un thread. Non seulement ces appels système sont spécifiques à Linux, mais l'API du noyau est susceptible de changer. L'utilisation de ces appels système (en particulier le format du type I<cap_user_*_t>) risque d'être étendue lors de nouvelles mises à jour du noyau, mais les anciens programmes continueront à fonctionner.

note: type: Plain text
en: The portable interfaces are B<cap_set_proc>(3)  and B<cap_get_proc>(3); if possible, you should use those interfaces in applications.  If you wish to use the Linux extensions in applications, you should use the easier-to-use interfaces B<capsetp>(3)  and B<capgetp>(3).
fr: L'interface portable est constituée des fonctions B<cap_set_proc>(3) et B<cap_get_proc>(3)\ ; si possible, utilisez plutôt ces routines dans vos applications. Si vous désirez vraiment utiliser les extensions Linux, essayez d'employer plutôt les interfaces plus simples B<capsetp>(3) et B<capgetp>(3).

note: type: SS
en: Current details
fr: Détails actuels

note: type: Plain text
en: Now that you have been warned, some current kernel details.  The structures are defined as follows.
fr: Maintenant que vous avez été avertis, quelques détails du noyau actuel. Les structures sont définies comme suit.

note: type: Plain text
en: The I<effective>, I<permitted>, and I<inheritable> fields are bit masks of the capabilities defined in B<capabilities>(7).  Note the B<CAP_*> values are bit indexes and need to be bit-shifted before ORing into the bit fields.  To define the structures for passing to the system call you have to use the I<struct __user_cap_header_struct> and I<struct __user_cap_data_struct> names because the typedefs are only pointers.
fr: I<effective>, I<permitted> et I<inheritable> sont des champs de bits de capacité définis dans I<capabilities>(7). Notez que les valeurs B<CAP_*> sont indexées par bit et nécessitent d'être décalées avant le OU logique avec le champ de bit. Pour définir les structures à passer à l'appel système, vous devez utiliser les noms I<struct __user_cap_header_struct> et I<struct __user_cap_data_struct> car les typedefs ne sont que des pointeurs.

note: type: Plain text
en: Kernels prior to 2.6.25 prefer 32-bit capabilities with version B<_LINUX_CAPABILITY_VERSION_1>, and kernels 2.6.25+ prefer 64-bit capabilities with version B<_LINUX_CAPABILITY_VERSION_2>.  Note, 64-bit capabilities use I<datap>[0] and I<datap>[1], whereas 32-bit capabilities use only I<datap>[0].
fr: Les noyau antérieurs à 2.6.25 préfèrent les capacités 32 bits avec la version B<_LINUX_CAPABILITY_VERSION_1>, et les noyaux 2.6.25 et suivants préfèrent les capacités 64 bits avec la version B<_LINUX_CAPABILITY_VERSION_2>. Notez que les capacités 64 bits utilisent I<datap>[0] et I<datap>[1], tandis que les capacités 32 bits n'utilisent que I<datap>[0].

note: type: Plain text
en: Another change affecting the behavior of these system calls is kernel support for file capabilities (VFS capability support).  This support is currently a compile time option (added in kernel 2.6.24).
fr: Une autre modification impactant le comportement de ces appels système est la gestion par le noyau de fichiers de capacités (la gestion VFS des capacité). Cette gestion est actuellement une option de compilation (ajoutée dans le noyau 2.6.24).

note: type: Plain text
en: For B<capget>()  calls, one can probe the capabilities of any process by specifying its process ID with the I<hdrp-E<gt>pid> field value.
fr: Pour les appels B<capget>(), on peut tester les capacités de n'importe quel processus en indiquant l'identifiant du processus avec la valeur du champ I<hdrp-E<gt>pid>.

note: type: SS
en: With VFS capability support
fr: Avec la prise en charge VFS des capacités

note: type: Plain text
en: VFS Capability support creates a file-attribute method for adding capabilities to privileged executables.  This privilege model obsoletes kernel support for one process asynchronously setting the capabilities of another.  That is, with VFS support, for B<capset>()  calls the only permitted values for I<hdrp-E<gt>pid> are 0 or B<getpid>(2), which are equivalent.
fr: Avec la prise en charge VFS pour les capacités, il existe une méthode permettant d'ajouter des capacités à des exécutables privilégiés à partir d'attributs de fichier. Ce modèle de privilèges rend obsolète la prise en charge par le noyau du paramétrage asynchrone des capacités d'un processus par un autre. C'est-à-dire que, avec la prise en charge VFS, pour les appels à B<capset>() les seules valeurs permises pour I<hdrp-E<gt>pid> sont 0 et B<getpid>(2), qui sont équivalentes.

note: type: SS
en: Without VFS capability support
fr: Sans la gestion VFS des capacités

note: type: Plain text
en: When the kernel does not support VFS capabilities, B<capset>()  calls can operate on the capabilities of the thread specified by the I<pid> field of I<hdrp> when that is nonzero, or on the capabilities of the calling thread if I<pid> is 0.  If I<pid> refers to a single-threaded process, then I<pid> can be specified as a traditional process ID; operating on a thread of a multithreaded process requires a thread ID of the type returned by B<gettid>(2).  For B<capset>(), I<pid> can also be: -1, meaning perform the change on all threads except the caller and B<init>(8); or a value less than -1, in which case the change is applied to all members of the process group whose ID is -I<pid>.
fr: Quand le noyau ne gère pas les capacités en VFS, les appels B<capset>() peuvent s'appliquer aux capacités du thread indiqué par le champ I<pid> de I<hdrp> lorsqu'il n'est pas nul, ou à celles du thread courant si I<pid> vaut 0. Si I<pid> correspond à un processus n'utilisant pas les threads, I<pid> peut être un identifiant de processus classique. Pour configurer les capacités d'un thread faisant partie d'un processus multithreadé, il faut utiliser un identifiant de thread du type que renvoie B<gettid>(2). Pour B<capset>(), I<pid> peut également être -1, ce qui affecte tous les threads sauf l'appelant et B<init>(8), ou bien une valeur inférieure à -1, ce qui applique la modification à tous les membres de groupe de processus identifié par -I<pid>.

note: type: Plain text
en: For details on the data, see B<capabilities>(7).
fr: Pour les détails sur les données, consultez B<capabilities>(7).

note: type: Plain text
en: The calls will fail with the error B<EINVAL>, and set the I<version> field of I<hdrp> to the kernel preferred value of B<_LINUX_CAPABILITY_VERSION_?> when an unsupported I<version> value is specified.  In this way, one can probe what the current preferred capability revision is.
fr: Les appels échoueront avec l'erreur B<EINVAL>, et définiront le champ I<version> de I<hdrp> avec la valeur B<_LINUX_CAPABILITY_VERSION_?> préférée par le noyau quand une I<version> non prise en charge est fournie. De cette façon, on peut tester quelle est la révision de capacité préférée.

note: type: Plain text
en: Bad memory address.  I<hdrp> must not be NULL.  I<datap> may be NULL only when the user is trying to determine the preferred capability version format supported by the kernel.
fr: Mauvaise adresse mémoire. I<hdrp> ne doit pas être NULL. I<datap> ne peut être NULL que quand l'utilisateur cherche à déterminer la version du format préféré des capacités gérée par le noyau.

note: type: Plain text
en: One of the arguments was invalid.
fr: Un argument est invalide.

note: type: Plain text
en: An attempt was made to add a capability to the Permitted set, or to set a capability in the Effective or Inheritable sets that is not in the Permitted set.
fr: On a essayé d'ajouter une capacité dans l'ensemble éventuel, ou de placer une capacité dans l'ensemble effectif ou héritable qui ne se trouvait pas dans l'ensemble éventuel.

note: type: Plain text
en: The caller attempted to use B<capset>()  to modify the capabilities of a thread other than itself, but lacked sufficient privilege.  For kernels supporting VFS capabilities, this is never permitted.  For kernels lacking VFS support, the B<CAP_SETPCAP> capability is required.  (A bug in kernels before 2.6.11 meant that this error could also occur if a thread without this capability tried to change its own capabilities by specifying the I<pid> field as a nonzero value (i.e., the value returned by B<getpid>(2))  instead of 0.)
fr: Le processus appelant a tenté d'utiliser B<capset>() pour modifier les capacités d'un thread autre que lui\(hymême, sans avoir les privilèges nécessaires. Pour les noyaux avec la gestion VFS des capacités, ce n'est jamais permis. Pour les noyaux sans la gestion VFS des capacités, la capacité B<CAP_SETPCAP> est requise. (En raison d'un bogue dans les noyaux antérieurs à 2.6.11, cette erreur était aussi renvoyée si un thread sans cette capacité tentait de modifier ses propres capacités en indiquant une valeur non nulle de I<pid> (la valeur renvoyée par B<getpid>(2)).)

note: type: Plain text
en: No such thread.
fr: Pas de thread correspondant.

note: type: Plain text
en: These system calls are Linux-specific.
fr: Ces appels système sont spécifiques à Linux.

note: type: Plain text
en: The portable interface to the capability querying and setting functions is provided by the I<libcap> library and is available here:
fr: L'interface portable pour les fonctions de lecture des capacités et de configuration est fournie par la bibliothèque I<libcap> disponible à\ :

note: type: TH
en: 2013-02-12
fr: 12 février 2013

note: type: Plain text
en: cpuset - confine processes to processor and memory node subsets
fr: cpuset - Confiner des processus à des sous-ensembles de processeurs et de nœuds mémoire

note: type: Plain text
en: The cpuset filesystem is a pseudo-filesystem interface to the kernel cpuset mechanism, which is used to control the processor placement and memory placement of processes.  It is commonly mounted at I</dev/cpuset>.
fr: Le système de fichiers cpuset (N.d.T. : « cpuset » signifie mot à mot « ensemble de CPU », mais comme il ne s'agit pas uniquement d'ensembles de CPU, le terme cpuset sera utilisé par la suite) est une interface sous forme d'un pseudosystème de fichiers pour le mécanisme « cpuset » du noyau, qui permet de contrôler le placement de processus sur des processeurs ou en mémoire. Il est habituellement monté dans I</dev/cpuset>.

note: type: Plain text
en: On systems with kernels compiled with built in support for cpusets, all processes are attached to a cpuset, and cpusets are always present.  If a system supports cpusets, then it will have the entry B<nodev cpuset> in the file I</proc/filesystems>.  By mounting the cpuset filesystem (see the B<EXAMPLE> section below), the administrator can configure the cpusets on a system to control the processor and memory placement of processes on that system.  By default, if the cpuset configuration on a system is not modified or if the cpuset filesystem is not even mounted, then the cpuset mechanism, though present, has no affect on the system's behavior.
fr: Sur les systèmes dont le noyau a été compilé avec la prise en charge des cpusets, tous les processus sont attachés à un cpuset, et les cpusets sont toujours présents. Si un système prend en charge les cpusets, alors il aura une entrée B<nodev cpuset> dans le fichier I</proc/filesystems>. En montant le système de fichiers cpuset (consultez la section B<EXEMPLE> ci-dessous), l'administrateur peut configurer les cpusets d'un système pour contrôler le placement des processus sur les CPU et dans la mémoire. Par défaut, si la configuration des cpusets d'un système n'est pas modifiée ou si le système de fichiers cpuset n'est même pas monté, le mécanisme des cpusets, même s'il est présent, n'a pas d'effets sur le comportement du système.

note: type: Plain text
en: A cpuset defines a list of CPUs and memory nodes.
fr: Un cpuset définit une liste de CPU et de nœuds mémoire.

note: type: Plain text
en: The CPUs of a system include all the logical processing units on which a process can execute, including, if present, multiple processor cores within a package and Hyper-Threads within a processor core.  Memory nodes include all distinct banks of main memory; small and SMP systems typically have just one memory node that contains all the system's main memory, while NUMA (non-uniform memory access) systems have multiple memory nodes.
fr: Les CPU d'un système comprennent toutes les unités de traitement logiques sur lesquelles peuvent s'exécuter des processus, comprenant, s'il y en a, les différents cœurs d'un processeur et les Hyper-Threads d'un cœur de processeur. Les nœuds mémoire comprennent tous les bancs distinct de mémoire ; les petits systèmes et les systèmes SMP ont typiquement un seul nœud mémoire qui contient toute la mémoire du système, alors que les systèmes NUMA (« non-uniform memory access » : accès non uniforme à la mémoire) ont plusieurs nœuds mémoire.

note: type: Plain text
en: Cpusets are represented as directories in a hierarchical pseudo-filesystem, where the top directory in the hierarchy (I</dev/cpuset>)  represents the entire system (all online CPUs and memory nodes)  and any cpuset that is the child (descendant) of another parent cpuset contains a subset of that parent's CPUs and memory nodes.  The directories and files representing cpusets have normal filesystem permissions.
fr: Les cpusets sont représentés par des répertoires dans un pseudosystème de fichiers hiérarchique dont le répertoire de plus haut niveau (I</dev/cpuset>) représente le système complet (tous les CPU et nœuds mémoire en ligne). Tout cpuset fils (le descendant) d'un autre cpuset père contient un sous-ensemble des CPU et des nœuds mémoire du père. Les répertoires et les fichiers qui représentent les cpusets ont les permissions habituelles des systèmes de fichiers.

note: type: Plain text
en: Every process in the system belongs to exactly one cpuset.  A process is confined to run only on the CPUs in the cpuset it belongs to, and to allocate memory only on the memory nodes in that cpuset.  When a process B<fork>(2)s, the child process is placed in the same cpuset as its parent.  With sufficient privilege, a process may be moved from one cpuset to another and the allowed CPUs and memory nodes of an existing cpuset may be changed.
fr: Chaque processus du système appartient à un unique cpuset. Un processus est obligé de s'exécuter sur les CPU du cpuset auquel il appartient et est obligé d'allouer de la mémoire uniquement sur les nœuds mémoire de ce cpuset. Quand un processus crée un fils avec B<fork>(2), le processus fils est placé dans le même cpuset que le processus père. S'il a les privilèges suffisants, le processus fils peut se déplacer d'un cpuset à un autre et les CPU ou nœuds mémoire d'un cpuset existant peuvent être changés.

note: type: Plain text
en: When the system begins booting, a single cpuset is defined that includes all CPUs and memory nodes on the system, and all processes are in that cpuset.  During the boot process, or later during normal system operation, other cpusets may be created, as subdirectories of this top cpuset, under the control of the system administrator, and processes may be placed in these other cpusets.
fr: Au début du démarrage du système, un seul cpuset est défini qui comprend tous les CPU et tous les nœuds mémoire du système et tous les processus se trouvent dans ce cpuset. Pendant le démarrage ou par la suite lors de l'exécution normale du système, d'autres cpusets peuvent être créés, en tant que sous-répertoire de ce cpuset de plus haut niveau, sous le contrôle de l'administrateur système. Des processus peuvent être placés dans ces autres cpusets.

note: type: Plain text
en: Cpusets are integrated with the B<sched_setaffinity>(2)  scheduling affinity mechanism and the B<mbind>(2)  and B<set_mempolicy>(2)  memory-placement mechanisms in the kernel.  Neither of these mechanisms let a process make use of a CPU or memory node that is not allowed by that process's cpuset.  If changes to a process's cpuset placement conflict with these other mechanisms, then cpuset placement is enforced even if it means overriding these other mechanisms.  The kernel accomplishes this overriding by silently restricting the CPUs and memory nodes requested by these other mechanisms to those allowed by the invoking process's cpuset.  This can result in these other calls returning an error, if for example, such a call ends up requesting an empty set of CPUs or memory nodes, after that request is restricted to the invoking process's cpuset.
fr: Les cpusets sont intégrés dans le noyau avec le mécanisme d'affinité d'ordonnancement de B<sched_setaffinity>(2) et les mécanismes de placement en mémoire de B<mbind>(2) et B<set_mempolicy>(2). Aucun de ces mécanismes ne permettent à un processus d'utiliser un CPU ou un nœud mémoire qui n'est pas autorisé par le cpuset du processus. Si une modification du cpuset entre en conflit avec ces autres mécanismes, le placement dans le cpuset est forcé, même si cela signifie qu'il faut outrepasser ces autres mécanismes. Ceci est fait silencieusement par le noyau en restreignant les CPU et nœuds mémoire demandés par ces autres mécanismes à ceux qui sont autorisés par le cpuset du processus appelant. Ces autres appels peuvent alors renvoyer une erreur si, par exemple, ils sont amenés à demander un ensemble vide de CPU ou de nœuds mémoire après que la demande est restreinte au cpuset du processus appelant.

note: type: Plain text
en: Typically, a cpuset is used to manage the CPU and memory-node confinement for a set of cooperating processes such as a batch scheduler job, and these other mechanisms are used to manage the placement of individual processes or memory regions within that set or job.
fr: Typiquement, un cpuset est utilisé pour gérer le confinement dans des CPU ou des nœuds mémoire pour un ensemble de processus qui coopèrent entre eux, comme un ordonnanceur de tâches, et ces autres mécanismes permettent de gérer le placement de chacun des processus ou des régions mémoire pour chacune de ces tâches.

note: type: SH
en: FILES
fr: FICHIERS

note: type: Plain text
en: Each directory below I</dev/cpuset> represents a cpuset and contains a fixed set of pseudo-files describing the state of that cpuset.
fr: Chaque répertoire de I</dev/cpuset> représente un cpuset et contient un ensemble définit de pseudofichiers qui décrivent l'état de ce cpuset.

note: type: Plain text
en: New cpusets are created using the B<mkdir>(2)  system call or the B<mkdir>(1)  command.  The properties of a cpuset, such as its flags, allowed CPUs and memory nodes, and attached processes, are queried and modified by reading or writing to the appropriate file in that cpuset's directory, as listed below.
fr: Les nouveaux cpusets sont créés avec l'appel système B<mkdir>(2) ou la commande B<mkdir>(1). Les propriétés d'un cpuset, comme ses drapeaux, les CPU et nœuds mémoire autorisés et les processus attachés sont récupérés ou modifiés en lisant ou écrivant dans le fichier approprié du répertoire du cpuset. Ces fichiers sont décrits ci-dessous.

note: type: Plain text
en: The pseudo-files in each cpuset directory are automatically created when the cpuset is created, as a result of the B<mkdir>(2)  invocation.  It is not possible to directly add or remove these pseudo-files.
fr: Les pseudofichiers dans chaque répertoire d'un cpuset sont créés automatiquement quand le cpuset est créé, suite à l'appel à B<mkdir>(2). Il n'est pas possible d'ajouter ou de supprimer directement ces pseudofichiers.

note: type: Plain text
en: A cpuset directory that contains no child cpuset directories, and has no attached processes, can be removed using B<rmdir>(2)  or B<rmdir>(1).  It is not necessary, or possible, to remove the pseudo-files inside the directory before removing it.
fr: Le répertoire d'un cpuset qui ne contient pas de répertoire pour un cpuset fils et n'a pas de processus lui étant attaché peut être supprimé à l'aide de B<rmdir>(2) ou B<rmdir>(1). Il n'est pas nécessaire, ou possible, de supprimer les pseudofichiers du répertoire avant de le supprimer.

note: type: Plain text
en: The pseudo-files in each cpuset directory are small text files that may be read and written using traditional shell utilities such as B<cat>(1), and B<echo>(1), or from a program by using file I/O library functions or system calls, such as B<open>(2), B<read>(2), B<write>(2), and B<close>(2).
fr: Les pseudofichiers des répertoires d'un cpuset sont de petits fichiers textes qui peuvent être lus ou écrits en utilisant les outils traditionnels comme B<cat>(1) et B<echo>(1) ou depuis un programme en utilisant des fonctions d'une bibliothèque d'entrées sorties ou des appels système, comme B<open>(2), B<read>(2), B<write>(2) et B<close>(2).

note: ====================== tasks ====================== type: Plain text
en: The pseudo-files in a cpuset directory represent internal kernel state and do not have any persistent image on disk.  Each of these per-cpuset files is listed and described below.
fr: Les pseudofichiers dans un répertoire d'un cpuset représentent l'état interne du noyau et n'ont pas de représentation persistante sur le disque. Les fichiers d'un cpuset sont listés et décrits ci-dessous.

note: type: Plain text
en: List of the process IDs (PIDs) of the processes in that cpuset.  The list is formatted as a series of ASCII decimal numbers, each followed by a newline.  A process may be added to a cpuset (automatically removing it from the cpuset that previously contained it) by writing its PID to that cpuset's I<tasks> file (with or without a trailing newline.)
fr: Liste des identifiants de processus (PID) des processus dans ce cpuset. La liste contient une série de nombres décimaux au format ASCII, chacun suivit d'une nouvelle ligne. Un processus peut être ajouté à un cpuset (ce qui le supprime automatiquement du cpuset qui le contenait auparavant) en écrivant son PID dans le fichier I<tasks> du cpuset (avec ou sans nouvelle ligne à la fin).

note: =================== notify_on_release =================== type: Plain text
en: B<Warning:> only one PID may be written to the I<tasks> file at a time.  If a string is written that contains more than one PID, only the first one will be used.
fr: B<Attention :> un seul PID peut être écrit à la fois dans le fichier I<tasks>. Si une chaîne est écrite et qu'elle contient plus d'un PID, seul le premier sera utilisé.

note: ====================== cpus ====================== type: Plain text
en: Flag (0 or 1).  If set (1), that cpuset will receive special handling after it is released, that is, after all processes cease using it (i.e., terminate or are moved to a different cpuset)  and all child cpuset directories have been removed.  See the B<Notify On Release> section, below.
fr: Drapeau (0 ou 1). Lorsqu'il est activé (1), ce cpuset sera géré de façon particulière une fois qu'il sera libéré, c'est-à-dire après que tous les processus cessent de l'utiliser (c'est-à-dire se terminent ou ont été déplacés dans un autre ensemble de CPU) et que tous les répertoires des cpusets fils ont été supprimés. Consultez la section B<Notification à la libération> ci-dessous.

note: type: Plain text
en: List of the physical numbers of the CPUs on which processes in that cpuset are allowed to execute.  See B<List Format> below for a description of the format of I<cpus>.
fr: Liste des numéros physiques des CPU sur lesquels les processus de ce cpuset ont le droit de s'exécuter. Consultez la section B<Format des listes> ci-dessous pour une description du format de I<cpus>.

note: ==================== cpu_exclusive ==================== type: Plain text
en: The CPUs allowed to a cpuset may be changed by writing a new list to its I<cpus> file.
fr: Les CPU autorisés pour un cpuset peuvent être changés en écrivant une nouvelle liste dans la fichier I<cpus>.

note: type: Plain text
en: Flag (0 or 1).  If set (1), the cpuset has exclusive use of its CPUs (no sibling or cousin cpuset may overlap CPUs).  By default this is off (0).  Newly created cpusets also initially default this to off (0).
fr: Drapeau (0 ou 1). S'il est activé (1), le cpuset a un accès exclusif à ses CPU (des cpusets frères ou cousins ne peuvent pas partager de CPU). Par défaut, il est désactivé (0). Les cpusets nouvellement créés ont aussi ce drapeau de désactivé (0).

note: ====================== mems ====================== type: Plain text
en: Two cpusets are I<sibling> cpusets if they share the same parent cpuset in the I</dev/cpuset> hierarchy.  Two cpusets are I<cousin> cpusets if neither is the ancestor of the other.  Regardless of the I<cpu_exclusive> setting, if one cpuset is the ancestor of another, and if both of these cpusets have nonempty I<cpus>, then their I<cpus> must overlap, because the I<cpus> of any cpuset are always a subset of the I<cpus> of its parent cpuset.
fr: Deux cpusets sont I<frères> s'ils ont le même cpuset père dans la hiérarchie I</dev/cpuset>. Deux cpusets sont I<cousins> si aucun n'est l'ancêtre de l'autre. Indépendamment du paramètre I<cpu_exclusive>, si un cpuset est l'ancêtre d'un autre et si ces deux cpusets ont des listes de CPU (I<cpus>) non vides, alors leurs listes de CPU doivent se chevaucher parce que la liste I<cpus> d'un cpuset est toujours un sous ensemble de la liste I<cpus> de son cpuset père.

note: ==================== mem_exclusive ==================== type: Plain text
en: List of memory nodes on which processes in this cpuset are allowed to allocate memory.  See B<List Format> below for a description of the format of I<mems>.
fr: Liste des nœuds mémoire sur lesquels les processus de ce cpuset ont le droit d'allouer de la mémoire. Consultez la section B<Format des listes> ci-dessous pour une description du format de I<mems>.

note: type: Plain text
en: Flag (0 or 1).  If set (1), the cpuset has exclusive use of its memory nodes (no sibling or cousin may overlap).  Also if set (1), the cpuset is a B<Hardwall> cpuset (see below.)  By default this is off (0).  Newly created cpusets also initially default this to off (0).
fr: Drapeau (0 ou 1). S'il est activé (1), le cpuset a un accès exclusif à ses nœuds mémoire (pas de partage entre frères ou cousins). S'il est activé, il s'agit également d'un cpuset « B<Hardwall> » (voir ci-dessous). Par défaut, il est désactivé (0). Les cpusets nouvellement créés ont aussi ce drapeau de désactivé (0).

note: ==================== mem_hardwall ==================== type: Plain text
en: Regardless of the I<mem_exclusive> setting, if one cpuset is the ancestor of another, then their memory nodes must overlap, because the memory nodes of any cpuset are always a subset of the memory nodes of that cpuset's parent cpuset.
fr: Indépendamment du paramètre I<mem_exclusive>, si un cpuset est l'ancêtre d'un autre, alors leurs nœuds mémoires doivent se chevaucher parce que l'ensemble des nœuds mémoire d'un cpuset est toujours un sous ensemble des nœuds mémoire du cpuset père.

note: type: TP
en: I<cpuset.mem_hardwall> (since Linux 2.6.26)
fr: I<cpuset.mem_hardwall> (depuis Linux 2.6.26)

note: ==================== memory_migrate ==================== type: Plain text
en: Flag (0 or 1).  If set (1), the cpuset is a B<Hardwall> cpuset (see below.)  Unlike B<mem_exclusive>, there is no constraint on whether cpusets marked B<mem_hardwall> may have overlapping memory nodes with sibling or cousin cpusets.  By default this is off (0).  Newly created cpusets also initially default this to off (0).
fr: Drapeau (0 ou 1). S'il est activé, le cpuset est de type B<Hardwall> (voir ci-dessous). Contrairement à B<mem_exclusive>, des cpusets marqués avec B<mem_hardwall> peuvent partager des nœuds mémoire avec des cpusets frères ou cousins. Par défaut, il est désactivé (0). Les cpusets nouvellement créés ont aussi ce drapeau de désactivé (0).

note: type: TP
en: I<cpuset.memory_migrate> (since Linux 2.6.16)
fr: I<cpuset.memory_migrate> (depuis Linux 2.6.16)

note: ==================== memory_pressure ==================== type: Plain text
en: Flag (0 or 1).  If set (1), then memory migration is enabled.  By default this is off (0).  See the B<Memory Migration> section, below.
fr: Drapeau (0 ou 1). S'il est activé (1), alors la migration mémoire est activée. Par défaut, il est désactivé. Consultez la section B<Migration mémoire> ci-dessous.

note: type: TP
en: I<cpuset.memory_pressure> (since Linux 2.6.16)
fr: I<cpuset.memory_pressure> (depuis Linux 2.6.16)

note: ================= memory_pressure_enabled ================= type: Plain text
en: A measure of how much memory pressure the processes in this cpuset are causing.  See the B<Memory Pressure> section, below.  Unless I<memory_pressure_enabled> is enabled, always has value zero (0).  This file is read-only.  See the B<WARNINGS> section, below.
fr: Une mesure de la pression mémoire causée par les processus d'un cpuset. Consultez la section B<Pression mémoire> ci-dessous. À moins que I<memory_pressure_enabled> soit activé, il vaut toujours zéro. Ce fichier est en lecture seule. Consultez la section B<AVERTISSEMENTS> ci-dessous.

note: type: TP
en: I<cpuset.memory_pressure_enabled> (since Linux 2.6.16)
fr: I<cpuset.memory_pressure_enabled> (depuis Linux 2.6.16)

note: ================== memory_spread_page ================== type: Plain text
en: Flag (0 or 1).  This file is present only in the root cpuset, normally I</dev/cpuset>.  If set (1), the I<memory_pressure> calculations are enabled for all cpusets in the system.  By default this is off (0).  See the B<Memory Pressure> section, below.
fr: Drapeau (0 ou 1). Ce fichier n'est présent que dans le cpuset racine, qui est normalement I</dev/cpuset>. S'il est activé (1), les calculs de I<memory_pressure> sont activés pour tous les cpusets du système. Par défaut, il est désactivé (0). Consultez la section B<Pression mémoire> ci-dessous.

note: type: TP
en: I<cpuset.memory_spread_page> (since Linux 2.6.17)
fr: I<cpuset.memory_spread_page> (depuis Linux 2.6.17)

note: ================== memory_spread_slab ================== type: Plain text
en: Flag (0 or 1).  If set (1), pages in the kernel page cache (filesystem buffers) are uniformly spread across the cpuset.  By default this is off (0) in the top cpuset, and inherited from the parent cpuset in newly created cpusets.  See the B<Memory Spread> section, below.
fr: Drapeau (0 ou 1). S'il est activé (1), les pages du cache de pages du noyau (les tampons des systèmes de fichiers) sont distribuées uniformément dans les cpusets. Par défaut, il est désactivé (0) dans le cpuset racine et hérité du cpuset père pour les cpusets nouvellement créés. Consultez la section B<Répartition mémoire> ci-dessous.

note: type: TP
en: I<cpuset.memory_spread_slab> (since Linux 2.6.17)
fr: I<cpuset.memory_spread_slab> (depuis Linux 2.6.17)

note: ================== sched_load_balance ================== type: Plain text
en: Flag (0 or 1).  If set (1), the kernel slab caches for file I/O (directory and inode structures) are uniformly spread across the cpuset.  By default this is off (0) in the top cpuset, and inherited from the parent cpuset in newly created cpusets.  See the B<Memory Spread> section, below.
fr: Drapeau (0 ou 1). S'il est activé (1), les caches slab (N.d.T. : tampons préalloués par le noyau) pour les entrées-sorties de fichiers (des structures pour des répertoires ou inœuds) sont répartis uniformément dans le cpuset. Par défaut, ce drapeau est désactivé (0) dans le cpuset racine et les nouveaux cpusets héritent du drapeau de leur père quand ils sont créés. Consultez la section B<Répartition mémoire> ci-dessous.

note: type: TP
en: I<cpuset.sched_load_balance> (since Linux 2.6.24)
fr: I<cpuset.sched_load_balance> (depuis Linux 2.6.24)

note: ================== sched_relax_domain_level ================== type: Plain text
en: Flag (0 or 1).  If set (1, the default) the kernel will automatically load balance processes in that cpuset over the allowed CPUs in that cpuset.  If cleared (0) the kernel will avoid load balancing processes in this cpuset, I<unless> some other cpuset with overlapping CPUs has its I<sched_load_balance> flag set.  See B<Scheduler Load Balancing>, below, for further details.
fr: Drapeau (0 ou 1). S'il est activé (1, la valeur par défaut), le noyau répartira automatiquement la charge des processus du cpuset au travers les CPU autorisés pour le cpuset. S'il est désactivé (0), le noyau ne répartira pas la charge des processus du cpuset, I<à moins> qu'un autre cpuset qui partage des CPU avec lui n'ait son drapeau I<sched_load_balance> activé. Consultez la section B<Répartition de la charge par l'ordonnanceur> ci-dessous pour plus de détails.

note: type: TP
en: I<cpuset.sched_relax_domain_level> (since Linux 2.6.26)
fr: I<cpuset.sched_relax_domain_level> (depuis Linux 2.6.26)

note: ================== proc cpuset ================== type: Plain text
en: Integer, between -1 and a small positive value.  The I<sched_relax_domain_level> controls the width of the range of CPUs over which the kernel scheduler performs immediate rebalancing of runnable tasks across CPUs.  If I<sched_load_balance> is disabled, then the setting of I<sched_relax_domain_level> does not matter, as no such load balancing is done.  If I<sched_load_balance> is enabled, then the higher the value of the I<sched_relax_domain_level>, the wider the range of CPUs over which immediate load balancing is attempted.  See B<Scheduler Relax Domain Level>, below, for further details.
fr: Entier, compris entre -1 et une petite valeur positive. I<sched_relax_domain_level> contrôle la largeur de l'intervalle des CPU pour lesquels le noyau effectue une répartition immédiate des tâches exécutables. Si I<sched_load_balance> est désactivé, alors I<sched_relax_domain_level> ne compte pas, puisqu'il n'y a pas de répartition de la charge. Si I<sched_load_balance> est activé, alors plus I<sched_relax_domain_level> est important, plus l'intervalle des CPU sur lesquels le noyau essaie de répartir la charge est important. Consultez la section B<Niveau du domaine de détente de l'ordonnanceur> ci-dessous pour plus de détails.

note: ================== proc status ================== type: Plain text
en: In addition to the above pseudo-files in each directory below I</dev/cpuset>, each process has a pseudo-file, I</proc/E<lt>pidE<gt>/cpuset>, that displays the path of the process's cpuset directory relative to the root of the cpuset filesystem.
fr: En plus des pseudofichiers décrits ci-dessus, dans chaque répertoire de I</dev/cpuset>, chaque processus a un pseudofichier, I</proc/E<lt>pidE<gt>/cpuset>, qui indique le chemin vers le répertoire du cpuset du processus, relativement à la racine du système de fichiers cpuset.

note: type: Plain text
en: Also the I</proc/E<lt>pidE<gt>/status> file for each process has four added lines, displaying the process's I<Cpus_allowed> (on which CPUs it may be scheduled) and I<Mems_allowed> (on which memory nodes it may obtain memory), in the two formats B<Mask Format> and B<List Format> (see below)  as shown in the following example:
fr: Quatre lignes sont également ajoutées dans le fichier I</proc/E<lt>pidE<gt>/status>, fournissant pour chaque processus les champs : I<Cpus_allowed> (sur quels CPU il peut être ordonnancé) et I<Mems_allowed> (sur quels nœuds mémoire de la mémoire peut être allouée), avec l'B<Affichage sous forme de masque> et l'B<Affichage sous forme de liste> (voir ci-dessous). Voici un exemple :

note: ================== EXTENDED CAPABILITIES ================== type: Plain text
en: The "allowed" fields were added in Linux 2.6.24; the "allowed_list" fields were added in Linux 2.6.26.
fr: Les champs « allowed » ont été ajoutés dans Linux 2.6.24 ; les champs « allowed_list » ont été ajoutés dans Linux 2.6.26.

note: type: SH
en: EXTENDED CAPABILITIES
fr: CAPACITÉS ÉTENDUES

note: ================== Exclusive Cpusets ================== type: Plain text
en: In addition to controlling which I<cpus> and I<mems> a process is allowed to use, cpusets provide the following extended capabilities.
fr: En plus de contrôler quels CPU (I<cpus>) et nœuds mémoire (I<mems>) un processus à le droit d'utiliser, les cpusets fournissent les fonctionnalités étendues suivantes.

note: type: SS
en: Exclusive cpusets
fr: Ensembles de CPU exclusifs

note: type: Plain text
en: If a cpuset is marked I<cpu_exclusive> or I<mem_exclusive>, no other cpuset, other than a direct ancestor or descendant, may share any of the same CPUs or memory nodes.
fr: Si un cpuset est marqué avec I<cpu_exclusive> ou I<mem_exclusive>, aucun autre cpuset, autre que des ancêtres ou descendants directs, peuvent partager des CPU ou des nœuds mémoire avec ce cpuset.

note: ================== Hardwall ================== type: Plain text
en: A cpuset that is I<mem_exclusive> restricts kernel allocations for buffer cache pages and other internal kernel data pages commonly shared by the kernel across multiple users.  All cpusets, whether I<mem_exclusive> or not, restrict allocations of memory for user space.  This enables configuring a system so that several independent jobs can share common kernel data, while isolating each job's user allocation in its own cpuset.  To do this, construct a large I<mem_exclusive> cpuset to hold all the jobs, and construct child, non-I<mem_exclusive> cpusets for each individual job.  Only a small amount of kernel memory, such as requests from interrupt handlers, is allowed to be placed on memory nodes outside even a I<mem_exclusive> cpuset.
fr: Un cpuset dont I<mem_exclusive> est activé restreint les allocations du noyau pour les pages des tampons de cache et autres données internes du noyau communément partagées par le noyau au travers différents utilisateurs. Tous les cpusets, que I<mem_exclusive> soit activé ou non, restreignent l'allocation de mémoire depuis l'espace utilisateur. Ceci permet de configurer un système de telle sorte que différentes tâches puissent partager des données du noyau, tout en isolant toutes les allocations en mode utilisateur des tâches dans leur propre cpuset. Pour ceci, il faut créer un gros cpuset, avec I<mem_exclusive> activé, pour contenir toutes les tâches, et créer des cpuset fils sans I<mem_exclusive> pour chacune des tâches. Seule une petite partie de la mémoire du noyau, comme les requêtes des gestionnaires d'interruptions, est autorisée à être placée sur des nœuds mémoire en dehors d'un cpuset, même si I<mem_exclusive> est activé.

note: type: Plain text
en: A cpuset that has I<mem_exclusive> or I<mem_hardwall> set is a I<hardwall> cpuset.  A I<hardwall> cpuset restricts kernel allocations for page, buffer, and other data commonly shared by the kernel across multiple users.  All cpusets, whether I<hardwall> or not, restrict allocations of memory for user space.
fr: Un cpuset pour lequel I<mem_exclusive> ou I<mem_hardwall> est activé est un cpuset I<hardwall>. Un cpuset I<hardwall> restreint les allocations mémoire du noyau pour les pages, tampons et toutes autre données partagés fréquemment par le noyau au travers différents utilisateurs. Tous les cpusets, I<hardwall> ou non, restreignent les allocations mémoire pour l'espace utilisateur.

note: type: Plain text
en: This enables configuring a system so that several independent jobs can share common kernel data, such as filesystem pages, while isolating each job's user allocation in its own cpuset.  To do this, construct a large I<hardwall> cpuset to hold all the jobs, and construct child cpusets for each individual job which are not I<hardwall> cpusets.
fr: Ceci permet de configurer un système de telle sorte que différentes tâches indépendantes puissent partager des données du noyau, comme des pages des systèmes de fichiers, tout en isolant les allocations de l'espace utilisateur de chaque tâche dans leur cpuset. Pour ceci, il faut créer un gros cpuset I<hardwall> qui contiendra toutes les tâches et créer des cpusets fils (non I<hardwall>) pour chacune des tâches.

note: ================== Notify On Release ================== type: Plain text
en: Only a small amount of kernel memory, such as requests from interrupt handlers, is allowed to be taken outside even a I<hardwall> cpuset.
fr: Seule une petite quantité de mémoire noyau, comme les demandes des gestionnaires d'interruption, peut être utilisée à l'extérieur d'un cpuset I<hardwall>.

note: type: SS
en: Notify on release
fr: Notification à la libération

note: type: Plain text
en: If the I<notify_on_release> flag is enabled (1) in a cpuset, then whenever the last process in the cpuset leaves (exits or attaches to some other cpuset)  and the last child cpuset of that cpuset is removed, the kernel will run the command I</sbin/cpuset_release_agent>, supplying the pathname (relative to the mount point of the cpuset filesystem) of the abandoned cpuset.  This enables automatic removal of abandoned cpusets.
fr: Si le drapeau I<notify_on_release> d'un cpuset est activé (1), alors quand le dernier processus quitte le cpuset (il se termine ou s'attache à un autre cpuset) et que le dernier cpuset fils de ce cpuset a été supprimé, le noyau exécutera la commande I</sbin/cpuset_release_agent> en lui fournissant le chemin (relatif au point de montage du système de fichiers cpuset) du cpuset abandonné. Ceci permet de supprimer automatiquement les cpusets abandonnés.

note: type: Plain text
en: The default value of I<notify_on_release> in the root cpuset at system boot is disabled (0).  The default value of other cpusets at creation is the current value of their parent's I<notify_on_release> setting.
fr: Le drapeau I<notify_on_release> du cpuset racine est désactivé (0) par défaut au moment du démarrage. La valeur par défaut pour les autres cpusets lors de leur création est égale à la valeur de I<notify_on_release> de leur cpuset parent.

note: type: Plain text
en: The command I</sbin/cpuset_release_agent> is invoked, with the name (I</dev/cpuset> relative path)  of the to-be-released cpuset in I<argv[1]>.
fr: La commande I</sbin/cpuset_release_agent> est appelée, avec dans I<argv[1]> le nom (un chemin relatif à I</dev/cpuset>) du cpuset à supprimer.

note: type: Plain text
en: The usual contents of the command I</sbin/cpuset_release_agent> is simply the shell script:
fr: Le contenu habituel de la commande I</sbin/cpuset_release_agent> est simplement le script shell suivant :

note: ================== Memory Pressure ================== type: Plain text
en: As with other flag values below, this flag can be changed by writing an ASCII number 0 or 1 (with optional trailing newline)  into the file, to clear or set the flag, respectively.
fr: Comme pour les autres drapeaux ci-dessous, ce drapeau peut être modifié en écrivant un 0 ou un 1 ASCII (avec ou sans fin de ligne) dans le fichier pour respectivement désactiver ou activer le drapeau.

note: type: SS
en: Memory pressure
fr: Pression mémoire

note: type: Plain text
en: The I<memory_pressure> of a cpuset provides a simple per-cpuset running average of the rate that the processes in a cpuset are attempting to free up in-use memory on the nodes of the cpuset to satisfy additional memory requests.
fr: Le fichier I<memory_pressure> d'un cpuset indique la moyenne instantanée du taux auquel les processus du cpuset tentent de libérer de la mémoire utilisée sur les nœuds du cpuset pour satisfaire les nouvelles demandes de mémoire.

note: type: Plain text
en: This enables batch managers that are monitoring jobs running in dedicated cpusets to efficiently detect what level of memory pressure that job is causing.
fr: Ceci permet à un gestionnaire de tâches de superviser les tâches qui s'exécutent dans des cpuset dédiés et détecter efficacement la pression mémoire qu'une tâche produit.

note: type: Plain text
en: This is useful both on tightly managed systems running a wide mix of submitted jobs, which may choose to terminate or reprioritize jobs that are trying to use more memory than allowed on the nodes assigned them, and with tightly coupled, long-running, massively parallel scientific computing jobs that will dramatically fail to meet required performance goals if they start to use more memory than allowed to them.
fr: Ceci est utile à la fois pour les systèmes très surveillés qui exécutent diverses tâches qui leurs sont fournies et peuvent choisir de terminer ou de changer la priorité des tâches qui essaient d'utiliser plus de mémoire que les nœuds mémoire qui leurs ont été assignés leurs permettent, et les systèmes pour du calcul scientifique avec des tâches parallèles, fortement couplées, au temps d'exécution important, qui ne pourraient plus fournir les performances demandées si elles se mettaient à utiliser plus de mémoire qu'elles n'en ont droit.

note: type: Plain text
en: This mechanism provides a very economical way for the batch manager to monitor a cpuset for signs of memory pressure.  It's up to the batch manager or other user code to decide what action to take if it detects signs of memory pressure.
fr: Ce mécanisme fourni un moyen très économique pour détecter des signes de pression mémoire sur un cpuset. L'action à effectuer lorsqu'un signe de pression mémoire est détecté est laissé au libre arbitre du gestionnaire des tâches ou autre code utilisateur.

note: type: Plain text
en: Unless memory pressure calculation is enabled by setting the pseudo-file I</dev/cpuset/cpuset.memory_pressure_enabled>, it is not computed for any cpuset, and reads from any I<memory_pressure> always return zero, as represented by the ASCII string "0\en".  See the B<WARNINGS> section, below.
fr: À moins que le calcul de la pression mémoire soit activé par le pseudofichier I</dev/cpuset/cpuset.memory_pressure_enabled>, cette pression mémoire n'est calculée pour aucun cpuset et les lectures dans les fichiers I<memory_pressure> renvoient toujours zéro, c'est-à-dire la chaîne ASCII « 0\en ». Consultez la section B<AVERTISSEMENTS> ci-dessous.

note: type: Plain text
en: A per-cpuset, running average is employed for the following reasons:
fr: Une moyenne instantanée par cpuset est utilisée pour les raisons suivantes :

note: type: Plain text
en: Because this meter is per-cpuset rather than per-process or per virtual memory region, the system load imposed by a batch scheduler monitoring this metric is sharply reduced on large systems, because a scan of the tasklist can be avoided on each set of queries.
fr: Comme cette métrique est par cpuset plutôt que par processus ou par région mémoire virtuelle, la charge du système due à la supervision de cette métrique par un gestionnaire de tâches est fortement réduite sur les gros systèmes, étant donné qu'il n'est pas nécessaire de parcourir la liste des tâches à chaque fois.

note: type: Plain text
en: Because this meter is a running average rather than an accumulating counter, a batch scheduler can detect memory pressure with a single read, instead of having to read and accumulate results for a period of time.
fr: Comme cette métrique est une moyenne instantanée plutôt qu'un compteur, un gestionnaire de tâches obtient la pression mémoire en une seule lecture sans avoir à lire et se souvenir des résultats pendant un certain temps.

note: type: Plain text
en: Because this meter is per-cpuset rather than per-process, the batch scheduler can obtain the key information\(emmemory pressure in a cpuset\(emwith a single read, rather than having to query and accumulate results over all the (dynamically changing)  set of processes in the cpuset.
fr: Comme cette métrique est par cpuset plutôt que par processus, le gestionnaire de tâches peut obtenir l'information importante, la pression mémoire dans un cpuset, en une seule lecture sans nécessiter d'obtenir et de se souvenir des résultats pour tous les processus d'un cpuset (la liste des processus peut changer dynamiquement).

note: type: Plain text
en: The I<memory_pressure> of a cpuset is calculated using a per-cpuset simple digital filter that is kept within the kernel.  For each cpuset, this filter tracks the recent rate at which processes attached to that cpuset enter the kernel direct reclaim code.
fr: La pression mémoire d'un cpuset est calculée en utilisant un simple filtre digital par cpuset dans le noyau. Pour chaque cpuset, ce filtre suit le taux auquel les processus attachés à ce cpuset demandent au noyau de réutiliser de la mémoire.

note: type: Plain text
en: The kernel direct reclaim code is entered whenever a process has to satisfy a memory page request by first finding some other page to repurpose, due to lack of any readily available already free pages.  Dirty filesystem pages are repurposed by first writing them to disk.  Unmodified filesystem buffer pages are repurposed by simply dropping them, though if that page is needed again, it will have to be reread from disk.
fr: Ces demandes de réutilisation de mémoire se produisent quand un processus doit satisfaire une demande de page mémoire en trouvant d'abord une page à réutiliser, du fait de l'absence de page disponible déjà prête. Les pages sales des systèmes de fichiers sont réutilisées en les écrivant d'abord sur le disque. Les tampons des systèmes de fichiers qui n'ont pas été modifiés sont réutilisés tout simplement en les abandonnant, mais si cette page est nécessaire de nouveau, il faudra la relire sur le disque.

note: ================== Memory Spread ================== type: Plain text
en: The I<cpuset.memory_pressure> file provides an integer number representing the recent (half-life of 10 seconds) rate of entries to the direct reclaim code caused by any process in the cpuset, in units of reclaims attempted per second, times 1000.
fr: Le fichier I<cpuset.memory_pressure> fournit un nombre entier qui représente le taux des demandes récentes (la demi-vie est de 10 secondes) de réutilisation de mémoire par les processus du cpuset, l'unité étant le nombre de demandes par seconde fois 1000.

note: type: SS
en: Memory spread
fr: Répartition mémoire

note: type: Plain text
en: There are two Boolean flag files per cpuset that control where the kernel allocates pages for the filesystem buffers and related in-kernel data structures.  They are called I<cpuset.memory_spread_page> and I<cpuset.memory_spread_slab>.
fr: Il y a deux fichiers, par cpuset, pour des drapeaux booléens qui contrôlent où le noyau alloue les pages pour les tampons des systèmes de fichiers et les structures de données liées internes au noyau. Ces fichiers sont I<cpuset.memory_spread_page> et I<cpuset.memory_spread_slab>.

note: type: Plain text
en: If the per-cpuset Boolean flag file I<cpuset.memory_spread_page> is set, then the kernel will spread the filesystem buffers (page cache) evenly over all the nodes that the faulting process is allowed to use, instead of preferring to put those pages on the node where the process is running.
fr: Si le drapeau booléen I<cpuset.memory_spread_page> est activé, alors le noyau répartit les tampons des systèmes de fichiers (les caches des pages) équitablement sur tous les nœuds autorisés pour le processus qui demande la page, au lieu de placer ces pages de préférence sur le nœud sur lequel s'exécute le processus.

note: type: Plain text
en: If the per-cpuset Boolean flag file I<cpuset.memory_spread_slab> is set, then the kernel will spread some filesystem-related slab caches, such as those for inodes and directory entries, evenly over all the nodes that the faulting process is allowed to use, instead of preferring to put those pages on the node where the process is running.
fr: Si le drapeau booléen I<cpuset.memory_spread_slab> d'un cpuset est activé, alors le noyau répartira uniformément les caches slab liés aux systèmes de fichiers, comme ceux pour des entrées d'inœuds ou de répertoires, sur tous les nœuds autorisés pour le processus qui demande de la mémoire, plutôt que de préférer mettre ces pages sur le nœud sur lequel s'exécute le processus.

note: type: Plain text
en: The setting of these flags does not affect the data segment (see B<brk>(2))  or stack segment pages of a process.
fr: La configuration de ces drapeaux n'affecte pas les pages du segment de données (consultez B<brk>(2)) ou du segment de la pile d'un processus.

note: type: Plain text
en: By default, both kinds of memory spreading are off and the kernel prefers to allocate memory pages on the node local to where the requesting process is running.  If that node is not allowed by the process's NUMA memory policy or cpuset configuration or if there are insufficient free memory pages on that node, then the kernel looks for the nearest node that is allowed and has sufficient free memory.
fr: Par défaut, les deux types de répartition de la mémoire sont désactivés et le noyau préfère allouer la mémoire sur le nœud local où s'exécute le processus. Si ce nœud n'est pas autorisé par la politique NUMA du processus ou par la configuration des cpusets ou s'il n'y a plus suffisamment de pages mémoire disponibles sur ce nœud, alors le noyau recherche le nœud le plus proche étant autorisé et ayant suffisamment de pages disponibles.

note: type: Plain text
en: When new cpusets are created, they inherit the memory spread settings of their parent.
fr: Quand un nouveau cpuset est créé, il hérite de la configuration de répartition mémoire de son père.

note: type: Plain text
en: Setting memory spreading causes allocations for the affected page or slab caches to ignore the process's NUMA memory policy and be spread instead.  However, the effect of these changes in memory placement caused by cpuset-specified memory spreading is hidden from the B<mbind>(2)  or B<set_mempolicy>(2)  calls.  These two NUMA memory policy calls always appear to behave as if no cpuset-specified memory spreading is in effect, even if it is.  If cpuset memory spreading is subsequently turned off, the NUMA memory policy most recently specified by these calls is automatically reapplied.
fr: Activer la répartition mémoire a pour effet d'ignorer la politique mémoire NUMA du processus pour les allocations de pages ou de caches slab, qui sont alors éparpillées. Cependant, les changements dus à la répartition mémoire demandée par un cpuset ne sont pas visibles pour les appels système B<mbind>(2) ou B<set_mempolicy>(2). Ces deux appels système liés à la politique mémoire NUMA semblent se comporter comme si aucune répartition mémoire n'était demandée par un cpuset, même si c'est le cas. Si la répartition mémoire est par la suite désactivée pour les cpuset, la dernière politique mémoire NUMA définie par ces appels est automatiquement appliquée de nouveau.

note: type: Plain text
en: Both I<cpuset.memory_spread_page> and I<cpuset.memory_spread_slab> are Boolean flag files.  By default they contain "0", meaning that the feature is off for that cpuset.  If a "1" is written to that file, that turns the named feature on.
fr: I<cpuset.memory_spread_page> et I<cpuset.memory_spread_slab> sont tous les deux des fichiers contenant des drapeaux booléens. Par défaut, ils contiennent un « 0 », ce qui signifie que la fonctionnalité est désactivée pour ce cpuset. Si un « 1 » est écrit dans le fichier, la fonctionnalité correspondante est activée.

note: type: Plain text
en: Cpuset-specified memory spreading behaves similarly to what is known (in other contexts) as round-robin or interleave memory placement.
fr: La répartition mémoire d'un cpuset se comporte de façon similaire à ce qui est connu (dans d'autres contextes) comme le placement mémoire à tour de rôle (« round-robin ») ou entrelacé (« interleave »).

note: type: Plain text
en: Cpuset-specified memory spreading can provide substantial performance improvements for jobs that:
fr: La configuration d'une stratégie de répartition mémoire pour un cpuset peut améliorer significativement les performances pour les tâches qui :

note: type: Plain text
en: need to place thread-local data on memory nodes close to the CPUs which are running the threads that most frequently access that data; but also
fr: nécessitent de placer les données locales des threads dans des nœuds mémoire proches des CPU qui exécutent les threads qui accèdent le plus fréquemment à ces données ; mais aussi

note: type: Plain text
en: need to access large filesystem data sets that must to be spread across the several nodes in the job's cpuset in order to fit.
fr: nécessitent d'accéder à de gros ensembles de données de systèmes de fichiers qui doivent être répartis sur différents nœuds du cpuset de la tâche du fait de leurs tailles.

note: ================== Memory Migration ================== type: Plain text
en: Without this policy, the memory allocation across the nodes in the job's cpuset can become very uneven, especially for jobs that might have just a single thread initializing or reading in the data set.
fr: Sans cette politique, la répartition des allocations mémoire sur les nœuds du cpuset de la tâche peut ne pas être équitable, particulièrement pour les tâches qui n'auraient qu'un thread chargé de l'initialisation ou de la lecture des données d'entrée.

note: type: SS
en: Memory migration
fr: Migration mémoire

note: type: Plain text
en: Normally, under the default setting (disabled) of I<cpuset.memory_migrate>, once a page is allocated (given a physical page of main memory) then that page stays on whatever node it was allocated, so long as it remains allocated, even if the cpuset's memory-placement policy I<mems> subsequently changes.
fr: Normalement, avec la configuration de I<cpuset.memory_migrate> par défaut (désactivé), une fois qu'une page est allouée (une page physique de la mémoire lui est donnée), cette page reste sur le nœud où elle a été allouée, tant qu'elle reste allouée, même si la politique de placement mémoire du cpuset (I<mems>) change par la suite.

note: type: Plain text
en: When memory migration is enabled in a cpuset, if the I<mems> setting of the cpuset is changed, then any memory page in use by any process in the cpuset that is on a memory node that is no longer allowed will be migrated to a memory node that is allowed.
fr: Quand la migration mémoire est activée pour un cpuset, si la configuration de I<mems> est modifiée alors toute page mémoire utilisée par un processus du cpuset qui se trouverait sur un nœud mémoire qui n'est plus autorisé sera déplacée sur un nœud mémoire qui est autorisé.

note: type: Plain text
en: Furthermore, if a process is moved into a cpuset with I<memory_migrate> enabled, any memory pages it uses that were on memory nodes allowed in its previous cpuset, but which are not allowed in its new cpuset, will be migrated to a memory node allowed in the new cpuset.
fr: De plus, si un processus est déplacé dans un cpuset dont le drapeau I<memory_migrate> est activé, toutes les pages mémoire qu'il utilise et qui se trouvent sur des nœuds mémoire qui étaient autorisés dans son cpuset précédant mais ne le sont plus dans le nouveau cpuset seront déplacées sur un nœud mémoire autorisé pour le nouveau cpuset.

note: ================== Scheduler Load Balancing ================== type: Plain text
en: The relative placement of a migrated page within the cpuset is preserved during these migration operations if possible.  For example, if the page was on the second valid node of the prior cpuset, then the page will be placed on the second valid node of the new cpuset, if possible.
fr: L'emplacement relatif d'un page déplacée d'un cpuset est préservé si possible lors de ces opérations de déplacement. Par exemple, si la page se trouvait sur le deuxième nœud valable du précédent cpuset, alors la page sera placée sur le deuxième nœud valable du nouveau cpuset, si c'est possible.

note: type: SS
en: Scheduler load balancing
fr: Répartition de la charge par l'ordonnanceur

note: type: Plain text
en: The kernel scheduler automatically load balances processes.  If one CPU is underutilized, the kernel will look for processes on other more overloaded CPUs and move those processes to the underutilized CPU, within the constraints of such placement mechanisms as cpusets and B<sched_setaffinity>(2).
fr: L'ordonnanceur du noyau répartit automatiquement la charge des processus. Si un CPU est sous-utilisé, le noyau recherchera des processus sur d'autres CPU plus chargés et déplacera ces processus sur le CPU sous-utilisé à condition que les mécanismes comme les cpuset et B<sched_setaffinity>(2) le permettent.

note: type: Plain text
en: The algorithmic cost of load balancing and its impact on key shared kernel data structures such as the process list increases more than linearly with the number of CPUs being balanced.  For example, it costs more to load balance across one large set of CPUs than it does to balance across two smaller sets of CPUs, each of half the size of the larger set.  (The precise relationship between the number of CPUs being balanced and the cost of load balancing depends on implementation details of the kernel process scheduler, which is subject to change over time, as improved kernel scheduler algorithms are implemented.)
fr: Le coût de l'algorithme de répartition de la charge et son impact sur les structures de données partagées du noyau, comme la liste des processus, augmente plus que linéairement avec le nombre de CPU qui interviennent pour la répartition de la charge. Par exemple le coût pour la répartition de la charge dans un grand ensemble de CPU sera supérieur à celui pour la répartition de la charge dans deux ensembles ayant moitié moins de CPU. (La relation entre le nombre de CPU intervenant dans la répartition de la charge et le coût de cette répartition de charge dépend de l'implémentation de l'ordonnanceur de processus du noyau, qui change dans le temps quand de meilleurs algorithmes d'ordonnancement sont implémentés)

note: type: Plain text
en: The per-cpuset flag I<sched_load_balance> provides a mechanism to suppress this automatic scheduler load balancing in cases where it is not needed and suppressing it would have worthwhile performance benefits.
fr: Le drapeau I<sched_load_balance> d'un cpuset permet de supprimer cette répartition automatique de la charge dans les cas où elle n'est pas nécessaire et que sa suppression améliorerait les performances.

note: type: Plain text
en: By default, load balancing is done across all CPUs, except those marked isolated using the kernel boot time "isolcpus=" argument.  (See B<Scheduler Relax Domain Level>, below, to change this default.)
fr: Par défaut, la répartition de la charge se fait sur tous les CPU, à l'exception de ceux marqués comme étant isolés en utilisant au moment du démarrage le paramètre du noyau « isolcpus= ». (Consultez la section B<Niveau du domaine de détente de l'ordonnanceur> ci-dessous pour changer le comportement par défaut)

note: type: Plain text
en: This default load balancing across all CPUs is not well suited to the following two situations:
fr: Cette répartition de la charge par défaut n'est pas bien adaptée aux situations suivantes :

note: type: Plain text
en: On large systems, load balancing across many CPUs is expensive.  If the system is managed using cpusets to place independent jobs on separate sets of CPUs, full load balancing is unnecessary.
fr: Sur les gros systèmes, la répartition de la charge sur beaucoup de CPU est très coûteuse. Si le système est géré avec des cpusets pour placer les tâches indépendantes sur différents ensembles de CPU, une répartition de la charge complète n'est pas nécessaire.

note: type: Plain text
en: Systems supporting real-time on some CPUs need to minimize system overhead on those CPUs, including avoiding process load balancing if that is not needed.
fr: Les systèmes avec une prise en charge temps-réel sur certains CPU doivent minimiser la surcharge du système sur ces CPU et donc éviter la répartition de la charge des processus si elle n'est pas nécessaire.

note: type: Plain text
en: When the per-cpuset flag I<sched_load_balance> is enabled (the default setting), it requests load balancing across all the CPUs in that cpuset's allowed CPUs, ensuring that load balancing can move a process (not otherwise pinned, as by B<sched_setaffinity>(2))  from any CPU in that cpuset to any other.
fr: Quand le drapeau I<sched_load_balance> d'un cpuset est activé (ce qui est le cas par défaut), une répartition de la charge sur tous les CPU autorisés par le cpuset est demandé, à condition que le processus puisse être déplacé d'un CPU du cpuset à un autre CPU (c'est-à-dire qu'il n'ait pas été attaché à des CPU avec, par exemple, B<sched_setaffinity>(2)).

note: type: Plain text
en: When the per-cpuset flag I<sched_load_balance> is disabled, then the scheduler will avoid load balancing across the CPUs in that cpuset, I<except> in so far as is necessary because some overlapping cpuset has I<sched_load_balance> enabled.
fr: Quand le drapeau I<sched_load_balance> d'un cpuset est désactivé, alors l'ordonnanceur évitera de déplacer des processus pour répartir la charge des CPU du cpuset, I<sauf> si un autre cpuset partage le même CPU et a son drapeau I<sched_load_balance> activé.

note: type: Plain text
en: So, for example, if the top cpuset has the flag I<sched_load_balance> enabled, then the scheduler will load balance across all CPUs, and the setting of the I<sched_load_balance> flag in other cpusets has no effect, as we're already fully load balancing.
fr: Ainsi, par exemple, si le cpuset racine a son drapeau I<sched_load_balance> activé, alors l'ordonnanceur répartira la charge sur tous les CPU et la configuration du drapeau I<sched_load_balance> des autres cpusets n'a pas d'effet, puisqu'une répartition complète de la charge est déjà demandée.

note: type: Plain text
en: Therefore in the above two situations, the flag I<sched_load_balance> should be disabled in the top cpuset, and only some of the smaller, child cpusets would have this flag enabled.
fr: Dans les deux situations ci-dessus, le drapeau I<sched_load_balance> devrait donc être désactivé sur le cpuset racine et seuls les cpusets fils plus petits devraient l'activer.

note: type: Plain text
en: When doing this, you don't usually want to leave any unpinned processes in the top cpuset that might use nontrivial amounts of CPU, as such processes may be artificially constrained to some subset of CPUs, depending on the particulars of this flag setting in descendant cpusets.  Even if such a process could use spare CPU cycles in some other CPUs, the kernel scheduler might not consider the possibility of load balancing that process to the underused CPU.
fr: Lorsque vous faites ceci, vous ne devez généralement pas laisser un processus non attaché à un CPU dans le cpuset racine qui pourrait utiliser les CPU de façon non négligeable. De cette façon les processus peuvent être artificiellement contraints à un sous ensemble des CPU en fonction de la configuration de ce drapeau dans les cpusets descendants. Même si ce processus pourrait utiliser des cycles CPU inutilisés par certains CPU, l'ordonnanceur du noyau ne cherchera pas à répartir la charge du processus sur le CPU sous utilisé.

note: ================== Scheduler Relax Domain Level ================== type: Plain text
en: Of course, processes pinned to a particular CPU can be left in a cpuset that disables I<sched_load_balance> as those processes aren't going anywhere else anyway.
fr: Bien sûr, les processus attachés à un CPU particulier peuvent être laissés dans un cpuset qui désactive I<sched_load_balance> puisque ces processus ne peuvent être déplacés de toute façon.

note: type: SS
en: Scheduler relax domain level
fr: Niveau du domaine de détente de l'ordonnanceur

note: type: Plain text
en: The kernel scheduler performs immediate load balancing whenever a CPU becomes free or another task becomes runnable.  This load balancing works to ensure that as many CPUs as possible are usefully employed running tasks.  The kernel also performs periodic load balancing off the software clock described in B<time>(7).  The setting of I<sched_relax_domain_level> applies only to immediate load balancing.  Regardless of the I<sched_relax_domain_level> setting, periodic load balancing is attempted over all CPUs (unless disabled by turning off I<sched_load_balance>.)  In any case, of course, tasks will be scheduled to run only on CPUs allowed by their cpuset, as modified by B<sched_setaffinity>(2)  system calls.
fr: L'ordonnanceur du noyau effectue une répartition de la charge immédiate lorsqu'un CPU devient disponible ou lorsqu'une autre tâche est prête. Cette répartition de la charge permet de s'assurer que le plus de CPU possibles sont utilisés efficacement en exécutant des tâches. Le noyau effectue aussi une répartition de la charge de façon plus sporadique sur la base de l'horloge logicielle décrite dans B<time>(7). La configuration de I<sched_relax_domain_level> ne s'applique qu'à la répartition de charge automatique. Indépendamment de la configuration de I<sched_relax_domain_level>, une répartition de charge sporadique est effectuée à travers tous les CPU (sauf si cela a été désactivé avec I<sched_load_balance>). Dans tous les cas, bien sûr, les tâches ne seront exécutées que sur les CPU autorisés par leur cpuset et par les appels systèmes B<sched_setaffinity>(2).

note: type: Plain text
en: On small systems, such as those with just a few CPUs, immediate load balancing is useful to improve system interactivity and to minimize wasteful idle CPU cycles.  But on large systems, attempting immediate load balancing across a large number of CPUs can be more costly than it is worth, depending on the particular performance characteristics of the job mix and the hardware.
fr: Sur les petits systèmes, avec peu de CPU, la répartition de charge immédiate est utile pour améliorer l'interactivité du système et minimiser les cycles CPU inutilisés. Mais sur les gros systèmes, essayer de répartir la charge immédiatement sur un nombre important de CPU peut être plus coûteux que ce que ça ne rapporte, en fonction des performances des différentes tâches et du matériel.

note: type: Plain text
en: The exact meaning of the small integer values of I<sched_relax_domain_level> will depend on internal implementation details of the kernel scheduler code and on the non-uniform architecture of the hardware.  Both of these will evolve over time and vary by system architecture and kernel version.
fr: La signification exacte des petites valeurs de I<sched_relax_domain_level> dépendra de l'implémentation de l'ordonnanceur du noyau et de l'architecture non uniforme du matériel. Ces deux paramètres évolueront dans le temps et dépendent de l'architecture du système et de la version du noyau.

note: type: Plain text
en: As of this writing, when this capability was introduced in Linux 2.6.26, on certain popular architectures, the positive values of I<sched_relax_domain_level> have the following meanings.
fr: À ce jour, quand cette capacité a été introduite sous Linux 2.6.26, la signification des valeurs positives de I<sched_relax_domain_level> est la suivante pour certaines des architectures les plus courantes :

note: type: Plain text
en: Perform immediate load balancing across Hyper-Thread siblings on the same core.
fr: Effectuer immédiatement une répartition de la charge sur les différents Hyper-Thread frères d'un même cœur.

note: type: Plain text
en: Perform immediate load balancing across other cores in the same package.
fr: Effectuer immédiatement une répartition de la charge sur les différents cœurs d'un processeur.

note: type: Plain text
en: Perform immediate load balancing across other CPUs on the same node or blade.
fr: Effectuer immédiatement une répartition de la charge sur les différents CPU d'un même nœud ou d'une même lame.

note: type: Plain text
en: Perform immediate load balancing across over several (implementation detail) nodes [On NUMA systems].
fr: Effectuer immédiatement une répartition de la charge sur les différents (détail d'implémentation) nœuds [pour les systèmes NUMA].

note: type: Plain text
en: Perform immediate load balancing across over all CPUs in system [On NUMA systems].
fr: Effectuer immédiatement une répartition de la charge sur tous les CPU d'un système [pour les systèmes NUMA].

note: type: Plain text
en: The I<sched_relax_domain_level> value of zero (0) always means don't perform immediate load balancing, hence that load balancing is done only periodically, not immediately when a CPU becomes available or another task becomes runnable.
fr: La valeur zéro (0) pour I<sched_relax_domain_level> signifie toujours qu'il n'y a pas de répartition de charge immédiate, et donc la répartition de la charge s'effectue périodiquement et non pas immédiatement quand un CPU devient disponible ou qu'une tâche peut être exécutée.

note: type: Plain text
en: The I<sched_relax_domain_level> value of minus one (-1)  always means use the system default value.  The system default value can vary by architecture and kernel version.  This system default value can be changed by kernel boot-time "relax_domain_level=" argument.
fr: La valeur -1 pour I<sched_relax_domain_level> signifie toujours qu'il faut utiliser la valeur par défaut du système. La valeur par défaut du système peut varier en fonction de l'architecture et du noyau. Cette valeur par défaut du système peut être modifiée en fournissant au noyau un paramètre « relax_domain_level= » lors du démarrage.

note: type: Plain text
en: In the case of multiple overlapping cpusets which have conflicting I<sched_relax_domain_level> values, then the highest such value applies to all CPUs in any of the overlapping cpusets.  In such cases, the value B<minus one (-1)> is the lowest value, overridden by any other value, and the value B<zero (0)> is the next lowest value.
fr: Si des cpusets partagent des CPU et ont des valeurs de I<sched_relax_domain_level> incompatibles, alors la valeur la plus élevée s'applique à tous les CPU de ces cpusets. Dans ce cas, la valeur B<moins un (-1)> est la valeur la plus faible, remplacée par toute autre valeur et la valeur B<zéro (0)> est la valeur la plus faible suivante.

note: ================== Mask Format ================== type: Plain text
en: The following formats are used to represent sets of CPUs and memory nodes.
fr: Les formats suivants sont utilisés pour représenter des ensembles de CPU et de nœuds mémoire.

note: type: SS
en: Mask format
fr: Affichage sous forme de masque

note: type: Plain text
en: The B<Mask Format> is used to represent CPU and memory-node bit masks in the I</proc/E<lt>pidE<gt>/status> file.
fr: L'B<Affichage sous forme de masque> est utilisé pour représenter les masques de bits des CPU et nœuds mémoire dans le fichier I</proc/E<lt>pidE<gt>/status>.

note: type: Plain text
en: This format displays each 32-bit word in hexadecimal (using ASCII characters "0" - "9" and "a" - "f"); words are filled with leading zeros, if required.  For masks longer than one word, a comma separator is used between words.  Words are displayed in big-endian order, which has the most significant bit first.  The hex digits within a word are also in big-endian order.
fr: Ce format affiche chaque mot de 32 bits au format hexadécimal (en utilisant les caractères ASCII « 0 » - « 9 » et « a » - « f ») ; le début des mots est complété par des zéros si nécessaire. Pour les masques de plus d'un mot, une virgule est utilisée pour séparer les mots. Les mots sont affiché au format grand boutiste, avec le bit le plus significatif en premier. Les chiffres hexadécimaux d'un mot utilise aussi l'ordre grand boutiste.

note: type: Plain text
en: The number of 32-bit words displayed is the minimum number needed to display all bits of the bit mask, based on the size of the bit mask.
fr: Le nombre de mots de 32 bits affichés est le nombre minimal nécessaire pour afficher tous les bits du masque, en fonction de la taille du masque de bits.

note: type: Plain text
en: Examples of the B<Mask Format>:
fr: Exemple d'B<Affichage sous forme de masque> :

note: type: Plain text
en: 00000001                        # just bit 0 set
    40000000,00000000,00000000      # just bit 94 set
    00000001,00000000,00000000      # just bit 64 set
    000000ff,00000000               # bits 32-39 set
    00000000,000E3862               # 1,5,6,11-13,17-19 set
fr: 00000001                        # seul le bit 0
    40000000,00000000,00000000      # seul le bit 94
    00000001,00000000,00000000      # seul le bit 64
    000000ff,00000000               # seuls les bits 32-39
    00000000,000E3862               # les bits 1,5,6,11-13,17-19

note: type: Plain text
en: A mask with bits 0, 1, 2, 4, 8, 16, 32, and 64 set displays as:
fr: Un masque avec les bits 0, 1, 2, 4, 8, 16, 32 et 64 activés sera affiché de cette façon :

note: ================== List Format ================== type: Plain text
en: The first "1" is for bit 64, the second for bit 32, the third for bit 16, the fourth for bit 8, the fifth for bit 4, and the "7" is for bits 2, 1, and 0.
fr: Le premier « 1 » correspond au bit 64, le second au bit 32, le troisième au bit 16, le quatrième au bit 8, le cinquième au bit 4 et le « 7 » correspond aux bits 2, 1 et 0.

note: type: SS
en: List format
fr: Affichage sous forme de liste

note: type: Plain text
en: The B<List Format> for I<cpus> and I<mems> is a comma-separated list of CPU or memory-node numbers and ranges of numbers, in ASCII decimal.
fr: L'B<Affichage sous forme de liste> pour les fichiers I<cpus> et I<mems> est une liste de numéros ou intervalles de CPU ou de nœuds mémoire séparés par des virgules, en décimal au format ASCII.

note: type: Plain text
en: Examples of the B<List Format>:
fr: Exemple d'B<Affichage sous forme de liste> :

note: type: Plain text
en: 0-4,9           # bits 0, 1, 2, 3, 4, and 9 set
    0-2,7,12-14     # bits 0, 1, 2, 7, 12, 13, and 14 set
fr: 0-4,9           # bits 0, 1, 2, 3, 4 et 9 activés
    0-2,7,12-14     # bits 0, 1, 2, 7, 12, 13 et 14 activés

note: ================== RULES ================== type: SH
en: RULES
fr: RÈGLES

note: type: Plain text
en: The following rules apply to each cpuset:
fr: Les règles suivantes s'appliquent à chaque cpuset :

note: type: Plain text
en: Its CPUs and memory nodes must be a (possibly equal)  subset of its parent's.
fr: Ses CPU et nœuds mémoire doivent être des sous-ensembles de ceux de leur parent (ou les mêmes ensembles).

note: type: Plain text
en: It can be marked I<cpu_exclusive> only if its parent is.
fr: Il ne peut être marqué avec I<cpu_exclusive> que si son parent l'est.

note: type: Plain text
en: It can be marked I<mem_exclusive> only if its parent is.
fr: Il ne peut être marqué avec I<mem_exclusive> que si son parent l'est.

note: type: Plain text
en: If it is I<cpu_exclusive>, its CPUs may not overlap any sibling.
fr: S'il est marqué avec I<cpu_exclusive>, ses CPU ne doivent pas être partagés avec ses frères.

note: ================== PERMISSIONS ================== type: Plain text
en: If it is I<memory_exclusive>, its memory nodes may not overlap any sibling.
fr: S'il est marqué avec I<memory_exclusive>, ses nœuds mémoire ne doivent pas être partagés avec ses frères.

note: type: Plain text
en: The permissions of a cpuset are determined by the permissions of the directories and pseudo-files in the cpuset filesystem, normally mounted at I</dev/cpuset>.
fr: Les permissions d'un cpuset sont déterminées par les permissions des répertoires et pseudofichiers du système de fichiers cpuset, normalement monté dans I</dev/cpuset>.

note: type: Plain text
en: For instance, a process can put itself in some other cpuset (than its current one) if it can write the I<tasks> file for that cpuset.  This requires execute permission on the encompassing directories and write permission on the I<tasks> file.
fr: Par exemple, un processus peut se placer dans un autre cpuset s'il peut écrire dans le fichier I<tasks> de ce cpuset. Ceci nécessite les permission d'exécution des répertoires à traverser et la permission d'écrire dans le fichier I<tasks>.

note: type: Plain text
en: An additional constraint is applied to requests to place some other process in a cpuset.  One process may not attach another to a cpuset unless it would have permission to send that process a signal (see B<kill>(2)).
fr: Une contrainte supplémentaire s'applique aux demandes de déplacement d'autres processus dans un cpuset. Un processus ne peut pas attacher un autre processus à un cpuset à moins qu'il ait la permission d'envoyer un signal à ce processus (consultez B<kill>(2)).

note: type: Plain text
en: A process may create a child cpuset if it can access and write the parent cpuset directory.  It can modify the CPUs or memory nodes in a cpuset if it can access that cpuset's directory (execute permissions on the each of the parent directories) and write the corresponding I<cpus> or I<mems> file.
fr: Un processus peut créer un cpuset fils s'il a accès et peut écrire dans le répertoire du cpuset père. Il peut modifier les CPU et nœuds mémoire d'un cpuset s'il a accès au répertoire de ce cpuset (les permissions d'exécuter tous les répertoires parents) et s'il peut écrire dans les fichiers correspondants I<cpus> ou I<mems>.

note: type: Plain text
en: There is one minor difference between the manner in which these permissions are evaluated and the manner in which normal filesystem operation permissions are evaluated.  The kernel interprets relative pathnames starting at a process's current working directory.  Even if one is operating on a cpuset file, relative pathnames are interpreted relative to the process's current working directory, not relative to the process's current cpuset.  The only ways that cpuset paths relative to a process's current cpuset can be used are if either the process's current working directory is its cpuset (it first did a B<cd> or B<chdir>(2)  to its cpuset directory beneath I</dev/cpuset>, which is a bit unusual)  or if some user code converts the relative cpuset path to a full filesystem path.
fr: Il y a une petite différence entre la manière dont ces permissions sont évaluées et la manière dont sont évaluées les permissions pour les opérations sur des systèmes de fichiers normaux. Le noyau interprète les chemins relatifs en fonction du répertoire de travail actuel d'un processus. Même quand on opère sur un fichier d'un cpuset, les chemins relatifs sont interprétés en fonction du répertoire de travail du processus, et non pas relativement au cpuset actuel du processus. Les seules façons pour que les chemins de cpusets soient interprétés relativement au cpuset actuel du processus sont soit que le processus utilise le répertoire du cpuset comme répertoire de travail (il a d'abord effectué un B<cd> ou B<chdir>(2) dans le répertoire de son cpuset dans I</dev/cpuset>, ce qui est plutôt inhabituel), soit que du code utilisateur convertit le chemin relatif au cpuset en un chemin absolu.

note: ================== WARNINGS ================== type: Plain text
en: In theory, this means that user code should specify cpusets using absolute pathnames, which requires knowing the mount point of the cpuset filesystem (usually, but not necessarily, I</dev/cpuset>).  In practice, all user level code that this author is aware of simply assumes that if the cpuset filesystem is mounted, then it is mounted at I</dev/cpuset>.  Furthermore, it is common practice for carefully written user code to verify the presence of the pseudo-file I</dev/cpuset/tasks> in order to verify that the cpuset pseudo-filesystem is currently mounted.
fr: En théorie, ceci signifie que le code utilisateur devrait indiquer les cpusets en utilisant des chemins absolus, ce qui nécessite de connaître le point de montage du système de fichier cpuset (d'habitude, mais sans que ce soit nécessaire, I</dev/cpuset>). En pratique, à la connaissance de l'auteur, tous les utilitaires en mode utilisateur supposent que si le système de fichier cpuset est monté, alors il est monté dans I</dev/cpuset>. De plus, une pratique assez courante utilisé pour du code écrit soigneusement consiste à vérifier la présence du pseudofichier I</dev/cpuset/tasks> afin de vérifier que le pseudosystème de fichiers cpuset est bien monté.

note: type: SH
en: WARNINGS
fr: AVERTISSEMENTS

note: type: SS
en: Enabling memory_pressure
fr: Activation de memory_pressure

note: type: Plain text
en: By default, the per-cpuset file I<cpuset.memory_pressure> always contains zero (0).  Unless this feature is enabled by writing "1" to the pseudo-file I</dev/cpuset/cpuset.memory_pressure_enabled>, the kernel does not compute per-cpuset I<memory_pressure>.
fr: Par défaut, le fichier I<cpuset.memory_pressure> d'un cpuset vaut zéro (0). À moins que cette fonctionnalité soit activée en écrivant « 1 » dans le pseudofichier I</dev/cpuset/cpuset.memory_pressure_enabled>, le noyau ne calcule pas les valeurs des fichiers I<memory_pressure> de chaque cpuset.

note: type: SS
en: Using the echo command
fr: Utilisation de la commande echo

note: Gack!  csh(1)'s echo does this type: Plain text
en: When using the B<echo> command at the shell prompt to change the values of cpuset files, beware that the built-in B<echo> command in some shells does not display an error message if the B<write>(2)  system call fails.  For example, if the command:
fr: Lorsque la commande B<echo> est utilisée dans un interpréteur de commandes pour changer les valeurs des fichiers d'un cpuset, soyez conscient que la commande B<echo> interne à certains interpréteurs de commandes n'affiche pas de message d'erreur si l'appel système B<write>(2) échoue. Par exemple, si la commande :

note: type: Plain text
en: failed because memory node 19 was not allowed (perhaps the current system does not have a memory node 19), then the B<echo> command might not display any error.  It is better to use the B</bin/echo> external command to change cpuset file settings, as this command will display B<write>(2)  errors, as in the example:
fr: échoue parce que le nœud mémoire numéro 19 n'est pas autorisé (par exemple le système n'a pas de nœud mémoire numéro 19), alors la commande B<echo> peut n'afficher aucune erreur. If faut mieux utiliser la commande externe B</bin/echo> pour changer la configuration d'un fichier d'un cpuset puisque cette commande affichera les erreurs de B<write>(2), comme par exemple :

note: type: Plain text
en: /bin/echo 19 E<gt> cpuset.mems
    /bin/echo: write error: Invalid argument
fr: /bin/echo 19 E<gt> cpuset.mems
    /bin/echo : erreur d'écriture : argument invalide

note: type: SS
en: Memory placement
fr: Placement mémoire

note: type: Plain text
en: Not all allocations of system memory are constrained by cpusets, for the following reasons.
fr: Les contraintes des cpusets ne s'appliquent pas à toutes les allocations de mémoire système pour les raisons suivantes :

note: type: Plain text
en: If hot-plug functionality is used to remove all the CPUs that are currently assigned to a cpuset, then the kernel will automatically update the I<cpus_allowed> of all processes attached to CPUs in that cpuset to allow all CPUs.  When memory hot-plug functionality for removing memory nodes is available, a similar exception is expected to apply there as well.  In general, the kernel prefers to violate cpuset placement, rather than starving a process that has had all its allowed CPUs or memory nodes taken offline.  User code should reconfigure cpusets to refer only to online CPUs and memory nodes when using hot-plug to add or remove such resources.
fr: Si la fonctionnalité de connexion à chaud est utilisée pour supprimer tous les CPU d'un cpuset, alors le noyau mettra à jour automatiquement la liste de CPU autorisés (I<cpus_allowed>) de tous les processus attachés aux CPU du cpuset et autorisera tous les CPU. Le comportement est similaire lorsque la fonctionnalité de connexion à chaud est utilisée pour la mémoire. En général, le noyau préfère ne pas tenir compte du placement sur les CPU ou les nœuds mémoire plutôt que d'abandonner un processus dont tous les CPU ou nœuds mémoire autorisés sont déconnectés. Le code utilisateur devrait reconfigurer les cpusets pour ne mentionner que les CPU et les nœuds mémoire en ligne lorsque la fonctionnalité de connexion à chaud est utilisée pour ajouter ou retirer ces ressources.

note: type: Plain text
en: A few kernel-critical, internal memory-allocation requests, marked GFP_ATOMIC, must be satisfied immediately.  The kernel may drop some request or malfunction if one of these allocations fail.  If such a request cannot be satisfied within the current process's cpuset, then we relax the cpuset, and look for memory anywhere we can find it.  It's better to violate the cpuset than stress the kernel.
fr: Quelques demandes d'allocation mémoire critiques et internes au noyau, marquées GFP_ATOMIC, doivent être satisfaites immédiatement. Le noyau peut rater des demandes ou ne pas fonctionner correctement si certaines de ces allocations échouent. Si une de ces demandes ne peut être satisfaite par le cpuset du processus en cours, alors les contraintes du cpuset sont relâchées et le noyau recherche de la mémoire là où il peut en trouver. Il est préférable de ne pas respecter un cpuset plutôt que de stresser le noyau.

note: type: Plain text
en: Allocations of memory requested by kernel drivers while processing an interrupt lack any relevant process context, and are not confined by cpusets.
fr: Les allocations de mémoire demandées par des pilotes du noyau lors du traitement d'une interruption ne se trouvent dans le contexte d'aucun processus et ne sont donc pas contraintes par les cpusets.

note: type: SS
en: Renaming cpusets
fr: Renommer des cpusets

note: ================== ERRORS ================== type: Plain text
en: You can use the B<rename>(2)  system call to rename cpusets.  Only simple renaming is supported; that is, changing the name of a cpuset directory is permitted, but moving a directory into a different directory is not permitted.
fr: Vous pouvez utiliser l'appel système B<rename>(2) pour renommer des cpusets. Seuls des renommages simples sont pris en charge ; c'est-à-dire que changer le nom du répertoire d'un cpuset est autorisé, mais déplacer le répertoire d'un cpuset dans un autre répertoire n'est pas autorisé.

note: type: Plain text
en: The Linux kernel implementation of cpusets sets I<errno> to specify the reason for a failed system call affecting cpusets.
fr: L'implémentation des cpusets du noyau Linux positionne I<errno> pour indiquer la raison de l'échec d'un appel système lié à un cpuset.

note: type: Plain text
en: The possible I<errno> settings and their meaning when set on a failed cpuset call are as listed below.
fr: Les valeurs possible pour I<errno> et leurs significations, lors d'un échec d'un appel système lié à un cpuset sont listées ci-dessous :

note: type: Plain text
en: Attempted a B<write>(2)  on a special cpuset file with a length larger than some kernel-determined upper limit on the length of such writes.
fr: Tentative d'écriture (B<write>(2)) dans un fichier spécial d'un cpuset avec une longueur supérieure à la longueur autorisée par le noyau pour ces écritures.

note: type: Plain text
en: Attempted to B<write>(2)  the process ID (PID) of a process to a cpuset I<tasks> file when one lacks permission to move that process.
fr: Tentative d'écriture (B<write>(2)) d'un identifiant de processus (PID) dans le fichier I<tasks> d'un cpuset alors que l'appelant n'est pas autorisé à déplacer le processus.

note: type: Plain text
en: Attempted to add, using B<write>(2), a CPU or memory node to a cpuset, when that CPU or memory node was not already in its parent.
fr: Tentative d'ajout, avec B<write>(2), d'un CPU ou d'un nœud mémoire dans un cpuset alors que ce CPU ou ce nœud mémoire ne se trouve pas dans le cpuset parent.

note: type: Plain text
en: Attempted to set, using B<write>(2), I<cpuset.cpu_exclusive> or I<cpuset.mem_exclusive> on a cpuset whose parent lacks the same setting.
fr: Tentative d'activation, avec B<write>(2), de I<cpuset.cpu_exclusive> ou de I<cpuset.mem_exclusive> sur un cpuset dont le parent n'a pas ces propriétés.

note: type: Plain text
en: Attempted to B<write>(2)  a I<cpuset.memory_pressure> file.
fr: Tentative d'écriture (B<write>(2)) dans un fichier I<cpuset.memory_pressure>.

note: type: Plain text
en: Attempted to create a file in a cpuset directory.
fr: Tentative de création d'un fichier dans le répertoire d'un cpuset.

note: type: Plain text
en: Attempted to remove, using B<rmdir>(2), a cpuset with attached processes.
fr: Tentative de suppression, avec B<rmdir>(2), d'un cpuset auquel sont attachés des processus.

note: type: Plain text
en: Attempted to remove, using B<rmdir>(2), a cpuset with child cpusets.
fr: Tentative de suppression, avec B<rmdir>(2), d'un cpuset ayant des ensembles de CPU fils.

note: type: Plain text
en: Attempted to remove a CPU or memory node from a cpuset that is also in a child of that cpuset.
fr: Tentative de suppression d'un CPU ou d'un nœud mémoire d'un cpuset alors que le CPU ou le nœud mémoire se trouve également dans un des fils du cpuset.

note: type: Plain text
en: Attempted to create, using B<mkdir>(2), a cpuset that already exists.
fr: Tentative de création, avec B<mkdir>(2), d'un cpuset qui existe déjà.

note: type: Plain text
en: Attempted to B<rename>(2)  a cpuset to a name that already exists.
fr: Tentative de renommage (B<rename>(2)) d'un cpuset avec un nom déjà utilisé.

note: type: Plain text
en: Attempted to B<read>(2)  or B<write>(2)  a cpuset file using a buffer that is outside the writing processes accessible address space.
fr: Tentative de lecture (B<read>(2)) ou d'écriture (B<write>(2)) dans un fichier d'un cpuset en utilisant un tampon en dehors de l'espace mémoire accessible par le processus appelant.

note: type: Plain text
en: Attempted to change a cpuset, using B<write>(2), in a way that would violate a I<cpu_exclusive> or I<mem_exclusive> attribute of that cpuset or any of its siblings.
fr: Tentative de modification d'un cpuset, en utilisant B<write>(2), de telle sorte que les attributs I<cpu_exclusive> ou I<mem_exclusive> ne soient plus respectés pour ce cpuset ou ses frères.

note: type: Plain text
en: Attempted to B<write>(2)  an empty I<cpuset.cpus> or I<cpuset.mems> list to a cpuset which has attached processes or child cpusets.
fr: Tentative d'écriture (avec B<write>(2)) d'une liste vide dans I<cpuset.cpus> ou I<cpuset.mems> pour un cpuset auquel sont déjà attachés des processus ou des cpuset fils.

note: type: Plain text
en: Attempted to B<write>(2)  a I<cpuset.cpus> or I<cpuset.mems> list which included a range with the second number smaller than the first number.
fr: Tentative d'écriture (avec B<write>(2)) dans I<cpuset.cpus> ou I<cpuset.mems> d'une liste qui comprend un intervalle dont la borne supérieure est inférieure à la borne inférieure.

note: type: Plain text
en: Attempted to B<write>(2)  a I<cpuset.cpus> or I<cpuset.mems> list which included an invalid character in the string.
fr: Tentative d'écriture (avec B<write>(2)) dans I<cpuset.cpus> ou I<cpuset.mems> d'une liste dont la chaîne comprend un caractère non valable.

note: type: Plain text
en: Attempted to B<write>(2)  a list to a I<cpuset.cpus> file that did not include any online CPUs.
fr: Tentative d'écriture (avec B<write>(2)) dans le fichier I<cpuset.cpus> d'une liste qui ne comprend aucun CPU en ligne.

note: type: Plain text
en: Attempted to B<write>(2)  a list to a I<cpuset.mems> file that did not include any online memory nodes.
fr: Tentative d'écriture (avec B<write>(2)) dans le fichier I<cpuset.mems> d'une liste qui ne comprend aucun nœud mémoire en ligne.

note: type: Plain text
en: Attempted to B<write>(2)  a list to a I<cpuset.mems> file that included a node that held no memory.
fr: Tentative d'écriture (avec B<write>(2)) dans le fichier I<cpuset.mems> d'une liste qui comprend un nœud qui ne contient pas de mémoire.

note: type: Plain text
en: Attempted to B<write>(2)  a string to a cpuset I<tasks> file that does not begin with an ASCII decimal integer.
fr: Tentative d'écriture (avec B<write>(2)) dans le fichier I<tasks> d'un cpuset d'une chaîne qui ne commence pas par un entier décimal au format ASCII.

note: type: Plain text
en: Attempted to B<rename>(2)  a cpuset into a different directory.
fr: Tentative de renommage (avec B<rename>(2)) d'un cpuset dans un autre répertoire.

note: type: Plain text
en: Attempted to B<read>(2)  a I</proc/E<lt>pidE<gt>/cpuset> file for a cpuset path that is longer than the kernel page size.
fr: Tentative de lecture (avec B<read>(2)) du fichier I</proc/E<lt>pidE<gt>/cpuset> d'un cpuset, pour lequel le chemin est plus long que la taille des pages du noyau.

note: type: Plain text
en: Attempted to create, using B<mkdir>(2), a cpuset whose base directory name is longer than 255 characters.
fr: Tentative de création, avec B<mkdir>(2), d'un cpuset dont le nom du répertoire de base fait plus de 255 caractères.

note: type: Plain text
en: Attempted to create, using B<mkdir>(2), a cpuset whose full pathname, including the mount point (typically "/dev/cpuset/") prefix, is longer than 4095 characters.
fr: Tentative de création, avec B<mkdir>(2), d'un cpuset dont le chemin complet, préfixe du point de montage compris (typiquement « /dev/cpuset/ »), fait plus de 4095 caractères.

note: type: Plain text
en: The cpuset was removed by another process at the same time as a B<write>(2)  was attempted on one of the pseudo-files in the cpuset directory.
fr: Le cpuset a été supprimé par un autre processus en même temps qu'une tentative d'écriture (avec B<write>(2)) sur un des pseudofichiers du répertoire du cpuset.

note: type: Plain text
en: Attempted to create, using B<mkdir>(2), a cpuset in a parent cpuset that doesn't exist.
fr: Tentative de création, avec B<mkdir>(2), d'un cpuset dans un cpuset parent qui n'existe pas.

note: type: Plain text
en: Attempted to B<access>(2)  or B<open>(2)  a nonexistent file in a cpuset directory.
fr: Tentative d'accéder à (avec B<access>(2)) ou d'ouvrir (avec B<open>(2)) un fichier inexistant du répertoire d'un cpuset.

note: type: Plain text
en: Insufficient memory is available within the kernel; can occur on a variety of system calls affecting cpusets, but only if the system is extremely short of memory.
fr: Pas assez de mémoire disponible pour le noyau ; ceci peut se produire pour différents appels système liés aux cpusets, mais seulement si le système manque beaucoup de mémoire.

note: type: Plain text
en: Attempted to B<write>(2)  the process ID (PID)  of a process to a cpuset I<tasks> file when the cpuset had an empty I<cpuset.cpus> or empty I<cpuset.mems> setting.
fr: Tentative d'écriture (avec B<write>(2)) de l'identifiant d'un processus dans le fichier I<tasks> d'un cpuset alors que les fichiers I<cpuset.cpus> ou I<cpuset.mems> sont vides.

note: type: Plain text
en: Attempted to B<write>(2)  an empty I<cpuset.cpus> or I<cpuset.mems> setting to a cpuset that has tasks attached.
fr: Tentative d'écriture (avec B<write>(2)) d'un fichier I<cpuset.cpus> ou I<cpuset.mems> vide dans un cpuset auquel sont attachées des tâches.

note: type: Plain text
en: Attempted to B<rename>(2)  a nonexistent cpuset.
fr: Tentative de renommage (avec B<rename>(2)) d'un cpuset qui n'existe pas.

note: type: Plain text
en: Attempted to remove a file from a cpuset directory.
fr: Tentative de suppression d'un fichier dans le répertoire d'un cpuset.

note: type: Plain text
en: Specified a I<cpuset.cpus> or I<cpuset.mems> list to the kernel which included a number too large for the kernel to set in its bit masks.
fr: Une liste pour I<cpuset.cpus> ou I<cpuset.mems> a été fournie au noyau mais comprend un nombre trop grand pour que le noyau l'ajoute à son champ de bits.

note: ================== VERSIONS ================== type: Plain text
en: Attempted to B<write>(2)  the process ID (PID) of a nonexistent process to a cpuset I<tasks> file.
fr: Tentative d'écriture (avec B<write>(2)) de l'identifiant d'un processus inexistant dans le fichier I<tasks> d'un cpuset.

note: ================== NOTES ================== type: Plain text
en: Cpusets appeared in version 2.6.12 of the Linux kernel.
fr: Les cpusets sont apparus dans la version 2.6.12 du noyau Linux.

note: ================== BUGS ================== type: Plain text
en: Despite its name, the I<pid> parameter is actually a thread ID, and each thread in a threaded group can be attached to a different cpuset.  The value returned from a call to B<gettid>(2)  can be passed in the argument I<pid>.
fr: Contrairement à ce que son nom indique, le paramètre I<pid> est en fait un identifiant de thread. Chaque thread d'un groupe de threads peut être attaché un cpuset différent. La valeur renvoyée par un appel à B<gettid>(2) peut être fournie comme paramètre I<pid>.

note: type: SH
en: BUGS
fr: BOGUES

note: ================== EXAMPLE ================== type: Plain text
en: I<cpuset.memory_pressure> cpuset files can be opened for writing, creation, or truncation, but then the B<write>(2)  fails with I<errno> set to B<EACCES>, and the creation and truncation options on B<open>(2)  have no effect.
fr: Les fichiers I<cpuset.memory_pressure> peuvent être ouverts en écriture en demandant une création ou troncature, mais dans ce cas B<write>(2) échouera en positionnant I<errno> à B<EACCES>, et les options de création ou de troncature de B<open>(2) n'ont aucun effet.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The following examples demonstrate querying and setting cpuset options using shell commands.
fr: Voici des exemples pour l'affichage et la modification d'options d'un cpuset à l'aide d'un interpréteur de commandes.

note: type: SS
en: Creating and attaching to a cpuset.
fr: Créer et s'attacher à un cpuset.

note: type: Plain text
en: To create a new cpuset and attach the current command shell to it, the steps are:
fr: Voici les étapes pour créer un nouveau cpuset et lui attacher l'interpréteur de commandes en cours :

note: type: Plain text
en: mkdir /dev/cpuset (if not already done)
fr: mkdir /dev/cpuset (si ce n'est déjà fait)

note: type: Plain text
en: mount -t cpuset none /dev/cpuset (if not already done)
fr: mount -t cpuset none /dev/cpuset (si ce n'est déjà fait)

note: type: Plain text
en: Create the new cpuset using B<mkdir>(1).
fr: Créer un nouveau cpuset avec B<mkdir>(1).

note: type: Plain text
en: Assign CPUs and memory nodes to the new cpuset.
fr: Assigner des CPU et nœuds mémoire au nouveau cpuset.

note: type: Plain text
en: Attach the shell to the new cpuset.
fr: Attacher l'interpréteur de commandes au nouveau cpuset.

note: type: Plain text
en: For example, the following sequence of commands will set up a cpuset named "Charlie", containing just CPUs 2 and 3, and memory node 1, and then attach the current shell to that cpuset.
fr: Par exemple, la séquence de commandes suivante définira un cpuset appelé « Charlie », ne contenant que les CPU 2 et 3 et le nœud mémoire 1, et attachera l'interpréteur de commandes en cours à ce cpuset.

note: type: Plain text
en: $B< mkdir /dev/cpuset>
    $B< mount -t cpuset cpuset /dev/cpuset>
    $B< cd /dev/cpuset>
    $B< mkdir Charlie>
    $B< cd Charlie>
    $B< /bin/echo 2-3 E<gt> cpuset.cpus>
    $B< /bin/echo 1 E<gt> cpuset.mems>
    $B< /bin/echo $$ E<gt> tasks>
    # The current shell is now running in cpuset Charlie
    # The next line should display '/Charlie'
    $B< cat /proc/self/cpuset>
fr: $B< mkdir /dev/cpuset>
    $B< mount -t cpuset cpuset /dev/cpuset>
    $B< cd /dev/cpuset>
    $B< mkdir Charlie>
    $B< cd Charlie>
    $B< /bin/echo 2-3 E<gt> cpuset.cpus>
    $B< /bin/echo 1 E<gt> cpuset.mems>
    $B< /bin/echo $$ E<gt> tasks>
    # Le shell en cours s'exécute désormais dans le cpuset Charlie
    # La ligne suivante devrait afficher « /Charlie »
    $B< cat /proc/self/cpuset>

note: type: SS
en: Migrating a job to different memory nodes.
fr: Déplacer des tâches sur d'autres nœuds mémoire.

note: type: Plain text
en: To migrate a job (the set of processes attached to a cpuset)  to different CPUs and memory nodes in the system, including moving the memory pages currently allocated to that job, perform the following steps.
fr: Pour déplacer les tâches attachées à un cpuset sur d'autres CPU et d'autres nœuds mémoire du système et déplacer les pages mémoires actuellement allouées par ces processus, effectuez les étapes suivantes :

note: type: Plain text
en: Let's say we want to move the job in cpuset I<alpha> (CPUs 4-7 and memory nodes 2-3) to a new cpuset I<beta> (CPUs 16-19 and memory nodes 8-9).
fr: Supposons qu'il faille déplacer les tâches du cpuset I<alpha> (les CPU 4-7 et nœuds mémoire 2-3) vers un autre cpuset I<beta> (CPU 16-19 et nœuds mémoire 8-9).

note: type: Plain text
en: First create the new cpuset I<beta>.
fr: Créer d'abord le nouveau cpuset I<beta>.

note: type: Plain text
en: Then allow CPUs 16-19 and memory nodes 8-9 in I<beta>.
fr: Autoriser les CPU 16-19 et les nœuds mémoire 8-9 pour I<beta>.

note: type: Plain text
en: Then enable I<memory_migration> in I<beta>.
fr: Activer I<memory_migration> dans I<beta>.

note: type: Plain text
en: Then move each process from I<alpha> to I<beta>.
fr: Déplacer chaque tâche d'I<alpha> vers I<beta>.

note: type: Plain text
en: The following sequence of commands accomplishes this.
fr: La séquence de commandes suivante effectue cela.

note: type: Plain text
en: The above should move any processes in I<alpha> to I<beta>, and any memory held by these processes on memory nodes 2-3 to memory nodes 8-9, respectively.
fr: La séquence ci-dessus déplace tous les processus de I<alpha> vers I<beta> et déplace toute mémoire utilisée par ces processus sur les nœuds mémoire 2-3 vers les nœuds mémoire 8-9.

note: type: Plain text
en: Notice that the last step of the above sequence did not do:
fr: Notez que la dernière étape de la séquence ci-dessus n'était pas :

note: type: Plain text
en: The I<while> loop, rather than the seemingly easier use of the B<cp>(1)  command, was necessary because only one process PID at a time may be written to the I<tasks> file.
fr: La boucle I<while>, plutôt que l'utilisation de la commande B<cp>(1), est nécessaire par ce qu'un seul identifiant de processus à la fois peut être écrit dans le fichier I<tasks>.

note: type: Plain text
en: The same effect (writing one PID at a time) as the I<while> loop can be accomplished more efficiently, in fewer keystrokes and in syntax that works on any shell, but alas more obscurely, by using the B<-u> (unbuffered) option of B<sed>(1):
fr: La même chose (l'écriture d'un PID à la fois) peut se faire plus efficacement qu'avec la boucle I<while>, en moins de caractère et dans une syntaxe qui fonctionne avec tous les interpréteurs de commandes mais malheureusement de façon moins intelligible, en utilisant l'option B<-u> (sans tampon) de B<sed>(1) :

note: type: Plain text
en: I<Documentation/cpusets.txt> in the Linux kernel source tree
fr: I<Documentation/cpusets.txt> dans les sources du noyau Linux

note: type: TH
en: 2013-12-27
fr: 27 décembre 2013

note: type: Plain text
en: credentials - process identifiers
fr: credentials - Identifiants de processus

note: type: SS
en: Process ID (PID)
fr: Identifiant de processus (PID)

note: type: Plain text
en: Each process has a unique nonnegative integer identifier that is assigned when the process is created using B<fork>(2).  A process can obtain its PID using B<getpid>(2).  A PID is represented using the type I<pid_t> (defined in I<E<lt>sys/types.hE<gt>>).
fr: Chaque processus a un identifiant entier positif, qui lui est attribué à sa création (avec B<fork>(2)). Un processus peut connaître son PID avec B<getpid>(2). Un PID est représenté par le type I<pid_t> (défini dans I<E<lt>sys/types.hE<gt>>).

note: .BR sched_rr_get_interval (2), .BR sched_getaffinity (2), .BR sched_setaffinity (2), .BR sched_getparam (2), .BR sched_setparam (2), .BR sched_setscheduler (2), .BR sched_getscheduler (2), .BR getsid (2), .BR waitid (2), .BR wait4 (2), type: Plain text
en: PIDs are used in a range of system calls to identify the process affected by the call, for example: B<kill>(2), B<ptrace>(2), B<setpriority>(2)  B<setpgid>(2), B<setsid>(2), B<sigqueue>(3), and B<waitpid>(2).
fr: Les PID sont utilisés dans un certain nombre d'appels système pour identifier le processus affecté, par exemple\ : B<kill>(2), B<ptrace>(2), B<setpriority>(2), B<setpgid>(2), B<setsid>(2), B<sigqueue>(3) et B<waitpid>(2).

note: type: Plain text
en: A process's PID is preserved across an B<execve>(2).
fr: Le PID d'un processus est conservé travers d'un B<execve>(2).

note: type: SS
en: Parent process ID (PPID)
fr: Identifiant du processus père (PPID)

note: type: Plain text
en: A process's parent process ID identifies the process that created this process using B<fork>(2).  A process can obtain its PPID using B<getppid>(2).  A PPID is represented using the type I<pid_t>.
fr: L'identifiant de processus père d'un processus identifie le processus qui l'a créé avec B<fork>(2). Un processus peut connaître son PPID avec B<getppid>(2). Un PPID est représenté à l'aide du type I<pid_t>.

note: type: Plain text
en: A process's PPID is preserved across an B<execve>(2).
fr: Le PPID d'un processus est conservé au travers d'un B<execve>(2).

note: type: SS
en: Process group ID and session ID
fr: Identifiant de groupe de processus et identifiant de session

note: type: Plain text
en: Each process has a session ID and a process group ID, both represented using the type I<pid_t>.  A process can obtain its session ID using B<getsid>(2), and its process group ID using B<getpgrp>(2).
fr: Chaque processus a un identifiant de session et un identifiant de groupe de processus, tous deux représentés par le type I<pid_t>. Un processus peut connaître son identifiant de session avec B<getsid>(2), et son identifiant de groupe de processus avec B<getpgrp>(2).

note: type: Plain text
en: A child created by B<fork>(2)  inherits its parent's session ID and process group ID.  A process's session ID and process group ID are preserved across an B<execve>(2).
fr: Un processus créé par B<fork>(2) hérite de l'identifiant de session et de l'identifiant de groupe de processus de son père. Les identifiants de session et de groupe de processus sont préservés par B<execve>(2).

note: type: Plain text
en: Sessions and process groups are abstractions devised to support shell job control.  A process group (sometimes called a "job") is a collection of processes that share the same process group ID; the shell creates a new process group for the process(es) used to execute single command or pipeline (e.g., the two processes created to execute the command "ls\ |\ wc" are placed in the same process group).  A process's group membership can be set using B<setpgid>(2).  The process whose process ID is the same as its process group ID is the I<process group leader> for that group.
fr: Les sessions et les groupes de processus sont des abstractions destinées à aider le contrôle des tâches dans le shell. Un groupe de processus (parfois appelé «\ tâche\ ») est un ensemble de processus ayant le même identifiant de groupe de processus\ ; le shell crée un nouveau groupe de processus pour exécuter une commande ou pipeline (par exemple, les deux processus créés pour exécuter la commande «\ ls\ |\ wc\ » sont placés dans le même groupe de processus). L'appartenance à un groupe de processus peut être changée avec B<setpgid>(2). Le processus dont le PID est égal à son identifiant de groupe de processus est le I<leader du groupe de processus>.

note: type: Plain text
en: A session is a collection of processes that share the same session ID.  All of the members of a process group also have the same session ID (i.e., all of the members of a process group always belong to the same session, so that sessions and process groups form a strict two-level hierarchy of processes.)  A new session is created when a process calls B<setsid>(2), which creates a new session whose session ID is the same as the PID of the process that called B<setsid>(2).  The creator of the session is called the I<session leader>.
fr: Une session est un ensemble de processus ayant le même identifiant de session. Tous les membres d'un groupe de processus ont également le même identifiant de session (tous les membres d'un groupe de processus appartiennent à la même session, donc les sessions et les groupes de processus forment une hiérarchie à deux niveaux). Une nouvelle session est créée lorsqu'un processus appelle B<setsid>(2), qui crée une nouvelle session dont l'identifiant est le PID de ce processus. Le créateur de cette session est appelé I<leader de session>.

note: type: Plain text
en: All of the processes in a session share a I<controlling terminal>.  The controlling terminal is established when the session leader first opens a terminal (unless the B<O_NOCTTY> flag is specified when calling B<open>(2)).  A terminal may be the controlling terminal of at most one session.
fr: Tous les processus d'une session partagent un I<terminal de contrôle>. Le terminal de contrôle est créé lorsque le leader de session ouvre un terminal pour la première fois (sauf si le paramètre B<O_NOCTTY> est précisé lors de l'appel de B<open>(2)). Un terminal ne peut être le terminal de contrôle que d'une seule session.

note: type: Plain text
en: At most one of the jobs in a session may be the I<foreground job>; other jobs in the session are I<background jobs>.  Only the foreground job may read from the terminal; when a process in the background attempts to read from the terminal, its process group is sent a B<SIGTTIN> signal, which suspends the job.  If the B<TOSTOP> flag has been set for the terminal (see B<termios>(3)), then only the foreground job may write to the terminal; writes from background job cause a B<SIGTTOU> signal to be generated, which suspends the job.  When terminal keys that generate a signal (such as the I<interrupt> key, normally control-C)  are pressed, the signal is sent to the processes in the foreground job.
fr: Il ne peut y avoir plus d'une tâche ayant la place de « tâche de premier plan » ; les autres tâches de la sessions sont des « tâches d'arrière plan ». Seul la tâche de premier plan peut recevoir des informations depuis le terminal ; si un job d'arrière plan tente de recevoir des informations du terminal, le signal B<SIGTTIN> est renvoyé au groupe du processus, ce qui a pour effet de suspendre la tâche. Si le terminal a reçu l'attribut B<TOSTOP> (consultez B<termios>(3)), alors seule la tâche de premier plan est autorisée à afficher des données dans le terminal ; l'envoi de données d'une tâche d'arrière plan vers le terminal déclenche un signal B<SIGTTOU>, ce qui a pour effet de suspendre la tâche. Lorsqu'une touche du clavier qui génère un signal est enfoncée (par exemple la touche I<interrupt>, qui provoque normalement un control-C), le signal est envoyé au processus de premier plan.

note: type: Plain text
en: Various system calls and library functions may operate on all members of a process group, including B<kill>(2), B<killpg>(2), B<getpriority>(2), B<setpriority>(2), B<ioprio_get>(2), B<ioprio_set>(2), B<waitid>(2), and B<waitpid>(2).  See also the discussion of the B<F_GETOWN>, B<F_GETOWN_EX>, B<F_SETOWN>, and B<F_SETOWN_EX> operations in B<fcntl>(2).
fr: Divers appels système ou fonctions de bibliothèque peuvent agir sur tous les membres d'un groupe de processus, notamment B<kill>(2), B<killpg>(2), B<getpriority>(2), B<setpriority>(2), B<ioprio_get>(2), B<ioprio_set>(2), B<waitid>(2) et B<waitpid>(2).  Consultez également la discussion au sujet de B<F_GETOWN>, B<F_GETOWN_EX>, B<F_SETOWN> et les opérations B<F_SETOWN_EX> de B<fcntl>(2).

note: type: SS
en: User and group identifiers
fr: Identifiants d'utilisateur et de groupe

note: type: Plain text
en: Each process has various associated user and groups IDs.  These IDs are integers, respectively represented using the types I<uid_t> and I<gid_t> (defined in I<E<lt>sys/types.hE<gt>>).
fr: Chaque processus a un certain nombre d'identifiants d'utilisateur et de groupe. Ces identifiants sont des entiers représentés respectivement avec les types I<uid_t> et I<gid_t> (définis dans I<E<lt>sys/types.hE<gt>>).

note: type: Plain text
en: On Linux, each process has the following user and group identifiers:
fr: Sous Linux, chaque processus a les identifiants d'utilisateur et de groupe suivants\ :

note: type: Plain text
en: Real user ID and real group ID.  These IDs determine who owns the process.  A process can obtain its real user (group) ID using B<getuid>(2)  (B<getgid>(2)).
fr: Identifiant d'utilisateur réel et identifiant de groupe réel. Ces identifiants déterminent le propriétaire du processus. Un processus peut déterminer ses UID et GID réels avec B<getuid>(2) et B<getgid>(2).

note: type: Plain text
en: Effective user ID and effective group ID.  These IDs are used by the kernel to determine the permissions that the process will have when accessing shared resources such as message queues, shared memory, and semaphores.  On most UNIX systems, these IDs also determine the permissions when accessing files.  However, Linux uses the filesystem IDs described below for this task.  A process can obtain its effective user (group) ID using B<geteuid>(2)  (B<getegid>(2)).
fr: UID effectif et GID effectif. Ces identifiants sont utilisés par le noyau pour déterminer les permissions de ce processus lors d'accès à des ressources partagées telles que les files de messages, la mémoire partagée ou les sémaphores. Sur la plupart des systèmes UNIX, ces identifiants déterminent aussi les permissions d'accès aux fichiers. Cependant, Linux utilise l'identifiant d'utilisateur du système de fichiers (décrit ci\(hydessous) pour cette tâche. Un processus peut déterminer son UID (GID) effectif avec B<geteuid>(2) (B<getegid>(2)).

note: type: Plain text
en: Saved set-user-ID and saved set-group-ID.  These IDs are used in set-user-ID and set-group-ID programs to save a copy of the corresponding effective IDs that were set when the program was executed (see B<execve>(2)).  A set-user-ID program can assume and drop privileges by switching its effective user ID back and forth between the values in its real user ID and saved set-user-ID.  This switching is done via calls to B<seteuid>(2), B<setreuid>(2), or B<setresuid>(2).  A set-group-ID program performs the analogous tasks using B<setegid>(2), B<setregid>(2), or B<setresgid>(2).  A process can obtain its saved set-user-ID (set-group-ID) using B<getresuid>(2)  (B<getresgid>(2)).
fr: UID sauvé et GID sauvé. Ces identifiants sont utilisés dans les programmes set-user-ID et set-group-ID pour sauvegarder une copie des identifiants effectifs correspondants lors de l'exécution du programme (consultez B<execve>(2)). Un programme set-user-ID peut prendre et abandonner des privilèges en changeant son UID effectif entre les valeurs de ses UID réel et sauvé. Cet échange est réalisé par les appels système B<seteuid>(2), B<setreuid>(2) ou B<setresuid>(2). Un programme set-group-ID peut effectuer les opérations correspondantes avec B<setegid>(2), B<setregid>(2) ou B<setresgid>(2). Un processus peut obtenir son UID (resp.\ GID) sauvé avec B<getresuid>(2) (resp.\ B<getresgid>(2)).

note: type: Plain text
en: Filesystem user ID and filesystem group ID (Linux-specific).  These IDs, in conjunction with the supplementary group IDs described below, are used to determine permissions for accessing files; see B<path_resolution>(7)  for details.  Whenever a process's effective user (group) ID is changed, the kernel also automatically changes the filesystem user (group) ID to the same value.  Consequently, the filesystem IDs normally have the same values as the corresponding effective ID, and the semantics for file-permission checks are thus the same on Linux as on other UNIX systems.  The filesystem IDs can be made to differ from the effective IDs by calling B<setfsuid>(2)  and B<setfsgid>(2).
fr: UID et GID du système de fichiers (spécifiques à Linux). Ces identifiants, ainsi que les identifiants de groupe additionnels décrits plus bas, sont utilisés pour déterminer les permissions d'accès aux fichiers\ ; consultez B<path_resolution>(7) pour plus de détails. Lorsque l'UID (ou GID) effectif d'un processus est modifié, le noyau définit automatiquement l'UID (ou GID) du système de fichiers à la même valeur. Ainsi, les identifiants du système de fichiers sont en général égaux aux identifiants effectifs, et la sémantique des vérifications de permissions sont les mêmes sous Linux et sous les autres UNIX. Les identifiants du système de fichiers peuvent prendre une valeur différente des identifiants effectifs en utilisant les appels B<setfsuid>(2) et B<setfsgid>(2).

note: Since kernel 2.6.4, the limit is visible via the read-only file /proc/sys/kernel/ngroups_max. As at 2.6.22-rc2, this file is still read-only. type: Plain text
en: Supplementary group IDs.  This is a set of additional group IDs that are used for permission checks when accessing files and other shared resources.  On Linux kernels before 2.6.4, a process can be a member of up to 32 supplementary groups; since kernel 2.6.4, a process can be a member of up to 65536 supplementary groups.  The call I<sysconf(_SC_NGROUPS_MAX)> can be used to determine the number of supplementary groups of which a process may be a member.  A process can obtain its set of supplementary group IDs using B<getgroups>(2), and can modify the set using B<setgroups>(2).
fr: GID additionnels. Il s'agit d'un ensemble d'identifiants de groupe qui sont utilisés pour les vérifications de permissions d'accès aux fichiers et autres ressources partagées. Sous les noyaux antérieurs à 2.6.4, un processus pouvait avoir jusqu'à 32 groupes additionnels\ ; depuis le noyau 2.6.4, cette limite est de 65536 groupes additionnels. L'appel I<sysconf(_SC_NGROUPS_MAX)> peut être utilisé pour déterminer le nombre de groupes additionnels auxquels un processus peut appartenir. Un processus peut consultez son ensemble de GID additionnels avec B<getgroups>(2), et le modifier avec B<setgroups>(2).

note: type: Plain text
en: A child process created by B<fork>(2)  inherits copies of its parent's user and groups IDs.  During an B<execve>(2), a process's real user and group ID and supplementary group IDs are preserved; the effective and saved set IDs may be changed, as described in B<execve>(2).
fr: Un processus fils créé par B<fork>(2) hérite des copies des UID et GID de son père. Lors d'un B<execve>(2), les UID et GID réels ainsi que les GID supplémentaires sont préservés\ ; les identifiants effectifs et sauvés peuvent être modifiés comme indiqué dans B<execve>(2).

note: type: Plain text
en: Aside from the purposes noted above, a process's user IDs are also employed in a number of other contexts:
fr: En dehors des contextes décrits ci\(hydessus, les UID d'un processus sont également utilisés dans les cas suivants\ :

note: type: Plain text
en: when determining the permissions for sending signals\(emsee B<kill>(2);
fr: lors de la vérification des permissions pour l'envoi de signaux \(em consultez B<kill>(2)\ ;

note: type: Plain text
en: when determining the permissions for setting process-scheduling parameters (nice value, real time scheduling policy and priority, CPU affinity, I/O priority) using B<setpriority>(2), B<sched_setaffinity>(2), B<sched_setscheduler>(2), B<sched_setparam>(2), and B<ioprio_set>(2);
fr: lors de la vérification des permissions pour la modification des paramètres d'ordonnancement (politesse, politique et priorité d'ordonnancement temps\(hyréel, priorité d'E/S) avec B<setpriority>(2), B<sched_setaffinity>(2), B<sched_setscheduler>(2), B<sched_setparam>(2) et B<ioprio_set>(2)\ ;

note: type: Plain text
en: when checking resource limits; see B<getrlimit>(2);
fr: lors de la vérification de limites de ressources\ ; consultez B<getrlimit>(2)\ ;

note: type: Plain text
en: when checking the limit on the number of inotify instances that the process may create; see B<inotify>(7).
fr: lorsque la limite du nombre d'instances inotify que le processus peut créer est vérifiée\ ; consultez B<inotify>(7).

note: type: Plain text
en: Process IDs, parent process IDs, process group IDs, and session IDs are specified in POSIX.1-2001.  The real, effective, and saved set user and groups IDs, and the supplementary group IDs, are specified in POSIX.1-2001.  The filesystem user and group IDs are a Linux extension.
fr: Les PID, PPID, PGID et SID sont spécifiés dans POSIX.1-2001. Les identifiants réels, effectifs et sauvés, et les identifiants de groupe additionnels sont spécifiés dans POSIX.1-2001. Les identifiants du système de fichiers sont une extension Linux.

note: type: Plain text
en: The POSIX threads specification requires that credentials are shared by all of the threads in a process.  However, at the kernel level, Linux maintains separate user and group credentials for each thread.  The NPTL threading implementation does some work to ensure that any change to user or group credentials (e.g., calls to B<setuid>(2), B<setresuid>(2))  is carried through to all of the POSIX threads in a process.
fr: La spécification POSIX des threads demande que les identifiants soient partagés par tous les threads d'un processus. Toutefois, au niveau du noyau, Linux maintient des identifiants d'utilisateurs et de groupes séparés pour chaque thread. L'implémentation des threads NPTL effectue un certain travail pour s'assurer que toute modification d'identifiants d'utilisateur ou de groupe (par exemple, via des appels à B<setuid>(2) ou B<setresuid>(2)) soit propagée vers tous les threads POSIX d'un processus.

note: type: TH
en: 2010-11-22
fr: 22 novembre 2010

note: type: Plain text
en: getgid, getegid - get group identity
fr: getgid, getegid - Obtenir l'identifiant du groupe

note: type: Plain text
en: B<getgid>()  returns the real group ID of the calling process.
fr: B<getgid>() retourne le GID réel du processus appelant.

note: type: Plain text
en: B<getegid>()  returns the effective group ID of the calling process.
fr: B<getegid>() retourne le GID effectif du processus appelant.

note: type: Plain text
en: These functions are always successful.
fr: Ces fonctions réussissent toujours.

note: type: Plain text
en: POSIX.1-2001, 4.3BSD.
fr: POSIX.1-2001, BSD\ 4.3.

note: type: Plain text
en: The original Linux B<getgid>()  and B<getegid>()  system calls supported only 16-bit group IDs.  Subsequently, Linux 2.4 added B<getgid32>()  and B<getegid32>(), supporting 32-bit IDs.  The glibc B<getgid>()  and B<getegid>()  wrapper functions transparently deal with the variations across kernel versions.
fr: Les appels système B<getgid>() et B<getegid>() originaux de Linux ne géraient que des identifiants de groupe sur 16 bits. En conséquence, Linux 2.4 a ajouté B<getgid32>() et B<getegid32>() qui prennent en charge des identifiants 32 bits. Les fonctions B<getgid>() et B<getegid>() de la glibc qui les encapsulent gèrent de manière transparente ces différences entre noyaux.

note: type: TH
en: 2013-10-18
fr: 18 octobre 2013

note: type: Plain text
en: getgroups, setgroups - get/set list of supplementary group IDs
fr: getgroups, setgroups - Lire et écrire la liste des groupes supplémentaires d'un processus

note: type: Plain text
en: B<setgroups>(): _BSD_SOURCE
fr: B<setgroups>() : _BSD_SOURCE

note: type: Plain text
en: B<getgroups>()  returns the supplementary group IDs of the calling process in I<list>.  The argument I<size> should be set to the maximum number of items that can be stored in the buffer pointed to by I<list>.  If the calling process is a member of more than I<size> supplementary groups, then an error results.  It is unspecified whether the effective group ID of the calling process is included in the returned list.  (Thus, an application should also call B<getegid>(2)  and add or remove the resulting value.)
fr: B<getgroups>() renvoie dans la liste I<list> les identifiants des groupes additionnels du processus appelant. Le paramètre I<size> doit indiquer le nombre maximal d'éléments qui peuvent être stockés dans le tampon pointé par I<list>. Si le processus appelant a plus que I<size> groupes additionnels, cela génère une erreur. Il n'est pas spécifié si l'identifiant du groupe effectif du processus appelant est inclus dans la liste renvoyée (ainsi une application devrait également appeler B<getegid>(2) et ajouter ou supprimer la valeur résultante).

note: type: Plain text
en: If I<size> is zero, I<list> is not modified, but the total number of supplementary group IDs for the process is returned.  This allows the caller to determine the size of a dynamically allocated I<list> to be used in a further call to B<getgroups>().
fr: Si I<size> vaut zéro, I<list> n'est pas modifiée, mais le nombre total de groupes additionnels  pour le processus est renvoyé. Ceci permet à l'appelant de déterminer la taille d'une liste I<list> allouée dynamiquement à utiliser dans une appel à B<getgroups>() ultérieur.

note: type: Plain text
en: B<setgroups>()  sets the supplementary group IDs for the calling process.  Appropriate privileges (Linux: the B<CAP_SETGID> capability) are required.  The I<size> argument specifies the number of supplementary group IDs in the buffer pointed to by I<list>.
fr: B<setgroups>() définit des identifiants de groupe additionnels pour le processus appelant. Les privilèges appropriés (sous Linux\ : la capacité B<CAP_SETGID>) sont nécessaires. Le paramètre I<size> indique le nombre d'identifiants de groupe additionnels du tampon pointé par I<list>.

note: type: Plain text
en: On success, B<getgroups>()  returns the number of supplementary group IDs.  On error, -1 is returned, and I<errno> is set appropriately.
fr: En cas de succès, B<getgroups>() renvoie le nombre d'identifiants de groupe additionnels. En cas d'erreur, -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: On success, B<setgroups>()  returns 0.  On error, -1 is returned, and I<errno> is set appropriately.
fr: En cas de succès, B<setgroups>() renvoie 0. En cas d'erreur, -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: I<list> has an invalid address.
fr: I<list> pointe en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: B<getgroups>()  can additionally fail with the following error:
fr: B<getgroups>() peut également échouer avec les erreurs suivantes :

note: type: Plain text
en: I<size> is less than the number of supplementary group IDs, but is not zero.
fr: I<size> est inférieur au nombre d'identifiants de groupe additionnels, et n'est pas nul.

note: type: Plain text
en: B<setgroups>()  can additionally fail with the following errors:
fr: B<setgroups>() peut également échouer avec les erreurs suivantes :

note: type: Plain text
en: I<size> is greater than B<NGROUPS_MAX> (32 before Linux 2.6.4; 65536 since Linux 2.6.4).
fr: I<size> est plus grand que B<NGROUPS_MAX> (32 avant Linux 2.6.4 ; 65536 depuis Linux 2.6.4).

note: type: Plain text
en: The calling process has insufficient privilege.
fr: L'appelant n'a pas les privilèges nécessaires.

note: type: Plain text
en: SVr4, 4.3BSD.  The B<getgroups>()  function is in POSIX.1-2001.  Since B<setgroups>()  requires privilege, it is not covered by POSIX.1-2001.
fr: SVr4, BSD\ 4.3. B<getgroups>() est conforme à POSIX.1-2001. Comme B<setgroups>() nécessite des privilèges, il n'est pas couvert par POSIX.1-2001.

note: type: Plain text
en: A process can have up to B<NGROUPS_MAX> supplementary group IDs in addition to the effective group ID.  The constant B<NGROUPS_MAX> is defined in I<E<lt>limits.hE<gt>>.  The set of supplementary group IDs is inherited from the parent process, and preserved across an B<execve>(2).
fr: Un processus peut avoir jusqu'à B<NGROUPS_MAX> identifiants de groupe additionnels en plus de son identifiant de groupe effectif. La constante B<NGROUPS_MAX> est définie dans I<E<lt>limits.hE<gt>>. Le jeu  d'identifiants de groupe additionnels est hérité du processus parent, et est préservé au travers des appels à B<execve>(2).

note: type: Plain text
en: The maximum number of supplementary group IDs can be found at run time using B<sysconf>(3):
fr: Le nombre maximal d'identifiants de groupe additionnels peut être obtenu pendant l'exécution au moyen de B<sysconf>(3) :

note: type: Plain text
en: The maximum return value of B<getgroups>()  cannot be larger than one more than this value.  Since Linux 2.6.4, the maximum number of supplementary group IDs is also exposed via the Linux-specific read-only file, I</proc/sys/kernel/ngroups_max>.
fr: La valeur de retour maximale de B<getgroups>() ne peut pas être plus grande que 1 plus cette valeur. Depuis Linux 2.6.4, le nombre maximal d’identifiants de groupe additionnels est aussi exposé à l’aide du fichier I</proc/sys/kernel/ngroups_max> en lecture seule et spécifique à Linux.

note: type: Plain text
en: The original Linux B<getgroups>()  system call supported only 16-bit group IDs.  Subsequently, Linux 2.4 added B<getgroups32>(), supporting 32-bit IDs.  The glibc B<getgroups>()  wrapper function transparently deals with the variation across kernel versions.
fr: L'appel système B<getgid>() original de Linux ne gérait que des identifiants de groupe sur 16 bits. En conséquence, Linux 2.4 a ajouté B<getgroups32>() qui prend en charge des identifiants 32 bits. La fonction B<getgroups>() de la glibc qui l'encapsule gère de manière transparente ces différences entre noyaux.

note: type: TH
en: 2008-09-23
fr: 23 septembre 2008

note: type: Plain text
en: getpid, getppid - get process identification
fr: getpid, getppid - Obtenir l'identifiant d'un processus

note: type: Plain text
en: B<getpid>()  returns the process ID of the calling process.  (This is often used by routines that generate unique temporary filenames.)
fr: B<getpid>() renvoie l'identifiant du processus appelant. Ceci est souvent utilisé par des routines qui créent des fichiers temporaires uniques.

note: type: Plain text
en: B<getppid>()  returns the process ID of the parent of the calling process.
fr: B<getppid>() renvoie le PID du processus père de l'appelant.

note: type: Plain text
en: POSIX.1-2001, 4.3BSD, SVr4.
fr: POSIX.1-2001, BSD\ 4.3, SVr4.

note: The following program demonstrates this "feature": #define _GNU_SOURCE #include <sys/syscall.h> #include <sys/wait.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> int main(int argc, char *argv[]) { /* The following statement fills the getpid() cache */ printf("parent PID = %ld ", (long
en: Since glibc version 2.3.4, the glibc wrapper function for B<getpid>()  caches PIDs, so as to avoid additional system calls when a process calls B<getpid>()  repeatedly.  Normally this caching is invisible, but its correct operation relies on support in the wrapper functions for B<fork>(2), B<vfork>(2), and B<clone>(2): if an application bypasses the glibc wrappers for these system calls by using B<syscall>(2), then a call to B<getpid>()  in the child will return the wrong value (to be precise: it will return the PID of the parent process).  See also B<clone>(2)  for discussion of a case where B<getpid>()  may return the wrong value even when invoking B<clone>(2)  via the glibc wrapper function.
fr: Depuis la glibc version 2.3.4, la fonction enveloppe de la glibc pour B<getpid>() faisait un cache des PID, de façon à éviter des appels système supplémentaires quand un processus appelle B<getpid>() de façon répétée. Normalement, ce cache n'est pas visible, mais son fonctionnement correct repose sur la gestion du cache dans les fonctions enveloppes pour B<fork>(2), B<vfork>(2) et B<clone>(2) : si une application se passe des enveloppes de la glibc pour ces appels système en appelant B<syscall>(2), alors un appel à B<getpid>() dans le fils renverra la mauvaise valeur (pour être précis : il renverra le PID du processus père). Consultez également B<clone>(2) pour une discussion sur un cas ou B<getpid>() peut renvoyer une mauvaise valeur quand B<clone>(2) est appelé via la fonction enveloppe de la glibc.

note: type: Plain text
en: getpriority, setpriority - get/set program scheduling priority
fr: getpriority, setpriority - Lire et écrire la priorité d'ordonnancement du processus

note: type: Plain text
en: The scheduling priority of the process, process group, or user, as indicated by I<which> and I<who> is obtained with the B<getpriority>()  call and set with the B<setpriority>()  call.
fr: La priorité d'ordonnancement du processus, du groupe de processus ou de l'utilisateur, comme précisé dans I<which> et I<who> est lue avec B<getpriority>() et définit avec B<setpriority>().

note: type: Plain text
en: The value I<which> is one of B<PRIO_PROCESS>, B<PRIO_PGRP>, or B<PRIO_USER>, and I<who> is interpreted relative to I<which> (a process identifier for B<PRIO_PROCESS>, process group identifier for B<PRIO_PGRP>, and a user ID for B<PRIO_USER>).  A zero value for I<who> denotes (respectively) the calling process, the process group of the calling process, or the real user ID of the calling process.  I<Prio> is a value in the range -20 to 19 (but see the Notes below).  The default priority is 0; lower priorities cause more favorable scheduling.
fr: La valeur de I<which> doit être B<PRIO_PROCESS>, B<PRIO_PGRP>, ou B<PRIO_USER>, et I<who> est interprété en fonction de I<which> (un ID de processus pour B<PRIO_PROCESS>, un ID de groupe de processus pour B<PRIO_PGRP>, et un ID d'utilisateur pour B<PRIO_USER>). Une valeur nulle pour I<who> indique (respectivement) le processus appelant, le groupe de processus de l'appelant ou l'UID réel du processus appelant. I<Prio> est une valeur dans l'intervalle -20 à 19 (voir les Notes plus bas). La priorité par défaut est 0, les priorités les plus faibles indiquant un ordonnancement le plus favorable.

note: type: Plain text
en: The B<getpriority>()  call returns the highest priority (lowest numerical value)  enjoyed by any of the specified processes.  The B<setpriority>()  call sets the priorities of all of the specified processes to the specified value.  Only the superuser may lower priorities.
fr: La fonction B<getpriority>() renvoie la plus haute priorité (la plus basse valeur numérique) dont bénéficie l'un des processus indiqué. La fonction B<setpriority>() définit la priorité des processus indiqués à la valeur fournie. Seul le superutilisateur peut diminuer la valeur numérique de la priorité.

note: type: Plain text
en: Since B<getpriority>()  can legitimately return the value -1, it is necessary to clear the external variable I<errno> prior to the call, then check it afterward to determine if -1 is an error or a legitimate value.  The B<setpriority>()  call returns 0 if there is no error, or -1 if there is.
fr: Comme B<getpriority>() peut tout à fait renvoyer la valeur -1, il faut effacer la variable externe I<errno> avant l'appel afin de vérifier si -1 indique une erreur ou une priorité légitime. L'appel B<setpriority>() renvoie 0 s'il réussit, ou -1 s'il échoue.

note: type: Plain text
en: I<which> was not one of B<PRIO_PROCESS>, B<PRIO_PGRP>, or B<PRIO_USER>.
fr: I<which> n'était ni B<PRIO_PROCESS>, ni B<PRIO_PGRP>, ni B<PRIO_USER>.

note: type: Plain text
en: No process was located using the I<which> and I<who> values specified.
fr: Aucun processus ne correspond aux valeurs de I<which> et I<who> indiquées.

note: type: Plain text
en: In addition to the errors indicated above, B<setpriority>()  may fail if:
fr: De plus B<setpriority>() peut échouer pour les erreurs suivantes\ :

note: type: Plain text
en: The caller attempted to lower a process priority, but did not have the required privilege (on Linux: did not have the B<CAP_SYS_NICE> capability).  Since Linux 2.6.12, this error occurs only if the caller attempts to set a process priority outside the range of the B<RLIMIT_NICE> soft resource limit of the target process; see B<getrlimit>(2)  for details.
fr: L'appelant a tenté de diminuer la priorité d'un processus, sans avoir les privilèges requis (sous Linux, il s'agit de la capacité B<CAP_SYS_NICE>). Depuis Linux 2.6.12, cette erreur ne survient que si l'appelant tente de définir la priorité en\(hydehors de la plage permise par la limite souple B<RLIMIT_NICE> du processus cible\ ; consultez B<getrlimit>(2) pour plus de détails.

note: type: Plain text
en: A process was located, but its effective user ID did not match either the effective or the real user ID of the caller, and was not privileged (on Linux: did not have the B<CAP_SYS_NICE> capability).  But see NOTES below.
fr: Un processus correspond bien aux valeurs indiquées, mais ni l'UID réel, ni l'UID effectif de l'appelant ne correspondent à l'UID effectif de ce processus, et (sur les systèmes Linux) l'appelant n'a pas la capacité B<CAP_SYS_NICE>. Voir les NOTES ci\(hydessous.

note: type: Plain text
en: SVr4, 4.4BSD (these function calls first appeared in 4.2BSD), POSIX.1-2001.
fr: SVr4, BSD\ 4.4 (ces fonctions sont apparues dans BSD\ 4.2), POSIX.1-2001.

note: type: Plain text
en: A child created by B<fork>(2)  inherits its parent's nice value.  The nice value is preserved across B<execve>(2).
fr: Un fils créé avec B<fork>(2) hérite de la valeur de courtoisie de son père. La valeur de courtoisie est préservée au travers d'un B<execve>(2).

note: type: Plain text
en: The degree to which their relative nice value affects the scheduling of processes varies across UNIX systems, and, on Linux, across kernel versions.  Starting with kernel 2.6.23, Linux adopted an algorithm that causes relative differences in nice values to have a much stronger effect.  This causes very low nice values (+19) to truly provide little CPU to a process whenever there is any other higher priority load on the system, and makes high nice values (-20) deliver most of the CPU to applications that require it (e.g., some audio applications).
fr: L'importance des variations d'ordonnancement des processus suivant leurs valeurs de courtoisies respectives dépend des systèmes UNIX et pour Linux, dépend de la version du noyau. Depuis le noyau 2.6.23, Linux emploie un algorithme rendant plus sensibles les variations de courtoisies. Les valeurs de courtoisies élevées (+19) ne laissent que très peu de temps CPU à un processus si d'autres programmes, plus prioritaires, réclament le processeur. Inversement, les valeurs de courtoisie basses (-20) fournissent beaucoup de temps CPU aux tâches qui en ont besoin (par exemple, certaines applications audio).

note: type: Plain text
en: The details on the condition for B<EPERM> depend on the system.  The above description is what POSIX.1-2001 says, and seems to be followed on all System V-like systems.  Linux kernels before 2.6.12 required the real or effective user ID of the caller to match the real user of the process I<who> (instead of its effective user ID).  Linux 2.6.12 and later require the effective user ID of the caller to match the real or effective user ID of the process I<who>.  All BSD-like systems (SunOS 4.1.3, Ultrix 4.2, 4.3BSD, FreeBSD 4.3, OpenBSD-2.5, ...) behave in the same manner as Linux 2.6.12 and later.
fr: Les détails concernant la condition d'erreur B<EPERM> dépendent du système. La description ci\(hydessus concerne ce que dit POSIX.1-2001, et qui semble être suivi par tous les systèmes de type System V. Les noyaux Linux antérieurs à 2.6.12 demandent que l'UID réel ou effectif de l'appelant correspondent à l'UID réel du processus I<who> (et non pas à son UID effectif). Linux 2.6.12 et suivants demandent que l'UID effectif de l'appelant corresponde à l'UID réel ou effectif du processus I<who>. Tous les systèmes de type BSD (SunOS\ 4.1.3, Ultrix\ 4.2, BSD\ 4.3, FreeBSD\ 4.3, OpenBSD-2.5, ...) se comportent de la même manière que Linux 2.6.12 et les suivants.

note: type: Plain text
en: The actual priority range varies between kernel versions.  Linux before 1.3.36 had -infinity..15.  Since kernel 1.3.43, Linux has the range -20..19.  Within the kernel, nice values are actually represented using the corresponding range 40..1 (since negative numbers are error codes) and these are the values employed by the B<setpriority>()  and B<getpriority>()  system calls.  The glibc wrapper functions for these system calls handle the translations between the user-land and kernel representations of the nice value according to the formula I<unice\ =\ 20\ -\ knice>.
fr: Le véritable intervalle des priorités varie suivant les versions du noyau. Sur les systèmes Linux antérieurs à 1.3.36, l'intervalle s'étendait de -infini à 15. Depuis la version 1.3.43, l'intervalle est -20..19. Dans le noyau, les valeurs de politesse sont représentées dans l'intervalle 40..1 (les nombres négatifs sont des codes d'erreurs), et ce sont ces valeurs qui sont utilisées par les appels système B<setpriority>() et B<getpriority>(). Les routines de la bibliothèque glibc se chargent des conversions entre les représentations dans le noyau et dans l'espace utilisateur grâce à la formule I<unice\ =\ 20\ -\ knice>.

note: type: Plain text
en: On some systems, the range of nice values is -20..20.
fr: Sur certains systèmes, les valeurs de politesse vont de -20 à 20.

note: type: Plain text
en: Including I<E<lt>sys/time.hE<gt>> is not required these days, but increases portability.  (Indeed, I<E<lt>sys/resource.hE<gt>> defines the I<rusage> structure with fields of type I<struct timeval> defined in I<E<lt>sys/time.hE<gt>>.)
fr: L'inclusion de I<E<lt>sys/time.hE<gt>> n'est plus obligatoire, mais améliore la portabilité. (En fait, I<E<lt>sys/resource.hE<gt>> définit la structure I<rusage> qui contient des champs de type I<struct timeval>, défini dans I<E<lt>sys/time.hE<gt>>).

note: type: Plain text
en: According to POSIX, the nice value is a per-process setting.  However, under the current Linux/NPTL implementation of POSIX threads, the nice value is a per-thread attribute: different threads in the same process can have different nice values.  Portable applications should avoid relying on the Linux behavior, which may be made standards conformant in the future.
fr: Selon la norme POSIX, la valeur de courtoisie (nice) est définie à l'échelle du processus. Cependant, les threads POSIX sont actuellement implémentés dans Linux/NPTL de telle sorte que la valeur de courtoisie est un attribut du thread : différents threads d'un même processus peuvent avoir des valeurs de courtoisie différentes. Les applications portables doivent donc éviter de s'appuyer sur cette propriété de Linux, qui devrait, à l'avenir, être mise en conformité avec les normes.

note: type: Plain text
en: I<Documentation/scheduler/sched-nice-design.txt> in the Linux kernel source tree (since Linux 2.6.23)
fr: I<Documentation/scheduler/sched-nice-design.txt> dans les sources du noyau (depuis Linux 2.6.23)

note: type: Plain text
en: getresuid, getresgid - get real, effective and saved user/group IDs
fr: getresuid, getresgid - Obtenir les UIDs ou les GIDs réels, effectifs et sauvés

note: type: Plain text
en: B<#define _GNU_SOURCE> /* See feature_test_macros(7) */
fr: B<#define _GNU_SOURCE> /* Consultez feature_test_macros(7) */

note: type: Plain text
en: B<getresuid>()  returns the real UID, the effective UID, and the saved set-user-ID of the calling process, in the arguments I<ruid>, I<euid>, and I<suid>, respectively.  B<getresgid>()  performs the analogous task for the process's group IDs.
fr: B<getresuid>() renvoie l'UID réel, l'UID effectif et le SUID sauvé du processus appelant dans les paramètres I<ruid>, I<euid> et I<suid>, respectivement. B<getresgid>() effectue la tâche analogue avec les identifiants de groupe du processus.

note: type: Plain text
en: One of the arguments specified an address outside the calling program's address space.
fr: L'un des arguments pointe en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: These system calls appeared on Linux starting with kernel 2.1.44.
fr: Ces appels système sont apparus sous Linux avec le noyau 2.1.44.

note: type: Plain text
en: The prototypes are given by glibc since version 2.3.2, provided B<_GNU_SOURCE> is defined.
fr: Les prototypes sont fournis par la glibc depuis la version 2.3.2, à condition que la constante B<_GNU_SOURCE> soit définie.

note: type: Plain text
en: These calls are nonstandard; they also appear on HP-UX and some of the BSDs.
fr: Ces appels ne sont pas standards\ ; ils apparaissent également sur HP-UX et certains BSD.

note: type: Plain text
en: The original Linux B<getresuid>()  and B<getresgid>()  system calls supported only 16-bit user and group IDs.  Subsequently, Linux 2.4 added B<getresuid32>()  and B<getresgid32>(), supporting 32-bit IDs.  The glibc B<getresuid>()  and B<getresgid>()  wrapper functions transparently deal with the variations across kernel versions.
fr: Les appels système B<getresuid>() et B<getresgid>() originaux de Linux ne géraient que des identifiants d'utilisateur et de groupe sur 16 bits. En conséquence, Linux 2.4 a ajouté B<getresuid32>() et B<getresgid32>() qui prennent en charge des identifiants 32 bits. Les fonctions B<getresuid>() et B<getresgid>() de la glibc qui les encapsulent gèrent de manière transparente ces différences entre noyaux.

note: type: TH
en: 2014-01-22
fr: 22 janvier 2014

note: type: Plain text
en: getrlimit, setrlimit, prlimit - get/set resource limits
fr: getrlimit, setrlimit, prlimit - Lire et écrire les limites et utilisations des ressources

note: type: Plain text
en: B<prlimit>(): _GNU_SOURCE && _FILE_OFFSET_BITS == 64
fr: B<prlimit>() : _GNU_SOURCE && _FILE_OFFSET_BITS == 64

note: type: Plain text
en: The B<getrlimit>()  and B<setrlimit>()  system calls get and set resource limits respectively.  Each resource has an associated soft and hard limit, as defined by the I<rlimit> structure:
fr: Les appels système B<getrlimit>() et B<setrlimit>() lisent ou écrivent les limites des ressources système. Chaque ressource a une limite souple et une limite stricte définies par la structure I<rlimit> (l'argument I<rlim> de B<getrlimit>() et B<setrlimit>())\ :

note: type: Plain text
en: struct rlimit {
        rlim_t rlim_cur;  /* Soft limit */
        rlim_t rlim_max;  /* Hard limit (ceiling for rlim_cur) */
    };
fr: struct rlimit {
      rlim_t rlim_cur; /* limite souple */
      rlim_t rlim_max; /* limite stricte (plafond
                          de rlim_cur) */
    };

note: type: Plain text
en: The soft limit is the value that the kernel enforces for the corresponding resource.  The hard limit acts as a ceiling for the soft limit: an unprivileged process may set only its soft limit to a value in the range from 0 up to the hard limit, and (irreversibly) lower its hard limit.  A privileged process (under Linux: one with the B<CAP_SYS_RESOURCE> capability) may make arbitrary changes to either limit value.
fr: La limite souple est la valeur que le noyau prend en compte pour la ressource correspondante. La limite stricte agit comme un plafond pour la limite souple\ : un processus non privilégié peut seulement modifier sa limite souple dans l'intervalle entre zéro et la limite stricte, et diminuer (de manière irréversible) sa limite stricte. Un processus privilégié (sous Linux\ : un processus ayant la capacité B<CAP_SYS_RESOURCE>) peut modifier ses deux limites à sa guise.

note: type: Plain text
en: The value B<RLIM_INFINITY> denotes no limit on a resource (both in the structure returned by B<getrlimit>()  and in the structure passed to B<setrlimit>()).
fr: La valeur B<RLIM_INFINITY> indique une limite infinie pour la ressource (aussi bien pour B<getrlimit>() que pour B<setrlimit>()).

note: type: Plain text
en: The I<resource> argument must be one of:
fr: Le paramètre I<resource> doit être l'un des éléments suivants\ :

note: since 2.0.27 / 2.1.12 type: Plain text
en: The maximum size of the process's virtual memory (address space) in bytes.  This limit affects calls to B<brk>(2), B<mmap>(2)  and B<mremap>(2), which fail with the error B<ENOMEM> upon exceeding this limit.  Also automatic stack expansion will fail (and generate a B<SIGSEGV> that kills the process if no alternate stack has been made available via B<sigaltstack>(2)).  Since the value is a I<long>, on machines with a 32-bit I<long> either this limit is at most 2 GiB, or this resource is unlimited.
fr: Taille maximum de la mémoire virtuelle du processus en octets. Cette limite affecte les appels à B<brk>(2), B<mmap>(2) et B<mremap>(2), qui échouent avec l'erreur B<ENOMEM> en cas de dépassement de cette limite. De même, l'extension de la pile automatique échouera (et générera un B<SIGSEGV> qui tuera le processus si aucune pile alternative n'a été définie par un appel à B<sigaltstack>(2)). Depuis que cette valeur est de type I<long>, sur les machines où le type I<long> est sur 32 bits, soit cette limite est au plus 2 GiB, soit cette ressource est illimitée.

note: type: Plain text
en: Maximum size of I<core> file.  When 0 no core dump files are created.  When nonzero, larger dumps are truncated to this size.
fr: Taille maximum du fichier I<core>. Lorsqu'elle vaut zéro, aucun fichier d'image noyau (Ndt\ : core dump) n'est créé. Lorsqu'elle ne vaut pas zéro, les fichiers d'image noyau plus grands sont tronqués à cette taille.

note: type: Plain text
en: CPU time limit in seconds.  When the process reaches the soft limit, it is sent a B<SIGXCPU> signal.  The default action for this signal is to terminate the process.  However, the signal can be caught, and the handler can return control to the main program.  If the process continues to consume CPU time, it will be sent B<SIGXCPU> once per second until the hard limit is reached, at which time it is sent B<SIGKILL>.  (This latter point describes Linux behavior.  Implementations vary in how they treat processes which continue to consume CPU time after reaching the soft limit.  Portable applications that need to catch this signal should perform an orderly termination upon first receipt of B<SIGXCPU>.)
fr: Limite de temps CPU en secondes. Si un processus atteint cette limite souple, il reçoit le signal B<SIGXCPU>. L'action par défaut pour ce signal est la terminaison du processus. Mais le signal peut être capturé et le gestionnaire peut rendre le contrôle au programme principal. Si le processus continue à consommer du temps CPU, il recevra B<SIGXCPU> toutes les secondes jusqu'à atteindre la limite stricte, où il recevra B<SIGKILL>. (Ce dernier point décrit le comportement de Linux. Les implémentations varient sur la façon de traiter le processus qui continue à consommer du temps CPU après dépassement de sa limite souple. Les applications portables qui doivent capturer ce signal devraient prévoir une terminaison propre dès la première réception de B<SIGXCPU>.)

note: type: Plain text
en: The maximum size of the process's data segment (initialized data, uninitialized data, and heap).  This limit affects calls to B<brk>(2)  and B<sbrk>(2), which fail with the error B<ENOMEM> upon encountering the soft limit of this resource.
fr: Taille maximale du segment de données d'un processus (données initialisées, non initialisées, et tas). Cette limite affecte les appels B<brk>(2) et B<sbrk>(2), qui échouent avec l'erreur B<ENOMEM> si la limite souple est dépassée.

note: type: Plain text
en: The maximum size of files that the process may create.  Attempts to extend a file beyond this limit result in delivery of a B<SIGXFSZ> signal.  By default, this signal terminates a process, but a process can catch this signal instead, in which case the relevant system call (e.g., B<write>(2), B<truncate>(2))  fails with the error B<EFBIG>.
fr: Taille maximale d'un fichier que le processus peut créer. Les tentatives d'extension d'un fichier au\(hydelà de cette limite résultent en un signal B<SIGXFSZ>. Par défaut ce signal termine le processus, mais il peut être capturé, et dans ce cas l'appel système concerné (par exemple B<write>(2), B<truncate>(2)) échoue avec l'erreur B<EFBIG>.

note: type: TP
en: B<RLIMIT_LOCKS> (Early Linux 2.4 only)
fr: B<RLIMIT_LOCKS> (Premiers Linux 2.4 seulement)

note: to be precise: Linux 2.4.0-test9; no longer in 2.4.25 / 2.5.65 type: Plain text
en: A limit on the combined number of B<flock>(2)  locks and B<fcntl>(2)  leases that this process may establish.
fr: Une limite sur le nombre combiné de verrous B<flock>(2) et B<fcntl>(2) que le processus peut établir.

note: type: Plain text
en: The maximum number of bytes of memory that may be locked into RAM.  In effect this limit is rounded down to the nearest multiple of the system page size.  This limit affects B<mlock>(2)  and B<mlockall>(2)  and the B<mmap>(2)  B<MAP_LOCKED> operation.  Since Linux 2.6.9 it also affects the B<shmctl>(2)  B<SHM_LOCK> operation, where it sets a maximum on the total bytes in shared memory segments (see B<shmget>(2))  that may be locked by the real user ID of the calling process.  The B<shmctl>(2)  B<SHM_LOCK> locks are accounted for separately from the per-process memory locks established by B<mlock>(2), B<mlockall>(2), and B<mmap>(2)  B<MAP_LOCKED>; a process can lock bytes up to this limit in each of these two categories.  In Linux kernels before 2.6.9, this limit controlled the amount of memory that could be locked by a privileged process.  Since Linux 2.6.9, no limits are placed on the amount of memory that a privileged process may lock, and this limit instead governs the amount of memory that an unprivileged process may lock.
fr: Le nombre maximal d'octets de mémoire virtuelle que le processus peut verrouiller en RAM. En pratique cette limite est arrondie vers le bas au multiple de la taille de page le plus proche. Cette limite affecte B<mlock>(2) et B<mlockall>(2) ainsi que l'opération B<MAP_LOCKED> de B<mmap>(2). Depuis Linux 2.6.9, elle affecte aussi l'opération B<SHM_LOCK> de B<shmctl>(2), où elle limite le nombre total d'octets dans des segments de mémoire partagée (consultez B<shmget>(2)) que l'UID réel du processus appelant peut verrouiller. Les verrous de B<shmctl>(2) B<SHM_LOCK> sont comptés séparément des verrous de mémoire par processus établis par B<mlock>(2), B<mlockall>(2) et B<mmap>(2) B<MAP_LOCKED>\ ; un processus peut verrouiller des octets jusqu'à la limite dans chacune de ces catégories. Dans les noyaux antérieurs à 2.6.9, cette limite contrôlait la quantité de mémoire qu'un processus privilégié pouvait verrouiller. Depuis Linux 2.6.9, un processus privilégie peut verrouiller autant de mémoire qu'il le souhaite, et cette limite contrôle la quantité de mémoire pouvant être verrouillée par un processus non privilégié.

note: type: TP
en: B<RLIMIT_MSGQUEUE> (since Linux 2.6.8)
fr: B<RLIMIT_MSGQUEUE> (depuis Linux 2.6.8)

note: type: Plain text
en: Specifies the limit on the number of bytes that can be allocated for POSIX message queues for the real user ID of the calling process.  This limit is enforced for B<mq_open>(3).  Each message queue that the user creates counts (until it is removed)  against this limit according to the formula:
fr: Indique la limite du nombre d'octets pouvant être alloués pour les files de messages POSIX pour l'UID réel du processus appelant. Cette limite est appliquée pour B<mq_open>(3). Le nombre d'octets pour chaque file de messages créée par l'utilisateur (jusqu'à sa destruction) est déterminé par la formule suivante\ :

note: type: Plain text
en:     bytes = attr.mq_maxmsg * sizeof(struct msg_msg *) +
                attr.mq_maxmsg * attr.mq_msgsize
fr:    octets = attr.mq_maxmsg * sizeof(struct msg_msg *) +
                attr.mq_maxmsg * attr.mq_msgsize

note: type: Plain text
en: where I<attr> is the I<mq_attr> structure specified as the fourth argument to B<mq_open>(3).
fr: où I<attr> est la structure I<mq_attr> passée comme quatrième argument à B<mq_open>(3).

note: type: Plain text
en: The first addend in the formula, which includes I<sizeof(struct msg_msg\ *)> (4 bytes on Linux/i386), ensures that the user cannot create an unlimited number of zero-length messages (such messages nevertheless each consume some system memory for bookkeeping overhead).
fr: Le premier terme de la formule, qui inclut I<sizeof(struct msg_msg\ *)> (4\ octets sur Linux/i386) garantit que l'utilisateur ne peut pas créer un nombre illimité de messages vides (ces messages consomment tout de même de la mémoire système).

note: type: TP
en: B<RLIMIT_NICE> (since Linux 2.6.12, but see BUGS below)
fr: B<RLIMIT_NICE> (depuis Linux 2.6.12, consultez la section BOGUES ci\(hydessous)

note: type: Plain text
en: Specifies a ceiling to which the process's nice value can be raised using B<setpriority>(2)  or B<nice>(2).  The actual ceiling for the nice value is calculated as I<20\ -\ rlim_cur>.  (This strangeness occurs because negative numbers cannot be specified as resource limit values, since they typically have special meanings.  For example, B<RLIM_INFINITY> typically is the same as -1.)
fr: Indique un plafond pour la valeur de politesse du processus pouvant être définie par B<setpriority>(2) ou B<nice>(2). Le plafond réel pour la valeur de politesse est calculé par la formule I<20\ -\ rlim_cur>. (Cette bizarrerie apparaît car des nombres négatifs ne peuvent pas être utilisés comme limites de ressources, en raison de leur signification souvent particulière. Par exemple, B<RLIM_INFINITY> est souvent la même chose que -1.)

note: type: Plain text
en: Specifies a value one greater than the maximum file descriptor number that can be opened by this process.  Attempts (B<open>(2), B<pipe>(2), B<dup>(2), etc.)  to exceed this limit yield the error B<EMFILE>.  (Historically, this limit was named B<RLIMIT_OFILE> on BSD.)
fr: Le nombre maximal de descripteurs de fichier qu'un processus peut ouvrir simultanément. Les tentatives d'ouverture (B<open>(2), B<pipe>(2), B<dup>(2), etc) dépassant cette limite renverront l'erreur B<EMFILE>. Historiquement, cette limite était appelée B<RLIMIT_OFILE> sur les BSD.

note: type: Plain text
en: The maximum number of processes (or, more precisely on Linux, threads)  that can be created for the real user ID of the calling process.  Upon encountering this limit, B<fork>(2)  fails with the error B<EAGAIN>.
fr: Le nombre maximal de processus (ou plus précisément, sous Linux, de threads) qui peuvent être créés pour l'UID réel du processus appelant. Une fois cette limite atteinte, B<fork>(2) échoue avec l'erreur B<EAGAIN>.

note: As at kernel 2.6.12, this limit still does nothing in 2.6 though talk of making it do something has surfaced from time to time in LKML -- MTK, Jul 05 type: Plain text
en: Specifies the limit (in pages) of the process's resident set (the number of virtual pages resident in RAM).  This limit has effect only in Linux 2.4.x, x E<lt> 30, and there affects only calls to B<madvise>(2)  specifying B<MADV_WILLNEED>.
fr: Indique la limite (en pages) pour la taille de l'ensemble résident du processus (le nombre de pages de mémoire virtuelle en RAM). Cette limite n'a d'effet que sous Linux 2.4.x où x\ E<lt>\ 30, et n'affecte que les appels B<madvise>(2) indiquant B<MADV_WILLNEED>.

note: type: TP
en: B<RLIMIT_RTPRIO> (since Linux 2.6.12, but see BUGS)
fr: B<RLIMIT_RTPRIO> (depuis Linux 2.6.12, mais consultez BOGUES)

note: type: Plain text
en: Specifies a ceiling on the real-time priority that may be set for this process using B<sched_setscheduler>(2)  and B<sched_setparam>(2).
fr: Indique un plafond pour la priorité temps\(hyréel pouvant être appliquée au processus par B<sched_setscheduler>(2) et B<sched_setparam>(2).

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

note: type: Plain text
en: Specifies a limit (in microseconds)  on the amount of CPU time that a process scheduled under a real-time scheduling policy may consume without making a blocking system call.  For the purpose of this limit, each time a process makes a blocking system call, the count of its consumed CPU time is reset to zero.  The CPU time count is not reset if the process continues trying to use the CPU but is preempted, its time slice expires, or it calls B<sched_yield>(2).
fr: Indique une limite de la quantité de temps (en microsecondes) CPU qu'un processus ordonnancé par une politique d'ordonnancement temps réel peut consommer sans bloquer lors de l'exécution d'un appel système. À cause de cette limite le décompte du temps CPU qu'il a consommé est remis à zéro à chaque fois qu'un processus exécute un appel système bloquant. Le décompte du temps CPU n'est pas remis à zéro si le processus continue d'essayer d'utiliser le CPU mais est préempté, ou si sa tranche de temps expire, ou s'il appelle B<sched_yield>(2).

note: type: Plain text
en: Upon reaching the soft limit, the process is sent a B<SIGXCPU> signal.  If the process catches or ignores this signal and continues consuming CPU time, then B<SIGXCPU> will be generated once each second until the hard limit is reached, at which point the process is sent a B<SIGKILL> signal.
fr: Quand la limite douce est atteinte, un signal B<SIGXCPU> est envoyé au processus. Si le processus attrape ou ignore ce signal et continue à consommer du temps CPU, alors un signal B<SIGXCPU> sera généré une fois par seconde jusqu'à ce que la limite dure soit atteinte, ce qui provoque l'envoie d'un signal B<SIGKILL> au processus.

note: type: Plain text
en: The intended use of this limit is to stop a runaway real-time process from locking up the system.
fr: L'objectif de cette limite est d'empêcher un processus temps réel fou de bloquer le système.

note: type: TP
en: B<RLIMIT_SIGPENDING> (since Linux 2.6.8)
fr: B<RLIMIT_SIGPENDING> (depuis Linux 2.6.8)

note: This replaces the /proc/sys/kernel/rtsig-max system-wide limit that was present in kernels <= 2.6.7.  MTK Dec 04 type: Plain text
en: Specifies the limit on the number of signals that may be queued for the real user ID of the calling process.  Both standard and real-time signals are counted for the purpose of checking this limit.  However, the limit is enforced only for B<sigqueue>(3); it is always possible to use B<kill>(2)  to queue one instance of any of the signals that are not already queued to the process.
fr: Spécifie la limite du nombre de signaux pouvant être mis en attente pour l'identifiant utilisateur réel du processus appelant. La vérification de cette limite prend en compte à la fois les signaux classiques et les signaux temps\(hyréel. Cependant, cette limite n'est appliquée que pour B<sigqueue>(3)\ ; il est toujours possible d'utiliser B<kill>(2) pour mettre en attente une instance de tout signal qui n'est pas déjà en attente pour le processus.

note: type: Plain text
en: The maximum size of the process stack, in bytes.  Upon reaching this limit, a B<SIGSEGV> signal is generated.  To handle this signal, a process must employ an alternate signal stack (B<sigaltstack>(2)).
fr: La taille maximale de la pile du processus, en octets. Une fois cette limite atteinte, un signal B<SIGSEGV> est déclenché. Pour gérer ce signal, le processus doit utiliser une pile spécifique pour signaux (B<sigaltstack>(2)).

note: type: Plain text
en: Since Linux 2.6.23, this limit also determines the amount of space used for the process's command-line arguments and environment variables; for details, see B<execve>(2).
fr: Depuis Linux 2.6.23, cette limite détermine également la quantité d'espace utilisé pour les paramètres et les variables d'environnement du processus ; consultez B<execve>(2) pour plus de détails.

note: commit c022a0acad534fd5f5d5f17280f6d4d135e74e81 Author: Jiri Slaby <jslaby@suse.cz> Date:   Tue May 4 18:03:50 2010 +0200 type: Plain text
en: The Linux-specific B<prlimit>()  system call combines and extends the functionality of B<setrlimit>()  and B<getrlimit>().  It can be used to both set and get the resource limits of an arbitrary process.
fr: L'appel système B<prlimit>()  spécifique à Linux combine et étend les fonctionnalités de B<setrlimit>()  et B<getrlimit>(). Il peut être utilisé pour affecter ou récupérer les limites de ressources de tout processus.

note: type: Plain text
en: The I<resource> argument has the same meaning as for B<setrlimit>()  and B<getrlimit>().
fr: Le paramètre I<resource> a le même sens que dans B<setrlimit>()  et B<getrlimit>().

note: type: Plain text
en: If the I<new_limit> argument is a not NULL, then the I<rlimit> structure to which it points is used to set new values for the soft and hard limits for I<resource>.  If the I<old_limit> argument is a not NULL, then a successful call to B<prlimit>()  places the previous soft and hard limits for I<resource> in the I<rlimit> structure pointed to by I<old_limit>.
fr: Si le paramètre I<new_limit> ne vaut pas NULL, alors la structure I<rlimit> vers laquelle il pointe est utilisée pour affecter de nouvelles valeurs aux limites souples et strictes pour I<resource>. Si le paramètres I<old_limit> ne vaut pas NULL, alors un appel à B<prlimit>()  qui réussit place les limites antérieures souples et strictes pour I<resource> dans la structure I<rlimit> pointée par I<old_limit>.

note: FIXME this permission check is strange Asked about this on LKML, 7 Nov 2010 "Inconsistent credential checking in prlimit() syscall" type: Plain text
en: The I<pid> argument specifies the ID of the process on which the call is to operate.  If I<pid> is 0, then the call applies to the calling process.  To set or get the resources of a process other than itself, the caller must have the B<CAP_SYS_RESOURCE> capability, or the real, effective, and saved set user IDs of the target process must match the real user ID of the caller I<and> the real, effective, and saved set group IDs of the target process must match the real group ID of the caller.
fr: L'argument I<pid> spécifie l'identifiant du processus sur lequel l'appel agit. Si I<pid> vaut 0, alors l'appel s'applique au processus appelant. Pour positionner ou interroger les ressources d'un processus autre que lui-même, soit l'appelant a la capacité B<CAP_SYS_RESOURCE>, soit les identifiants d'utilisateur réel et effectif et le set-UID sauvé du processus cible correspond à l'identifiant d'utilisateur réel de l'appelant I<et> les identifiants de groupe réel et effectif et le set-GID sauvé du processus cible correspond à l'identifiant de groupe réel du processus.

note: type: Plain text
en: On success, these system calls return 0.  On error, -1 is returned, and I<errno> is set appropriately.
fr: Ces appels système renvoient 0 en cas de succès, ou -1 en cas d'échec, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: A pointer argument points to a location outside the accessible address space.
fr: L'un des arguments pointe en\(hydehors de l'espace d'adressage accessible.

note: type: Plain text
en: The value specified in I<resource> is not valid; or, for B<setrlimit>()  or B<prlimit>(): I<rlim-E<gt>rlim_cur> was greater than I<rlim-E<gt>rlim_max>.
fr: La valeur spécifiée dans I<resource> n'est pas valide\ ; ou, pour B<setrlimit>()  ou B<prlimit>(), I<rlim-E<gt>rlim_cur> est plus grand que I<rlim-E<gt>rlim_max>.

note: type: Plain text
en: An unprivileged process tried to raise the hard limit; the B<CAP_SYS_RESOURCE> capability is required to do this.  Or, the caller tried to increase the hard B<RLIMIT_NOFILE> limit above the current kernel maximum (B<NR_OPEN>).  Or, the calling process did not have permission to set limits for the process specified by I<pid>.
fr: Un processus non privilégié a essayé d'augmenter la limite stricte ; la capacité B<CAP_SYS_RESOURCE> est nécessaire pour pouvoir faire cela. Ou le processus a essayé d'augmenter la limite stricte B<RLIMIT_NOFILE> au\(hydessus du maximum (B<NR_OPEN>) du noyau actuel. Ou alors le processus appelant n'avait pas la permission de changer les limites du processus spécifié par I<pid>.

note: type: Plain text
en: Could not find a process with the ID specified in I<pid>.
fr: Impossible de trouver un processus dont l'identifiant est indiqué par I<pid>.

note: type: Plain text
en: The B<prlimit>()  system call is available since Linux 2.6.36.  Library support is available since glibc 2.13.
fr: L'appel système B<prlimit>() est disponible depuis Linux 2.6.36 ; la prise en charge dans la glibc est disponible depuis la version\ 2.13.

note: type: Plain text
en: B<getrlimit>(), B<setrlimit>(): SVr4, 4.3BSD, POSIX.1-2001.
fr: B<getrlimit>(), B<setrlimit>() : SVr4, BSD\ 4.3, POSIX.1-2001.

note: type: Plain text
en: B<prlimit>(): Linux-specific.
fr: B<prlimit>() : spécifique à Linux.

note: type: Plain text
en: B<RLIMIT_MEMLOCK> and B<RLIMIT_NPROC> derive from BSD and are not specified in POSIX.1-2001; they are present on the BSDs and Linux, but on few other implementations.  B<RLIMIT_RSS> derives from BSD and is not specified in POSIX.1-2001; it is nevertheless present on most implementations.  B<RLIMIT_MSGQUEUE>, B<RLIMIT_NICE>, B<RLIMIT_RTPRIO>, B<RLIMIT_RTTIME>, and B<RLIMIT_SIGPENDING> are Linux-specific.
fr: B<RLIMIT_MEMLOCK> et B<RLIMIT_NPROC> proviennent de BSD et ne sont pas définis dans POSIX.1-2001\ ; ils sont présents dans les BSD et Linux, mais dans peu d'autres implémentations. B<RLIMIT_RSS> vient de BSD et n'est pas défini dans POSIX.1-2001\ ; cependant, il est présent sur la plupart des implémentations. B<RLIMIT_MSGQUEUE>, B<RLIMIT_NICE>, B<RLIMIT_RTPRIO>, B<RLIMIT_RTTIME> et B<RLIMIT_SIGPENDING> sont spécifiques à Linux.

note: type: Plain text
en: A child process created via B<fork>(2)  inherits its parent's resource limits.  Resource limits are preserved across B<execve>(2).
fr: Un processus fils créé avec B<fork>(2) hérite des limites de ressource de son père. Les limites de ressource sont préservées à travers un B<execve>(2).

note: type: Plain text
en: Lowering the soft limit for a resource below the process's current consumption of that resource will succeed (but will prevent the process from further increasing its consumption of the resource).
fr: Descendre la limite souple d'une ressource en dessous de l'actuelle utilisation par le processus de cette ressource fonctionne (mais cela empêchera le processus d'augmenter ultérieurement sa consommation de cette ressource).

note: type: Plain text
en: One can set the resource limits of the shell using the built-in I<ulimit> command (I<limit> in B<csh>(1)).  The shell's resource limits are inherited by the processes that it creates to execute commands.
fr: On peut définir les limites de ressources de l'interpréteur de commandes en utilisant la commande interne I<ulimit> (I<limit> dans B<csh>(1)). Les limites de ressources de l'interpréteur de commandes sont héritées par les processus qu'il crée pour exécuter les commandes.

note: type: Plain text
en: Since Linux 2.6.24, the resource limits of any process can be inspected via I</proc/[pid]/limits>; see B<proc>(5).
fr: À partir de Linux 2.6.24, les limites de ressource de n'importe quel processus peuvent être examinées en consultant I</proc/[pid]/limits> ; consultez B<proc>(5).

note: type: Plain text
en: Ancient systems provided a B<vlimit>()  function with a similar purpose to B<setrlimit>().  For backward compatibility, glibc also provides B<vlimit>().  All new applications should be written using B<setrlimit>().
fr: Des systèmes anciens fournissent une fonction B<vlimit>() qui remplit le même rôle que B<setrlimit>(). Pour des raisons de compatibilité ascendante, la glibc fournit aussi une fonction B<vlimit>(), mais toutes les nouvelles applications devraient utiliser B<setrlimit>().

note: FIXME prlimit() does not suffer https://bugzilla.kernel.org/show_bug.cgi?id=5042 http://sources.redhat.com/bugzilla/show_bug.cgi?id=12201 Since versions 2.13, glibc has library implementations of getrlimit() and setrlimit() that use prlimit() to work around this bug. type: Plain text
en: In older Linux kernels, the B<SIGXCPU> and B<SIGKILL> signals delivered when a process encountered the soft and hard B<RLIMIT_CPU> limits were delivered one (CPU) second later than they should have been.  This was fixed in kernel 2.6.8.
fr: Dans les noyaux Linux plus anciens, les signaux B<SIGXCPU> et B<SIGKILL> envoyés lorsqu'un processus dépassait les limites souple et stricte pour B<RLIMIT_CPU> étaient envoyés une seconde (CPU) plus tard qu'ils n'auraient dû l'être. Cela a été corrigé dans le noyau 2.6.8.

note: see http://marc.theaimsgroup.com/?l=linux-kernel&m=114008066530167&w=2 type: Plain text
en: In 2.6.x kernels before 2.6.17, a B<RLIMIT_CPU> limit of 0 is wrongly treated as "no limit" (like B<RLIM_INFINITY>).  Since Linux 2.6.17, setting a limit of 0 does have an effect, but is actually treated as a limit of 1 second.
fr: Dans les noyaux de la série 2.6 antérieurs à 2.6.17, une limite B<RLIMIT_CPU> à 0 est interprétée par erreur comme «\ pas de limite\ » (comme B<RLIM_INFINITY>). Depuis Linux 2.6.17, définir la limite à 0 a un effet, mais la limite est en fait d'une seconde.

note: See https://lwn.net/Articles/145008/ type: Plain text
en: A kernel bug means that B<RLIMIT_RTPRIO> does not work in kernel 2.6.12; the problem is fixed in kernel 2.6.13.
fr: En raison d'un bogue du noyau, B<RLIMIT_RTPRIO> ne marche pas dans le noyau 2.6.12\ ; le problème a été corrigé dans le noyau 2.6.13.

note: see http://marc.theaimsgroup.com/?l=linux-kernel&m=112256338703880&w=2 type: Plain text
en: In kernel 2.6.12, there was an off-by-one mismatch between the priority ranges returned by B<getpriority>(2)  and B<RLIMIT_NICE>.  This had the effect that the actual ceiling for the nice value was calculated as I<19\ -\ rlim_cur>.  This was fixed in kernel 2.6.13.
fr: Dans le noyau 2.6.12, il y avait une différence de 1 entre les valeurs de priorité renvoyées par B<getpriority>(2) et B<RLIMIT_NICE>. Du coup, la limite réelle pour la valeur de politesse était calculée comme I<19\ -\ rlim_cur>. Ceci est corrigé depuis le noyau 2.6.13.

note: The relevant patch, sent to LKML, seems to be http://thread.gmane.org/gmane.linux.kernel/273462 From: Roland McGrath <roland <at> redhat.com> Subject: [PATCH 7/7] make RLIMIT_CPU/SIGXCPU per-process Date: 2005-01-23 23:27:46 GMT Tested Solaris 10, FreeBSD 9, OpenBSD 5.0 FIXME https://bugzilla.kernel
en: Since Linux 2.6.12, if a process reaches its soft B<RLIMIT_CPU> limit and has a handler installed for B<SIGXCPU>, then, in addition to invoking the signal handler, the kernel increases the soft limit by one second.  This behavior repeats if the process continues to consume CPU time, until the hard limit is reached, at which point the process is killed.  Other implementations do not change the B<RLIMIT_CPU> soft limit in this manner, and the Linux behavior is probably not standards conformant; portable applications should avoid relying on this Linux-specific behavior.  The Linux-specific B<RLIMIT_RTTIME> limit exhibits the same behavior when the soft limit is encountered.
fr: A partir de Linux 2.6.12, si un processus atteint sa limite souple B<RLIMIT_CPU> et qu'il dispose d'un gestionnaire pour B<SIGXCPU>, alors en plus d'invoquer le gestionnaire de signal, le noyau augmente la limite souple d'une seconde. Ce comportement se répète si le processus continue de consommer du temps processeur, jusqu'à ce que la limite stricte soit atteinte, auquel cas le processus est tué. D'autres implémentations ne modifient pas la limite souple B<RLIMIT_CPU> de cette façon, et le comportement de Linux n'est alors probablement pas conforme aux standards ; pour cette raison, les applications portables doivent éviter de tabler sur ce comportement. La limite propre à Linux B<RLIMIT_RTTIME> se comporte de façon analogue lorsque la limite souple est atteinte.

note: type: Plain text
en: Kernels before 2.4.22 did not diagnose the error B<EINVAL> for B<setrlimit>()  when I<rlim-E<gt>rlim_cur> was greater than I<rlim-E<gt>rlim_max>.
fr: Les noyaux antérieurs à 2.4.22 ne détectaient pas l'erreur B<EINVAL> pour B<setrlimit>() quand I<rlim-E<gt>rlim_cur> était plus grand que I<rlim-E<gt>rlim_max>.

note: type: Plain text
en: The program below demonstrates the use of B<prlimit>().
fr: Le programme ci-dessous démontre l'utilisation de B<prlimit>().

note: type: Plain text
en:     if (!(argc == 2 || argc == 4)) {
            fprintf(stderr, "Usage: %s E<lt>pidE<gt> [E<lt>new-soft-limitE<gt> "
                    "E<lt>new-hard-limitE<gt>]\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (!(argc == 2 || argc == 4)) {
            fprintf(stderr, "Usage: %s E<lt>pidE<gt> [E<lt>nouvelle-limite-soupleE<gt> "
                    "E<lt>nouvelle-limite-stricteE<gt>]\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     pid = atoi(argv[1]);        /* PID of target process */
fr:     pid = atoi(argv[1]);        /* PID du processus cible */

note: type: Plain text
en:     /* Set CPU time limit of target process; retrieve and display
           previous limit */
fr:     /* Définir la limite de temps CPU du processus cible ;
           récupérer et afficher la limite de temps CPU antérieure */

note: type: Plain text
en:     if (prlimit(pid, RLIMIT_CPU, newp, &old) == -1)
            errExit("prlimit-1");
        printf("Previous limits: soft=%lld; hard=%lld\en",
                (long long) old.rlim_cur, (long long) old.rlim_max);
fr:     if (prlimit(pid, RLIMIT_CPU, newp, &old) == -1)
            errExit("prlimit-1");
        printf("Limites précédentes : souple=%lld; stricte=%lld\en",
                (long long) old.rlim_cur, (long long) old.rlim_max);

note: type: Plain text
en:     /* Retrieve and display new CPU time limit */
fr:     /* Récupérer et afficher la nouvelle limite de temps CPU */

note: type: Plain text
en:     if (prlimit(pid, RLIMIT_CPU, NULL, &old) == -1)
            errExit("prlimit-2");
        printf("New limits: soft=%lld; hard=%lld\en",
                (long long) old.rlim_cur, (long long) old.rlim_max);
fr:     if (prlimit(pid, RLIMIT_CPU, NULL, &old) == -1)
            errExit("prlimit-2");
        printf("Nouvelles limites: souple=%lld; stricte=%lld\en",
                (long long) old.rlim_cur, (long long) old.rlim_max);

note: type: TH
en: 2010-09-26
fr: 26 septembre 2010

note: type: Plain text
en: getrusage - get resource usage
fr: getrusage - Lire l'utilisation des ressources

note: type: Plain text
en: B<getrusage>()  returns resource usage measures for I<who>, which can be one of the following:
fr: B<getrusage>() renvoie la mesure de l'utilisation des ressources pour I<who>, qui peut valoir une des valeurs suivantes :

note: type: Plain text
en: Return resource usage statistics for the calling process, which is the sum of resources used by all threads in the process.
fr: Renvoyer les statistiques d'utilisation des ressources pour le processus appelant, ce qui correspond à la somme des ressources utilisées par tous les processus légers (I<threads>) du processus.

note: type: Plain text
en: Return resource usage statistics for all children of the calling process that have terminated and been waited for.  These statistics will include the resources used by grandchildren, and further removed descendants, if all of the intervening descendants waited on their terminated children.
fr: Renvoyer les statistiques d'utilisation des ressources pour tous les processus fils du processus appelant qui se sont terminés et dont la fin a été attendue (avec B<wait>(2)). Ces statistiques incluront les ressources utilisées par les petits-enfants, et autres descendants déjà retirés si tous les descendants en question ont attendu la fin de leurs enfants.

note: type: TP
en: B<RUSAGE_THREAD> (since Linux 2.6.26)
fr: B<RUSAGE_THREAD> (depuis Linux 2.6.26)

note: type: Plain text
en: Return resource usage statistics for the calling thread.
fr: Renvoyer les statistiques d'utilisation des ressources du processus léger appelant.

note: type: Plain text
en: The resource usages are returned in the structure pointed to by I<usage>, which has the following form:
fr: L'utilisation des ressources est renvoyée dans la structure pointée par I<usage>, qui est de la forme suivante :

note: type: Plain text
en: struct rusage {
        struct timeval ru_utime; /* user CPU time used */
        struct timeval ru_stime; /* system CPU time used */
        long   ru_maxrss;        /* maximum resident set size */
        long   ru_ixrss;         /* integral shared memory size */
        long   ru_idrss;         /* integral unshared data size */
        long   ru_isrss;         /* integral unshared stack size */
        long   ru_minflt;        /* page reclaims (soft page faults) */
        long   ru_majflt;        /* page faults (hard page faults) */
        long   ru_nswap;         /* swaps */
        long   ru_inblock;       /* block input operations */
        long   ru_oublock;       /* block output operations */
        long   ru_msgsnd;        /* IPC messages sent */
        long   ru_msgrcv;        /* IPC messages received */
        long   ru_nsignals;      /* signals received */
        long   ru_nvcsw;         /* voluntary context switches */
        long   ru_nivcsw;        /* involuntary context switches */
    };
fr: struct rusage {
      struct timeval ru_utime; /* Temps CPU utilisateur écoulé     */
      struct timeval ru_stime; /* Temps CPU système écoulé         */
      long  ru_maxrss;         /* Taille résidente maximale        */
      long  ru_ixrss;          /* Taille de mémoire partagée       */
      long  ru_idrss;          /* Taille des données non partagées */
      long  ru_isrss;          /* Taille de pile                   */
      long  ru_minflt;         /* Demandes de pages (soft)         */
      long  ru_majflt;         /* Nombre de fautes de pages (hard) */
      long  ru_nswap;          /* Nombre de swaps                  */
      long  ru_inblock;        /* Nombre de lectures de blocs      */
      long  ru_oublock;        /* Nombre d'écritures de blocs      */
      long  ru_msgsnd;         /* Nombre de messages IPC émis      */
      long  ru_msgrcv;         /* Nombre de messages IPC reçus     */
      long  ru_nsignals;       /* Nombre de signaux reçus          */
      long  ru_nvcsw;          /* Chgmnts de contexte volontaires  */
      long  ru_nivcsw;         /* Chgmnts de contexte involontaires*/
    };

note: type: Plain text
en: Not all fields are completed; unmaintained fields are set to zero by the kernel.  (The unmaintained fields are provided for compatibility with other systems, and because they may one day be supported on Linux.)  The fields are interpreted as follows:
fr: Tous les champs ne sont pas complètement remplis ; les champs non maintenus sont mis à zéro par le noyau (les champs non maintenus sont fournis pour assurer la compatibilité avec d'autres systèmes, et parce qu'ils pourraient un jour être supportés par Linux). Ces champs ont la signification suivante :

note: type: Plain text
en: This is the total amount of time spent executing in user mode, expressed in a I<timeval> structure (seconds plus microseconds).
fr: Temps total passé en mode utilisateur, mis dans une structure I<timeval> (secondes et microsecondes).

note: type: Plain text
en: This is the total amount of time spent executing in kernel mode, expressed in a I<timeval> structure (seconds plus microseconds).
fr: Temps total passé en mode noyau, mis dans une structure I<timeval> (secondes et microsecondes).

note: type: TP
en: I<ru_maxrss> (since Linux 2.6.32)
fr: I<ru_maxrss> (depuis Linux 2.6.32)

note: type: Plain text
en: This is the maximum resident set size used (in kilobytes).  For B<RUSAGE_CHILDREN>, this is the resident set size of the largest child, not the maximum resident set size of the process tree.
fr: Taille maximale de mémoire résidente utilisée (en kilooctets). Pour B<RUSAGE_CHILDREN>, il s'agit de la taille résidente du fils le plus grand, et non de la taille résidente maximale du processus.

note: type: TP
en: I<ru_ixrss> (unmaintained)
fr: I<ru_ixrss> (non maintenu)

note: On some systems, this field records the number of signals received. type: Plain text
en: This field is currently unused on Linux.
fr: Ce champ n'est actuellement pas utilisé par Linux.

note: type: TP
en: I<ru_idrss> (unmaintained)
fr: I<ru_idrss> (non maintenu)

note: type: TP
en: I<ru_isrss> (unmaintained)
fr: I<ru_isrss> (non maintenu)

note: type: Plain text
en: The number of page faults serviced without any I/O activity; here I/O activity is avoided by ``reclaiming'' a page frame from the list of pages awaiting reallocation.
fr: Le nombre d'erreurs de pagination (I<page fault>) sans activité d'entrées-sorties. Ici, cette activité est empêchée en réclamant une page qui se trouve dans la liste des pages qui attendent d'être réallouées.

note: type: Plain text
en: The number of page faults serviced that required I/O activity.
fr: Le nombre d'erreurs de pagination avec activité d'entrées-sorties.

note: type: TP
en: I<ru_nswap> (unmaintained)
fr: I<ru_nswap> (non maintenu)

note: type: TP
en: I<ru_inblock> (since Linux 2.6.22)
fr: I<ru_inblock> (depuis Linux 2.6.22)

note: type: Plain text
en: The number of times the filesystem had to perform input.
fr: Le nombre de fois où le système de fichiers a dû traiter des entrées.

note: type: TP
en: I<ru_oublock> (since Linux 2.6.22)
fr: I<ru_oublock> (depuis Linux 2.6.22)

note: type: Plain text
en: The number of times the filesystem had to perform output.
fr: Le nombre de fois où le système de fichiers a dû traiter des sorties.

note: type: TP
en: I<ru_msgsnd> (unmaintained)
fr: I<ru_msgsnd> (non maintenu)

note: type: TP
en: I<ru_msgrcv> (unmaintained)
fr: I<ru_msgrcv> (non maintenu)

note: type: TP
en: I<ru_nsignals> (unmaintained)
fr: I<ru_nsignals> (non maintenu)

note: type: TP
en: I<ru_nvcsw> (since Linux 2.6)
fr: I<ru_nvcsw> (depuis Linux 2.6)

note: type: Plain text
en: The number of times a context switch resulted due to a process voluntarily giving up the processor before its time slice was completed (usually to await availability of a resource).
fr: Le nombre de changements de contexte provoqués par un processus qui abandonne volontairement le processeur avant la fin de la tranche de temps qui lui est dévolue (habituellement pour attendre la disponibilité d'une ressource).

note: type: TP
en: I<ru_nivcsw> (since Linux 2.6)
fr: I<ru_nivcsw> (depuis Linux 2.6)

note: type: Plain text
en: The number of times a context switch resulted due to a higher priority process becoming runnable or because the current process exceeded its time slice.
fr: Le nombre de changements de contexte provoqués par un processus de plus grande priorité qui devient disponible à l'exécution, ou parce que le processus actuel a dépassé le temps limite qui lui était alloué.

note: type: Plain text
en: I<usage> points outside the accessible address space.
fr: I<usage> pointe en dehors de l'espace d'adressage disponible.

note: type: Plain text
en: I<who> is invalid.
fr: I<who> est invalide.

note: type: Plain text
en: SVr4, 4.3BSD.  POSIX.1-2001 specifies B<getrusage>(), but specifies only the fields I<ru_utime> and I<ru_stime>.
fr: SVr4, BSD\ 4.3. POSIX.1-2001 spécifie B<getrusage>(), mais spécifie seulement les champs I<ru_utime> et I<ru_stime>.

note: type: Plain text
en: B<RUSAGE_THREAD> is Linux-specific.
fr: B<RUSAGE_THREAD> est spécifique à Linux.

note: type: Plain text
en: Resource usage metrics are preserved across an B<execve>(2).
fr: Les mesures de l'utilisation des ressources sont conservées au travers d'un B<execve>(2).

note: type: Plain text
en: Including I<E<lt>sys/time.hE<gt>> is not required these days, but increases portability.  (Indeed, I<struct timeval> is defined in I<E<lt>sys/time.hE<gt>>.)
fr: L'inclusion de I<E<lt>sys/time.hE<gt>> n'est plus obligatoire mais améliore la portabilité. (En fait, I<struct timeval> est définie dans I<E<lt>sys/time.hE<gt>>).

note: See the description of getrusage() in XSH. A similar statement was also in SUSv2. type: Plain text
en: In Linux kernel versions before 2.6.9, if the disposition of B<SIGCHLD> is set to B<SIG_IGN> then the resource usages of child processes are automatically included in the value returned by B<RUSAGE_CHILDREN>, although POSIX.1-2001 explicitly prohibits this.  This nonconformance is rectified in Linux 2.6.9 and later.
fr: Sous Linux avant la version 2.6.9, si le traitement de B<SIGCHLD> est configuré avec B<SIG_IGN>, les statistiques d'utilisation des processus enfants sont automatiquement incluses dans les valeurs renvoyées par B<RUSAGE_CHILDREN>, bien que POSIX.1-2001 interdise explicitement cela. Cette non conformité est corrigée sous Linux 2.6.9 et ultérieurs.

note: type: Plain text
en: The structure definition shown at the start of this page was taken from 4.3BSD Reno.
fr: La définition de la structure fournie au début de cette page provient de 4.3BSD Reno.

note: type: Plain text
en: Ancient systems provided a B<vtimes>()  function with a similar purpose to B<getrusage>().  For backward compatibility, glibc also provides B<vtimes>().  All new applications should be written using B<getrusage>().
fr: Des systèmes anciens fournissent une fonction B<vlimit>() qui remplit le même rôle que B<getrusage>(). Pour des raisons de compatibilité ascendante, la glibc fournit aussi une fonction B<vlimit>(), mais toutes les nouvelles applications devraient utiliser B<getrusage>().

note: type: Plain text
en: See also the description of I</proc/PID/stat> in B<proc>(5).
fr: Consultez aussi la description de I</proc/PID/stat> dans B<proc>(5).

note: type: Plain text
en: getsid - get session ID
fr: getsid - Obtenir l'identifiant de session

note: type: Plain text
en: B<getsid>():
fr: B<getsid>() :

note: type: Plain text
en: || /* Since glibc 2.12: */ _POSIX_C_SOURCE\ E<gt>=\ 200809L
fr: || /* Depuis la glibc 2.12 : */ _POSIX_C_SOURCE\ E<gt>=\ 200809L

note: type: Plain text
en: I<getsid(0)> returns the session ID of the calling process.  I<getsid(p)> returns the session ID of the process with process ID I<p>.  (The session ID of a process is the process group ID of the session leader.)
fr: I<getsid(0)> renvoie l'identifiant de session du processus appelant. I<getsid(p)> renvoie l'identifiant de session du processus de PID I<p>. (L'identifiant de session d'un processus est l'identifiant du groupe de processus du leader de session.)

note: type: Plain text
en: On success, a session ID is returned.  On error, I<(pid_t)\ -1> will be returned, and I<errno> is set appropriately.
fr: L'appel renvoie un identifiant de session quand il réussit, ou I<(pid_t)\ -1> s'il échoue, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: A process with process ID I<p> exists, but it is not in the same session as the calling process, and the implementation considers this an error.
fr: Un processus de PID I<p> existe, mais il n'est pas dans la même session que le processus appelant, et l'implémentation considère ceci comme une erreur.

note: type: Plain text
en: No process with process ID I<p> was found.
fr: Il n'y a pas de processus de PID numéro I<p>.

note: Linux has this system call since Linux 1.3.44. There is libc support since libc 5.2.19. type: Plain text
en: This system call is available on Linux since version 2.0.
fr: Cet appel système est disponible sous Linux depuis la version 2.0.

note: type: Plain text
en: Linux does not return B<EPERM>.
fr: Linux ne renvoie pas d'erreur B<EPERM>.

note: type: Plain text
en: getuid, geteuid - get user identity
fr: getuid, geteuid - Obtenir l'identifiant de l'utilisateur

note: type: Plain text
en: B<getuid>()  returns the real user ID of the calling process.
fr: B<getuid>() retourne l'UID réel du processus appelant.

note: type: Plain text
en: B<geteuid>()  returns the effective user ID of the calling process.
fr: B<geteuid>() retourne l'UID effectif du processus appelant.

note: type: SS
en: History
fr: Historique

note: type: Plain text
en: In UNIX V6 the B<getuid>()  call returned I<(euid E<lt>E<lt> 8) + uid>.  UNIX V7 introduced separate calls B<getuid>()  and B<geteuid>().
fr: Dans UNIX V6, l'appel B<getuid>() renvoie I<(euid E<lt>E<lt> 8) + uid>. UNIX V7 a introduit des appels B<getuid>() et B<geteuid>() séparés.

note: type: Plain text
en: The original Linux B<getuid>()  and B<geteuid>()  system calls supported only 16-bit user IDs.  Subsequently, Linux 2.4 added B<getuid32>()  and B<geteuid32>(), supporting 32-bit IDs.  The glibc B<getuid>()  and B<geteuid>()  wrapper functions transparently deal with the variations across kernel versions.
fr: Les appels système B<getuid>() et B<geteuid>() originaux de Linux ne géraient que des identifiants d'utilisateur sur 16 bits. En conséquence, Linux 2.4 a ajouté B<getuid32>() et B<geteuid32>() qui prennent en charge des identifiants 32 bits. Les fonctions B<getuid>() et B<geteuid>() de la glibc qui les encapsulent gèrent de manière transparente ces différences entre noyaux.

note: type: TH
en: 2013-03-15
fr: 15 mars 2013

note: type: Plain text
en: iopl - change I/O privilege level
fr: iopl - Modifier le niveau de privilège d'entrée-sortie

note: type: Plain text
en: B<iopl>()  changes the I/O privilege level of the calling process, as specified by the two least significant bits in I<level>.
fr: B<iopl>() modifie le niveau de droits pour les entrées-sorties du processus appelant, en utilisant les deux bits de poids faible indiqués dans I<level>.

note: type: Plain text
en: This call is necessary to allow 8514-compatible X servers to run under Linux.  Since these X servers require access to all 65536 I/O ports, the B<ioperm>(2)  call is not sufficient.
fr: Cette fonction est indispensable pour permettre aux serveurs X compatibles 8514 de fonctionner sous Linux. Comme ces serveurs X ont besoin de l'accès aux 65536 ports d'entrée-sortie, la fonction B<ioperm>(2) ne serait pas suffisante.

note: type: Plain text
en: In addition to granting unrestricted I/O port access, running at a higher I/O privilege level also allows the process to disable interrupts.  This will probably crash the system, and is not recommended.
fr: En plus de disposer d'un accès illimité aux ports d'entrée-sortie, un processus tournant à un niveau de privilège élevé pourra également inhiber les interruptions. Ceci risque d'engendrer un plantage du système, et est fortement déconseillé.

note: type: Plain text
en: Permissions are inherited by B<fork>(2)  and B<execve>(2).
fr: Les permissions sont héritées aussi bien par B<fork>(2) que par B<execve>(2).

note: type: Plain text
en: The I/O privilege level for a normal process is 0.
fr: Le niveau de privilège d'entrée-sortie pour un utilisateur normal vaut 0.

note: type: Plain text
en: This call is mostly for the i386 architecture.  On many other architectures it does not exist or will always return an error.
fr: Cet appel existe principalement pour l'architecture i386. Sur beaucoup d'autres architectures, il est soit inexistant soit renvoie toujours une erreur.

note: type: Plain text
en: I<level> is greater than 3.
fr: I<level> est plus grand que 3.

note: type: Plain text
en: This call is unimplemented.
fr: Cet appel n'est pas implémenté.

note: type: Plain text
en: The calling process has insufficient privilege to call B<iopl>(); the B<CAP_SYS_RAWIO> capability is required to raise the I/O privilege level above its current value.
fr: Le processus appelant n'a pas assez de droits pour appeler B<iopl>() ; la capacité B<CAP_SYS_RAWIO> est nécessaire pour augmenter le niveau de droits d'entrées et sorties au-delà de sa valeur actuelle.

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

note: type: Plain text
en: Libc5 treats it as a system call and has a prototype in I<E<lt>unistd.hE<gt>>.  Glibc1 does not have a prototype.  Glibc2 has a prototype both in I<E<lt>sys/io.hE<gt>> and in I<E<lt>sys/perm.hE<gt>>.  Avoid the latter, it is available on i386 only.
fr: Libc5 considère qu'il s'agit d'un appel système et fournit le prototype dans I<E<lt>unistd.hE<gt>>. glibc1 n'offre pas de prototype. glibc2 fournit un prototype à la fois dans I<E<lt>sys/io.hE<gt>> et dans I<E<lt>sys/perm.hE<gt>>. Évitez ce dernier, il n'est disponible que sur les i386.

note: type: Plain text
en: ioprio_get, ioprio_set - get/set I/O scheduling class and priority
fr: ioprio_get, ioprio_set - Lire et écrire la classe et la priorité d'ordonnancement des E/S

note: type: Plain text
en: I<Note>: There are no glibc wrappers for these system calls; see NOTES.
fr: I<Note> : il n'y a pas de fonctions d'enrobage pour ces appels système. Consultez les NOTES.

note: type: Plain text
en: The B<ioprio_get>()  and B<ioprio_set>()  system calls respectively get and set the I/O scheduling class and priority of one or more threads.
fr: Les appels système B<ioprio_get>() et B<ioprio_set>() respectivement lisent et écrivent la classe et la priorité d'ordonnancement des entrées et sorties pour un ou plusieurs processus.

note: type: Plain text
en: The I<which> and I<who> arguments identify the thread(s) on which the system calls operate.  The I<which> argument determines how I<who> is interpreted, and has one of the following values:
fr: Les arguments I<which> et I<who> identifient le(s) thread(s) sur lesquels les appels système agissent. L'argument I<which> détermine comment I<who> est interprété, et prend l'une des valeurs suivantes\ :

note: type: Plain text
en: I<who> is a process ID or thread ID identifying a single process or thread.  If I<who> is 0, then operate on the calling thread.
fr: I<who> est l'identifiant d'un processus ou d'un thread. Si I<who> vaut 0, alors l'action s'applique au thread appelant.

note: type: Plain text
en: I<who> is a process group ID identifying all the members of a process group.  If I<who> is 0, then operate on the process group of which the caller is a member.
fr: I<who> est l'identifiant d'un groupe de processus et se réfère à tous les membres de ce groupe. Si I<who> vaut 0, alors l'action s'applique au groupe de processus auquel l'appelant appartient.

note: FIXME who==0 needs to be documented, See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=652443 type: Plain text
en: I<who> is a user ID identifying all of the processes that have a matching real UID.
fr: I<who> est un UID identifiant tous les processus dont l'UID réel correspond.

note: type: Plain text
en: If I<which> is specified as B<IOPRIO_WHO_PGRP> or B<IOPRIO_WHO_USER> when calling B<ioprio_get>(), and more than one process matches I<who>, then the returned priority will be the highest one found among all of the matching processes.  One priority is said to be higher than another one if it belongs to a higher priority class (B<IOPRIO_CLASS_RT> is the highest priority class; B<IOPRIO_CLASS_IDLE> is the lowest)  or if it belongs to the same priority class as the other process but has a higher priority level (a lower priority number means a higher priority level).
fr: Si I<which> vaut B<IOPRIO_WHO_PGRP> ou B<IOPRIO_WHO_USER> à l'appel de B<ioprio_get>(), et si plus d'un processus correspond à I<who>, la priorité renvoyée sera la plus grande des priorités des processus correspondants. Une priorité est dite plus grande qu'une autre si elle appartient à une classe de priorité supérieure (B<IOPRIO_CLASS_RT> est la classe la plus haute\ ; B<IOPRIO_CLASS_IDLE> est la plus basse) ou si elle appartient à la même classe mais a un niveau de priorité plus élevé (donc un numéro de priorité plus faible).

note: type: Plain text
en: The I<ioprio> argument given to B<ioprio_set>()  is a bit mask that specifies both the scheduling class and the priority to be assigned to the target process(es).  The following macros are used for assembling and dissecting I<ioprio> values:
fr: L'argument I<ioprio> donné à B<ioprio_set>() est un masque de bits indiquant la classe et la priorité à donner au(x) processus cible(s). Les macros suivantes servent à créer et à tester les valeurs I<ioprio>\ :

note: type: Plain text
en: Given a scheduling I<class> and priority (I<data>), this macro combines the two values to produce an I<ioprio> value, which is returned as the result of the macro.
fr: Étant données une classe d'ordonnancement (I<class>) et une priorité (I<data>), cette macro combine les deux valeurs pour créer une valeur I<ioprio>, qui est renvoyée comme résultat.

note: type: Plain text
en: Given I<mask> (an I<ioprio> value), this macro returns its I/O class component, that is, one of the values B<IOPRIO_CLASS_RT>, B<IOPRIO_CLASS_BE>, or B<IOPRIO_CLASS_IDLE>.
fr: À partir de I<mask> (une valeur I<ioprio>) cette macro renvoie sa classe d'E/S, c'est-à-dire une valeur parmi B<IOPRIO_CLASS_RT>, B<IOPRIO_CLASS_BE> et B<IOPRIO_CLASS_IDLE>.

note: type: Plain text
en: Given I<mask> (an I<ioprio> value), this macro returns its priority (I<data>)  component.
fr: Étant donné I<mask> (une valeur I<ioprio>), renvoie la priorité (I<data>) correspondante.

note: type: Plain text
en: See the NOTES section for more information on scheduling classes and priorities.
fr: Consultez la section NOTES pour plus d'informations sur les classes et priorités d'ordonnancement.

note: type: Plain text
en: I/O priorities are supported for reads and for synchronous (B<O_DIRECT>, B<O_SYNC>)  writes.  I/O priorities are not supported for asynchronous writes because they are issued outside the context of the program dirtying the memory, and thus program-specific priorities do not apply.
fr: Les priorités d'E/S sont gérées pour les lectures et pour les écritures synchrones (B<O_DIRECT>, B<O_SYNC>). Les priorités d'E/S ne sont pas gérées pour les écritures asynchrones parce qu'elles sont lancées hors du contexte du programme touchant la mémoire, ce qui fait que les priorités spécifiques à chaque programme ne s'appliquent pas.

note: type: Plain text
en: On success, B<ioprio_get>()  returns the I<ioprio> value of the process with highest I/O priority of any of the processes that match the criteria specified in I<which> and I<who>.  On error, -1 is returned, and I<errno> is set to indicate the error.
fr: Lorsqu'il réussit, B<ioprio_get>() renvoie la valeur I<ioprio> du processus dont la priorité d'E/S est la plus grande parmi les processus correspondant aux critères indiqués par I<which> et I<who>. En cas d'erreur, -1 est renvoyé, et I<errno> contient le code d'erreur.

note: type: Plain text
en: On success, B<ioprio_set>()  returns 0.  On error, -1 is returned, and I<errno> is set to indicate the error.
fr: S'il réussit, B<ioprio_set>() renvoie zéro. En cas d'erreur, il renvoie -1 et remplit I<errno> avec la valeur d'erreur.

note: type: Plain text
en: Invalid value for I<which> or I<ioprio>.  Refer to the NOTES section for available scheduler classes and priority levels for I<ioprio>.
fr: I<which> ou I<ioprio> est invalide. Consultez la section NOTES pour les classes et priorités d'ordonnancement disponibles pour I<ioprio>.

note: type: Plain text
en: The calling process does not have the privilege needed to assign this I<ioprio> to the specified process(es).  See the NOTES section for more information on required privileges for B<ioprio_set>().
fr: Le processus appelant n'a pas les privilèges nécessaires pour attribuer cette priorité I<ioprio> au(x) processus indiqué(s). Consultez la section NOTES pour plus d'informations sur les privilèges nécessaires pour B<ioprio_set>().

note: type: Plain text
en: No process(es) could be found that matched the specification in I<which> and I<who>.
fr: Aucun processus ne correspond aux critères indiqués par I<which> et I<who>.

note: type: Plain text
en: These system calls have been available on Linux since kernel 2.6.13.
fr: Ces appels système sont disponibles sous Linux depuis le noyau 2.6.13.

note: type: Plain text
en: Glibc does not provide a wrapper for these system calls; call them using B<syscall>(2).
fr: La glibc ne fournit pas de fonction d'enrobage autour de ces appels système\ ; appelez-les avec B<syscall>(2).

note: type: Plain text
en: Two or more processes or threads can share an I/O context.  This will be the case when B<clone>(2)  was called with the B<CLONE_IO> flag.  However, by default, the distinct threads of a process will B<not> share the same I/O context.  This means that if you want to change the I/O priority of all threads in a process, you may need to call B<ioprio_set>()  on each of the threads.  The thread ID that you would need for this operation is the one that is returned by B<gettid>(2)  or B<clone>(2).
fr: Plusieurs processus ou threads peuvent partager un contexte d'entrées-sorties. Cela est le cas lorsque B<clone>(2) a été appelé avec l'attribut B<CLONE_IO>. Cependant, par défaut, les threads distincts d'un processus B<ne> partagent B<pas> le même contexte d'entrées-sorties. Cela signifie que si vous voulez changer la priorité d'entrées-sortie de tous les threads d'un processus, il peut être nécessaire d'appeler B<ioprio_set>() sur chacun de ces threads. L'identifiant du thread nécessaire pour cette opération est renvoyé par B<gettid>(2) ou B<clone>(2).

note: type: Plain text
en: These system calls have an effect only when used in conjunction with an I/O scheduler that supports I/O priorities.  As at kernel 2.6.17 the only such scheduler is the Completely Fair Queuing (CFQ) I/O scheduler.
fr: Ces appels système n'ont d'effet que lorsqu'ils sont utilisés avec un ordonnanceur d'E/S qui gère les priorités d'E/S. Sous Linux 2.6.17, l'ordonnanceur «\ Completely Fair Queuing\ » (CFQ) est le seul ordonnanceur d'E/S de ce type.

note: type: SS
en: Selecting an I/O scheduler
fr: Choisir un ordonnanceur d'E/S

note: type: Plain text
en: I/O Schedulers are selected on a per-device basis via the special file I</sys/block/E<lt>deviceE<gt>/queue/scheduler>.
fr: Les ordonnanceurs d'E/S sont sélectionnés pour chaque périphérique par le fichier spécial I</sys/block/E<lt>deviceE<gt>/queue/scheduler>.

note: type: Plain text
en: One can view the current I/O scheduler via the I</sys> filesystem.  For example, the following command displays a list of all schedulers currently loaded in the kernel:
fr: On peut voir quel ordonnanceur d'E/S est actuellement sélectionné via le système de fichiers I</sys>. Par exemple, la commande suivante affiche la liste des ordonnanceurs chargés dans le noyau\ :

note: type: Plain text
en: The scheduler surrounded by brackets is the one actually in use for the device (I<hda> in the example).  Setting another scheduler is done by writing the name of the new scheduler to this file.  For example, the following command will set the scheduler for the I<hda> device to I<cfq>:
fr: L'ordonnanceur entre crochets est celui qui est utilisé pour le périphérique (I<hda> dans l'exemple). Pour choisir un autre ordonnanceur, on écrit son nom dans ce fichier. Par exemple, la commande suivante définit l'ordonnanceur pour le périphérique I<hda> à I<cfq>\ :

note: type: SS
en: The Completely Fair Queuing (CFQ) I/O scheduler
fr: L'ordonnanceur d'E/S «\ Completely Fair Queuing\ » (CFQ)

note: type: Plain text
en: Since v3 (aka CFQ Time Sliced) CFQ implements I/O nice levels similar to those of CPU scheduling.  These nice levels are grouped in three scheduling classes each one containing one or more priority levels:
fr: Depuis la version 3 («\ CFQ Time Sliced\ »), CFQ implémente des niveaux de politesse d'E/S similaires à ceux de l'ordonnancement CPU. Ces niveaux de politesse sont groupés en trois classes d'ordonnancement, chacune de ces classes contenant un ou plusieurs niveaux de priorité\ :

note: type: Plain text
en: This is the real-time I/O class.  This scheduling class is given higher priority than any other class: processes from this class are given first access to the disk every time.  Thus this I/O class needs to be used with some care: one I/O real-time process can starve the entire system.  Within the real-time class, there are 8 levels of class data (priority) that determine exactly how much time this process needs the disk for on each service.  The highest real-time priority level is 0; the lowest is 7.  In the future this might change to be more directly mappable to performance, by passing in a desired data rate instead.
fr: Il s'agit de la classe d'E/S temps réel. Cette classe d'ordonnancement a une priorité plus grande que toutes les autres classes\ : les processus de cette classe ont toujours accès au disque en premier. Cette classe d'E/S doit donc être utilisée avec parcimonie\ : un seul processus avec des E/S temps réel peut bloquer tout le système. Au sein de la classe temps réel, il y a 8 niveaux de priorité qui déterminent exactement pendant combien de temps ce processus aura besoin du disque à chaque service. La plus haute priorité temps réel est 0\ ; la plus basse est 7. Dans le futur, ceci pourra changer afin d'être plus directement corrélé à la performance, en passant le débit de données souhaité à la place de la priorité.

note: type: Plain text
en: This is the best-effort scheduling class, which is the default for any process that hasn't set a specific I/O priority.  The class data (priority) determines how much I/O bandwidth the process will get.  Best-effort priority levels are analogous to CPU nice values (see B<getpriority>(2)).  The priority level determines a priority relative to other processes in the best-effort scheduling class.  Priority levels range from 0 (highest) to 7 (lowest).
fr: Classe d'ordonnancement «\ best-effort\ », qui est utilisée par défaut pour les processus qui n'ont pas indiqué de priorité d'E/S particulière. La priorité de classe détermine combien de bande passante d'E/S le processus obtiendra. Les niveaux de priorité best-effort sont similaires aux valeurs de politesse CPU (consultez B<getpriority>(2)). Le niveau de priorité détermine une priorité par rapport aux autres processus dans la classe d'ordonnancement best-effort. Les niveaux de priorité vont de 0 (plus prioritaire) à 7 (moins prioritaire).

note: type: Plain text
en: This is the idle scheduling class.  Processes running at this level only get I/O time when no-one else needs the disk.  The idle class has no class data.  Attention is required when assigning this priority class to a process, since it may become starved if higher priority processes are constantly accessing the disk.
fr: Classe d'ordonnancement «\ idle\ ». Les processus s'exécutant à ce niveau n'obtiennent du temps d'E/S que lorsque personne d'autre n'a besoin du disque. La classe idle n'a pas de donnée (priorité) de classe. Il faut faire attention lorsque l'on met un processus dans cette classe de priorité, car il peut être bloqué si des processus de plus haute priorité accèdent constamment au disque.

note: type: Plain text
en: Refer to I<Documentation/block/ioprio.txt> for more information on the CFQ I/O Scheduler and an example program.
fr: Consultez I<Documentation/block/ioprio.txt> pour plus d'informations sur l'ordonnanceur d'E/S CFQ et un exemple de programme.

note: type: SS
en: Required permissions to set I/O priorities
fr: Permissions nécessaires pour définir les priorités d'E/S

note: type: Plain text
en: Permission to change a process's priority is granted or denied based on two assertions:
fr: La permission de modifier la priorité d'un processus est accordée ou refusée en fonction de deux critères\ :

note: type: TP
en: B<Process ownership>
fr: B<Propriétaire du processus>

note: type: Plain text
en: An unprivileged process may set only the I/O priority of a process whose real UID matches the real or effective UID of the calling process.  A process which has the B<CAP_SYS_NICE> capability can change the priority of any process.
fr: Un processus non privilégié ne peut définir la priorité d'E/S que des processus dont l'UID réel est égal à l'UID réel ou effectif du processus appelant. Un processus ayant la capacité B<CAP_SYS_NICE> peut modifier la priorité de n'importe quel processus.

note: type: TP
en: B<What is the desired priority>
fr: B<Priorité désirée>

note: type: Plain text
en: Attempts to set very high priorities (B<IOPRIO_CLASS_RT>)  require the B<CAP_SYS_ADMIN> capability.  Kernel versions up to 2.6.24 also required B<CAP_SYS_ADMIN> to set a very low priority (B<IOPRIO_CLASS_IDLE>), but since Linux 2.6.25, this is no longer required.
fr: Pour pouvoir définir une priorité très haute ((B<IOPRIO_CLASS_RT>), il faut avoir la capacité B<CAP_SYS_ADMIN>. Les noyaux antérieurs à 2.6.24 (compris) nécessitent également B<CAP_SYS_ADMIN> pour définir une priorité très faible ((B<IOPRIO_CLASS_IDLE>), mais depuis 2.6.25, ce n'est plus le cas.

note: type: Plain text
en: A call to B<ioprio_set>()  must follow both rules, or the call will fail with the error B<EPERM>.
fr: Un appel à B<ioprio_set>() doit suivre ces deux règles, sans quoi il échoue avec l'erreur B<EPERM>.

note: 6 May 07: Bug report raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=4464 Ulrich Drepper replied that he wasn't going to add these to glibc. type: Plain text
en: Glibc does not yet provide a suitable header file defining the function prototypes and macros described on this page.  Suitable definitions can be found in I<linux/ioprio.h>.
fr: Glibc ne fournit pas encore de fichier d'en\(hytête définissant les prototypes de fonctions et les macros décrits dans cette page. Les définitions se trouvent dans I<linux/ioprio.h>.

note: type: Plain text
en: I<Documentation/block/ioprio.txt> in the Linux kernel source tree
fr: I<Documentation/block/ioprio.txt> dans les sources du noyau Linux

note: type: TH
en: 2012-10-16
fr: 16 octobre 2012

note: type: Plain text
en: ipc - System V IPC system calls
fr: ipc - Appeler les fonctions IPC du System V

note: type: Plain text
en: B<ipc>()  is a common kernel entry point for the System V IPC calls for messages, semaphores, and shared memory.  I<call> determines which IPC function to invoke; the other arguments are passed through to the appropriate call.
fr: B<ipc>() est un point commun d'entrée dans le noyau pour les appels système IPC du System V qui concernent les messages, les sémaphores et la mémoire partagée. I<call> indique la fonction IPC à invoquer. Les autres arguments sont transmis à l'appel système approprié.

note: type: Plain text
en: User programs should call the appropriate functions by their usual names.  Only standard library implementors and kernel hackers need to know about B<ipc>().
fr: Les programmes utilisateurs doivent appeler les fonctions par leurs noms habituels. Seuls les implémenteurs de bibliothèques standards et les hackers Linux peuvent avoir besoin d'employer B<ipc>().

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

note: type: Plain text
en: On some architectures\(emfor example x86-64 and ARM\(emthere is no B<ipc>()  system call; instead B<msgctl>(2), B<semctl>(2), B<shmctl>(2), and so on really are implemented as separate system calls.
fr: Sur quelques architectures — par exemple x86-64 et ARM — il n'existe pas d'appel système B<ipc>()\ ; B<msgctl>(2), B<semctl>(2), B<shmctl>(2) et autres y sont implémentés comme des appels système distincts.

note: type: TH
en: 2012-07-02
fr: 2 juillet 2012

note: type: Plain text
en: seteuid, setegid - set effective user or group ID
fr: seteuid, setegid - Définir les UID et GID effectifs

note: type: Plain text
en: B<seteuid>(), B<setegid>():
fr: B<seteuid>(), B<setegid>()\ :

note: type: Plain text
en: B<seteuid>()  sets the effective user ID of the calling process.  Unprivileged user processes may only set the effective user ID to the real user ID, the effective user ID or the saved set-user-ID.
fr: B<seteuid>() définit l'UID effectif du processus appelant. Les processus non privilégiés peuvent uniquement définir leur UID effectif à la valeur de leur UID réel, de leur UID effectif ou de leur UID sauvé.

note: When .I euid equals \-1, nothing is changed. (This is an artifact of the implementation in glibc of seteuid() using setresuid(2).) type: Plain text
en: Precisely the same holds for B<setegid>()  with "group" instead of "user".
fr: Ceci fonctionne exactement de la même façon avec B<setegid>() en raisonnant en terme de groupe (GID) au lieu d'utilisateur (UID).

note: type: Plain text
en: The calling process is not privileged (Linux: does not have the B<CAP_SETUID> capability in the case of B<seteuid>(), or the B<CAP_SETGID> capability in the case of B<setegid>())  and I<euid> (respectively, I<egid>)  is not the real user (group) ID, the effective user (group) ID, or the saved set-user-ID (saved set-group-ID).
fr: Le processus appelant n'est pas privilégié (sous Linux\ : n'a pas la capacité B<CAP_SETUID> dans le cas de B<seteuid>(), ou la capacité B<CAP_SETGID> dans le cas de B<setegid>()), et l'argument I<euid> (respectivement I<egid>) n'est pas l'UID (respectivement GID) réel, effectif ou sauvé.

note: type: Plain text
en: 4.3BSD, POSIX.1-2001.
fr: BSD\ 4.3, POSIX.1-2001.

note: type: Plain text
en: Setting the effective user (group) ID to the saved set-user-ID (saved set-group-ID) is possible since Linux 1.1.37 (1.1.38).  On an arbitrary system one should check B<_POSIX_SAVED_IDS>.
fr: Définir l'UID (GID) effectif à la valeur de l'UID (GID) sauvé est possible depuis Linux 1.1.37 (1.1.38). Sur un système UNIX inconnu, il faut vérifier la présence de la constante B<_POSIX_SAVED_IDS>.

note: type: Plain text
en: Under libc4, libc5 and glibc 2.0 B<seteuid(>I<euid>B<)> is equivalent to B<setreuid(-1,>I< euid>B<)> and hence may change the saved set-user-ID.  Under glibc 2.1 and later it is equivalent to B<setresuid(-1,>I< euid>B<, -1)> and hence does not change the saved set-user-ID.  Analogous remarks hold for B<setegid>(), with the difference that the change in implementation from B<setregid(-1,>I< egid>B<)> to B<setresgid(-1,>I< egid>B<, -1)> occurred in glibc 2.2 or 2.3 (depending on the hardware architecture).
fr: Sous libc4, libc5, et glibc 2.0, B<seteuid(>I<euid>B<)> est équivalent à B<setreuid(-1,>I< euid>B<)> et modifie ainsi l'UID sauvé. Sous glibc 2.1 et les versions suivantes, c'est équivalent à B<setresuid(-1,>I< euid>B<, -1)> et ne modifie donc pas l'UID sauvé. Les mêmes remarques sont valables pour B<setegid>(), à la différence que le changement d'implémentation de B<setregid(-1,>I< egid>B<)> à B<setresgid(-1,>I< egid>B<, -1)> est apparu dans glibc 2.2 ou 2.3 (en fonction de l'architecture matérielle).

note: type: Plain text
en: According to POSIX.1, B<seteuid>()  (B<setegid>())  need not permit I<euid> (I<egid>)  to be the same value as the current effective user (group) ID, and some implementations do not permit this.
fr: D'après POSIX.1, B<seteuid>() (resp. B<setegid>()) n'a pas besoin de permettre à I<euid> (resp. I<egid>) d'avoir la même valeur que l'identifiant d'utilisateur (resp. de groupe) effectif, et certaines implémentations ne le permettent effectivement pas.

note: type: TH
en: 2013-08-08
fr: 8 août 2013

note: type: Plain text
en: setfsgid - set group identity used for filesystem checks
fr: setfsgid - Définir le GID pour les vérifications d'accès au système de fichiers

note: type: Plain text
en: The system call B<setfsgid>()  changes the value of the caller's filesystem group ID\(emthe group ID that the Linux kernel uses to check for all accesses to the filesystem.  Normally, the value of the filesystem group ID will shadow the value of the effective group ID.  In fact, whenever the effective group ID is changed, the filesystem group ID will also be changed to the new value of the effective group ID.
fr: L'appel B<setfsgid>() modifie la valeur de l'identifiant du groupe (GID) que le noyau Linux utilise pour valider les accès au système de fichiers. Normalement, la valeur de l'identifiant s'alignera sur la valeur effective de l'identifiant de l'utilisateur. En pratique, si le GID effectif est modifié, la valeur du GID au niveau du système de fichiers sera également mise à jour à la nouvelle valeur du GID effectif.

note: type: Plain text
en: Explicit calls to B<setfsuid>(2)  and B<setfsgid>()  are usually used only by programs such as the Linux NFS server that need to change what user and group ID is used for file access without a corresponding change in the real and effective user and group IDs.  A change in the normal user IDs for a program such as the NFS server is a security hole that can expose it to unwanted signals.  (But see below.)
fr: L'appel explicite de B<setfsuid>(2) ou B<setfsgid>() n'est normalement utile qu'aux programmes tels que le serveur NFS qui ont besoin de modifier le GID utilisé pour les accès aux fichiers sans changer véritablement leurs GID réels et effectifs. Une modification des identifiants normaux d'un programme comme un serveur NFS serait un trou de sécurité qui l'exposerait à des signaux indésirables. Voir ci\(hydessous.

note: type: Plain text
en: B<setfsgid>()  will succeed only if the caller is the superuser or if I<fsgid> matches either the caller's real group ID, effective group ID, saved set-group-ID, or current the filesystem user ID.
fr: B<setfsgid>() ne réussira que si l'appelant est le superutilisateur ou si I<fsgid> correspond au GID réel de l'appelant, à son GID effectif, à son GID sauvé, ou encore à la valeur de l'identifiant de l'utilisateur dans le système de fichiers au moment de l'appel.

note: type: Plain text
en: On both success and failure, this call returns the previous filesystem group ID of the caller.
fr: En cas de succès comme en cas d'échec, l'appel renvoie la dernière valeur de l'identifiant du groupe (GID) de l'appelant dans le système de fichiers.

note: This system call is present since Linux 1.1.44 and in libc since libc 4.7.6. type: Plain text
en: This system call is present in Linux since version 1.2.
fr: Cet appel système est présent sous Linux depuis la version 1.2.

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

note: type: Plain text
en: When glibc determines that the argument is not a valid group ID, it will return -1 and set I<errno> to B<EINVAL> without attempting the system call.
fr: Lorsque la bibliothèque glibc s'aperçoit que l'argument n'est pas un GID valide, elle renvoie -1 et place B<EINVAL> dans I<errno> sans essayer d'appeler l'appel système réel.

note: type: Plain text
en: Note that at the time this system call was introduced, a process could send a signal to a process with the same effective user ID.  Today signal permission handling is slightly different.  See B<setfsuid>(2)  for a discussion of why the use of both B<setfsuid>(2)  and B<setfsgid>()  is nowadays unneeded.
fr: Notez que lors de l'introduction de cet appel système, un processus pouvait envoyer un signal à un autre processus avec le même UID effectif. De nos jours, les permissions pour les signaux sont légèrement différentes. Consultez  B<setfsuid>(2) si vous souhaitez connaître les raisons pour lesquelles B<setfsuid>(2)  et B<setfsgid>() ne sont désormais plus nécessaires.

note: type: Plain text
en: The original Linux B<setfsgid>()  system call supported only 16-bit group IDs.  Subsequently, Linux 2.4 added B<setfsgid32>()  supporting 32-bit IDs.  The glibc B<setfsgid>()  wrapper function transparently deals with the variation across kernel versions.
fr: L'appel système B<setfsgid>() original de Linux ne gérait que des identifiants de groupe sur 16 bits. En conséquence, Linux 2.4 a ajouté B<setfsgid32>() qui prend en charge des identifiants 32 bits. La fonction B<setfsgid>() de la glibc qui l'encapsule gère de manière transparente ces différences entre noyaux.

note: type: Plain text
en: No error indications of any kind are returned to the caller, and the fact that both successful and unsuccessful calls return the same value makes it impossible to directly determine whether the call succeeded or failed.  Instead, the caller must resort to looking at the return value from a further call such as I<setfsgid(-1)> (which will always fail), in order to determine if a preceding call to B<setfsgid>()  changed the filesystem group ID.  At the very least, B<EPERM> should be returned when the call fails (because the caller lacks the B<CAP_SETGID> capability).
fr: Aucune indication concernant l'erreur n'est renvoyée à l'appelant et le fait que la même valeur soit retournée en cas de succès ou d'échec ne permet pas de savoir si l'appel a réussi ou échoué. Pour cela, l'appelant devra se référer à la valeur renvoyée par un appel ultérieur par exemple à I<setfsgid(-1)> (qui échouera toujours). Cet appel permettra de savoir si un appel antérieur à B<setfsgid>() a changé l'identifiant du groupe (GID) au niveau du système de fichiers. Au minimum, B<EPERM> doit être renvoyé lorsque l'appel échoue (puisque l'appelant ne dispose pas des privilèges B<CAP_SETGID>).

note: type: Plain text
en: setfsuid - set user identity used for filesystem checks
fr: setfsuid - Définir l'UID pour les vérifications d'accès au système de fichiers

note: type: Plain text
en: The system call B<setfsuid>()  changes the value of the caller's filesystem user ID\(emthe user ID that the Linux kernel uses to check for all accesses to the filesystem.  Normally, the value of the filesystem user ID will shadow the value of the effective user ID.  In fact, whenever the effective user ID is changed, the filesystem user ID will also be changed to the new value of the effective user ID.
fr: L'appel B<setfsuid>() modifie la valeur de l'identifiant de l'appelant (UID) que le noyau Linux utilise pour valider les accès au système de fichiers. Normalement, la valeur de l'identifiant s'alignera sur la valeur effective de l'identifiant de l'utilisateur. En pratique, si l'UID effectif est modifié, la valeur de l'UID au niveau du système de fichiers sera également mise à jour à la nouvelle valeur de l'UID effectif.

note: type: Plain text
en: Explicit calls to B<setfsuid>()  and B<setfsgid>(2)  are usually used only by programs such as the Linux NFS server that need to change what user and group ID is used for file access without a corresponding change in the real and effective user and group IDs.  A change in the normal user IDs for a program such as the NFS server is a security hole that can expose it to unwanted signals.  (But see below.)
fr: L'appel explicite de B<setfsuid>() ou B<setfsgid>(2) n'est normalement utile qu'aux programmes tels que le serveur NFS qui ont besoin de modifier le GID utilisé pour les accès aux fichiers sans changer véritablement leurs GID réels et effectifs. Une modification des identifiants normaux d'un programme comme un serveur NFS serait un trou de sécurité qui l'exposerait à des signaux indésirables. Voir ci\(hydessous.

note: type: Plain text
en: B<setfsuid>()  will succeed only if the caller is the superuser or if I<fsuid> matches either the caller's real user ID, effective user ID, saved set-user-ID, or current filesystem user ID.
fr: B<setfsuid>() ne réussira que si l'appelant est le superutilisateur ou si I<fsuid> correspond à l'UID réel de l'appelant, à son l'UID effectif, à son UID sauvé, ou encore à la valeur de I'UID au niveau du système de fichier au moment de l'appel.

note: type: Plain text
en: On both success and failure, this call returns the previous filesystem user ID of the caller.
fr: En cas de succès comme en cas d'échec, l'appel renvoie la dernière valeur de l'identifiant utilisateur (UID) de l'appelant dans le système de fichiers.

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

note: type: Plain text
en: When glibc determines that the argument is not a valid user ID, it will return -1 and set I<errno> to B<EINVAL> without attempting the system call.
fr: Lorsque la bibliothèque glibc s'aperçoit que l'argument n'est pas un UID valide, elle renvoie -1 et place B<EINVAL> dans I<errno> sans essayer d'appeler l'appel système réel.

note: type: Plain text
en: At the time when this system call was introduced, one process could send a signal to another process with the same effective user ID.  This meant that if a privileged process changed its effective user ID for the purpose of file permission checking, then it could become vulnerable to receiving signals sent by another (unprivileged) process with the same user ID.  The filesystem user ID attribute was thus added to allow a process to change its user ID for the purposes of file permission checking without at the same time becoming vulnerable to receiving unwanted signals.  Since Linux 2.0, signal permission handling is different (see B<kill>(2)), with the result that a process change can change its effective user ID without being vulnerable to receiving signals from unwanted processes.  Thus, B<setfsuid>()  is nowadays unneeded and should be avoided in new applications (likewise for B<setfsgid>(2)).
fr: Lorsque cet appel système a été introduit, un processus pouvait envoyer un signal à un autre processus avec le même identifiant utilisateur effectif. Cela avait pour conséquence que si un processus disposant de privilèges changeait son identifiant utilisateur effectif afin de valider les droits d'un fichier, il était susceptible de recevoir des signaux d'un autre processus (ne disposant pas de privilèges) avec le même identifiant utilisateur. Pour cette raison, l'attribut ID utilisateur a été introduit au niveau du système de fichiers pour permettre à un processus de changer son identifiant utilisateur et valider les droits d'un fichier, sans pour autant devenir vulnérables au signaux envoyés par d'autres processus. A partir de Linux 2.0, la prise en charge des permissions des signaux a évolué (consultez B<kill>(2)), de sorte que la modification d'un processus puisse changer l'ID utilisateur effectif sans pour autant rendre le processus vulnérable aux signaux non sollicités envoyés par d'autres processus. Ainsi, B<setfsuid>() n'est désormais plus nécessaire et on doit éviter d'y avoir recours dans les nouvelles applications (de même qu'on évitera d'utiliser B<setfsgid>(2)).

note: type: Plain text
en: The original Linux B<setfsuid>()  system call supported only 16-bit user IDs.  Subsequently, Linux 2.4 added B<setfsuid32>()  supporting 32-bit IDs.  The glibc B<setfsuid>()  wrapper function transparently deals with the variation across kernel versions.
fr: L'appel système B<setfsuid>() original de Linux ne gérait que des identifiants d'utilisateur sur 16 bits. En conséquence, Linux 2.4 a ajouté B<setfsuid32>() qui prend en charge des identifiants 32 bits. La fonction B<setfsuid>() de la glibc qui l'encapsule gère de manière transparente ces différences entre noyaux.

note: type: Plain text
en: No error indications of any kind are returned to the caller, and the fact that both successful and unsuccessful calls return the same value makes it impossible to directly determine whether the call succeeded or failed.  Instead, the caller must resort to looking at the return value from a further call such as I<setfsuid(-1)> (which will always fail), in order to determine if a preceding call to B<setfsuid>()  changed the filesystem user ID.  At the very least, B<EPERM> should be returned when the call fails (because the caller lacks the B<CAP_SETUID> capability).
fr: Aucune indication concernant l'erreur n'est renvoyée à l'appelant et le fait que la même valeur soit retournée en cas de succès ou d'échec ne permet pas de savoir si l'appel a réussi ou échoué. Pour cela, l'appelant devra se référer à la valeur renvoyée par un appel ultérieur par exemple à I<setfsuid(-1)> (qui échouera toujours). Cet appel permettra de savoir si un appel antérieur à B<setfsuid>() a changé l'identifiant utilisateur au niveau du système de fichiers. Au minimum, B<EPERM> doit être renvoyé lorsque l'appel échoue (puisque l'appelant ne dispose pas des privilèges B<CAP_SETUID>).

note: type: Plain text
en: setgid - set group identity
fr: setgid - Définir l'identifiant de groupe

note: type: Plain text
en: B<setgid>()  sets the effective group ID of the calling process.  If the caller is the superuser, the real GID and saved set-group-ID are also set.
fr: B<setgid>() définit le GID effectif du processus appelant. Si l'appelant est le superutilisateur, les GID réel et sauvé sont également définis.

note: type: Plain text
en: Under Linux, B<setgid>()  is implemented like the POSIX version with the B<_POSIX_SAVED_IDS> feature.  This allows a set-group-ID program that is not set-user-ID-root to drop all of its group privileges, do some un-privileged work, and then reengage the original effective group ID in a secure manner.
fr: Sous Linux B<setgid>() est implémenté comme la version POSIX avec l'option B<_POSIX_SAVED_IDS>. Ceci permet à un programme Set-GID (autre que root) d'abandonner tous ses privilèges de groupe, d'effectuer des tâches non privilégiées, et de retrouver son GID effectif de manière sécurisée.

note: type: Plain text
en: The calling process is not privileged (does not have the B<CAP_SETGID> capability), and I<gid> does not match the real group ID or saved set-group-ID of the calling process.
fr: Le processus appelant n'est pas privilégié (ne possède pas la capacité B<CAP_SETGID>) et I<gid> ne correspond ni au GID réel, ni au GID sauvé du processus appelant.

note: type: Plain text
en: The original Linux B<setgid>()  system call supported only 16-bit group IDs.  Subsequently, Linux 2.4 added B<setgid32>()  supporting 32-bit IDs.  The glibc B<setgid>()  wrapper function transparently deals with the variation across kernel versions.
fr: L'appel système B<setgid>() original de Linux ne gérait que des identifiants de groupe sur 16 bits. En conséquence, Linux 2.4 a ajouté B<setgid32>() qui prend en charge des identifiants 32 bits. La fonction B<setgid>() de la glibc qui l'encapsule gère de manière transparente ces différences entre noyaux.

note: type: TH
en: 2014-01-07
fr: 7 janvier 2014

note: type: Plain text
en: setpgid, getpgid, setpgrp, getpgrp - set/get process group
fr: setpgid, getpgid, setpgrp, getpgrp - Définir ou lire le groupe du processus

note: type: Plain text
en: B<pid_t getpgrp(void);> /* POSIX.1 version */
fr: B<pid_t getpgrp(void);> /* version POSIX.1 */

note: type: Plain text
en: B<pid_t getpgrp(pid_t >I<pid>B<);\ \ \ \ \ \ \ \ \ \ \ > /* BSD version */
fr: B<pid_t getpgrp(pid_t >I<pid>B<);\ \ \ \ \ \ \ \ \ \ \ > /* version BSD */

note: type: Plain text
en: B<int setpgrp(void);> /* System V version */
fr: B<int setpgrp(void);> /* version System V */

note: type: Plain text
en: B<int setpgrp(pid_t >I<pid>B<, pid_t >I<pgid>B<);\ > /* BSD version */
fr: B<int setpgrp(pid_t >I<pid>B<, pid_t >I<pgid>B<);>  /* version BSD */

note: type: Plain text
en: B<getpgid>():
fr: B<getpgid>() :

note: type: Plain text
en: B<setpgrp>() (POSIX.1):
fr: B<setpgrp>() (POSIX.1) :

note: type: Plain text
en:     || /* Since glibc 2.19: */ _BSD_SOURCE
fr:     || /* Depuis la glibc 2.19: */ _BSD_SOURCE

note: type: Plain text
en: B<setpgrp>()\ (BSD), B<getpgrp>()\ (BSD) [before glibc 2.19]:
fr: B<setpgrp>()\ (BSD), B<getpgrp>()  (BSD) [avant glibc 2.19] :

note: type: Plain text
en: All of these interfaces are available on Linux, and are used for getting and setting the process group ID (PGID) of a process.  The preferred, POSIX.1-specified ways of doing this are: B<getpgrp>(void), for retrieving the calling process's PGID; and B<setpgid>(), for setting a process's PGID.
fr: Toutes ces interfaces sont disponibles sous Linux et sont utilisées pour récupérer et définir l'identifiant du groupe de processus (PGID : « Process Group ID ») d'un processus. La façon préférée, celle spécifiée par POSIX.1 est : B<getpgrp>(void) pour récupérer le PGID du processus appelant et B<setpgid>() pour définir le PGID d'un processus.

note: type: Plain text
en: B<setpgid>()  sets the PGID of the process specified by I<pid> to I<pgid>.  If I<pid> is zero, then the process ID of the calling process is used.  If I<pgid> is zero, then the PGID of the process specified by I<pid> is made the same as its process ID.  If B<setpgid>()  is used to move a process from one process group to another (as is done by some shells when creating pipelines), both process groups must be part of the same session (see B<setsid>(2)  and B<credentials>(7)).  In this case, the I<pgid> specifies an existing process group to be joined and the session ID of that group must match the session ID of the joining process.
fr: B<setpgid>() définit à I<pgid> le PGID du processus mentionné par I<pid>. Si I<pid> vaut zéro, alors le PID du processus appelant est utilisé. Si I<pgid> vaut zéro, alors le PGID du processus indiqué par I<pid> est positionné à la même valeur que l'identifiant du processus. Si B<setpgid> est utilisé pour déplacer un processus d'un groupe dans un autre (comme cela peut être fait par certains shell pour les pipelines), les deux groupes de processus doivent appartenir à la même session (consultez B<setsid>(2) et B<credentials>(7)). Dans ce cas, I<pgid> indique un groupe de processus existant à rejoindre et l'ID de session de ce groupe doit être celui du processus concerné.

note: type: Plain text
en: The POSIX.1 version of B<getpgrp>(), which takes no arguments, returns the PGID of the calling process.
fr: La version POSIX.1 de B<getpgrp>(), qui ne prend pas de paramètre, renvoie le PGID du processus appelant.

note: type: Plain text
en: B<getpgid>()  returns the PGID of the process specified by I<pid>.  If I<pid> is zero, the process ID of the calling process is used.  (Retrieving the PGID of a process other than the caller is rarely necessary, and the POSIX.1 B<getpgrp>()  is preferred for that task.)
fr: B<getpgid>() renvoie le PGID du processus indiqué par I<pid>. Si I<pid> vaut zéro, le PID du processus appelant est utilisé. La récupération du PGID d'un processus autre que l'appelant est rarement utilisée et B<getpgrp>() est préférée pour cette tâche.

note: type: Plain text
en: The System V-style B<setpgrp>(), which takes no arguments, is equivalent to I<setpgid(0,\ 0)>.
fr: L'appel B<setpgrp>() de System V, qui ne prend pas de paramètre, est équivalent à I<setpgid(0, 0)>.

note: type: Plain text
en: The BSD-specific B<setpgrp>()  call, which takes arguments I<pid> and I<pgid>, is is a wrapper function that calls
fr: L'appel B<setpgrp>() spécifique à BSD qui prend les paramètres I<pid> et I<pgid> est une fonction d'encapsulation de

note: The true BSD setpgrp() system call differs in allowing the PGID to be set to arbitrary values, rather than being restricted to PGIDs in the same session. type: Plain text
en: Since glibc 2.19, the BSD-specific B<setpgrp>()  function is no longer exposed by I<E<lt>unistd.hE<gt>>; calls should be replaced with the B<setpgid>()  call shown above.
fr: A partir de glibc 2.19, la fonction spécifique à BSD B<setpgrp>() ne figure plus dans  I<E<lt>unistd.hE<gt>> ; les appels à cette fonction doivent être remplacés par des appels à B<setpgid>() tel qu'indiqué précédemment.

note: type: Plain text
en: The BSD-specific B<getpgrp>()  call, which takes a single I<pid> argument, is a wrapper function that calls
fr: L'appel B<getpgrp>() spécifique à BSD qui prend un unique paramètre I<pid> est une fonction d'encapsulation de

note: type: Plain text
en: Since glibc 2.19, the BSD-specific B<getpgrp>()  function is no longer exposed by I<E<lt>unistd.hE<gt>>; calls should be replaced with calls to the POSIX.1 B<getpgrp>()  which takes no arguments (if the intent is to obtain the caller's PGID), or with the B<getpgid>()  call shown above.
fr: A partir de glibc 2.19, la fonction spécifique à BSD B<getpgrp>() ne figure plus dans  I<E<lt>unistd.hE<gt>> ; les appels à cette fonction doivent être remplacés par des appels à la fonction POSIX.1 B<getpgrp>() qui ne prend pas d'argument (si l'appel a pour objet de récupérer le PGID du processus appelant), ou par des appels à B<getpgid>() tel que décrit précédemment.

note: type: Plain text
en: On success, B<setpgid>()  and B<setpgrp>()  return zero.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<setpgid>() et B<setpgrp>() renvoient zéro s'ils réussissent, ou -1 s'ils échouent, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: The POSIX.1 B<getpgrp>()  always returns the PGID of the caller.
fr: L'appel B<getpgrp>() de POSIX.1 renvoie le PGID du processus appelant.

note: type: Plain text
en: B<getpgid>(), and the BSD-specific B<getpgrp>()  return a process group on success.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<getpgid>() et l'appel spécifique à BSD B<getpgrp>() renvoient le groupe du processus s'il réussit. En cas d'erreur -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: An attempt was made to change the process group ID of one of the children of the calling process and the child had already performed an B<execve>(2)  (B<setpgid>(), B<setpgrp>()).
fr: On a essayé de changer le groupe de processus d'un enfant du processus appelant, et ce fils a déjà effectué un B<execve>(2) (B<setpgid>(), B<setpgrp>()).

note: type: Plain text
en: I<pgid> is less than 0 (B<setpgid>(), B<setpgrp>()).
fr: I<pgid> est inférieur à 0 (B<setpgid>(), B<setpgrp>()).

note: type: Plain text
en: An attempt was made to move a process into a process group in a different session, or to change the process group ID of one of the children of the calling process and the child was in a different session, or to change the process group ID of a session leader (B<setpgid>(), B<setpgrp>()).
fr: On a essayé de déplacer un processus dans un groupe d'une session différente, ou de changer le groupe d'un fils du processus appelant qui se trouve dans une autre session, ou de modifier le groupe d'un leader de session (B<setpgid>(), B<setpgrp>()).

note: type: Plain text
en: For B<getpgid>(): I<pid> does not match any process.  For B<setpgid>(): I<pid> is not the calling process and not a child of the calling process.
fr: Pour B<getpgid>()\ : I<pid> ne correspond à aucun processus. Pour B<setpgid>()\ : I<pid> n'est ni le processus appelant, ni l'un de ses enfants.

note: type: Plain text
en: B<setpgid>()  and the version of B<getpgrp>()  with no arguments conform to POSIX.1-2001.
fr: B<setpgid>() et la version de B<getpgrp>() sans paramètre sont conformes à POSIX.1-2001.

note: type: Plain text
en: POSIX.1-2001 also specifies B<getpgid>()  and the version of B<setpgrp>()  that takes no arguments.  (POSIX.1-2008 marks this B<setpgrp>()  specification as obsolete.)
fr: POSIX.1-2001 spécifie également B<getpgid>() et la version de B<setpgrp>() qui ne prend pas de paramètre. (POSIX.1-2008 marque cette spécification de B<setpgrp>() comme obsolète)

note: type: Plain text
en: The version of B<getpgrp>()  with one argument and the version of B<setpgrp>()  that takes two arguments derive from 4.2BSD, and are not specified by POSIX.1.
fr: La version de B<getpgrp>() avec un paramètre et la version de B<setpgrp>() qui prend deux paramètres provient de BSD 4.2 et ne sont pas spécifiées par POSIX.1.

note: type: Plain text
en: A child created via B<fork>(2)  inherits its parent's process group ID.  The PGID is preserved across an B<execve>(2).
fr: Un processus fils créé par B<fork>(2) hérite du PGID de son père. Le PGID est conservé au travers d'un B<execve>(2).

note: type: Plain text
en: Each process group is a member of a session and each process is a member of the session of which its process group is a member.
fr: Chaque groupe de processus est membre d'une session et chaque processus est membre de cette session.

note: type: Plain text
en: A session can have a controlling terminal.  At any time, one (and only one) of the process groups in the session can be the foreground process group for the terminal; the remaining process groups are in the background.  If a signal is generated from the terminal (e.g., typing the interrupt key to generate B<SIGINT>), that signal is sent to the foreground process group.  (See B<termios>(3)  for a description of the characters that generate signals.)  Only the foreground process group may B<read>(2)  from the terminal; if a background process group tries to B<read>(2)  from the terminal, then the group is sent a B<SIGTTIN> signal, which suspends it.  The B<tcgetpgrp>(3)  and B<tcsetpgrp>(3)  functions are used to get/set the foreground process group of the controlling terminal.
fr: Une session peut avoir un terminal de contrôle. À tout moment, un (et un seul) des groupes de processus de cette session peut être le groupe de premier plan du terminal ; les autre groupes de processus sont en arrière plan. Si un signal est généré depuis le terminal (par exemple une touche d'interruption pour générer un B<SIGINT>), ce signal est envoyé au groupe de processus au premier plan. Consultez B<termios>(3) pour la liste des caractères qui génèrent des signaux. Seul le groupe de processus au premier plan peut lire avec B<read>(2) sur le terminal ; si un groupe de processus essaie de lire avec B<read>(2) sur le terminal, alors le groupe reçoit un signal B<SIGTTIN>, qui le suspend. Les fonctions B<tcgetpgrp>(3) et B<tcsetpgrp>(3) sont utilisées pour récupérer ou positionner le groupe de processus au premier plan du terminal de contrôle.

note: type: Plain text
en: The B<setpgid>()  and B<getpgrp>()  calls are used by programs such as B<bash>(1)  to create process groups in order to implement shell job control.
fr: Les appels B<setpgid>() et B<getpgrp>() sont utilisés par des programmes comme B<bash>(1) pour créer des groupes de processus pour l'implémentation du contrôle des travaux depuis l'interpréteur de commande.

note: type: Plain text
en: If a session has a controlling terminal, and the B<CLOCAL> flag for that terminal is not set, and a terminal hangup occurs, then the session leader is sent a B<SIGHUP>.  If the session leader exits, then a B<SIGHUP> signal will also be sent to each process in the foreground process group of the controlling terminal.
fr: Si une session a un terminal de contrôle et le drapeau B<CLOCAL> de ce terminal n'est pas actif, et une déconnexion se produit, alors le leader de la session recevra un signal B<SIGHUP>. Si le leader se termine, le signal B<SIGHUP> sera envoyé à tous les processus du groupe au premier plan sur le terminal de contrôle.

note: exit.3 refers to the following text: type: Plain text
en: If the exit of the process causes a process group to become orphaned, and if any member of the newly orphaned process group is stopped, then a B<SIGHUP> signal followed by a B<SIGCONT> signal will be sent to each process in the newly orphaned process group.  An orphaned process group is one in which the parent of every member of process group is either itself also a member of the process group or is a member of a process group in a different session (see also B<credentials>(7)).
fr: Si la fin du processus rend un groupe de processus orphelin, et si l'un des membres de ce groupe est arrêté, alors un signal B<SIGHUP> suivi d'un signal B<SIGCONT> sera envoyé à tous les processus du groupe orphelin. Un groupe de processus est orphelin si le parent de chaque processus du groupe est soit membre de ce groupe ou soit membre d'un groupe de processus dans une session différente (voyez B<credentials>(7)).

note: type: Plain text
en: setresuid, setresgid - set real, effective and saved user or group ID
fr: setresuid, setresgid - Définir les UID ou les GID réels, effectifs et sauvés

note: type: Plain text
en: B<setresuid>()  sets the real user ID, the effective user ID, and the saved set-user-ID of the calling process.
fr: B<setresuid>() définit les UID réel, effectif et (effectif) sauvé du processus appelant.

note: type: Plain text
en: Unprivileged user processes may change the real UID, effective UID, and saved set-user-ID, each to one of: the current real UID, the current effective UID or the current saved set-user-ID.
fr: Un processus utilisateur non privilégié peut définir son UID réel, effectif ou sauvé avec sa valeur d'UID actuel, d'UID effectif actuel, ou d'UID sauvé.

note: type: Plain text
en: Privileged processes (on Linux, those having the B<CAP_SETUID> capability)  may set the real UID, effective UID, and saved set-user-ID to arbitrary values.
fr: Un processus privilégié (sous Linux, qui a la capacité B<CAP_SETUID>) peut positionner son UID réel, effectif ou sauvé à une valeur quelconque.

note: type: Plain text
en: If one of the arguments equals -1, the corresponding value is not changed.
fr: Si l'un des paramètres vaut -1, la valeur correspondante n'est pas modifiée.

note: type: Plain text
en: Regardless of what changes are made to the real UID, effective UID, and saved set-user-ID, the filesystem UID is always set to the same value as the (possibly new) effective UID.
fr: Indépendamment des changements concernant les UID réel, effectif et sauvés, le fsuid est toujours défini à la même valeur que l'UID effectif.

note: type: Plain text
en: Completely analogously, B<setresgid>()  sets the real GID, effective GID, and saved set-group-ID of the calling process (and always modifies the filesystem GID to be the same as the effective GID), with the same restrictions for unprivileged processes.
fr: De manière analogue, B<setresgid>() définit les GID réel, effectif et sauvé du processus appelant (et définit toujours le fsgid à la même valeur que le GID effectif) avec les mêmes restrictions pour les processus n'ayant aucun GID nul.

note: type: Plain text
en: I<uid> does not match the current UID and this call would bring that user ID over its B<RLIMIT_NPROC> resource limit.
fr: I<uid> ne correspond pas à l'UID courant et cet appel pourrait porter cet UID au-delà de sa limite B<RLIMIT_NPROC>.

note: type: Plain text
en: The calling process is not privileged (did not have the B<CAP_SETUID> capability) and tried to change the IDs to values that are not permitted.
fr: Le processus n'a pas de privilèges (n'a pas la capacité B<CAP_SETUID>) et essaie de modifier ses ID de manière interdite.

note: type: Plain text
en: These calls are available under Linux since Linux 2.1.44.
fr: Ces appels sont disponibles sous Linux depuis la version 2.1.44.

note: type: Plain text
en: Under HP-UX and FreeBSD, the prototype is found in I<E<lt>unistd.hE<gt>>.  Under Linux the prototype is provided by glibc since version 2.3.2.
fr: Sous HP-UX et FreeBSD, le prototype se trouve dans I<E<lt>unistd.hE<gt>>. Sous Linux, le prototype est fourni par la glibc depuis la version 2.3.2.

note: type: Plain text
en: The original Linux B<setresuid>()  and B<setresgid>()  system calls supported only 16-bit user and group IDs.  Subsequently, Linux 2.4 added B<setresuid32>()  and B<setresgid32>(), supporting 32-bit IDs.  The glibc B<setresuid>()  and B<setresgid>()  wrapper functions transparently deal with the variations across kernel versions.
fr: Les appels système B<setresuid>() et B<setresgid>() originaux de Linux ne géraient que des identifiants d'utilisateur et de groupe sur 16 bits. En conséquence, Linux 2.4 a ajouté B<setresuid32>() et B<setresgid32>() qui prennent en charge des identifiants 32 bits. Les fonctions B<setresuid>() et B<setresgid>() de la glibc qui les encapsulent gèrent de manière transparente ces différences entre noyaux.

note: type: TH
en: 2013-12-12
fr: 12 décembre 2013

note: type: Plain text
en: setreuid, setregid - set real and/or effective user or group ID
fr: setreuid, setregid - Définir les UID et GID effectifs et/ou réels

note: type: Plain text
en: B<setreuid>(), B<setregid>():
fr: B<setreuid>(), B<setregid>()\ :

note: type: Plain text
en: B<setreuid>()  sets real and effective user IDs of the calling process.
fr: B<setreuid>() définit les ID d'utilisateur effectif et réel du processus appelant.

note: type: Plain text
en: Supplying a value of -1 for either the real or effective user ID forces the system to leave that ID unchanged.
fr: Fournir une valeur -1 pour l'un des arguments demande au système de ne pas modifier l'ID correspondant

note: type: Plain text
en: Unprivileged processes may only set the effective user ID to the real user ID, the effective user ID, or the saved set-user-ID.
fr: Les processus non privilégiés peuvent seulement définir leur UID effectif à la valeur de l'UID réel, de l'UID effectif ou de l'UID sauvé.

note: type: Plain text
en: Unprivileged users may only set the real user ID to the real user ID or the effective user ID.
fr: Les utilisateurs non privilégiés peuvent seulement définir l'UID réel à la valeur de l'UID réel ou de l'UID effectif.

note: type: Plain text
en: If the real user ID is set (i.e., I<ruid> is not -1) or the effective user ID is set to a value not equal to the previous real user ID, the saved set-user-ID will be set to the new effective user ID.
fr: Si l'UID réel est changé (c'est-à-dire si I<ruid> est différent de -1), ou si l'UID effectif a avec une valeur différente de l'UID réel précédent, le set-uid sauvegardé prendra également la valeur du nouvel UID effectif.

note: type: Plain text
en: Completely analogously, B<setregid>()  sets real and effective group ID's of the calling process, and all of the above holds with "group" instead of "user".
fr: De manière analogue, B<setregid>() définit les ID de groupe du processus appelant, et toutes les remarques précédentes s'appliquent, en remplaçant GID par UID.

note: type: Plain text
en: The calling process is not privileged (Linux: does not have the B<CAP_SETUID> capability in the case of B<setreuid>(), or the B<CAP_SETGID> capability in the case of B<setregid>())  and a change other than (i)  swapping the effective user (group) ID with the real user (group) ID, or (ii) setting one to the value of the other or (iii) setting the effective user (group) ID to the value of the saved set-user-ID (saved set-group-ID) was specified.
fr: Le processus appelant n'est pas privilégié (sous Linux\ : n'a pas la capacité B<CAP_SETUID> dans le cas de B<setreuid>(), ou la capacité B<CAP_SETGID> dans le cas de B<setregid>()), des modifications ont été demandées autres que (i) l'échange de l'UID (resp. GID) effectif avec l'UID (GID) réel, (ii) la copie d'un UID (GID) dans un autre, ou (iii) le remplissage de l'UID (GID) effectif avec la valeur de l'UID (GID) sauvé.

note: type: Plain text
en: POSIX.1-2001, 4.3BSD (the B<setreuid>()  and B<setregid>()  function calls first appeared in 4.2BSD).
fr: POSIX.1-2001, BSD\ 4.3 (les fonctions B<setreuid>() et B<setregid>() sont apparues dans BSD\ 4.2).

note: type: Plain text
en: Setting the effective user (group) ID to the saved set-user-ID (saved set-group-ID) is possible since Linux 1.1.37 (1.1.38).
fr: Définir l'UID (GID) effectif avec la valeur de l'UID (GID) sauvé est possible depuis Linux 1.1.37 (1.1.38).

note: type: Plain text
en: POSIX.1 does not specify all of possible ID changes that are permitted on Linux for an unprivileged process.  For B<setreuid>(), the effective user ID can be made the same as the real user ID or the save set-user-ID, and it is unspecified whether unprivileged processes may set the real user ID to the real user ID, the effective user ID, or the saved set-user-ID.  For B<setregid>(), the real group ID can be changed to the value of the saved set-group-ID, and the effective group ID can be changed to the value of the real group ID or the saved set-group-ID.  The precise details of what ID changes are permitted vary across implementations.
fr: POSIX.1 ne donne pas tous les changements d'identifiants qui sont autorisés sous Linux pour un processus non privilégié. Pour B<setreuid>(), l'identifiant d'utilisateur effectif peut être celui de l'identifiant d'utilisateur réel ou celui de l'identifiant d'utilisateur sauvé. Il n'est pas indiqué si des processus non privilégiés peuvent changer l'identifiant d'utilisateur réel en l'identifiant d'utilisateur effectif ou en celui sauvé. Pour B<setregid>(), l'identifiant de groupe réel peut être changé en la valeur de l'identifiant de groupe sauvé, et l'identifiant de groupe effectif peut être changé en la valeur de l'identifiant de groupe réel ou de celui sauvé. Les détails précis sur les changements d'identifiants autorisés varient en fonction de l'implémentation.

note: type: Plain text
en: POSIX.1 makes no specification about the effect of these calls on the saved set-user-ID and saved set-group-ID.
fr: POSIX.1 ne dit rien de l'effet de ces appels sur les set-user-ID et set-group-ID sauvés.

note: type: Plain text
en: The original Linux B<setreuid>()  and B<setregid>()  system calls supported only 16-bit user and group IDs.  Subsequently, Linux 2.4 added B<setreuid32>()  and B<setregid32>(), supporting 32-bit IDs.  The glibc B<setreuid>()  and B<setregid>()  wrapper functions transparently deal with the variations across kernel versions.
fr: Les appels système B<setreuid>() et B<setregid>() originaux de Linux ne géraient que des identifiants d'utilisateur et de groupe sur 16 bits. En conséquence, Linux 2.4 a ajouté B<setreuid32>() et B<setregid32>() qui prennent en charge des identifiants 32 bits. Les fonctions B<setreuid>() et B<setregid>() de la glibc qui les encapsulent gèrent de manière transparente ces différences entre noyaux.

note: type: TH
en: 2013-02-11
fr: 11 février 2013

note: type: Plain text
en: setsid - creates a session and sets the process group ID
fr: setsid - Créer une session et définir l'identifiant du groupe de processus

note: type: Plain text
en: B<setsid>()  creates a new session if the calling process is not a process group leader.  The calling process is the leader of the new session, the process group leader of the new process group, and has no controlling terminal.  The process group ID and session ID of the calling process are set to the PID of the calling process.  The calling process will be the only process in this new process group and in this new session.
fr: B<setsid>() crée une nouvelle session si le processus appelant n'est pas un leader de groupe. Le processus appelant devient le leader du nouveau groupe, et n'a pas de terminal de contrôle. L'ID du groupe de processus et l'ID de session du processus appelant sont définis à la valeur de PID du processus en cours. Le processus en cours sera le seul dans son groupe et sa session.

note: type: Plain text
en: On success, the (new) session ID of the calling process is returned.  On error, I<(pid_t)\ -1> is returned, and I<errno> is set to indicate the error.
fr: En cas de succès, l'identifiant de la (nouvelle) session du processus appelant est renvoyé. En cas d'échec, I<(pid_t)\ -1> est renvoyé, et I<errno> contient le code de l'erreur.

note: type: Plain text
en: The process group ID of any process equals the PID of the calling process.  Thus, in particular, B<setsid>()  fails if the calling process is already a process group leader.
fr: L'identifiant du groupe de processus d'un processus quelconque est égal au PID du processus appelant. En particulier B<setsid>() échoue si le processus appelant est déjà leader d'un groupe.

note: type: Plain text
en: A child created via B<fork>(2)  inherits its parent's session ID.  The session ID is preserved across an B<execve>(2).
fr: Un fils créé par B<fork>(2) hérite de l'identifiant de session de son père. L'identifiant de session est conservé au travers d'un B<execve>(2).

note: type: Plain text
en: A process group leader is a process with process group ID equal to its PID.  In order to be sure that B<setsid>()  will succeed, B<fork>(2)  and B<_exit>(2), and have the child do B<setsid>().
fr: Le leader d'un groupe est le processus dont le PID est égal à l'ID du groupe. Pour s'assurer que B<setsid>() réussira, il faut effectuer un B<fork>(2), suivi d'un B<_exit>(2) pour le père, et le fils appellera B<setsid>().

note: type: Plain text
en: setuid - set user identity
fr: setuid - Définir l'identifiant de l'utilisateur

note: type: Plain text
en: B<setuid>()  sets the effective user ID of the calling process.  If the effective UID of the caller is root, the real UID and saved set-user-ID are also set.
fr: B<setuid>() définit l'UID effectif du processus appelant. Si cet UID effectif est celui du superutilisateur, les UID réels et sauvés sont également définis.

note: type: Plain text
en: Under Linux, B<setuid>()  is implemented like the POSIX version with the B<_POSIX_SAVED_IDS> feature.  This allows a set-user-ID (other than root) program to drop all of its user privileges, do some un-privileged work, and then reengage the original effective user ID in a secure manner.
fr: Sous Linux B<setuid>() est implémenté comme le spécifie POSIX, avec l'option B<_POSIX_SAVED_IDS>. Ceci permet à un programme Set-UID (autre que root) d'abandonner tous ses privilèges, d'effectuer des tâches non privilégiées, et de retrouver son UID effectif de manière sécurisée.

note: type: Plain text
en: If the user is root or the program is set-user-ID-root, special care must be taken.  The B<setuid>()  function checks the effective user ID of the caller and if it is the superuser, all process-related user ID's are set to I<uid>.  After this has occurred, it is impossible for the program to regain root privileges.
fr: Si l'utilisateur est le superutilisateur, ou si le programme est Set-UID root, des précautions particulières doivent être prises. La fonction B<setuid>() vérifie l'UID effectif de l'appelant et si c'est le superutilisateur, tous les UID du processus sont mis à I<uid>. Une fois ceci effectué, il est impossible au programme de retrouver ses privilèges de superutilisateur.

note: type: Plain text
en: Thus, a set-user-ID-root program wishing to temporarily drop root privileges, assume the identity of an unprivileged user, and then regain root privileges afterward cannot use B<setuid>().  You can accomplish this with B<seteuid>(2).
fr: Ainsi un programme Set-UID root désireux d'abandonner temporairement ses privilèges, en prenant l'identité d'un utilisateur ordinaire, puis de récupérer ses privilèges par la suite ne doit pas utiliser B<setuid>(). On peut accomplir ceci en utilisant l'appel B<seteuid>(2).

note: type: Plain text
en: The I<uid> does not match the current uid and I<uid> brings process over its B<RLIMIT_NPROC> resource limit.
fr: I<uid> ne correspond pas à l'UID courant et I<uid> porterait le processus au-delà de sa limite B<RLIMIT_NPROC>.

note: type: Plain text
en: The user is not privileged (Linux: does not have the B<CAP_SETUID> capability) and I<uid> does not match the real UID or saved set-user-ID of the calling process.
fr: L'utilisateur n'est pas privilégié (sous Linux\ : n'a pas la capacité B<CAP_SETUID>) et I<uid> ne correspond ni à l'UID réel, ni au set-uid sauvé du processus.

note: SVr4 documents an additional EINVAL error condition. type: Plain text
en: SVr4, POSIX.1-2001.  Not quite compatible with the 4.4BSD call, which sets all of the real, saved, and effective user IDs.
fr: SVr4, POSIX.1-2001. Pas tout à fait compatible avec l'appel système BSD\ 4.4, qui positionne l'ensemble des ID réel, sauvé et effectif.

note: type: Plain text
en: Linux has the concept of the filesystem user ID, normally equal to the effective user ID.  The B<setuid>()  call also sets the filesystem user ID of the calling process.  See B<setfsuid>(2).
fr: Linux dispose d'un concept d'UID de système de fichiers, qui est normalement égal à l'UID effectif. L'appel B<setuid>() définit également l'UID de système de fichiers du processus appelant. Consultez B<setfsuid>(2).

note: type: Plain text
en: If I<uid> is different from the old effective UID, the process will be forbidden from leaving core dumps.
fr: Si l'I<uid> est différent de l'ancien UID effectif, le processus ne pourra pas laisser d'image mémoire (core dump) sur le disque.

note: type: Plain text
en: The original Linux B<setuid>()  system call supported only 16-bit user IDs.  Subsequently, Linux 2.4 added B<setuid32>()  supporting 32-bit IDs.  The glibc B<setuid>()  wrapper function transparently deals with the variation across kernel versions.
fr: L'appel système B<setuid>() original de Linux ne gérait que des identifiants d'utilisateur sur 16 bits. En conséquence, Linux 2.4 a ajouté B<setuid32>() qui prend en charge des identifiants 32 bits. La fonction B<setuid>() de la glibc qui l'encapsule gère de manière transparente ces différences entre noyaux.

note: type: Plain text
en: svipc - System V interprocess communication mechanisms
fr: svipc - Mécanismes System V de communication entre processus

note: type: Plain text
en: This manual page refers to the Linux implementation of the System V interprocess communication (IPC) mechanisms: message queues, semaphore sets, and shared memory segments.  In the following, the word I<resource> means an instantiation of one among such mechanisms.
fr: Cette page de manuel documente l'implémentation sous Linux des mécanismes System V de communication entre processus (IPC : « InterProcess Communication »)\ : les files de messages, les ensembles de sémaphores, et les segments de mémoire partagée. Par la suite, le mot I<ressource> se rapportera à l'un de ces mécanismes.

note: type: SS
en: Resource access permissions
fr: Autorisations d'accès aux ressources

note: type: Plain text
en: For each resource, the system uses a common structure of type I<struct ipc_perm> to store information needed in determining permissions to perform an IPC operation.  The I<ipc_perm> structure includes the following members:
fr: Pour chaque ressource, le système utilise une structure commune, de type I<struct ipc_perm>, pour enregistrer les informations permettant de déterminer les autorisations concernant les opérations IPC. La structure I<ipc_perm> comporte les membres suivants :

note: type: Plain text
en: struct ipc_perm {
        uid_t          cuid;   /* creator user ID */
        gid_t          cgid;   /* creator group ID */
        uid_t          uid;    /* owner user ID */
        gid_t          gid;    /* owner group ID */
        unsigned short mode;   /* r/w permissions */
    };
fr: struct ipc_perm {
        uid_t          cuid;   /* UID du créateur */
        gid_t          cgid;   /* GID du créateur */
        uid_t          uid;    /* UID du propriétaire */
        gid_t          gid;    /* GID du propriétaire */
        unsigned short mode;   /* autorisations l/e */
    };

note: type: Plain text
en: The I<mode> member of the I<ipc_perm> structure defines, with its lower 9 bits, the access permissions to the resource for a process executing an IPC system call.  The permissions are interpreted as follows:
fr: Le membre I<mode> de la structure I<ipc_perm> définit, sur ses 9 bits de poids faibles, les permissions d'accès à la ressource, pour un processus effectuant un appel système IPC. Les permissions sont interprétées ainsi (nombres en octal)\ :

note: type: Plain text
en:     0400    Read by user.
        0200    Write by user.
fr:     0400    Lecture par le propriétaire.
        0200    Écriture par le propriétaire.

note: type: Plain text
en:     0040    Read by group.
        0020    Write by group.
fr:     0040    Lecture par le groupe.
        0020    Écriture par le groupe.

note: type: Plain text
en:     0004    Read by others.
        0002    Write by others.
fr:     0004    Lecture par les autres.
        0002    Écriture par les autres.

note: type: Plain text
en: Bits 0100, 0010, and 0001 (the execute bits) are unused by the system.  Furthermore, "write" effectively means "alter" for a semaphore set.
fr: Les bits 0100, 0010 et 0001 (bits exécution) ne sont pas utilisés par ces appels système. De plus, «\ écriture\ » a la signification «\ modification\ » pour un ensemble de sémaphores.

note: type: Plain text
en: The same system header file also defines the following symbolic constants:
fr: Le même fichier d'en-tête définit également les constantes symboliques suivantes\ :

note: type: Plain text
en: Create entry if key doesn't exist.
fr: Créer une entrée si la clé n'existe pas.

note: type: Plain text
en: Fail if key exists.
fr: Échouer si la clé existe.

note: type: Plain text
en: Error if request must wait.
fr: Retourner éventuellement une erreur, mais ne pas attendre.

note: type: Plain text
en: Private key.
fr: Clé privée.

note: type: Plain text
en: Remove resource.
fr: Supprimer la ressource.

note: type: Plain text
en: Set resource options.
fr: Positionner une option concernant la ressource.

note: type: Plain text
en: Get resource options.
fr: Obtenir les options concernant la ressource.

note: type: Plain text
en: Note that B<IPC_PRIVATE> is a I<key_t> type, while all the other symbolic constants are flag fields and can be OR'ed into an I<int> type variable.
fr: Notez que B<IPC_PRIVATE> est du type I<key_t> alors que les autres constantes symboliques sont des champs d'indicateurs qui peuvent être regroupés avec un OU logique dans une variable de type I<int>.

note: type: SS
en: Message queues
fr: Files de messages

note: type: Plain text
en: A message queue is uniquely identified by a positive integer (its I<msqid>)  and has an associated data structure of type I<struct msqid_ds>, defined in I<E<lt>sys/msg.hE<gt>>, containing the following members:
fr: Une file de message est définie de manière unique par un entier positif (son I<msqid>) et dispose d'une structure associée de type I<struct msqid_ds>, définie dans I<E<lt>sys/msg.hE<gt>>, qui contient les membres suivants :

note: type: Plain text
en: struct msqid_ds {
        struct ipc_perm msg_perm;
        msgqnum_t       msg_qnum;    /* no of messages on queue */
        msglen_t        msg_qbytes;  /* bytes max on a queue */
        pid_t           msg_lspid;   /* PID of last msgsnd(2) call */
        pid_t           msg_lrpid;   /* PID of last msgrcv(2) call */
        time_t          msg_stime;   /* last msgsnd(2) time */
        time_t          msg_rtime;   /* last msgrcv(2) time */
        time_t          msg_ctime;   /* last change time */
    };
fr: struct msqid_ds {
        struct ipc_perm msg_perm;
        msgqnum_t       msg_qnum;    /* nb messages dans la file */
        msglen_t        msg_qbytes;  /* octets maxi dans la file */
        pid_t           msg_lspid;   /* PID du dernier appel à msgsnd(2) */
        pid_t           msg_lrpid;   /* PID du dernier appel à msgrcv(2) */
        time_t          msg_stime;   /* heure du dernier appel à msgsnd(2) */
        time_t          msg_rtime;   /* heure du dernier appel à msgrcv(2) */
        time_t          msg_ctime;   /* heure de dernière modification */
    };

note: type: Plain text
en: I<ipc_perm> structure that specifies the access permissions on the message queue.
fr: Structure I<ipc_perm> qui indique les permissions d'accès sur la file de messages.

note: type: Plain text
en: Number of messages currently on the message queue.
fr: Nombre de messages actuellement dans la file.

note: type: Plain text
en: Maximum number of bytes of message text allowed on the message queue.
fr: Nombre maximal d'octets pour le contenu d'un message de la file.

note: type: Plain text
en: ID of the process that performed the last B<msgsnd>(2)  system call.
fr: PID du processus qui a effectué le dernier appel système B<msgsnd>(2).

note: type: Plain text
en: ID of the process that performed the last B<msgrcv>(2)  system call.
fr: PID du processus qui a effectué le dernier appel système B<msgrcv>(2).

note: type: Plain text
en: Time of the last B<msgsnd>(2)  system call.
fr: Heure du dernier appel système B<msgsnd>(2).

note: type: Plain text
en: Time of the last B<msgrcv>(2)  system call.
fr: Heure du dernier appel système B<msgrcv>(2).

note: type: Plain text
en: Time of the last system call that changed a member of the I<msqid_ds> structure.
fr: Heure du dernier appel système qui a modifié un membre de la structure I<msqid_ds>.

note: type: SS
en: Semaphore sets
fr: Jeux de sémaphores

note: type: Plain text
en: A semaphore set is uniquely identified by a positive integer (its I<semid>)  and has an associated data structure of type I<struct semid_ds>, defined in I<E<lt>sys/sem.hE<gt>>, containing the following members:
fr: Un ensemble de sémaphores est défini de manière unique par un entier positif (son I<semid>) et dispose d'une structure associée de type I<struct semid_ds>, définie dans I<E<lt>sys/sem.hE<gt>>, qui contient les membres suivants :

note: type: Plain text
en: struct semid_ds {
        struct ipc_perm sem_perm;
        time_t          sem_otime;   /* last operation time */
        time_t          sem_ctime;   /* last change time */
        unsigned long   sem_nsems;   /* count of sems in set */
    };
fr: struct semid_ds {
        struct ipc_perm sem_perm;
        time_t          sem_otime;   /* heure dernière opération */
        time_t          sem_ctime;   /* heure dernière modification */
        unsigned long   sem_nsems;   /* nb sémaphores dans le jeu */
    };

note: type: Plain text
en: I<ipc_perm> structure that specifies the access permissions on the semaphore set.
fr: Structure I<ipc_perm> qui indique les permissions d'accès sur l'ensemble de sémaphores.

note: type: Plain text
en: Time of last B<semop>(2)  system call.
fr: Heure du dernier appel système B<semop>(2).

note: type: Plain text
en: Time of last B<semctl>(2)  system call that changed a member of the above structure or of one semaphore belonging to the set.
fr: Heure du dernier appel système B<semctl>(2), qui a modifié un membre de la structure ci-dessus ou l'état d'un sémaphore de l'ensemble.

note: type: Plain text
en: Number of semaphores in the set.  Each semaphore of the set is referenced by a nonnegative integer ranging from B<0> to I<sem_nsems-1>.
fr: Nombre de sémaphores dans l'ensemble. Chaque sémaphore est référencé par un nombre positif ou nul dans l'intervalle B<0> à I<sem_nsems-1>.

note: type: Plain text
en: A semaphore is a data structure of type I<struct sem> containing the following members:
fr: Un sémaphore est une structure de données de type I<struct sem> contenant les membres suivants :

note: unsigned short semncnt; /* nr awaiting semval to increase */ unsigned short semzcnt; /* nr awaiting semval = 0 */ type: Plain text
en: struct sem {
        int semval;  /* semaphore value */
        int sempid;  /* PID for last operation */
    };
fr: struct sem {
        int semval;  /* valeur du sémaphore */
        int sempid;  /* PID de la dernière opération */
    };

note: type: Plain text
en: Semaphore value: a nonnegative integer.
fr: Valeur du sémaphore\ : entier positif ou nul.

note: .TP .I semncnt Number of processes suspended awaiting for .I semval to increase. .I semznt to become zero. type: Plain text
en: ID of the last process that performed a semaphore operation on this semaphore.
fr: PID du dernier processus ayant effectué une opération sur le sémaphore.

note: type: SS
en: Shared memory segments
fr: Segments de mémoire partagée

note: type: Plain text
en: A shared memory segment is uniquely identified by a positive integer (its I<shmid>)  and has an associated data structure of type I<struct shmid_ds>, defined in I<E<lt>sys/shm.hE<gt>>, containing the following members:
fr: Un segment de mémoire partagée est défini de manière unique par un entier positif (son I<shmid>) et dispose d'une structure associée de type I<struct shmid_ds>, définie dans I<E<lt>sys/shm.hE<gt>>, qui contient les membres suivants :

note: type: Plain text
en: struct shmid_ds {
        struct ipc_perm shm_perm;
        size_t          shm_segsz;   /* size of segment */
        pid_t           shm_cpid;    /* PID of creator */
        pid_t           shm_lpid;    /* PID, last operation */
        shmatt_t        shm_nattch;  /* no. of current attaches */
        time_t          shm_atime;   /* time of last attach */
        time_t          shm_dtime;   /* time of last detach */
        time_t          shm_ctime;   /* time of last change */
    };
fr: struct shmid_ds {
        struct ipc_perm shm_perm;
        size_t          shm_segsz;   /* taille segment */
        pid_t           shm_cpid;    /* PID du créateur */
        pid_t           shm_lpid;    /* PID, dernière opération */
        shmatt_t        shm_nattch;  /* nombre d'attachements */
        time_t          shm_atime;   /* heure dernier attachement */
        time_t          shm_dtime;   /* heure dernier détachement */
        time_t          shm_ctime;   /* heure dernière modification */
    };

note: type: Plain text
en: I<ipc_perm> structure that specifies the access permissions on the shared memory segment.
fr: Structure I<ipc_perm> qui indique les permissions d'accès sur le segment de mémoire partagée.

note: type: Plain text
en: Size in bytes of the shared memory segment.
fr: Taille en octets du segment.

note: type: Plain text
en: ID of the process that created the shared memory segment.
fr: PID du processus ayant créé le segment.

note: type: Plain text
en: ID of the last process that executed a B<shmat>(2)  or B<shmdt>(2)  system call.
fr: PID du processus ayant effectué le dernier appel système B<shmat>(2) ou B<shmdt>(2).

note: type: Plain text
en: Number of current alive attaches for this shared memory segment.
fr: Nombre d'attachements en cours pour ce segment.

note: type: Plain text
en: Time of the last B<shmat>(2)  system call.
fr: Heure du dernier appel système B<shmat>(2).

note: type: Plain text
en: Time of the last B<shmdt>(2)  system call.
fr: Heure du dernier appel système B<shmdt>(2).

note: type: Plain text
en: Time of the last B<shmctl>(2)  system call that changed I<shmid_ds>.
fr: Heure du dernier appel système B<shmctl>(2) qui a modifié la structure I<shmid_ds>.

note: type: TH
en: 2008-08-06
fr: 6 août 2008

note: type: Plain text
en: ulimit - get and set user limits
fr: ulimit - Lire ou écrire les limites d'utilisation

note: type: Plain text
en: Warning: This routine is obsolete.  Use B<getrlimit>(2), B<setrlimit>(2), and B<sysconf>(3)  instead.  For the shell command B<ulimit>(), see B<bash>(1).
fr: Attention\ : Cette routine est obsolète. Utilisez B<getrlimit>(2), B<setrlimit>(2) et B<sysconf>(3) à la place. Pour avoir des informations sur la commande shell B<ulimit>(), reportez-vous à B<bash>(1).

note: type: Plain text
en: The B<ulimit>()  call will get or set some limit for the calling process.  The I<cmd> argument can have one of the following values.
fr: L'appel B<ulimit>() permet de lire ou d'écrire certaines limitations pour le processus appelant. L'argument I<cmd> peut prendre l'une des valeurs suivantes\ :

note: type: Plain text
en: Return the limit on the size of a file, in units of 512 bytes.
fr: Lire la limitation de taille d'un fichier en unités de 512 octets.

note: type: Plain text
en: Set the limit on the size of a file.
fr: Écrire la limitation de taille d'un fichier.

note: type: Plain text
en: (Not implemented for Linux.)  Return the maximum possible address of the data segment.
fr: (Non implémenté sous Linux) Renvoyer l'adresse maximale du segment de données.

note: type: Plain text
en: (Implemented but no symbolic constant provided.)  Return the maximum number of files that the calling process can open.
fr: (Implémenté, mais sans nom symbolique) Lire le nombre maximal de fichiers que l'appelant peut ouvrir.

note: type: Plain text
en: On success, B<ulimit>()  returns a nonnegative value.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'il réussit, B<ulimit>() renvoie une valeur positive ou nulle. En cas d'erreur, il renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: A unprivileged process tried to increase a limit.
fr: Un processus non privilégié essaye d'augmenter une de ses limitations.

note: type: Plain text
en: SVr4, POSIX.1-2001.  POSIX.1-2008 marks B<ulimit>()  as obsolete.
fr: SVr4, POSIX.1-2001. POSIX.1-2008 marque B<ulimit>() comme obsolète.
