Provided by: manpages-fr_3.32d0.2p4-1_all bug

NOM

       credentials - Identifiants de processus

DESCRIPTION

   Identifiant de processus (PID)
       Chaque processus a un identifiant entier positif, qui lui est attribué à sa création (avec
       fork(2)). Un processus peut connaître son PID avec getpid(2). Un PID est représenté par le
       type pid_t (défini dans <sys/types.h>).

       Les PID sont utilisés dans un certain nombre d'appels système pour identifier le processus
       affecté,  par  exemple :  kill(2),  ptrace(2),  setpriority(2),   setpgid(2),   setsid(2),
       sigqueue(2) et waitpid(2).

       Le PID d'un processus est conservé travers d'un execve(2).

   Identifiant du processus père (PPID)
       L'identifiant  de  processus  père d'un processus identifie le processus qui l'a créé avec
       fork(2). Un processus peut connaître son PPID avec getppid(2). Un PPID  est  représenté  à
       l'aide du type pid_t.

       Le PPID d'un processus est conservé au travers d'un execve(2).

   Identifiant de groupe de processus et identifiant de session
       Chaque  processus  a  un  identifiant de session et un identifiant de groupe de processus,
       tous deux représentés par le type pid_t. Un processus peut connaître  son  identifiant  de
       session avec getsid(2), et son identifiant de groupe de processus avec getpgrp(2).

       Un  processus  créé  par 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 execve(2).

       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  setpgid(2).
       Le  processus  dont le PID est égal à son identifiant de groupe de processus est le leader
       du groupe de processus.

       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  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é leader
       de session.

   Identifiants d'utilisateur et de groupe
       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 uid_t et gid_t
       (définis dans <sys/types.h>).

       Sous Linux, chaque processus a les identifiants d'utilisateur et de groupe suivants :

       *  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 getuid(2) et getgid(2).

       *  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‐dessous)  pour  cette  tâche.  Un  processus  peut déterminer son UID (GID)
          effectif avec geteuid(2) (getegid(2)).

       *  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 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  seteuid(2),
          setreuid(2)  ou  setresuid(2).  Un programme set-group-ID peut effectuer les opérations
          correspondantes avec setegid(2), setregid(2) ou setresgid(2). Un processus peut obtenir
          son UID (resp. GID) sauvé avec getresuid(2) (resp. getresgid(2)).

       *  UID  et  GID  du système de fichiers (spécifiques à Linux). Ces identifiants, ainsi que
          les identifiants de  groupe  supplémentaires  décrits  plus  bas,  sont  utilisés  pour
          déterminer  les  permissions  d'accès  aux fichiers ; consultez path_resolution(7) pour
          plus de détails. Lorsque l'UID (ou GID) effectif d'un processus est modifié,  le  noyau
          fixe 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  setfsuid(2)  et
          setfsgid(2).

       *  GID supplémentaires. 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
          supplémentaires. L'appel 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  getgroups(2),  et  le  modifier  avec
          setgroups(2).

       Un processus fils créé par fork(2) hérite des copies des UID et GID de son père. Lors d'un
       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 execve(2).

       En  dehors des contextes décrits ci‐dessus, les UID d'un processus sont également utilisés
       dans les cas suivants :

       *  lors de la vérification des permissions pour l'envoi de signaux — consultez kill(2) ;

       *  lors  de  la  vérification  des  permissions  pour  la  modification   des   paramètres
          d'ordonnancement   (politesse,   politique  et  priorité  d'ordonnancement  temps‐réel,
          priorité  d'E/S)  avec  setpriority(2),  sched_setaffinity(2),   sched_setscheduler(2),
          sched_setparam(2) et ioprio_set(2) ;

       *  lors de la vérification de limites de ressources ; consultez getrlimit(2) ;

       *  lorsque  la  limite  du  nombre  d'instances  inotify  que  le processus peut créer est
          vérifiée ; consultez inotify(7).

CONFORMITÉ

       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 groupes additionnels sont spécifiés dans
       POSIX.1-2001. Les identifiants du système de fichiers sont une extension Linux.

NOTES

       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,  des  appels  à   setuid(2),
       setresuid(2), etc.) soit propagée vers tous les threads POSIX d'un processus.

VOIR AUSSI

       bash(1),   csh(1),   ps(1),   access(2),  execve(2),  faccessat(2),  fork(2),  getpgrp(2),
       getpid(2), getppid(2), getsid(2), kill(2), killpg(2), setegid(2), seteuid(2), setfsgid(2),
       setfsuid(2),  setgid(2),  setgroups(2), setresgid(2), setresuid(2), setuid(2), waitpid(2),
       euidaccess(3),     initgroups(3),     tcgetpgrp(3),     tcsetpgrp(3),     capabilities(7),
       path_resolution(7), unix(7)

COLOPHON

       Cette  page  fait partie de la publication 3.32 du projet man-pages Linux. Une description
       du projet et des  instructions  pour  signaler  des  anomalies  peuvent  être  trouvées  à
       l'adresse <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis    2010,    cette   traduction   est   maintenue   à   l'aide   de   l'outil   po4a
       <URL:http://po4a.alioth.debian.org/> par l'équipe de traduction  francophone  au  sein  du
       projet perkamon <URL:http://perkamon.alioth.debian.org/>.

       Julien Cristau et l'équipe francophone de traduction de Debian (2006-2009).

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>  ou  par  un  rapport  de  bogue   sur   le   paquet
       manpages-fr.

       Vous  pouvez  toujours  avoir  accès  à la version anglaise de ce document en utilisant la
       commande « man -L C <section> <page_de_man> ».