Provided by: manpages-fr-dev_3.65d1p1-1_all bug

NOM

       prctl - Opérations sur un processus

SYNOPSIS

       #include <sys/prctl.h>

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

DESCRIPTION

       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_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 la
              limitation 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 des capacités liées 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.

       PR_CAPBSET_DROP (depuis Linux 2.6.25)
              Si  le thread appelant a la capacité CAP_SETPCAP, alors enlever la capacité indiquée par arg2 dans
              l'ensemble de limitation de capacités du thread appelant. Les fils 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ée dans le noyau, auquel cas les limitations ne sont pas
              prises en charge par le noyau.

       PR_SET_CHILD_SUBREAPER (depuis Linux 3.4)
              Si arg2 n'est pas égal à zéro, activer l'attribut « child subreaper » du processus  appelant ;  si
              arg2 vaut zéro, désactiver l'attribut. Si processus est marqué comme « child subreaper », tous ses
              fils et descendants sont marqués comme ayant un « reaper ». En pratique, un « subreaper »  remplit
              la  fonction  de init(1) pour ses descendants. Lorsqu'un processus orphelin se termine (orphelin :
              dont le parent immédiat est  déjà  terminé)  et  que  ce  processus  est  marqué  comme  ayant  un
              « subreaper »,  alors  l'ancêtre  le plus proche et toujours en cours d'exécution reçoit un signal
              SIGCHLD qui lui permet de se mettre en attente (wait(2)) du processus orphelin, et  de  déterminer
              son code de retour.

       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'attribut déterminant si un fichier core est produit lorsque le processus appelant reçoit
              un  signal  dont  le  comportement  par  défaut  est de produire un fichier core. (Normalement cet
              attribut est par défaut validé pour un processus, mais est effacé  à  l'exécution  d'un  programme
              Set-UID ou Set-GID ainsi que par divers appels système manipulant des UID et GID). Dans les noyaux
              jusqu'à 2.6.12 inclus, arg2 doit valoir 0 (pas de fichier core)  ou  1  (fichier  core  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 core 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).) La commande  ptrace(2)  PTRACE_ATTACH  ne
              permet pas d'attacher des processus qui ne produisent pas normalement de fichier core.

       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 core 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
              pseudopetit 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_FPEMU (depuis Linux 2.4.18, 2.5.9, seulement sur ia64)
              Définir  les  bits  de  contrôle de l'émulation de FPU à arg2. Passer PR_FPEMU_NOPRINT pour émuler
              silencieusement les opérations flottantes, ou PR_FPEMU_SIGFPE pour ne pas  émuler  les  opérations
              flottantes, 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 flottante à arg2. Passer la valeur PR_FP_EXC_SW_ENABLE pour utiliser
              FPEXC pour activer les exceptions flottantes, PR_FP_EXC_DIV  pour  les  divisions  flottantes  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  flottants  inexacts,
              PR_FP_EXC_INV  pour  les  opérations  flottantes invalides, PR_FP_EXC_DISABLED pour désactiver les
              exceptions flottantes, PR_FP_EXC_NONRECOV pour le mode d'exceptions  asynchrone  non  récupérable,
              PR_FP_EXC_ASYNC  pour  le mode d'exceptions asynchrone récupérable, PR_FP_EXC_PRECISE pour le mode
              d'exception précis.

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

       PR_SET_KEEPCAPS (depuis Linux 2.2.18)
              Définir l'état de l'attribut de conservation des capacités  du  thread  (keep  capabilities),  qui
              détermine  si  l'ensemble  des  capacités  disponibles  est effacé lorsqu'on modifie les UID réel,
              effectif et sauvé du thread de manière à ce que tous soient non nuls alors qu'auparavant  l'un  au
              moins  était  nul.  Par  défaut,  l'ensemble  des  capacités  disponibles est effacé lorsqu'un tel
              changement intervient. Définir l'attribut de conservation des capacités du thread l'empêche d'être
              effacé.  arg2  doit valoir 0 (les capacités disponibles sont effacées) ou 1 (capacités disponibles
              conservées). L'ensemble des capacités effectives est  toujours  effacé  lorsqu'un  tel  changement
              intervient,  quelle  que  soit la valeur de l'attribut de conservation des capacités. Cet attribut
              est remis à zéro pour les appels ultérieurs à 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.

       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 et doit être terminé par un caractère  nul  s'il
              est  plus  petit. Ce  même  attribut  peut  être défini par  pthread_setname_np(3) et consulté par
              pthread_getname_np(3). On peut également y accéder via /proc/self/task/[tid]/comm, où  tid désigne
              le nom du thread appelant.

       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 caractère  nul
              si elle est plus petite.

       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 à quoique 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).

              Pour plus d'informations,  consultez  le  fichier  Documentation/prctl/no_new_privs.txt  dans  les
              sources du noyau.

       PR_GET_NO_NEW_PRIVS (depuis Linux 3.5)
              Renvoyer  (comme  résultat  de  la fonction) la valeur du bit no_new_privs du processus actuel. 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_SET_PDEATHSIG (depuis Linux 2.1.57)
              Configurer  le  signal de mort du père du processus appelant avec la valeur arg2 (qui peut être un
              numéro de signal dans l'intervalle 1..maxsig, ou être nul pour effacer le signal).  Il  s'agit  du
              numéro  du  signal  que  le  processus  appelant  recevra si son père se termine. Cette valeur est
              effacée pour le fils d'un fork(2), et (depuis Linux 2.4.36 et 2.6.23)  lors  de  l'exécution  d'un
              binaire Set-UID ou Set-GID. Cette valeur est préservée par execve(2).

       PR_GET_PDEATHSIG (depuis Linux 2.3.15)
              Renvoyer  la  valeur  actuelle  du signal de mort du processus père, 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 arg2est é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/security/Yama.txt dans les sources du
              noyau.

       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.  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) et sigreturn(2). Les autres appels système provoque 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'une 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/prctl/seccomp_filter.txt dans les
              sources du noyau.

       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.  Cette  opération  n'est
              disponible que si le noyau a été configuré avec l'option CONFIG_SECCOMP activée.

       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_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 jobs
              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 fils 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) l'état 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)
              Récupérer  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.

       PR_SET_TIMERSLACK (depuis Linux 2.6.28)
              Définir la valeur actuelle de temporisation relâchée pour le thread appelant à la  valeur  fournie
              par  arg2  en  nanoseconde.  Si  arg2 est inférieur ou égal à zéro, réinitialiser la temporisation
              relâchée actuelle à la valeur de temporisation relâchée par défaut  du  thread.  La  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és  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)).

              Tous les threads ont deux valeurs de temporisation relâchée  associées :  une  valeur  par  défaut
              (« default »,  et  une  actuelle  (« current »).  La  valeur  actuelle  est  celle qui gouverne le
              groupement des délais d'expiration. Quand  un  nouveau  thread  est  créé,  les  deux  valeurs  de
              temporisation  relâchée  sont  rendues  identiques  à  la  valeur actuelle du thread qui l'a créé.
              Ensuite, un thread peut  ajuster  sa  valeur  de  temporisation  relâchée  actuelle  à  l'aide  de
              PR_SET_TIMERSLACK (la valeur par défaut peut ê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 préservées à travers execve(2).

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

       PR_SET_TIMING (depuis Linux 2.6.0-test4)
              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-test4)
              Renvoyer  (en  résultat  de  fonction) quelle méthode de mesure du temps du processus est utilisée
              actuellement.

       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  source
              tools/perf/design.txt 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_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. Utilisez 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) 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 utilisateurs sont
              silencieusement corrigés, et PR_UNALIGN_SIGBUS cause l'envoi de SIGBUS lors d'un accès non aligné.

       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 (int *) arg2.

       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  retardé, 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  fils.  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 la politique actuelle (par processus) de suppression des processus empoisonnés. Tous  les
              arguments non utilisés de prctl()  doivent être nuls.

       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  dynamique
              (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 celle  de  programmes  se
              modifiant  eux-mêmes, un programme pourra trouver utile de pouvoir changer sa propre projection de
              mémoire. Cette fonctionnalité n'est disponible  que  si  le  noyau  est  construit  avec  l'option
              CONFIG_CHECKPOINT_RESTORE  activée. Le processus appelant doit avoir la capacité CAP_SYS_RESOURCE.
              La valeur d'arg2 est l'une des options ci-dessous, alors qu'arg3 fournit une nouvelle valeur  pour
              l'option.

              PR_SET_MM_START_CODE
                     Sélectionner  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  doit ne pas pouvoir être partagée (consultez mprotect(2) et mmap(2) pour plus
                     d'informations).

              PR_SET_MM_END_CODE
                     Sélectionner 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 doit ne pas pouvoir être partagée.

              PR_SET_MM_START_DATA
                     Sélectionner 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 doit ne pas pouvoir être partagée.

              PR_SET_MM_END_DATA
                     Sélectionner 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 doit ne 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 la taille du segment de
                     données ne peut 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
                     Remplace 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 example, le noyau crée
                     en général au moins un espace mémoire d'exécutable pour la section ELF .text).

                     La seconde restriction est que de tels changements ne peuvent  être  réalisés  qu'une  fois
                     dans  la  vie  d'un  processus.  Au  delà, tout tentative sera refusée. Cela peut aider les
                     administrateurs système à repérer des transitions  de  liens  symboliques  anormales  parmi
                     l'ensemble de processus en cours d'exécution dans le système.

VALEUR RENVOYÉE

       En   cas   de   réussite,   PR_GET_DUMPABLE,  PR_GET_KEEPCAPS,  PR_GET_NO_NEW_PRIVS,  PR_GET_THP_DISABLE,
       PR_CAPBSET_READ, PR_GET_TIMING, PR_GET_TIMERSLACK, PR_GET_SECUREBITS, PR_MCE_KILL_GET et (si elle rend la
       main)  PR_GET_SECCOMP  renvoient  les  valeurs  positives décrites ci-dessus. Toute autre valeur d'option
       renvoie 0 en cas de réussite. En cas d'échec, -1 est renvoyé et errno contient le code d'erreur.

ERREURS

       EFAULT arg2 est une adresse non valable.

       EINVAL La valeur de option n'est pas reconnue.

       EINVAL option vaut PR_MCE_KILL, PR_MCE_KILL_GET ou PR_SET_MM, et au moins un des paramètres non  utilisés
              de prctl()  n'est pas nul.

       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_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 valide.

       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, ouarg3, 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 estnon nul.

       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_KEEPCAPS et l'attribut SECURE_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.

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

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

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

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, le nombre  maximal
       de  processeurs  utilisables  par  un  processus, vérifier si un processus est bloqué, lire ou définir la
       taille des piles, etc.

VOIR AUSSI

       signal(2), core(5)

COLOPHON

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

TRADUCTION

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

       Christophe       Blaess       <http://www.blaess.fr/christophe/>      (1996-2003),      Alain      Portal
       <http://manpagesfr.free.fr/> (2003-2006).  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> ».