Provided by: manpages-fr_4.18.1-1_all bug

NOM

       credentials - Identifiants de processus

DESCRIPTION

   Identifiant de processus (PID)
       Chaque processus a un identifiant unique 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(3) et waitpid(2).

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

   Identifiant du processus parent (PPID)
       L'identifiant  de processus parent 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  enfant  créé  par  fork(2)  hérite  de  l'identifiant  de  session  et  de
       l'identifiant de groupe de processus de son parent. Les  identifiants  de  session  et  de
       groupe de processus sont préservés au travers d'un execve(2).

       Les  sessions  et  les  groupes  de  processus  sont des abstractions destinées à aider au
       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 le(s) processus utilisé(s) pour exécuter une  commande
       unique  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 stricte à 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.

       Tous les processus d'une session  partagent  un  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 O_NOCTTY est précisé lors de l'appel de  open(2)).  Un  terminal  ne
       peut être le terminal de contrôle que d'une seule session.

       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 ». Seule 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  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
       TOSTOP (consultez 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 de tâches d'arrière plan vers
       le terminal déclenche un signal 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
       interrupt qui provoque normalement un Contrôle-C), le signal est envoyé  au  processus  de
       premier plan.

       Divers  appels système et fonctions de bibliothèque peuvent agir sur tous les membres d'un
       groupe  de  processus,  notamment  kill(2),  killpg(2),  getpriority(2),   setpriority(2),
       ioprio_get(2),  ioprio_set(2),  waitid(2) et waitpid(2). Consultez également la discussion
       au sujet des opérations F_GETOWN, F_GETOWN_EX, F_SETOWN et F_SETOWN_EX dans fcntl(2).

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

       •  UID sauvegardé et GID sauvegardé. 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 sauvegardé. 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 sauvegardé avec getresuid(2) et son GID sauvegardé
          avec getresgid(2)).

       •  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  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   setfsuid(2)   et
          setfsgid(2).

       •  GID  additionnels. Il s'agit d'un ensemble d'identifiants de groupe supplémentaires qui
          sont utilisés pour les vérifications de permissions  d'accès  aux  fichiers  et  autres
          ressources partagées. Avant Linux  2.6.4, un processus pouvait avoir jusqu'à 32 groupes
          additionnels ; depuis Linux 2.6.4, cette  limite  est  de  65536 groupes  additionnels.
          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  consulter  son
          ensemble de GID additionnels avec getgroups(2).

       Un  processus enfant créé par fork(2) hérite des copies des UID et GID de son parent. 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  sauvegardé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), sched_setattr(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)).

   Modification des UID et GID d'un processus
       Soumis  aux  règles  décrites  dans  les  pages de manuel concernées, un processus peut se
       servir des API suivantes pour modifier ses UID et GID.

       setuid(2) (setgid(2))
              Modifier l'UID (ou le GID) réel (et éventuellement  effectif  et  sauvegardé)  d'un
              processus.

       seteuid(2) (setegid(2))
              Modifier l'UID (ou le GID) effectif d'un processus.

       setfsuid(2) (setfsgid(2))
              Modifier l'UID (ou le GID) du système de fichiers d'un processus.

       setreuid(2) (setregid(2))
              Modifier  les  UID (ou le GID) réel et effectif (et éventuellement sauvegardé) d'un
              processus.

       setresuid(2) (setresgid(2))
              Modifier les UID (ou le GID) réel, effectif et sauvegardé d'un processus.

       setgroups(2)
              Modifier la liste des groupes additionnels d'un processus

       Toutes les modifications d'UID (ou de GID) effectif d'un  processus  sont  automatiquement
       propagées  sur  l'UID  (ou  le GID) du système de fichiers du processus. Les modifications
       d'UID (ou de GID) effectif d'un processus peuvent aussi affecter  l'attribut  « dumpable »
       du processus, comme décrit dans prctl(2).

       Les  modifications  d'UID  (ou  de  GID)  d'un processus peuvent affecter les capacités du
       processus, comme décrit dans capabilities(7).

STANDARDS

       Les PID, PPID, PGID et SID sont  spécifiés  dans  POSIX.1-2001.  Les  identifiants  réels,
       effectifs  et  sauvegardés, et les identifiants de groupe additionnels sont spécifiés dans
       POSIX.1-2001. Les UID et GID du système de fichiers sont une extension de Linux.

NOTES

       Plusieurs champs du  fichier  /proc/pid/status  montrent  les  identifiants  du  processus
       décrits ci‐dessus. Consultez proc(5) pour plus d'informations.

       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, au moyen d'appels à setuid(2) ou
       setresuid(2)) soit propagée vers tous les threads POSIX d'un processus. Consultez  nptl(7)
       pour plus de détails.

VOIR AUSSI

       bash(1), csh(1), groups(1), id(1), newgrp(1), ps(1), runuser(1), setpriv(1), sg(1), su(1),
       access(2),  execve(2),  faccessat(2),  fork(2),   getgroups(2),   getpgrp(2),   getpid(2),
       getppid(2),   getsid(2),   kill(2),   setegid(2),  seteuid(2),  setfsgid(2),  setfsuid(2),
       setgid(2), setgroups(2), setpgid(2),  setresgid(2),  setresuid(2),  setsid(2),  setuid(2),
       waitpid(2),    euidaccess(3),   initgroups(3),   killpg(3),   tcgetpgrp(3),   tcgetsid(3),
       tcsetpgrp(3),   group(5),   passwd(5),    shadow(5),    capabilities(7),    namespaces(7),
       path_resolution(7),   pid_namespaces(7),   pthreads(7),  signal(7),  system_data_types(7),
       unix(7), user_namespaces(7), sudo(8)

TRADUCTION

       La traduction française de cette  page  de  manuel  a  été  créée  par  Christophe  Blaess
       <https://www.blaess.fr/christophe/>,  Stéphan  Rafin  <stephan.rafin@laposte.net>, Thierry
       Vignaud <tvignaud@mandriva.com>, François Micaux, Alain  Portal  <aportal@univ-montp2.fr>,
       Jean-Philippe    Guérard   <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-
       luc.coulon@wanadoo.fr>,   Julien    Cristau    <jcristau@debian.org>,    Thomas    Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>,  Denis
       Barbier   <barbier@debian.org>,   David   Prévot  <david@tilapin.org>,  Cédric  Boutillier
       <cedric.boutillier@gmail.com>,  Frédéric  Hantrais  <fhantrais@gmail.com>  et  Jean-Pierre
       Giraud <jean-pierregiraud@neuf.fr>

       Cette  traduction  est  une  documentation libre ; veuillez vous reporter à la GNU General
       Public  License  version 3  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩   concernant   les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à ⟨debian-l10n-french@lists.debian.org⟩.