Provided by: manpages-fr-dev_4.13-4_all bug

NOM

       prctl - Opérations sur un processus ou un thread

SYNOPSIS

       #include <sys/prctl.h>

       int prctl(int option, unsigned long arg2, unsigned long arg3,
                 unsigned long arg4, unsigned long arg5);

DESCRIPTION

       prctl() gère divers aspects du comportement du thread ou du processus appelant.

       Notez  qu'une  utilisation  peu  soigneuse  de certaines opérations de prctl() peut perdre
       l'environnement d’exécution de l'espace  utilisateur,  donc  il  faut  les  utiliser  avec
       rigueur.

       prctl()  est invoqué avec un premier paramètre indiquant ce qu'il faut faire, (ses valeurs
       sont  définies  dans  <linux/prctl.h>),  et  des  paramètres   supplémentaires   dont   la
       signification dépend du premier paramètre. Celui-ci peut être :

       PR_CAP_AMBIENT (depuis Linux 4.3)
              Lire  ou  modifier  l'ensemble  environnant des capacités paramétrées sur le thread
              appelant, en fonction de la valeur de arg2, qui doit être une des suivantes :

              PR_CAP_AMBIENT_RAISE
                     La capacité indiquée dans arg3 est ajoutée à  l'ensemble  environnant.  Elle
                     doit être déjà présente dans les ensembles environnants autorisés et hérités
                     du processus. Cette opération n'est pas autorisée  si  le  bit  de  sécurité
                     SECBIT_NO_CAP_AMBIENT_RAISE est positionné.

              PR_CAP_AMBIENT_LOWER
                     La capacité indiquée dans arg3 est supprimée de l'ensemble environnant.

              PR_CAP_AMBIENT_IS_SET
                     L'appel  prctl()  renvoie  1  si  la  capacité  indiquée  dans arg3 est dans
                     l'ensemble environnant et, sinon, 0.

              PR_CAP_AMBIENT_CLEAR_ALL
                     Toutes les capacités seront  supprimées  de  l'ensemble  environnant.  Cette
                     opération implique que arg3 soit positionné sur zéro.

              Dans toutes les opérations ci-dessus, arg4 et arg5 doivent valoir 0.

              Des  interfaces  de  plus  haut  niveau  qui  constituent  la  couche au-dessus des
              opérations ci-dessus sont fournies dans la bibliothèque  libcap(3)  sous  la  forme
              cap_get_ambient(3), cap_set_ambient(3), et cap_reset_ambient(3).

       PR_CAPBSET_READ (depuis Linux 2.6.25)
              Renvoyer  (en résultat de fonction) 1 si la capacité indiquée par arg2 est présente
              dans l’ensemble limitant de capacités du thread appelant ou 0 si elle ne l'est pas.
              Les  constantes  des  capacités sont définies dans <linux/capability.h>. L'ensemble
              limitant les capacités contrôle si le processus peut recevoir la  capacité  par  un
              ensemble de capacités autorisées pour un fichier lors d'un appel futur à execve(2).

              Si  la  capacité  indiquée  dans  arg2 n'est pas valable, alors l'appel échoue avec
              l'erreur EINVAL.

              Une interface de plus haut niveau constituant la couche par-dessus cette  opération
              est fournie dans la bibliothèque libcap(3) sous la forme cap_get_bound(3).

       PR_CAPBSET_DROP (depuis Linux 2.6.25)
              Si  le  thread  appelant  a  la  capacité  CAP_SETPCAP  dans  son  espace  de  noms
              utilisateur, alors enlever  la  capacité  indiquée  par  arg2  dans  l'ensemble  de
              limitation  de  capacités  du  thread  appelant.  Les  enfants  du  thread appelant
              hériteront de cette nouvelle limitation de capacités réduite.

              L'appel échoue avec l'erreur EPERM si  le  thread  appelant  n'a  pas  la  capacité
              CAP_SETPCAP ;  ou  avec  l'erreur  EINVAL  si  arg2  ne représente pas une capacité
              correcte ; ou avec l'erreur EINVAL si les capacités de fichier ne sont pas activées
              dans  le  noyau,  auquel  cas  les  limitations ne sont pas prises en charge par le
              noyau.

              Une interface de  plus  haut  niveau  constituant  la  couche  au-dessus  de  cette
              opération   est   fournie   par   la   bibliothèque   libcap(3)   sous   la   forme
              cap_drop_bound(3).

       PR_SET_CHILD_SUBREAPER (depuis Linux 3.4)
              Si arg2 ne vaut pas zéro, positionner l'attribut « child subreaper »  du  processus
              appelant ; si arg2 vaut zéro, déconfigurer l'attribut.

              Un  subreaper  (suppresseur)  joue  le  rôle de init(1) pour ses processus enfants.
              Quand un processus devient orphelin (c'est-à-dire, que son parent le plus proche se
              termine),  ce processus sera adopté par le subreaper parent toujours vivant le plus
              proche. Par conséquent, les appels getppid(2) dans le processus orphelin renverront
              désormais l'identifiant de processus du subreaper et quand l'orphelin se terminera,
              c'est le processus subreaper qui recevra le signal  SIGCHLD  et  pourra  surveiller
              (wait(2)) le processus pour détecter son état de fin.

              Le  paramètre  de l'attribut « child subreaper » n'est pas récupéré par les enfants
              créés par fork(2) et clone(2). Le paramètre est préservé lors d'un execve(2).

              Établir un processus subreaper est utile dans  les  environnements  de  gestion  de
              sessions où un groupe hiérarchique de processus est géré par un processus subreaper
              qui a besoin de savoir quand un des processus — par exemple, un  démon  forké  deux
              fois —  se  termine  (pour  pouvoir  peut-être  redémarrer  ce processus). Certains
              environnements init(1) (comme systemd(1)) utilisent un processus subreaper pour les
              mêmes raisons.

       PR_GET_CHILD_SUBREAPER (depuis Linux 3.4)
              Renvoyer  l'état  « child  subreaper »  du  processus  appelant, dans l'emplacement
              pointé par (int *) arg2.

       PR_SET_DUMPABLE (depuis Linux 2.3.20)
              Définir l'état de l'attribut « dumpable » qui détermine si les fichiers de  vidages
              mémoire  (core  dump)  sont  produits pour le processus appelant lors de l'envoi du
              signal, dont le comportement par défaut est de produire un fichier d’image mémoire.

              Dans les noyaux jusqu'à 2.6.12 inclus, arg2 doit valoir 0  (SUID_DUMP_DISABLE,  pas
              de  vidage mémoire) ou 1 (SUID_DUMP_USER, vidage possible). Entre les noyaux 2.6.13
              et 2.6.17, la valeur 2 était également autorisée ; elle permettait à un binaire qui
              ne produirait normalement pas de fichier de vidage d'en créer un lisible uniquement
              par root ; cette fonctionnalité a  été  supprimée  pour  des  raisons  de  sécurité
              (consultez aussi la description de /proc/sys/fs/suid_dumpable dans proc(5)).

              Normalement,  l'attribut  « dumpable »  est  positionné  sur  1.  Cependant, il est
              positionné sur la valeur actuelle du fichier /proc/sys/fs/suid_dumpable (qui a  une
              valeur de 0 par défaut), dans les circonstances suivantes :

              –  L'identifiant d'utilisateur ou de groupe effectif du processus a été modifié.

              –  L'identifiant  d'utilisateur  ou de groupe du système de fichiers du processus a
                 été modifié (voir credentials(7)).

              –  Le processus exécute (execve(2)) un programme set-user-ID  ou  set-group-ID,  ce
                 qui fait changer l'identifiant d'utilisateur ou de groupe effectif.

              –  Le  processus  exécute  (execve(2))  un programme qui a les capacités de fichier
                 (voir  capabilities(7)),  mais  seulement  si  les  capacités   acquises   ainsi
                 autorisées dépassent celles autorisées pour le processus.

              Les  processus  qui  ne  génèrent  pas  de  fichier  de  vidage ne peuvent pas être
              rattachés à l'aide de PTRACE_ATTACH de ptrace(2) ;  voir  ptrace(2)  pour  plus  de
              détails.

              Si  un processus ne génère pas de fichier de vidage, l'appartenance des fichiers du
              répertoire /proc/[pid] du processus est modifiée comme le décrit proc(5).

       PR_GET_DUMPABLE (depuis Linux 2.3.20)
              Renvoyer (en résultat de fonction) l'état  actuel  de  l'attribut  de  création  de
              fichier de vidage du processus appelant.

       PR_SET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC)
              Définir  le  boutisme  (endianness)  du  processus appelant à la valeur donnée dans
              arg2, qui doit être l'une des valeurs suivantes : PR_ENDIAN_BIG,  PR_ENDIAN_LITTLE,
              ou PR_ENDIAN_PPC_LITTLE (PowerPC pseudo petit boutiste).

       PR_GET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC)
              Renvoyer  le boutisme (endianness) du processus appelant, dans l'emplacement pointé
              par (int *) arg2.

       PR_SET_FP_MODE (depuis Linux 4.0, seulement sur MIPS)
              Sur l'architecture MIPS, le code en  espace  utilisateur  peut  être  construit  en
              utilisant une ABI qui permet l'édition de liens avec du code ayant des exigences de
              virgule  flottante  (FP)  plus  restrictives.  Par  exemple,  un  code  en   espace
              utilisateur peut être construit pour cibler l'ABI FPXX O32 et lié au code construit
              pour une ou plusieurs ABI plus restrictives  FP32  ou  FP64.  Quand  du  code  plus
              restrictif  est  lié, l'exigence supplémentaire du processus est d'utiliser le mode
              de virgule flottante plus restrictif.

              Le noyau n'ayant aucun moyen de savoir à l'avance le mode  dans  lequel  doit  être
              exécuté  le  processus,  et  ces  restrictions  pouvant  changer  durant  la vie du
              processus, l'opération PR_SET_FP_MODE est fournie pour  permettre  un  contrôle  du
              mode de virgule flottante à partir de l'espace utilisateur.

              L'argument  (unsigned  int) arg2 est un masque de bits décrivant le mode de virgule
              flottante utilisé :

              PR_FP_MODE_FR
                     Quand le bit est unset (ce  qui  est  appelé  le  mode  FR=0  ou  FR0),  les
                     registres 32  de virgule flottante ont une taille de 32 bits et ceux 64 bits
                     sont représentés sous forme de paire de registres (numérotés par  un  nombre
                     pair  ou impair, avec le registre pair contenant les 32 bits de poids faible
                     et celui impair contenant les 32 bits de poids fort).

                     Quand ce bit est set (sur le matériel pris en charge), les registres  32  de
                     virgule  flottante ont une taille de 64 bits (ce qui est appelé le mode FR=1
                     ou FR1). Remarquez que les implémentations MIPS modernes  (MIPS R6  et  plus
                     récentes) ne gèrent que le mode FR=1.

                     Les  applications  qui  utilisent  l'ABI O32 FP32 ne peuvent fonctionner que
                     lorsque ce bit est unset (FR=0 ; ou elles peuvent être  utilisées  avec  FRE
                     activé,  voir ci-dessous). Les applications qui utilisent l'ABI O32 FP64 (et
                     l'ABI O32 FP64A qui existe pour offrir la capacité d'agir avec le code  FP32
                     existant ; voir ci-dessous) ne peuvent agir que quand ce bit est set (FR=1).
                     Les applications qui utilisent l'ABI O32 FPXX  peuvent  agir  avec  FR=0  ou
                     FR=1.

              PR_FP_MODE_FRE
                     Activer  l'émulation  du mode flottant 32 bits. Quand ce mode est activé, il
                     émule les opérations de virgule flottante 32 bits en plaçant  une  exception
                     d'instruction  réservée sur chaque instruction utilisant les formats 32 bits
                     et le noyau prend alors en charge l'instruction au niveau logiciel (c'est le
                     problème  du décalage entre la gestion des registres aux numéros pairs , qui
                     sont les 32 bits supérieurs des registres 64 bits ayant les numéros  impairs
                     en  mode  FR=0, et les parties 32 bits de poids faible des registres 64 bits
                     de numéros impairs en mode FR=1). L'activation de ce bit est nécessaire pour
                     du  code  dont l'ABI O32 FP3 doit agir sur du code ayant des ABI compatibles
                     O32 FPXX ou O32 FP64A (ce qui implique le mode FR=1 FPU), ou  lorsqu'il  est
                     exécuté  sur  du  matériel  plus  récent (après MIPS R6) qui ne prend pas en
                     charge le mode FR=0 quand un binaire avec l'ABI FP32 est utilisé.

                     Remarquez que ce mode n'a de sens que lorsque le FPU est  en  mode  64  bits
                     (FR=1).

                     Remarquez  que l'utilisation de l'émulation a par nature des conséquences en
                     termes de performance et qu’elle doit être évitée si possible.

              Dans l'ABI N32/N64, le mode de virgule  flottante  64 bits  est  toujours  utilisé,
              l'émulation  FPU  n'est  donc  pas  nécessaire et le mode FPU agit toujours en mode
              FR=1.

              Cette option vise principalement les éditeurs de liens dynamiques (ld.so(8)).

              Les paramètres arg3, arg4 et arg5 sont ignorés.

       PR_GET_FP_MODE (depuis Linux 4.0, seulement sur MIPS)
              Renvoyer (comme résultat de la fonction) le mode de virgule flottante actuel  (voir
              la description de PR_SET_FP_MODE pour les détails).

              En  cas  de  succès,  l'appel  renvoie  un masque de bits qui représente le mode de
              virgule flottante actuel.

              Les paramètres arg2, arg3, arg4 et arg5 sont ignorés.

       PR_SET_FPEMU (depuis Linux 2.4.18, 2.5.9, seulement sur ia64)
              Définir les bits de contrôle de l'émulation de virgule  flottante  à  arg2.  Passer
              PR_FPEMU_NOPRINT  pour  émuler silencieusement les opérations de virgule flottante,
              ou PR_FPEMU_SIGFPE pour ne pas émuler ces opérations et envoyer SIGFPE.

       PR_GET_FPEMU (depuis Linux 2.4.18, 2.5.9, seulement sur ia64)
              Renvoyer les bits de contrôle de l'émulation de FPU, dans l'emplacement pointé  par
              (int *) arg2.

       PR_SET_FPEXC (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC)
              Définir  le  mode  d'exception  de  virgule  flottante  à  arg2.  Passer  la valeur
              PR_FP_EXC_SW_ENABLE pour utiliser FPEXC pour activer les  exceptions  de  flottant,
              PR_FP_EXC_DIV  pour  les  divisions  de  flottant  par zéro, PR_FP_EXC_OVF pour les
              dépassements de capacité vers le  haut,  PR_FP_EXC_UND  pour  les  dépassements  de
              capacité  vers  le  bas,  PR_FP_EXC_RES  pour  les  résultats de flottant inexacts,
              PR_FP_EXC_INV pour les opérations de flottant non valables, PR_FP_EXC_DISABLED pour
              désactiver  les exceptions de flottant, PR_FP_EXC_NONRECOV pour le mode d'exception
              asynchrone non récupérable, PR_FP_EXC_ASYNC pour  le  mode  d'exception  asynchrone
              récupérable, PR_FP_EXC_PRECISE pour le mode d'exception de précision.

       PR_GET_FPEXC (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC)
              Renvoyer  le  mode  d'exception de virgule flottante, dans l'emplacement pointé par
              (int *) arg2.

       PR_SET_IO_FLUSHER (depuis Linux 5.6)
              Si le processus d'un utilisateur est impliqué dans la couche de blocs ou le  chemin
              d'E/S  du  système  de fichiers, et s'il peut allouer de la mémoire en traitant les
              requêtes E/S, il doit positionner arg2 sur 1. Cela  mettra  le  processus  en  état
              IO_FLUSHER,  ce  qui  lui  accorde  un  traitement  spécial pour progresser lors de
              l'allocation de la mémoire. Si arg2 vaut 0, le processus effacera l'état IO_FLUSHER
              et le comportement par défaut sera utilisé.

              Le processus appelant doit avoir la capacité CAP_SYS_RESOURCE.

              arg3, arg4 et arg5 doivent valoir 0.

              L'état  IO_FLUSHER est récupéré par un processus enfant créé à l'aide de fork(2) et
              il est préservé pendant un execve(2).

              Des exemples d'applications IO_FLUSHER sont les démons FUSE,  ceux  d'émulation  de
              périphériques   SCSI   et  ceux  gérant  des  erreurs  comme  les  applications  de
              récupération de chemins multipath.

       PR_GET_IO_FLUSHER (depuis Linux 5.6)
              Renvoyer (en tant que résultat de la fonction) l'état IO_FLUSHER de l'appelant. Une
              valeur  de  1  indique  que l'appelant est dans l'état IO_FLUSHER ; 0 indique qu'il
              n'est pas dans cet état.

              Le processus appelant doit avoir la capacité CAP_SYS_RESOURCE.

              arg2, arg3, arg4 et arg5 doivent valoir zéro.

       PR_SET_KEEPCAPS (depuis Linux 2.2.18)
              Définir l'état de l'attribut « keep capabilities » du thread appelant.  L'effet  de
              cet  attribut  est  décrit  dans  capabilities(7). arg2 doit valoir soit 0 (effacer
              l'attribut), soit 1 (positionner l'attribut). La valeur  de  « keep  capabilities »
              sera remise à 0 lors des prochains appels à execve(2).

       PR_GET_KEEPCAPS (depuis Linux 2.2.18)
              Renvoyer  (en résultat de fonction) l'état actuel de l'attribut de conservation des
              capacités du thread appelant. Voir capabilities(7)  pour  une  description  de  cet
              attribut.

       PR_MCE_KILL (depuis Linux 2.6.32)
              Définir  la  politique  de  suppression  de mémoire corrompue de la machine pour le
              thread actuel. Si arg2 vaut PR_MCE_KILL_CLEAR, effacer la politique de  suppression
              de  mémoire  corrompue et utiliser la valeur par défaut du système (qui est définie
              dans  /proc/sys/vm/memory_failure_early_kill,  consultez  proc(5)).  Si  arg2  vaut
              PR_MCE_KILL_SET,  utiliser  une  politique  de  suppression  de  mémoire  corrompue
              spécifique au thread. Dans ce cas, arg3  définit  si  la  politique  est  immédiate
              (early kill avec PR_MCE_KILL_EARLY), différée (late kill avec PR_MCE_KILL_LATE), ou
              la valeur par défaut du système (PR_MCE_KILL_DEFAULT).  Une  suppression  immédiate
              signifie  que  le  thread  reçoit  un  signal  SIGBUS dès que la corruption mémoire
              matérielle est détectée à l'intérieur de son espace d'adressage. En  mode  différé,
              le  processus  n'est  tué  que  lorsqu'il  accède  à  une page corrompue. Consultez
              sigaction(2) pour plus d'informations sur le signal  SIGBUS.  Cette  politique  est
              héritée  par  les enfants. Les arguments restants de prctl(), non utilisés, doivent
              être mis à zéro pour préparer la future compatibilité.

       PR_MCE_KILL_GET (depuis Linux 2.6.32)
              Renvoyer (comme résultat de la fonction) la politique  actuelle  par  processus  de
              suppression  de  mémoire  corrompue.  Tous  les  arguments  de prctl() non utilisés
              doivent être zéro

       PR_SET_MM (depuis Linux 3.3)
              Modifier certains champs du descripteur de projection de mémoire du noyau  pour  le
              processus  appelant.  D'habitude,  ces  champs  sont  déterminés par le noyau et le
              chargeur de liens dynamiques (consultez ld.so(8) pour plus d'informations)  et  une
              application normale ne devrait pas utiliser cette fonctionnalité. En revanche, dans
              certaines situations, telles que celles de programmes se  modifiant  eux-mêmes,  un
              programme pourra trouver utile de pouvoir changer sa propre projection en mémoire.

              Le  processus  appelant  doit avoir la capacité CAP_SYS_RESOURCE. La valeur de arg2
              est une des options ci-dessous, tandis que arg3 fournit  la  nouvelle  valeur  pour
              l'option.  Les  paramètres  de  arg4 et de arg5 doivent être de 0 s'ils ne sont pas
              utilisés.

              Avant Linux 3.10, cette  fonctionnalité  n'est  disponible  que  si  le  noyau  est
              construit avec l'option CONFIG_CHECKPOINT_RESTORE.

              PR_SET_MM_START_CODE
                     Définir  l'adresse  au  dessus  de  laquelle le texte du programme peut être
                     exécuté. La zone de mémoire correspondante doit être accessible  en  lecture
                     et  en  exécution, mais pas en écriture et ne doit pas pouvoir être partagée
                     (consultez mprotect(2) et mmap(2) pour plus d'informations).

              PR_SET_MM_END_CODE
                     Définir l'adresse en dessous de laquelle le texte  du  programme  peut  être
                     exécuté.  La  zone de mémoire correspondante doit être accessible en lecture
                     et en exécution, mais pas en écriture et ne doit pas pouvoir être partagée.

              PR_SET_MM_START_DATA
                     Définir l'adresse au-dessus de laquelle  les  données  initialisées  et  non
                     initialisées (bss) sont placées. La zone de mémoire correspondante doit être
                     accessible en lecture et en écriture, mais pas en exécution et ne  doit  pas
                     pouvoir être partagée.

              PR_SET_MM_END_DATA
                     Définir  l'adresse  en  dessous  de laquelle les données initialisées et non
                     initialisées (bss) sont placées. La zone de mémoire correspondante doit être
                     accessible  en  lecture et en écriture, mais pas en exécution et ne doit pas
                     pouvoir être partagée.

              PR_SET_MM_START_STACK
                     Sélectionner  l'adresse  du  début  de  la  pile.  La  région   de   mémoire
                     correspondante doit être accessible en lecture et en écriture.

              PR_SET_MM_START_BRK
                     Sélectionner  l'adresse  au-dessus de laquelle le tas du programme peut être
                     étendu avec l'appel brk(2).  L'adresse  doit  être  au-dessus  de  l'adresse
                     terminant  le  segment  de  données  actuel du programme. De plus, la taille
                     combinée du tas obtenu et du segment de données  ne  peut  pas  dépasser  la
                     limite de ressource RLIMIT_DATA (consultez setrlimit(2)).

              PR_SET_MM_BRK
                     Sélectionnez  la  valeur  actuelle  de brk(2). Les conditions pour l'adresse
                     sont les mêmes que pour l'option PR_SET_MM_START_BRK.

              Les options suivantes sont disponibles depuis Linux 3.5.

              PR_SET_MM_ARG_START
                     Sélectionner l'adresse  au-dessus  de  laquelle  la  ligne  de  commande  du
                     programme est placée.

              PR_SET_MM_ARG_END
                     Sélectionner  l'adresse  en  dessous  de  laquelle  la  ligne de commande du
                     programme est placée.

              PR_SET_MM_ENV_START
                     Sélectionner l'adresse au-dessus de laquelle  l'environnement  du  programme
                     est placé.

              PR_SET_MM_ENV_END
                     Sélectionner  l'adresse  en dessous de laquelle l'environnement du programme
                     est placé.

                     L'adresse transmise au  moyen  de   PR_SET_MM_ARG_START,  PR_SET_MM_ARG_END,
                     PR_SET_MM_ENV_START  et  de  PR_SET_MM_ENV_END  doit  appartenir  à l'espace
                     mémoire  d'une  pile  de  processus.  Par   conséquent,   l'espace   mémoire
                     correspondant  doit  être  accessible  en  lecture, en écriture et (selon la
                     configuration  du  noyau)  disposer  de  l'attribut   MAP_GROWSDOWN   défini
                     (consultez mmap(2)).

              PR_SET_MM_AUXV
                     Sélectionner  le  nouveau vecteur auxiliaire. Le paramètre arg3 doit fournir
                     l'adresse du vecteur. Le paramètre arg4 est la taille du vecteur.

              PR_SET_MM_EXE_FILE
                     Remplacer le lien symbolique /proc/pid/exe par un nouveau lien pointant vers
                     un nouveau fichier exécutable identifié par le descripteur de fichier fourni
                     via le paramètre arg3. Le descripteur de fichier peut être obtenu  au  moyen
                     d'un appel à open(2).

                     Pour  changer le lien symbolique, il faut supprimer tous les espaces alloués
                     en mémoire et contenant du code exécutable, y  compris  ceux  créés  par  le
                     noyau  (par  exemple,  le  noyau  crée en général au moins un espace mémoire
                     d'exécutable pour la section ELF .text).

                     Sur Linux 4.9 et antérieurs, l'opération  PR_SET_MM_EXE_FILE  ne  peut  être
                     effectuée  qu'une  fois  dans  la  vie d'un processus ; si on l'effectue une
                     seconde fois, elle donnera l'erreur EPERM. Cette restriction a été renforcée
                     pour des raisons de sécurité jugées plus tard curieuses, donc la restriction
                     a été  supprimée  dans  Linux 4.10  car  certaines  applications  en  espace
                     utilisateur avaient besoin d'effectuer cette opération plus d'une fois.

              Les options suivantes sont disponibles depuis Linux 3.18.

              PR_SET_MM_MAP
                     Fournir  un  accès  unique  à  toutes  les  adresses  en  passant une struct
                     prctl_mm_map (comme défini dans <linux/prctl.h>).  Le  paramètre  arg4  doit
                     fournir la taille de la structure.

                     Cette  fonctionnalité  n'est disponible que si le noyau a été construit avec
                     l'option CONFIG_CHECKPOINT_RESTORE activée.

              PR_SET_MM_MAP_SIZE
                     Renvoyer la taille attendue par le noyau de  la  struct  prctl_mm_map.  Cela
                     permet  à  l'espace  utilisateur  de  trouver  une  structure compatible. Le
                     paramètre arg4 doit être un pointeur vers un entier non signé.

                     Cette fonctionnalité n'est disponible que si le noyau a été  construit  avec
                     l'option CONFIG_CHECKPOINT_RESTORE activée.

       PR_MPX_ENABLE_MANAGEMENT,  PR_MPX_DISABLE_MANAGEMENT  (depuis  Linux 3.19,  supprimée dans
       Linux 5.4 ; seulement sur x86)
              Activer ou désactiver la gestion par le noyau  des  tables  de  limitations  Memory
              Protection eXtensions (MPX). Les paramètres arg2, arg3, arg4 et arg5 doivent valoir
              zéro.

              MPX est un mécanisme assisté par  le  matériel  pour  effectuer  des  contrôles  de
              limites  sur  les pointeurs. Il consiste dans un ensemble de registres stockant les
              informations des limites et un ensemble  de  préfixes  d'instruction  spéciaux  qui
              disent  au  processeur sur quelle instruction il doit poser des limites renforcées.
              Il existe un nombre limité de ces registres et quand il y a plus de  pointeurs  que
              de  registres,  leur  contenu  doit  être « déversé » (spilled) dans un ensemble de
              tables. Ces tables s'appellent des « bounds tables » et les opérations  prctl()  de
              MPX décident si le noyau gère leur allocation ou leur libération.

              Quand  la  gestion  est  activée,  le  noyau  prendra  en charge l'allocation et la
              libération des tables de limites. Il le fait en piégeant  les  exceptions  #BR  qui
              conduisent  d’abord  à  l'utilisation  de  tables de limites manquantes, et au lieu
              d'envoyer l'exception à l'espace utilisateur, il alloue  la  table  et  remplit  le
              répertoire des limites avec l'emplacement de la nouvelle table. Pour la libération,
              le noyau vérifie dans les tables de limites la présence de mémoire non  allouée  et
              les libère.

              Avant d'activer la gestion MPX en utilisant PR_MPX_ENABLE_MANAGEMENT, l'application
              doit d'abord avoir alloué un tampon dans l'espace utilisateur pour le répertoire de
              limites, et placé l'emplacement de ce répertoire dans le registre bndcfgu.

              Ces  appels  échouent  si  le processeur ou le noyau ne gèrent pas MPX. La prise en
              charge  par  le  noyau   de   MPX   s'active   avec   l'option   de   configuration
              CONFIG_X86_INTEL_MPX. Vous pouvez vérifier que le processeur prend en charge MPX en
              recherchant le bit de CPUID mpx, avec une commande telle que :

                  cat /proc/cpuinfo | grep ' mpx '

              Il se peut qu'un thread ne bascule pas en ou hors du mode long (64 bits) quand  MPX
              est activé.

              Tous les threads d'un processus sont concernés par ces appels.

              L'enfant  d'un fork(2) hérite de l'état de la gestion MPX. Pendant un execve(2), la
              gestion MPX est réinitialisée à un état tel que si PR_MPX_DISABLE_MANAGEMENT  avait
              été appelé.

              Pour   plus   d'informations   sur   le   MPX   d'Intel,   consultez   le   fichier
              Documentation/x86/intel_mpx.txt dans les sources du noyau.

              Du   fait   d'un   manque   de   prise   en   charge   de   l'ensemble    d'outils,
              PR_MPX_ENABLE_MANAGEMENT  et  PR_MPX_DISABLE_MANAGEMENT  ne  sont  pas  gérés  dans
              Linux 5.4 et ultérieurs.

       PR_SET_NAME (depuis Linux 2.6.9)
              Définir le nom du thread appelant, en utilisant la valeur de  l'emplacement  pointé
              par  (char *)  arg2. Le nom peut avoir jusqu'à 16 octets de long, y compris l’octet
              NULL final (en cas de dépassement, octet NULL final inclus, la chaîne est  tronquée
              silencieusement).   C’est   le   même   attribut   qui   peut   être   défini   par
              pthread_setname_np(3) et consulté par pthread_getname_np(3). On  peut  également  y
              accéder  à  l’aide  de  /proc/self/task/[tid]/comm  (voir  proc(5)), où tid désigne
              l'identifiant du thread appelant tel que renvoyé par gettid(2).

       PR_GET_NAME (depuis Linux 2.6.11)
              Renvoyer le nom du thread appelant, dans le tampon pointé  par  (char *)  arg2.  Le
              tampon  doit  être  suffisamment  grand pour contenir jusqu'à 16 octets ; la chaîne
              sera terminée par un octet NULL.

       PR_SET_NO_NEW_PRIVS (depuis Linux 3.5)
              Affecter au bit no_new_privs du processus appelant la  valeur  dans  arg2.  Lorsque
              no_new_privs  a la valeur 1, execve(2) promet de ne pas donner de droits à quoi que
              ce soit qui n'aurait pas pu être fait sans l'appel execve(2) (par  exemple,  rendre
              non  fonctionnels  les  bits de permission set-user-ID et set-group-ID, ou bien les
              capacités de fichiers). Une fois affecté, le bit ne  peut  pas  être  réinitialisé.
              L'affectation  de  ce bit est héritée par les enfants créés par fork(2) et clone(2)
              et préservée à travers execve(2).

              Depuis Linux 4.10, la valeur de l'attribut no_new_privs  d'un  thread  est  visible
              dans le champ NoNewPrivs du fichier /proc/[pid]/status.

              Pour         plus         d'informations,        consultez        le        fichier
              Documentation/userspace-api/no_new_privs.rst                                    (ou
              Documentation/prctl/no_new_privs.txt  avant  Linux 4.13) dans les sources du noyau.
              Voir seccomp(2).

       PR_GET_NO_NEW_PRIVS (depuis Linux 3.5)
              Renvoyer (comme résultat de la fonction) la valeur du bit  no_new_privs  du  thread
              appelant.  La  valeur 0  indique le comportement habituel de execve(2). La valeur 1
              indique que execve(2) va opérer dans le mode limiteur de droits décrit ci-dessus.

       PR_PAC_RESET_KEYS (depuis Linux 5.0, seulement sur arm64)
              Réinitialiser de manière sûre les clés d'authentification  du  pointeur  du  thread
              pour rafraîchir les valeurs aléatoires générées par le noyau.

              Le  jeu  de clés à réinitialiser est indiqué avec arg2, qui doit être un OU logique
              de zéro ou plusieurs des valeurs suivantes :

              PR_PAC_APIAKEY
                     clé A d'authentification d'instruction

              PR_PAC_APIBKEY
                     clé B d'authentification d'instruction

              PR_PAC_APDAKEY
                     clé A d'authentification de données

              PR_PAC_APDBKEY
                     clé B d'authentification de données

              PR_PAC_APGAKEY
                     clé “A” d'authentification générique

                     (Oui les amis, il n'y a vraiment pas de clé B générique).

              Il  existe  un  cas  particulier  où  si  arg2  vaut  0,  toutes  les   clés   sont
              réinitialisées.  Comme  de  nouvelles  clés pourraient être ajoutées dans le futur,
              c'est la manière recommandée pour  nettoyer  les  clés  existantes  pour  créer  un
              contexte  d'exécution  propre.  Remarquez  qu'il  n'est  pas  nécessaire d'utiliser
              PR_PAC_RESET_KEYS pour préparer un appel execve(2), puisque execve(2)  réinitialise
              toutes les clés d'authentification des pointeurs.

              Les autres arguments arg3, arg4 et arg5 doivent être nuls.

              Si  les paramètres ne sont pas valables, et notamment si arg2 contient des bits non
              reconnus ou correspondant à une clé  indisponible  sur  cette  plateforme,  l'appel
              échoue avec l'erreur EINVAL.

              Attention :  le compilateur ou l'environnement d'exécution pouvant utiliser tout ou
              partie des clés, un  PR_PAC_RESET_KEYS  réussi  peut  faire  planter  le  processus
              appelant.  Les  conditions  pour  l'utiliser  en  toute  sécurité sont complexes et
              dépendent du système. Ne l'utilisez pas sauf si vous savez ce que vous faites.

              Pour        plus        d'informations,        consultez         le         fichier
              Documentation/arm64/pointer-authentication.rst                                  (ou
              Documentation/arm64/pointer-authentication.txt avant Linux 5.3) dans les sources du
              noyau.

       PR_SET_PDEATHSIG (depuis Linux 2.1.57)
              Configurer  le  signal  de mort du parent du processus appelant avec la valeur arg2
              (qui peut être un numéro de signal dans l'intervalle 1..NSIG-1, ou  être  nul  pour
              effacer le signal). Il s'agit du numéro du signal que le processus appelant recevra
              si son parent meurt.

              Attention : c'est le thread qui est, dans ce cas, considéré comme le « parent » qui
              a  créé  ce  processus.  Autrement  dit,  le  signal sera envoyé quand ce thread se
              terminera (à l'aide de pthread_exit(3), par exemple) et  non  après  que  tous  les
              threads du processus parent ne se soient terminés.

              Le  signal  de  la  mort  du  parent est envoyé lors de la fin ultérieure du thread
              parent et lors de la fin de chaque processus  subreaper  (voir  la  description  de
              PR_SET_CHILD_SUBREAPER ci-dessus) auquel l'appelant est alors affilié. Si le thread
              parent et tous les subreapers ancêtres sont déjà terminés au moment de  l'opération
              PR_SET_PDEATHSIG, aucun signal de la mort du parent n'est envoyé à l'appelant.

              Le  signal  de  la  mort  du parent est envoyé au processus (voir signal(7)) et, si
              l'enfant  installe  un  gestionnaire  en   utilisant   l'attribut   SA_SIGINFO   de
              sigaction(2),  le  champ  si_pid  du  paramètre  siginfo_t du gestionnaire contient
              l'identifiant du processus parent qui se termine.

              Le paramétrage de signal de mort du parent est vidé pour l'enfant d'un fork(2).  Il
              est  également  vidé  (depuis Linux 2.4.36/2.6.23) lors de l'exécution d'un binaire
              Set-UID  ou  Set-GID  ou  d'un  binaire  qui  a  des  capacités   associées   (voir
              capabilities(7)) ;  sinon  cette valeur est préservée par execve(2). Le paramétrage
              du signal de mort du parent est aussi vidé lors du changement des  droits  suivants
              d'un  thread :  l'identifiant  utilisateur  ou  de  groupe  effectif, l'identifiant
              utilisateur ou groupe du système de fichiers.

       PR_GET_PDEATHSIG (depuis Linux 2.3.15)
              Renvoyer  la  valeur  actuelle  du  signal  de  mort  du  processus  parent,   dans
              l'emplacement pointé par (int *) arg2.

       PR_SET_PTRACER (depuis Linux 3.4)
              Cela  n'a  de  sens  que  lorsque  le  LSM Yama est actif et en mode 1 ("restricted
              ptrace", visible dans /proc/sys/kernel/yama/ptrace_scope). Lorsqu'un identifiant de
              processus ptracer (« ptracer process ID ») est passé en argument arg2, le composant
              appelant déclare que le  processus  ptracer  peut  appeler  la  fonction  ptrace(2)
              appliquée  au processus appelant, comme si celui-ci était un ancêtre direct. Chaque
              opération PR_SET_PTRACER remplace l'identifiant  du  processus  ptracer  précédent.
              L'emploi  de  PR_SET_PTRACER  avec  l'argument  arg2  égal  à  0  supprime tous les
              identifiants  de  processus  ptracer  de   l'appelant.   Si   arg2   est   égal   à
              PR_SET_PTRACER_ANY,  les  restrictions  ptrace  apportées  par  Yama  sont  de fait
              désactivées pour le processus appelant.

              Pour        plus        d'informations,        consultez         le         fichier
              Documentation/admin-guide/LSM/Yama.rst    dans    les    sources   du   noyau   (ou
              Documentation/security/Yama.txt avant Linux 4.13).

       PR_SET_SECCOMP (depuis Linux 2.6.23)
              Sélectionner le mode de traitement sécurisé (seccomp) pour le thread appelant, afin
              de  limiter  les appels système disponibles. L'appel système plus récent seccomp(2)
              fournit un superensemble de fonctions de PR_SET_SECCOMP.

              Le mode de traitement sécurisé est sélectionné par arg2 (les constantes du mode  de
              traitement sécurisé sont définies dans <linux/seccomp.h>).

              Lorsque  arg2  vaut  SECCOMP_MODE_STRICT,  les  seuls appels système permis pour le
              thread sont read(2), write(2), _exit(2) (mais pas exit_group(2))  et  sigreturn(2).
              Les  autres  appels système provoquent la réception d'un signal SIGKILL. Le mode de
              traitement sécurisé strict est utile pour les applications de traitement  numérique
              qui  peuvent avoir besoin d'exécuter des instructions ne provenant pas d'une source
              de confiance, lues à partir d'un tuyau (« pipe ») ou d'un socket.  Cette  opération
              n'est  disponible  que  si  le  noyau  a été configuré avec l'option CONFIG_SECCOMP
              activée.

              Lorsque  arg2  vaut  SECCOMP_MODE_FILTER  (depuis  Linux 3.5)  les  appels  système
              autorisés  sont définis par un pointeur vers un filtre de paquets Berkeley passé en
              arg3. Cet argument est un pointeur vers struct sock_fprog ; il peut être conçu pour
              filtrer des appels système arbitraires et les arguments des appels système. Ce mode
              est   seulement   disponible   si   le   noyau   est   configuré   avec    l'option
              CONFIG_SECCOMP_FILTER activée.

              Si  les filtres SECCOMP_MODE_FILTER autorisent fork(2), alors le mode de traitement
              sécurisé est hérité par les enfants créés par fork(2) ; si execve(2) est  autorisé,
              alors  le  mode  de  traitement  sécurisé  est préservé à travers execve(2). Si les
              filtres autorisent les appels prctl(), alors des filtres additionnels peuvent  être
              ajoutés ; ils sont exécutés dans l'ordre jusqu'au premier résultat non autorisé.

              Pour         plus         d'informations,        consultez        le        fichier
              Documentation/userspace-api/seccomp_filter.rst  dans  les  sources  du  noyau   (ou
              Documentation/prctl/seccomp_filter.txt avant Linux 4.13).

       PR_GET_SECCOMP (depuis Linux 2.6.23)
              Renvoyer  (comme  résultat de la fonction) le mode de traitement sécurisé du thread
              appelant. Si l'appelant n'est pas  dans  un  mode  de  traitement  sécurisé,  cette
              opération renvoie 0 ; si l'appelant est dans le mode de traitement sécurisé strict,
              alors l'appel prctl() provoquera l'envoi  d'un  signal  SIGKILL  au  processus.  Si
              l'appelant  est  dans  le mode filtre et que cet appel système est autorisé par les
              filtres seccomp, cette opération renvoie 2 ; sinon le processus  est  tué  avec  un
              signal  SIGKILL.  Cette  opération n'est disponible que si le noyau a été configuré
              avec l'option CONFIG_SECCOMP activée.

              Depuis Linux 3.8, le champ Seccomp du fichier /proc/[pid]/status offre une  méthode
              pour  obtenir  la même information sans risquer que le processus ne soit tué ; voir
              proc(5).

       PR_SET_SECUREBITS (depuis Linux 2.6.26)
              Configurer l'attribut « securebits » du thread appelant à  la  valeur  fournie  par
              arg2. Consultez capabilities(7).

       PR_GET_SECUREBITS (depuis Linux 2.6.26)
              Renvoyer  (en  résultat  de fonction) l'état actuel de l'attribut « securebits » du
              thread appelant. Consultez capabilities(7).

       PR_GET_SPECULATION_CTRL (depuis Linux 4.17)
              Renvoyer (en tant que résultat de la fonction) l'état de la fonction défectueuse de
              spéculation  indiquée  dans  arg2.  Actuellement, la seule valeur autorisée pour ce
              paramètre est PR_SPEC_STORE_BYPASS (sans quoi l'appel échoue avec l'erreur ENODEV).

              Le code de retour utilise les bits 0 à 3 ayant la signification suivante :

              PR_SPEC_PRCTL
                     L'atténuation peut être contrôlée par thread via PR_SET_SPECULATION_CTRL.

              PR_SPEC_ENABLE
                     La fonction de spéculation est activée, l'atténuation est désactivée.

              PR_SPEC_DISABLE
                     La fonction de spéculation est désactivée, l'atténuation est activée.

              PR_SPEC_FORCE_DISABLE
                     Identique à PR_SPEC_DISABLE mais ne peut pas être annulé.

              PR_SPEC_DISABLE_NOEXEC (depuis Linux 5.1)
                     Identique à PR_SPEC_DISABLE, mais l'état sera vidé pendant un execve(2).

              Si tous les bits valent 0,  le  processeur  n'est  pas  concerné  par  la  fonction
              défectueuse de spéculation.

              Si  PR_SPEC_PRCTL  est  positionné,  le  contrôle  par  thread de l'atténuation est
              disponible. Sinon, prctl() échouera pour la fonction défectueuse de spéculation.

              Les paramètres arg3, arg4 et arg5 doivent être  indiqués  en  tant  que  0 ;  sinon
              l'appel échoue avec l'erreur EINVAL.

       PR_SET_SPECULATION_CTRL (depuis Linux 4.17)
              Définir  l'état  de  la  fonction défectueuse de spéculation indiqué dans arg2. Ces
              paramètres sont des attributs par thread.

              Actuellement, arg2 doit valoir une des valeurs suivantes :

              PR_SPEC_STORE_BYPASS
                     Définir l'état de la  fonction  défectueuse  de  contournement  de  stockage
                     spéculatif.

              PR_SPEC_INDIRECT_BRANCH (depuis Linux 4.20)
                     Positionner  l'état  de  la  fonction  défectueuse de spéculation de branche
                     indirecte.

              Si arg2 n'a pas une des valeurs ci-dessus, l'appel échoue avec l'erreur ENODEV.

              Le paramètre arg3 est utilisé pour récupérer le code de contrôle, qui peut être  un
              des suivants :

              PR_SPEC_ENABLE
                     La fonction de spéculation est activée, l'atténuation est désactivée.

              PR_SPEC_DISABLE
                     La fonction de spéculation est désactivée, l'atténuation est activée.

              PR_SPEC_FORCE_DISABLE
                     Identique  à  PR_SPEC_DISABLE,  mais ne peut pas être annulé. Un prctl(arg2,
                     PR_SPEC_ENABLE) ultérieur avec  la  même  valeur  pour  arg2  échouera  avec
                     l'erreur EPERM.

              PR_SPEC_DISABLE_NOEXEC (depuis Linux 5.1)
                     Identique  à  PR_SPEC_DISABLE,  mais  l'état  sera vidé lors d'un execve(2).
                     Actuellement, seul arg2 égal à PR_SPEC_STORE_BYPASS est pris en charge.

              Toute valeur non valable de arg3 fera échouer l'appel avec l'erreur ERANGE.

              Les paramètres arg4 et arg5 doivent être indiqués en tant  que  0 ;  sinon  l'appel
              échoue avec l'erreur EINVAL.

              La  fonctionnalité  de  spéculation  peut  aussi être gérée par l'option d'amorçage
              spec_store_bypass_disable. Ce paramètre applique une règle  de  lecture  seule  qui
              fera  échouer  un appel prctl() avec une erreur ENXIO. Pour de plus amples détails,
              voir le  fichier  Documentation/admin-guide/kernel-parameters.txt  des  sources  du
              noyau.

       PR_SVE_SET_VL (depuis Linux 4.15, seulement sur arm64)
              Configurer  la  taille  du vecteur SVE du thread comme indiqué dans (int) arg2. Les
              paramètres arg3, arg4 et arg5 sont ignorés.

              Les bits de arg2 correspondant à PR_SVE_VL_LEN_MASK doivent être positionnés sur la
              taille  souhaitée  du  vecteur  en  octets.  Elle  est interprétée comme une limite
              supérieure : le noyau sélectionnera la taille de vecteur disponible la plus  grande
              qui ne dépasse pas celle indiquée. En particulier, indiquer SVE_VL_MAX (défini dans
              <asm/sigcontext.h>) pour les bits PR_SVE_VL_LEN_MASK exige la  taille  maximale  de
              vecteur prise en charge.

              En outre, les autres bits de arg2 doivent être positionnés sur une des combinaisons
              suivantes d'attributs :

              0      Effectuer les modifications immédiatement. Lors du prochain  execve(2)  dans
                     le  thread,  la taille du vecteur sera réinitialisée à celle configurée dans
                     /proc/sys/abi/sve_default_vector_length.

              PR_SVE_VL_INHERIT
                     Effectuer les changements  immédiatement.  Les  prochains  appels  execve(2)
                     préserveront la nouvelle taille du vecteur.

              PR_SVE_SET_VL_ONEXEC
                     Différer  la  modification pour qu'elle soit effectuée au prochain execve(2)
                     dans le thread. Les appels execve(2) suivants réinitialiseront la taille  du
                     vecteur à la valeur configurée dans /proc/sys/abi/sve_default_vector_length.

              PR_SVE_SET_VL_ONEXEC | PR_SVE_VL_INHERIT
                     Différer  la  modification pour qu'elle soit effectuée au prochain execve(2)
                     dans le thread. Les prochains  appels  execve(2)  préserveront  la  nouvelle
                     taille du vecteur.

              Dans  tous  les  cas,  toute  modification précédemment différée et en attente sera
              annulée.

              L'appel échoue avec l'erreur EINVAL si SVE n'est pas géré  par  la  plateforme,  si
              arg2  n'est  pas  reconnu  ou  n'est  pas valable, ou si la valeur des bits de arg2
              correspondant à PR_SVE_VL_LEN_MASK dépasse la plage SVE_VL_MIN..SVE_VL_MAX ou n'est
              pas un multiple de 16.

              En  cas  de succès, une valeur non négative est renvoyée décrivant la configuration
              de selected. Si PR_SVE_SET_VL_ONEXEC  faisait  partie  de  arg2,  la  configuration
              décrite  par  le  code  de  retour  prendra  effet  au prochain execve(). Sinon, la
              configuration s'applique déjà quand l'appel PR_SVE_SET_VL renvoie.  Dans  les  deux
              cas, la valeur est encodée de la même façon que le code de retour de PR_SVE_GET_VL.
              Remarquez qu'il n'y a pas d'attribut explicite dans le code de retour correspondant
              à PR_SVE_SET_VL_ONEXEC.

              La  configuration  (y compris les modifications différées en attente) est récupérée
              lors d'un fork(2) et d'un clone(2).

              Pour plus d'informations, consultez le fichier Documentation/arm64/sve.rst dans les
              sources du noyau (ou Documentation/arm64/sve.txt avant Linux 5.3).

              Attention :  le  compilateur  ou  l'environnement d'exécution pouvant utiliser SVE,
              l'utilisation de cet appel sans l'attribut PR_SVE_SET_VL_ONEXEC peut faire  planter
              le  processus  appelant.  Les conditions nécessaires pour une utilisation sûre sont
              complexes et dépendent du système. Ne l'utilisez pas sauf si vous savez vraiment ce
              que vous faites.

       PR_SVE_GET_VL (depuis Linux 4.15, seulement sur arm64)
              Récupérer la configuration de la taille du vecteur SVE du thread actuel.

              Les paramètres arg2, arg3, arg4 et arg5 sont ignorés.

              Si  le  noyau  et  la  plateforme  gèrent SVE, cette opération réussit toujours, en
              renvoyant une valeur non négative qui décrit la configuration  actuelle.  Les  bits
              correspondant  à  PR_SVE_VL_LEN_MASK  contiennent la taille du vecteur actuellement
              configuré en octets. Le bit correspondant à PR_SVE_VL_INHERIT indique si la  taille
              du vecteur sera récupérée à travers execve(2).

              Remarquez  qu'il  n'y  a  aucun moyen de savoir s'il y a un changement de taille de
              vecteur en attente non encore appliqué.

              Pour plus d'informations, consultez le fichier Documentation/arm64/sve.rst dans les
              sources du noyau (ou Documentation/arm64/sve.txt avant Linux 5.3).

       PR_SET_TAGGED_ADDR_CTRL (depuis Linux 5.4, seulement sur arm64)
              Contrôler  la  gestion du passage d'adresses labellisées de l'espace utilisateur au
              noyau (c'est-à-dire des adresses où les bits 56—63 ne valent pas 0).

              Le niveau de prise en charge est sélectionné par arg2, qui  peut  prendre  une  des
              valeurs suivantes :

              0      Les  adresses  qui sont passées pour être déréférencées par le noyau doivent
                     être non labellisées.

              PR_TAGGED_ADDR_ENABLE
                     Les adresses qui sont passées pour être déréférencées par le  noyau  doivent
                     être labellisées, sauf celles résumées ci-dessous.

              Les autres arguments arg3, arg4 et arg5 doivent être nuls.

              En  cas  de succès, le mode indiqué dans arg2 est positionné sur le thread appelant
              et le code de retour est 0. Si les paramètres ne sont pas valables, le mode indiqué
              dans  arg2 n'est pas reconnu, ou si la fonctionnalité n'est pas prise en charge par
              le    noyau    ou    bien    si    elle    est    désactivée    à     l'aide     de
              /proc/sys/abi/tagged_addr_disabled, l'appel échoue avec l'erreur EINVAL.

              En  particulier,  si prctl(PR_SET_TAGGED_ADDR_CTRL, 0, 0, 0, 0) échoue avec EINVAL,
              toutes les adresses transmises au noyau doivent être non labellisées.

              Indépendamment du mode défini,  les  adresses  transmises  à  certaines  interfaces
              doivent toujours être non labellisées :

                •
                brk(2), mmap(2), shmat(2), shmdt(2) et le paramètre new_address de mremap(2).

                (avant  Linux  5.6,  ils  acceptaient  les  adresses  labellisées  mais cela peut
                entraîner un comportement non prévu. Ne vous y fiez pas).

                •
                Les interfaces ‘polymorphic’ (polymorphes) qui acceptent les pointeurs  vers  des
                types  arbitraires  changent  à void * ou un autre type générique, en particulier
                prctl(),  ioctl(2)  et  généralement  setsockopt(2)  (seules  certaines   options
                spécifiques de setsockopt(2) acceptent les adresses labellisées).

              Cette  liste  d'exceptions  peut diminuer au fil des versions du noyau. Si le noyau
              peut garantir une rétrocompatibilité, les  effets  de  la  transmission  d'adresses
              labellisées à ces interfaces ne sont pas spécifiés pour les nouveaux logiciels.

              Le  mode  défini  par cet appel est récupéré à travers fork(2) et clone(2). Le mode
              est remis à 0 par execve(2) (c'est-à-dire les  adresses  labellisées  ne  sont  pas
              autorisées dans l'ABI de l'utilisateur ou du noyau).

              Pour         plus         d'informations,        consultez        le        fichier
              Documentation/arm64/tagged-address-abi.rst dans les sources du noyau.

              Attention : cet appel est d'abord conçu pour une utilisation par  un  environnement
              d'exécution.  Un appel PR_SET_TAGGED_ADDR_CTRL réussi peut, ailleurs, faire planter
              le processus appelant. Les conditions pour une utilisation sûre sont  complexes  et
              dépendantes du système. Ne l'utilisez pas sauf si vous savez ce que vous faites.

       PR_GET_TAGGED_ADDR_CTRL (depuis Linux 5.4, seulement sur arm64)
              Renvoyer le mode d'adressage étiqueté actuel du thread appelant.

              Les paramètres arg2, arg3, arg4 et arg5 doivent être nuls.

              Si les paramètres ne sont pas valables ou si cette fonctionnalité est désactivée ou
              non prise en charge par le noyau, l'appel échoue avec EINVAL.  En  particulier,  si
              prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0) échoue avec EINVAL, cette fonction n'est
              clairement     pas      prise      en      charge      ou      désactivée      avec
              /proc/sys/abi/tagged_addr_disabled.  Dans ce cas, toutes les adresses transmises au
              noyau doivent être non labellisées.

              Sinon, l'appel renvoie une  valeur  non  négative  décrivant  le  mode  d'adressage
              labellisé   actuel,   encodé   de   la  même  manière  que  le  paramètre  arg2  de
              PR_SET_TAGGED_ADDR_CTRL.

              Pour        plus        d'informations,        consultez         le         fichier
              Documentation/arm64/tagged-address-abi.rst dans les sources du noyau.

       PR_TASK_PERF_EVENTS_DISABLE (depuis Linux 2.6.31)
              Désactiver  tous  les  compteurs  de  performance  attachés  au processus appelant,
              indépendamment du fait que ces compteurs ont été créés par ce processus ou  par  un
              autre.  Les  compteurs de performance créés par le processus appelant pour d'autres
              processus ne sont pas concernés. Pour plus  d'informations  sur  les  compteurs  de
              performance, consultez le fichier tools/perf/design.txt des sources du noyau Linux.

              Initialement  appelé  PR_TASK_PERF_COUNTERS_DISABLE.  Renommé  (avec la même valeur
              numérique) dans Linux 2.6.32.

       PR_TASK_PERF_EVENTS_ENABLE (depuis Linux 2.6.31)
              L'inverse de PR_TASK_PERF_EVENTS_DISABLE.  Activer  les  compteurs  de  performance
              attachés au processus appelant.

              Initialement appelé PR_TASK_PERF_COUNTERS_ENABLE. Renommé dans Linux 2.6.32.

       PR_SET_THP_DISABLE (depuis Linux 3.15)
              Affecter  l'état  de  l'attribut « THP disable » pour le thread appelant. Si arg2 a
              une valeur non nulle, l'attribut  est  activé ;  dans  le  cas  contraire,  il  est
              désactivé. L'utilisation de cet attribut fournit un moyen de supprimer les pages de
              très grande taille correspondant à des travaux pour lesquels le code  ne  peut  pas
              être  modifié,  et dans les cas où le recours à des routines malloc associées à des
              appels madvise(2) n'offre pas de solution (c'est-à-dire pour des  données  allouées
              statiquement).  L'activation de l'attribut « THP disable » est transmis aux enfants
              créés au moyen de fork(2) et est conservé lors d'un appel à execve(2).

       PR_GET_THP_DISABLE (depuis Linux 3.15)
              Renvoyer (en résultat de fonction) le réglage actuel de l'attribut « THP  disable »
              du  thread  appelant,  c'est  à  dire  1  si l'attribut est activé et 0 dans le cas
              contraire.

       PR_GET_TID_ADDRESS (depuis Linux 3.5)
              Renvoyer  l'adresse  clear_child_tid  configurée  par  set_tid_address(2)  et   par
              l'attribut   CLONE_CHILD_CLEARTID   de   clone(2),   à   l'emplacement  que  pointe
              (int **) arg2. Cette option n'est disponible que si le  noyau  est  construit  avec
              l'option CONFIG_CHECKPOINT_RESTORE. Notez que comme l'appel système prctl() n'a pas
              d'implémentation compatible pour les ABI AMD64 et MIPS n32, et comme le noyau écrit
              un  pointeur en utilisant la taille du pointeur du noyau, cette opération attend un
              tampon en espace utilisateur de 8 octets (et non 4) sur ces ABI.

       PR_SET_TIMERSLACK (depuis Linux 2.6.28)
              Chaque  thread  comporte  deux  valeurs  de  temporisation  relâchée :  une  valeur
              « default »  et  une  valeur  « current ».  Cette  opération  positionne  la valeur
              « current » du temporisateur du thread appelant. arg2 est un entier long non signé,
              la  valeur  « current »  maximale est donc ULONG_MAX et celle minimale est 1. Si la
              valeur  en  nanoseconde  fournie  dans  arg2  est  supérieure  à  zéro,  la  valeur
              « current »  est  positionnée  sur  cette  valeur.  Si  arg2  est  égal  à zéro, la
              temporisation « current » est réinitialisée à la valeur « default » du thread.

              La valeur « current » (actuelle) de temporisation  relâchée  est  utilisée  par  le
              noyau  pour  grouper les délais d'expiration des threads appelants qui sont proches
              les uns des autres. Par conséquent, les délais d'expiration des threads  pourraient
              être  en retard jusqu'au nombre de nanosecondes indiqué (mais jamais en avance). Le
              groupement des délais d'expiration permet de réduire la consommation  d'énergie  du
              système en minimisant les réveils du processeur.

              Les  délais  d'expiration  affectés par la temporisation relâchée sont ceux définis
              par  select(2),  pselect(2),  poll(2),  ppoll(2),  epoll_wait(2),   epoll_pwait(2),
              clock_nanosleep(2), nanosleep(2) et futex(2) (et donc les fonctions de bibliothèque
              implémentées     par     futex,      y      compris      pthread_cond_timedwait(3),
              pthread_mutex_timedlock(3),                          pthread_rwlock_timedrdlock(3),
              pthread_rwlock_timedwrlock(3) et sem_timedwait(3)).

              La temporisation relâchée ne s'applique pas aux threads qui  sont  programmés  avec
              une stratégie d'ordonnancement en temps réel (consultez sched_setscheduler(2)).

              Quand  un  nouveau thread est créé, les deux valeurs de temporisation relâchée sont
              rendues identiques à la valeur « current » du thread  qui  l'a  créé.  Ensuite,  un
              thread  peut  ajuster  sa  valeur de temporisation relâchée « current » à l'aide de
              PR_SET_TIMERSLACK. La valeur « default » ne peut pas être modifiée. Les valeurs  de
              temporisation  relâchée  d'init  (PID 1),  l'ancêtre de tous les processus, sont de
              50 000 nanosecondes (50 microsecondes). Les valeurs de temporisation relâchée  sont
              transmises aux enfants créés avec fork(2) et sont préservées à travers execve(2).

              Depuis  Linux  4.6,  la valeur « current » de temporisation relâchée d'un processus
              peut être visualisée et modifiée à  l'aide  du  fichier  /proc/[pid]/timerslack_ns.
              Voir proc(5).

       PR_GET_TIMERSLACK (depuis Linux 2.6.28)
              Renvoyer  (comme  résultat  de  la fonction) la valeur « current » de temporisation
              relâchée du thread appelant.

       PR_SET_TIMING (depuis Linux 2.6.0)
              Permettre de choisir la méthode de mesure du temps  du  processus  à  utiliser,  en
              passant  dans  arg2 soit PR_TIMING_STATISTICAL (méthode statistique traditionnelle)
              ou   PR_TIMING_TIMESTAMP    (méthode    exacte    utilisant    des    horodatages).
              PR_TIMING_TIMESTAMP  n'est  pas implémenté pour l'instant (l'utilisation de ce mode
              renverra l'erreur EINVAL).

       PR_GET_TIMING (depuis Linux 2.6.0)
              Renvoyer (en résultat de fonction) quelle méthode de mesure du temps  du  processus
              est utilisée actuellement.

       PR_SET_TSC (depuis Linux 2.6.26, seulement sur x86)
              Configurer  l'état  de l'attribut qui indique si le compteur d'horodatage peut être
              lu par le processus.  Utiliser  PR_TSC_ENABLE  pour  arg2  permet  d'autoriser  les
              lectures  ou  PR_TSC_SIGSEGV  pour produire un SIGSEGV quand le processus essaie de
              lire le compteur d'horodatage.

       PR_GET_TSC (depuis Linux 2.6.26, seulement sur x86)
              Renvoyer, dans l'emplacement pointé par (int *)  arg2,  l'état  de  l'attribut  qui
              indique si le compteur d'horodatage peut être lu.

       PR_SET_UNALIGN
              (Seulement sur : ia64, depuis Linux 2.3.48 ; parisc, depuis Linux 2.6.15 ; PowerPC,
              depuis Linux 2.6.18 ; Alpha, depuis Linux 2.6.22 ; sh, depuis Linux 2.6.34 ;  tile,
              depuis Linux 3.12). Définir les bits de contrôle pour les accès non alignés à arg2.
              La  valeur  PR_UNALIGN_NOPRINT  signifie  que  les  accès  non  alignés  en  espace
              utilisateur  sont  silencieusement  corrigés, et PR_UNALIGN_SIGBUS cause l'envoi de
              SIGBUS lors d'un accès  utilisateur  non  aligné.  Alpha  gère  aussi  un  attribut
              supplémentaire  dont  la  valeur  est  4 et qui n'a pas de constante correspondante
              nommée, qui demande au noyau de corriger  les  accès  non  alignés  (il  revient  à
              utiliser  l'attribut  UAC_NOFIX  dans  l'opération  SSI_NVPAIRS  de l'appel système
              setsysinfo() sur Tru64).

       PR_GET_UNALIGN
              (Consultez  PR_SET_UNALIGN  pour  les  informations  sur  les   versions   et   les
              architectures).  Renvoyer  les  bits  de  contrôle  des  accès  non  alignés,  dans
              l'emplacement pointé par (unsigned int *) arg2.

VALEUR RENVOYÉE

       En    cas    de    réussite,    PR_CAP_AMBIENT+PR_CAP_AMBIENT_IS_SET,     PR_CAPBSET_READ,
       PR_GET_DUMPABLE,   PR_GET_FP_MODE,  PR_GET_IO_FLUSHER,  PR_GET_KEEPCAPS,  PR_MCE_KILL_GET,
       PR_GET_NO_NEW_PRIVS,    PR_GET_SECUREBITS,     PR_GET_SPECULATION_CTRL,     PR_SVE_GET_VL,
       PR_SVE_SET_VL,       PR_GET_TAGGED_ADDR_CTRL,      PR_GET_THP_DISABLE,      PR_GET_TIMING,
       PR_GET_TIMERSLACK et (s'il rend la main) PR_GET_SECCOMP renvoient  les  valeurs  positives
       décrites  ci-dessus.  Toute  autre  valeur  d'option  renvoie  0  en cas de succès. En cas
       d'erreur, -1 est renvoyé et errno est positionné en fonction.

ERREURS

       EACCES option vaut PR_SET_SECCOMP et arg2 vaut SECCOMP_MODE_FILTER, mais le processus  n'a
              pas  la  capacité CAP_SYS_ADMIN ou n'a pas positionné l'attribut no_new_privs (voir
              le point sur PR_SET_NO_NEW_PRIVS ci-dessus).

       EACCES option vaut PR_SET_MM, et  arg3  vaut  PR_SET_MM_EXE_FILE,  le  fichier  n'est  pas
              exécutable.

       EBADF  option  vaut  PR_SET_MM, arg3 vaut PR_SET_MM_EXE_FILE, et le descripteur de fichier
              passé dans le paramètre arg4 n'est pas valable.

       EBUSY  option vaut PR_SET_MM, arg3 vaut PR_SET_MM_EXE_FILE, et il  s'agit  de  la  seconde
              tentative  de  modification  du  lien  symbolique  /proc/pid/exe,  ce qui n'est pas
              autorisé.

       EFAULT arg2 est une adresse non valable.

       EFAULT option vaut PR_SET_SECCOMP,,  arg2  vaut  SECCOMP_MODE_FILTER,  le  système  a  été
              construit avec CONFIG_SECCOMP_FILTER et arg2 n'est pas une adresse valable.

       EINVAL La valeur de option n'est pas reconnue ou n'est pas prise en charge sur ce système.

       EINVAL option  vaut  PR_MCE_KILL,  PR_MCE_KILL_GET  ou  PR_SET_MM,  et  les paramètres non
              utilisés de prctl() n'ont pas été réglés à zéro.

       EINVAL arg2 n'est pas une valeur valable pour cette option.

       EINVAL option vaut PR_SET_SECCOMP ou PR_GET_SECCOMP et le noyau n'a pas été configuré avec
              CONFIG_SECCOMP.

       EINVAL option  vaut  PR_SET_SECCOMP, arg2 vaut SECCOMP_MODE_FILTER et le noyau n'a pas été
              configuré avec CONFIG_SECCOMP_FILTER.

       EINVAL option vaut PR_SET_MM, et l'une des assertions suivantes est vraie :

              –  arg4 ou arg5 est non nul ;

              –  arg3 est strictement plus grand que  TASK_SIZE  (la  limite  sur  la  taille  de
                 l'espace d'adressage utilisateur pour cette architecture) ;

              –  arg2   vaut   PR_SET_MM_START_CODE,   PR_SET_MM_END_CODE,  PR_SET_MM_START_DATA,
                 PR_SET_MM_END_DATA ou PR_SET_MM_START_STACK, et les permissions pour la zone  de
                 mémoire correspondante ne satisfont pas les conditions requises ;

              –  arg2  vaut PR_SET_MM_START_BRK ou PR_SET_MM_BRK, et arg3 est inférieur ou égal à
                 la fin du segment de données, ou indique une valeur qui causerait le dépassement
                 de la limite de ressource RLIMIT_DATA.

       EINVAL option  vaut  PR_SET_PTRACER et arg2 ne vaut ni 0, ni PR_SET_PTRACER_ANY, ni le PID
              d'un processus existant.

       EINVAL option vaut PR_SET_PDEATHSIG et arg2 n'est pas un numéro de signal valable.

       EINVAL option  vaut  PR_SET_DUMPABLE  et   arg2   ne   vaut   ni   SUID_DUMP_DISABLE,   ni
              SUID_DUMP_USER.

       EINVAL option vaut PR_SET_TIMING et arg2 n'a pas la valeur PR_TIMING_STATISTICAL.

       EINVAL option  vaut  PR_SET_NO_NEW_PRIVS  et arg2 ne vaut pas 1, ou arg3, arg4 ou arg5 est
              non nul.

       EINVAL option vaut PR_GET_NO_NEW_PRIVS et arg2, arg3, arg4 ou arg5 est non nul.

       EINVAL option vaut PR_SET_THP_DISABLE et arg3, arg4 ou arg5 est non nul.

       EINVAL option vaut PR_GET_THP_DISABLE et arg2, arg3, arg4 ou arg5 est non nul.

       EINVAL option vaut PR_CAP_AMBIENT et un paramètre inutilisé (arg4, arg5 ou, dans le cas de
              PR_CAP_AMBIENT_CLEAR_ALL,  arg3)  ne  vaut pas zéro ; ou bien arg2 a une valeur non
              valable ;   ou   arg2   vaut    PR_CAP_AMBIENT_LOWER,    PR_CAP_AMBIENT_RAISE    ou
              PR_CAP_AMBIENT_IS_SET et arg3 n'indique pas de capacité valable.

       EINVAL option  valait PR_GET_SPECULATION_CTRL ou PR_SET_SPECULATION_CTRL et des paramètres
              inutilisés de prctl() ne valent pas 0. EINVAL option vaut PR_PAC_RESET_KEYS et  les
              paramètres  ne  sont  pas  valables  ou  non pris en charge. Voir la description de
              PR_PAC_RESET_KEYS ci-dessus pour des détails.

       EINVAL option vaut PR_SVE_SET_VL et les paramètres ne sont pas valables  ou  ne  sont  pas
              pris  en  charge,  ou  bien  SVE n'est pas disponible sur cette plateforme. Voir la
              description de PR_SVE_SET_VL ci-dessus pour des détails.

       EINVAL option vaut PR_SVE_GET_VL et SVE n'est pas disponible sur cette plateforme.

       EINVAL option vaut PR_SET_TAGGED_ADDR_CTRL et les paramètres ne sont pas  valables  ou  ne
              sont  pas  pris en charge. Voir la description de PR_SET_TAGGED_ADDR_CTRL ci-dessus
              pour des détails.

       EINVAL option vaut PR_GET_TAGGED_ADDR_CTRL et les paramètres ne sont pas  valables  ou  ne
              sont  pas  pris  en charge. Voir la description de PR_GET_TAGGED_ADDR_CTRL pour des
              détails.

       ENODEV option vaut PR_SET_SPECULATION_CTRL et le noyau ou le processeur  ne  gère  pas  la
              fonction défectueuse de spéculation demandée.

       ENXIO  option vaut PR_MPX_ENABLE_MANAGEMENT ou PR_MPX_DISABLE_MANAGEMENT et le noyau ou le
              processeur ne prennent pas en charge la gestion de MPX. Vérifiez que le noyau et le
              processeur gèrent le MPX.

       ENXIO  option  vaut  PR_SET_SPECULATION_CTRL,  impliquant  que  le contrôle de la fonction
              défectueuse de spéculation sélectionnée n'est pas possible. Voir les champs de  bit
              de PR_GET_SPECULATION_CTRL pour savoir les options disponibles.

       EOPNOTSUPP
              option vaut PR_SET_FP_MODE et arg2 a une valeur non prise en charge ou non valable.

       EPERM  option  vaut  PR_SET_SECUREBITS  et  l'appelant  n'a pas la capacité CAP_SETPCAP, a
              essayé d'enlever un attribut de « verrouillage » ou  a  essayé  de  positionner  un
              attribut  pour  lequel  l'attribut  de  verrouillage  était  positionné  (consultez
              capabilities(7)).

       EPERM  option vaut PR_SET_SPECULATION_CTRL alors que la spéculation  est  désactivée  avec
              PR_SPEC_FORCE_DISABLE et l'appelant a essayé de la réactiver.

       EPERM  option vaut PR_SET_KEEPCAPS et l'attribut SECBIT_KEEP_CAPS_LOCKED de l'appelant est
              positionné (consultez capabilities(7)).

       EPERM  option vaut PR_CAPBSET_DROP et l'appelant n'a pas la capacité CAP_SETPCAP.

       EPERM  option vaut PR_SET_MM et l'appelant n'a pas la capacité CAP_SYS_RESOURCE.

       EPERM  option vaut PR_CAP_AMBIENT et arg2 vaut PR_CAP_AMBIENT_RAISE, mais soit la capacité
              indiquée dans arg3 n'est pas présente dans les capacités autorisées et récupérables
              du processus, ou bien le bit de sécurité PR_CAP_AMBIENT_LOWER a été positionné.

       ERANGE option  vaut  PR_SET_SPECULATION_CTRL  et  arg3  ne  vaut  ni  PR_SPEC_ENABLE,   ni
              PR_SPEC_DISABLE, ni PR_SPEC_FORCE_DISABLE, ni PR_SPEC_DISABLE_NOEXEC.

VERSIONS

       L'appel système prctl() a été introduit dans Linux 2.1.57.

CONFORMITÉ

       Cet  appel  système  est  spécifique  à  Linux.  IRIX  dispose  d'un appel système prctl()
       (également introduit dans Linux 2.1.44 sur l'architecture MIPS sous  le  nom  irix_prctl),
       dont le prototype est

           ptrdiff_t prctl(int option, int arg2, int arg3);

       et  les  options  permettent  de d'obtenir le nombre maximal de processus par utilisateur,
       d’obtenir le nombre maximal de processeurs utilisables par un processus, de vérifier si un
       processus est bloqué, d’obtenir ou de définir la taille maximale de la pile, etc.

VOIR AUSSI

       signal(2), core(5)

COLOPHON

       Cette  page  fait partie de la publication 5.10 du projet man-pages Linux. Une description
       du projet et des instructions pour signaler des anomalies et la dernière version de  cette
       page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.

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-Philippe
       MENGUAL <jpmengual@debian.org>

       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 ⟨⟩.