.\" -*- coding: UTF-8 -*- .\" Copyright (C) 1998 Andries Brouwer (aeb@cwi.nl) .\" and Copyright (C) 2002, 2006, 2008, 2012, 2013, 2015 Michael Kerrisk .\" and Copyright Guillem Jover .\" and Copyright (C) 2010 Andi Kleen .\" and Copyright (C) 2012 Cyrill Gorcunov .\" and Copyright (C) 2014 Dave Hansen / Intel .\" and Copyright (c) 2016 Eugene Syromyatnikov .\" and Copyright (c) 2018 Konrad Rzeszutek Wilk .\" and Copyright (c) 2020 Dave Martin .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\" Modified Thu Nov 11 04:19:42 MET 1999, aeb: added PR_GET_PDEATHSIG .\" Modified 27 Jun 02, Michael Kerrisk .\" Added PR_SET_DUMPABLE, PR_GET_DUMPABLE, .\" PR_SET_KEEPCAPS, PR_GET_KEEPCAPS .\" Modified 2006-08-30 Guillem Jover .\" Updated Linux versions where the options where introduced. .\" Added PR_SET_TIMING, PR_GET_TIMING, PR_SET_NAME, PR_GET_NAME, .\" PR_SET_UNALIGN, PR_GET_UNALIGN, PR_SET_FPEMU, PR_GET_FPEMU, .\" PR_SET_FPEXC, PR_GET_FPEXC .\" 2008-04-29 Serge Hallyn, Document PR_CAPBSET_READ and PR_CAPBSET_DROP .\" 2008-06-13 Erik Bosman, .\" Document PR_GET_TSC and PR_SET_TSC. .\" 2008-06-15 mtk, Document PR_SET_SECCOMP, PR_GET_SECCOMP .\" 2009-10-03 Andi Kleen, document PR_MCE_KILL .\" 2012-04 Cyrill Gorcunov, Document PR_SET_MM .\" 2012-04-25 Michael Kerrisk, Document PR_TASK_PERF_EVENTS_DISABLE and .\" PR_TASK_PERF_EVENTS_ENABLE .\" 2012-09-20 Kees Cook, update PR_SET_SECCOMP for mode 2 .\" 2012-09-20 Kees Cook, document PR_SET_NO_NEW_PRIVS, PR_GET_NO_NEW_PRIVS .\" 2012-10-25 Michael Kerrisk, Document PR_SET_TIMERSLACK and .\" PR_GET_TIMERSLACK .\" 2013-01-10 Kees Cook, document PR_SET_PTRACER .\" 2012-02-04 Michael Kerrisk, document PR_{SET,GET}_CHILD_SUBREAPER .\" 2014-11-10 Dave Hansen, document PR_MPX_{EN,DIS}ABLE_MANAGEMENT .\" .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH prctl 2 "2 mai 2024" "Pages du manuel de Linux 6.8" .SH NOM prctl \- Opérations sur un processus ou un thread .SH BIBLIOTHÈQUE Bibliothèque C standard (\fIlibc\fP, \fI\-lc\fP) .SH SYNOPSIS .nf \fB#include \fP .P \fBint prctl(int \fP\fIop\fP\fB, ...\fP \fB \fP/*\fB unsigned long \fP\fIarg2\fP\fB, unsigned long \fP\fIarg3\fP\fB,\fP \fB unsigned long \fP\fIarg4\fP\fB, unsigned long \fP\fIarg5\fP\fB \fP*/\fB );\fP .fi .SH DESCRIPTION \fBprctl\fP() gère divers aspects du comportement du thread ou du processus appelant. .P Notez qu'une utilisation peu soigneuse de certaines opérations de \fBprctl\fP() peut perdre l'environnement d’exécution de l'espace utilisateur, donc il faut les utiliser avec rigueur. .P .\" .\" prctl PR_CAP_AMBIENT \fBprctl\fP() est invoqué avec un premier paramètre indiquant ce qu'il faut faire, (ses valeurs sont définies dans \fI\fP), et des paramètres supplémentaires dont la signification dépend du premier paramètre. Celui\-ci peut être\ : .TP \fBPR_CAP_AMBIENT\fP (depuis Linux 4.3) .\" commit 58319057b7847667f0c9585b9de0e8932b0fdb08 Lire ou modifier l'ensemble environnant des capacités paramétrées sur le thread appelant, en fonction de la valeur de \fIarg2\fP, qui doit être une des suivantes : .RS .\" .TP \fBPR_CAP_AMBIENT_RAISE\fP La capacité indiquée dans \fIarg3\fP 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é \fBSECBIT_NO_CAP_AMBIENT_RAISE\fP est positionné. .TP \fBPR_CAP_AMBIENT_LOWER\fP La capacité indiquée dans \fIarg3\fP est supprimée de l'ensemble environnant. .TP \fBPR_CAP_AMBIENT_IS_SET\fP L'appel \fBprctl\fP() renvoie \fB1\fP si la capacité indiquée dans \fIarg3\fP est dans l'ensemble environnant et, sinon, \fB0\fP. .TP \fBPR_CAP_AMBIENT_CLEAR_ALL\fP Toutes les capacités seront supprimées de l'ensemble environnant. Cette opération implique que \fIarg3\fP soit positionné sur zéro. .RE .IP Dans toutes les opérations ci\-dessus, \fIarg4\fP et \fIarg5\fP doivent valoir \fB0\fP. .IP .\" prctl PR_CAPBSET_READ Des interfaces de plus haut niveau qui constituent la couche au\-dessus des opérations ci\-dessus sont fournies dans la bibliothèque \fBlibcap\fP(3) sous la forme \fBcap_get_ambient\fP(3), \fBcap_set_ambient\fP(3), et \fBcap_reset_ambient\fP(3). .TP \fBPR_CAPBSET_READ\fP (depuis Linux 2.6.25) Renvoyer (en résultat de fonction) \fB1\fP si la capacité indiquée par \fIarg2\fP est présente dans l’ensemble limitant de capacités du thread appelant ou \fB0\fP si elle ne l'est pas. Les constantes des capacités sont définies dans \fI\fP. 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 à \fBexecve\fP(2). .IP Si la capacité indiquée dans \fIarg2\fP n'est pas valable, alors l'appel échoue avec l'erreur \fBEINVAL\fP. .IP .\" prctl PR_CAPBSET_DROP Une interface de plus haut niveau constituant la couche par\-dessus cette opération est fournie dans la bibliothèque \fBlibcap\fP(3) sous la forme \fBcap_get_bound\fP(3). .TP \fBPR_CAPBSET_DROP\fP (depuis Linux 2.6.25) Si le thread appelant a la capacité \fBCAP_SETPCAP\fP dans son espace de noms utilisateur, alors enlever la capacité indiquée par \fIarg2\fP 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. .IP L'appel échoue avec l'erreur \fBEPERM\fP si le thread appelant n'a pas la capacité \fBCAP_SETPCAP\fP ; ou avec l'erreur \fBEINVAL\fP si \fIarg2\fP ne représente pas une capacité correcte ; ou avec l'erreur \fBEINVAL\fP 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. .IP .\" prctl PR_SET_CHILD_SUBREAPER Une interface de plus haut niveau constituant la couche au\-dessus de cette opération est fournie par la bibliothèque \fBlibcap\fP(3) sous la forme \fBcap_drop_bound\fP(3). .TP \fBPR_SET_CHILD_SUBREAPER\fP (depuis Linux 3.4) .\" commit ebec18a6d3aa1e7d84aab16225e87fd25170ec2b Si \fIarg2\fP ne vaut pas zéro, positionner l'attribut « child subreaper » du processus appelant ; si \fIarg2\fP vaut zéro, déconfigurer l'attribut. .IP Un subreaper (suppresseur) joue le rôle de \fBinit\fP(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 \fBgetppid\fP(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 \fBSIGCHLD\fP et pourra surveiller (\fBwait\fP(2)) le processus pour détecter son état de fin. .IP Le paramètre de l'attribut « child subreaper » n'est pas récupéré par les enfants créés par \fBfork\fP(2) et \fBclone\fP(2). Le paramètre est préservé lors d'un \fBexecve\fP(2). .IP .\" prctl PR_GET_CHILD_SUBREAPER É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 \fBinit\fP(1) (comme \fBsystemd\fP(1)) utilisent un processus subreaper pour les mêmes raisons. .TP \fBPR_GET_CHILD_SUBREAPER\fP (depuis Linux 3.4) .\" prctl PR_SET_DUMPABLE Renvoyer l'état « child subreaper » du processus appelant, dans l'emplacement pointé par \fI(int\ *) arg2\fP. .TP \fBPR_SET_DUMPABLE\fP (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. .IP .\" commit abf75a5033d4da7b8a7e92321d74021d1fcfb502 .\" See http://marc.theaimsgroup.com/?l=linux-kernel&m=115270289030630&w=2 .\" Subject: Fix prctl privilege escalation (CVE-2006-2451) .\" From: Marcel Holtmann .\" Date: 2006-07-12 11:12:00 Dans les noyaux jusqu'à 2.6.12 inclus, \fIarg2\fP doit valoir \fB0\fP (\fBSUID_DUMP_DISABLE\fP, pas de vidage mémoire) ou \fB1\fP (\fBSUID_DUMP_USER\fP, vidage possible). Entre les noyaux 2.6.13 et 2.6.17, la valeur \fB2\fP é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 \fI/proc/sys/fs/\:suid_dumpable\fP dans \fBproc\fP(5)). .IP .\" See kernel/cred.c::commit_creds() (Linux 3.18 sources) Normalement, l'attribut « dumpable » est positionné sur \fB1\fP. Cependant, il est positionné sur la valeur actuelle du fichier \fI/proc/sys/fs/\:suid_dumpable\fP (qui a une valeur de \fB0\fP par défaut), dans les circonstances suivantes : .RS .IP \- 3 L'identifiant d'utilisateur ou de groupe effectif du processus a été modifié. .IP \- L'identifiant d'utilisateur ou de groupe du système de fichiers du processus a été modifié (voir \fBcredentials\fP(7)). .IP \- Le processus exécute (\fBexecve\fP(2)) un programme set\-user\-ID ou set\-group\-ID, ce qui fait changer l'identifiant d'utilisateur ou de groupe effectif. .IP \- .\" See kernel/cred.c::commit_creds() .\" Also certain namespace operations; Le processus exécute (\fBexecve\fP(2)) un programme qui a les capacités de fichier (voir \fBcapabilities\fP(7)), mais seulement si les capacités acquises ainsi autorisées dépassent celles autorisées pour le processus. .RE .IP Les processus qui ne génèrent pas de fichier de vidage ne peuvent pas être rattachés à l'aide de \fBPTRACE_ATTACH\fP de \fBptrace\fP(2) ; voir \fBptrace\fP(2) pour plus de détails. .IP .\" prctl PR_GET_DUMPABLE Si un processus ne génère pas de fichier de vidage, l'appartenance des fichiers du répertoire \fI/proc/\fPpid du processus est modifiée comme le décrit \fBproc\fP(5). .TP \fBPR_GET_DUMPABLE\fP (depuis Linux 2.3.20) .\" Since Linux 2.6.13, the dumpable flag can have the value 2, .\" but in Linux 2.6.13 PR_GET_DUMPABLE simply returns 1 if the dumpable .\" flags has a nonzero value. This was fixed in Linux 2.6.14. .\" prctl PR_SET_ENDIAN Renvoyer (en résultat de fonction) l'état actuel de l'attribut de création de fichier de vidage du processus appelant. .TP \fBPR_SET_ENDIAN\fP (depuis Linux 2.6.18, seulement sur PowerPC) .\" Respectively 0, 1, 2 .\" prctl PR_GET_ENDIAN Définir le boutisme (endianness) du processus appelant à la valeur donnée dans \fIarg2\fP, qui doit être l'une des valeurs suivantes\ : \fBPR_ENDIAN_BIG\fP, \fBPR_ENDIAN_LITTLE\fP, ou \fBPR_ENDIAN_PPC_LITTLE\fP (PowerPC pseudo petit boutiste). .TP \fBPR_GET_ENDIAN\fP (depuis Linux 2.6.18, seulement sur PowerPC) .\" prctl PR_SET_FP_MODE Renvoyer le boutisme (endianness) du processus appelant, dans l'emplacement pointé par \fI(int\ *) arg2\fP. .TP \fBPR_SET_FP_MODE\fP (depuis Linux 4.0, seulement sur MIPS) .\" commit 9791554b45a2acc28247f66a5fd5bbc212a6b8c8 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. .IP 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 \fBPR_SET_FP_MODE\fP est fournie pour permettre un contrôle du mode de virgule flottante à partir de l'espace utilisateur. .IP .\" https://dmz-portal.mips.com/wiki/MIPS_O32_ABI_-_FR0_and_FR1_Interlinking L'argument \fI(unsigned int) arg2\fP est un masque de bits décrivant le mode de virgule flottante utilisé : .RS .TP \fBPR_FP_MODE_FR\fP Quand le bit est \fIunset\fP (ce qui est appelé le mode \fBFR=0\fP ou \fBFR0\fP), 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). .IP Quand ce bit est \fIset\fP (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 \fBFR=1\fP ou \fBFR1\fP). Remarquez que les implémentations MIPS modernes (MIPS R6 et plus récentes) ne gèrent que le mode \fBFR=1\fP. .IP Les applications qui utilisent l'ABI O32 FP32 ne peuvent fonctionner que lorsque ce bit est \fIunset\fP (\fBFR=0\fP ; 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 \fIset\fP (\fBFR=1\fP). Les applications qui utilisent l'ABI O32 FPXX peuvent agir avec \fBFR=0\fP ou \fBFR=1\fP. .TP \fBPR_FP_MODE_FRE\fP 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 \fBFR=0\fP, et les parties 32 bits de poids faible des registres 64 bits de numéros impairs en mode \fBFR=1\fP). 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 \fBFR=1\fP 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 \fBFR=0\fP quand un binaire avec l'ABI FP32 est utilisé. .IP Remarquez que ce mode n'a de sens que lorsque le FPU est en mode 64 bits (\fBFR=1\fP). .IP 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. .RE .IP 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 \fBFR=1\fP. .IP Cette opération vise principalement les éditeurs de liens dynamiques (\fBld.so\fP(8)). .IP .\" prctl PR_GET_FP_MODE Les paramètres \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .TP \fBPR_GET_FP_MODE\fP (depuis Linux 4.0, seulement sur MIPS) Renvoyer (comme résultat de la fonction) le mode de virgule flottante actuel (voir la description de \fBPR_SET_FP_MODE\fP pour les détails). .IP En cas de succès, l'appel renvoie un masque de bits qui représente le mode de virgule flottante actuel. .IP .\" prctl PR_SET_FPEMU Les paramètres \fIarg2\fP, \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .TP \fBPR_SET_FPEMU\fP (depuis Linux 2.4.18, 2.5.9, seulement sur ia64) .\" prctl PR_GET_FPEMU Définir les bits de contrôle de l'émulation de virgule flottante à \fIarg2\fP. Passer \fBPR_FPEMU_NOPRINT\fP pour émuler silencieusement les opérations de virgule flottante, ou \fBPR_FPEMU_SIGFPE\fP pour ne pas émuler ces opérations et envoyer \fBSIGFPE\fP. .TP \fBPR_GET_FPEMU\fP (depuis Linux 2.4.18, 2.5.9, seulement sur ia64) .\" prctl PR_SET_FPEXC Renvoyer les bits de contrôle de l'émulation de FPU dans l'emplacement vers lequel pointe \fI(int\ *) arg2\fP. .TP \fBPR_SET_FPEXC\fP (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC) .\" prctl PR_GET_FPEXC Définir le mode d'exception de virgule flottante à \fIarg2\fP. Passer la valeur \fBPR_FP_EXC_SW_ENABLE\fP pour utiliser FPEXC pour activer les exceptions de flottant, \fBPR_FP_EXC_DIV\fP pour les divisions de flottant par zéro, \fBPR_FP_EXC_OVF\fP pour les dépassements de capacité vers le haut, \fBPR_FP_EXC_UND\fP pour les dépassements de capacité vers le bas, \fBPR_FP_EXC_RES\fP pour les résultats de flottant inexacts, \fBPR_FP_EXC_INV\fP pour les opérations de flottant non valables, \fBPR_FP_EXC_DISABLED\fP pour désactiver les exceptions de flottant, \fBPR_FP_EXC_NONRECOV\fP pour le mode d'exception asynchrone non récupérable, \fBPR_FP_EXC_ASYNC\fP pour le mode d'exception asynchrone récupérable, \fBPR_FP_EXC_PRECISE\fP pour le mode d'exception de précision. .TP \fBPR_GET_FPEXC\fP (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC) .\" prctl PR_SET_IO_FLUSHER Renvoyer le mode d'exception de virgule flottante dans l'emplacement vers lequel pointe \fI(int\ *) arg2\fP. .TP \fBPR_SET_IO_FLUSHER\fP (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 \fIarg2\fP sur \fB1\fP. 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 \fIarg2\fP vaut \fB0\fP, le processus effacera l'état IO_FLUSHER et le comportement par défaut sera utilisé. .IP Le processus appelant doit avoir la capacité \fBCAP_SYS_RESOURCE\fP. .IP \fIarg3\fP, \fIarg4\fP et \fIarg5\fP doivent valoir \fB0\fP. .IP L'état IO_FLUSHER est récupéré par un processus enfant créé à l'aide de \fBfork\fP(2) et il est préservé pendant un \fBexecve\fP(2). .IP .\" prctl PR_GET_IO_FLUSHER 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. .TP \fBPR_GET_IO_FLUSHER\fP (depuis Linux 5.6) Renvoyer (en tant que résultat de la fonction) l'état IO_FLUSHER de l'appelant. Une valeur de \fB1\fP indique que l'appelant est dans l'état IO_FLUSHER ; \fB0\fP indique qu'il n'est pas dans cet état. .IP Le processus appelant doit avoir la capacité \fBCAP_SYS_RESOURCE\fP. .IP .\" prctl PR_SET_KEEPCAPS \fIarg2\fP, \fIarg3\fP, \fIarg4\fP et \fIarg5\fP doivent valoir zéro. .TP \fBPR_SET_KEEPCAPS\fP (depuis Linux 2.2.18) .\" prctl PR_GET_KEEPCAPS Définir l'état de l'attribut « keep capabilities » du thread appelant. L'effet de cet attribut est décrit dans \fBcapabilities\fP(7). \fIarg2\fP doit valoir soit \fB0\fP (effacer l'attribut), soit \fB1\fP (positionner l'attribut). La valeur de « keep capabilities » sera remise à \fB0\fP lors des prochains appels à \fBexecve\fP(2). .TP \fBPR_GET_KEEPCAPS\fP (depuis Linux 2.2.18) .\" prctl PR_MCE_KILL Renvoyer (en résultat de fonction) l'état actuel de l'attribut de conservation des capacités du thread appelant. Voir \fBcapabilities\fP(7) pour une description de cet attribut. .TP \fBPR_MCE_KILL\fP (depuis Linux 2.6.32) .\" prctl PR_MCE_KILL_GET Définir la politique de suppression de mémoire corrompue de la machine pour le thread actuel. Si \fIarg2\fP vaut \fBPR_MCE_KILL_CLEAR\fP, effacer la politique de suppression de mémoire corrompue et utiliser la valeur par défaut du système (qui est définie dans \fI/proc/sys/vm/memory_failure_early_kill\fP, consultez \fBproc\fP(5)). Si \fIarg2\fP vaut \fBPR_MCE_KILL_SET\fP, utiliser une politique de suppression de mémoire corrompue spécifique au thread. Dans ce cas, \fIarg3\fP définit si la politique est immédiate (\fIearly kill\fP avec \fBPR_MCE_KILL_EARLY\fP), différée (\fIlate kill\fP avec \fBPR_MCE_KILL_LATE\fP), ou la valeur par défaut du système (\fBPR_MCE_KILL_DEFAULT\fP). Une suppression immédiate signifie que le thread reçoit un signal \fBSIGBUS\fP 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 \fBsigaction\fP(2) pour plus d'informations sur le signal \fBSIGBUS\fP. Cette politique est héritée par les enfants. Les arguments restants de \fBprctl\fP(), non utilisés, doivent être mis à zéro pour préparer la future compatibilité. .TP \fBPR_MCE_KILL_GET\fP (depuis Linux 2.6.32) .\" prctl PR_SET_MM Renvoyer (comme résultat de la fonction) la politique actuelle par processus de suppression de mémoire corrompue. Tous les arguments de \fBprctl\fP() non utilisés doivent être zéro .TP \fBPR_SET_MM\fP (depuis Linux 3.3) .\" commit 028ee4be34a09a6d48bdf30ab991ae933a7bc036 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 \fBld.so\fP(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. .IP Le processus appelant doit avoir la capacité \fBCAP_SYS_RESOURCE\fP. La valeur de \fIarg2\fP est une des options ci\-dessous, tandis que \fIarg3\fP fournit la nouvelle valeur pour l'option. Les paramètres de \fIarg4\fP et de \fIarg5\fP doivent être de \fB0\fP s'ils ne sont pas utilisés. .IP .\" commit 52b3694157e3aa6df871e283115652ec6f2d31e0 Avant Linux 3.10, cette fonctionnalité n'est disponible que si le noyau est construit avec l'option \fBCONFIG_CHECKPOINT_RESTORE\fP. .RS .TP \fBPR_SET_MM_START_CODE\fP 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 \fBmprotect\fP(2) et \fBmmap\fP(2) pour plus d'informations). .TP \fBPR_SET_MM_END_CODE\fP 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. .TP \fBPR_SET_MM_START_DATA\fP 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. .TP \fBPR_SET_MM_END_DATA\fP 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. .TP \fBPR_SET_MM_START_STACK\fP 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. .TP \fBPR_SET_MM_START_BRK\fP Sélectionner l'adresse au\-dessus de laquelle le tas du programme peut être étendu avec l'appel \fBbrk\fP(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 \fBRLIMIT_DATA\fP (consultez \fBsetrlimit\fP(2)). .TP \fBPR_SET_MM_BRK\fP Sélectionnez la valeur actuelle de \fBbrk\fP(2). Les conditions pour l'adresse sont les mêmes que pour l'option \fBPR_SET_MM_START_BRK\fP. .P .\" commit fe8c7f5cbf91124987106faa3bdf0c8b955c4cf7 Les options suivantes sont disponibles depuis Linux 3.5. .TP \fBPR_SET_MM_ARG_START\fP Sélectionner l'adresse au\-dessus de laquelle la ligne de commande du programme est placée. .TP \fBPR_SET_MM_ARG_END\fP Sélectionner l'adresse en dessous de laquelle la ligne de commande du programme est placée. .TP \fBPR_SET_MM_ENV_START\fP Sélectionner l'adresse au\-dessus de laquelle l'environnement du programme est placé. .TP \fBPR_SET_MM_ENV_END\fP Sélectionner l'adresse en dessous de laquelle l'environnement du programme est placé. .IP L'adresse transmise au moyen de \fBPR_SET_MM_ARG_START\fP, \fBPR_SET_MM_ARG_END\fP, \fBPR_SET_MM_ENV_START\fP et de \fBPR_SET_MM_ENV_END\fP 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 \fBMAP_GROWSDOWN\fP défini (consultez \fBmmap\fP(2)). .TP \fBPR_SET_MM_AUXV\fP Sélectionner le nouveau vecteur auxiliaire. Le paramètre \fIarg3\fP doit fournir l'adresse du vecteur. Le paramètre \fIarg4\fP est la taille du vecteur. .TP \fBPR_SET_MM_EXE_FILE\fP .\" commit b32dfe377102ce668775f8b6b1461f7ad428f8b6 Remplacer le lien symbolique \fI/proc/\fPpid\fI/exe\fP par un nouveau lien pointant vers un nouveau fichier exécutable identifié par le descripteur de fichier fourni à l'aide du paramètre \fIarg3\fP. Le descripteur de fichier peut être obtenu au moyen d'un appel à \fBopen\fP(2). .IP 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 \fI.text\fP). .IP .\" commit 3fb4afd9a504c2386b8435028d43283216bf588e Sur Linux 4.9 et antérieurs, l'opération \fBPR_SET_MM_EXE_FILE\fP 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 \fBEPERM\fP. 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. .P .\" commit f606b77f1a9e362451aca8f81d8f36a3a112139e Les options suivantes sont disponibles depuis Linux 3.18. .TP \fBPR_SET_MM_MAP\fP Fournir un accès unique à toutes les adresses en passant une \fIstruct prctl_mm_map\fP (comme défini dans \fI\fP). Le paramètre \fIarg4\fP doit fournir la taille de la structure. .IP Cette fonctionnalité n'est disponible que si le noyau a été construit avec l'option \fBCONFIG_CHECKPOINT_RESTORE\fP activée. .TP \fBPR_SET_MM_MAP_SIZE\fP Renvoyer la taille attendue par le noyau de la \fIstruct prctl_mm_map\fP. Cela permet à l'espace utilisateur de trouver une structure compatible. Le paramètre \fIarg4\fP doit être un pointeur vers un entier non signé. .IP Cette fonctionnalité n'est disponible que si le noyau a été construit avec l'option \fBCONFIG_CHECKPOINT_RESTORE\fP activée. .RE .\" prctl PR_SET_VMA .TP \fBPR_SET_VMA\fP (depuis Linux 5.17) .\" Commit 9a10064f5625d5572c3626c1516e0bebc6c9fe9b Positionner un attribut indiqué dans \fIarg2\fP pour les zones de mémoire virtuelles commençant à l'adresse indiquée dans \fIarg3\fP et couvrant la taille indiquée dans \fIarg4\fP. \fIarg5\fP indique la valeur de l'attribut à positionner. .IP Remarquez que l'affectation d'un attribut à une zone de mémoire virtuelle pourrait l'empêcher de se fusionner avec les zones adjacentes du fait d'une différence de valeur de cet attribut. .IP Actuellement, \fIarg2\fP doit valoir une des valeurs suivantes : .RS .TP \fBPR_SET_VMA_ANON_NAME\fP Définir un nom pour les zones de mémoire virtuelle anonymes. \fIarg5\fP doit être un pointeur vers une chaîne se terminant par l’octet NULL contenant le nom. La taille du nom, y compris l'octet NULL, ne peut pas dépasser 80\ octets. Si \fIarg5\fP vaut NULL, le nom des zones de mémoire virtuelle anonymes adéquat sera réinitialisé. Le nom ne peut contenir que des caractères ASCII imprimables (dont des espaces), sauf « [ », « ] », « \e », « $ » et « \[ga] ». .RE .\" prctl PR_MPX_ENABLE_MANAGEMENT .TP \fBPR_MPX_ENABLE_MANAGEMENT\fP .TQ \fBPR_MPX_DISABLE_MANAGEMENT\fP (depuis Linux 3.19, supprimée dans Linux 5.4 ; seulement sur x86) .\" commit fe3d197f84319d3bce379a9c0dc17b1f48ad358c .\" See also http://lwn.net/Articles/582712/ .\" See also https://gcc.gnu.org/wiki/Intel%20MPX%20support%20in%20the%20GCC%20compiler .\" commit e9d1b4f3c60997fe197bf0243cb4a41a44387a88 Activer ou désactiver la gestion par le noyau des tables de limitations Memory Protection eXtensions (MPX). Les paramètres \fIarg2\fP, \fIarg3\fP, \fIarg4\fP et \fIarg5\fP doivent valoir zéro. .IP 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 \fBprctl\fP() de MPX décident si le noyau gère leur allocation ou leur libération. .IP 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. .IP Avant d'activer la gestion MPX en utilisant \fBPR_MPX_ENABLE_MANAGEMENT\fP, 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 \fIbndcfgu\fP. .IP 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 \fBCONFIG_X86_INTEL_MPX\fP. Vous pouvez vérifier que le processeur prend en charge MPX en recherchant le bit de CPUID \fImpx\fP, avec une commande telle que : .IP .in +4n .EX cat /proc/cpuinfo | grep \[aq] mpx \[aq] .EE .in .IP Il se peut qu'un thread ne bascule pas en ou hors du mode long (64 bits) quand MPX est activé. .IP Tous les threads d'un processus sont concernés par ces appels. .IP L'enfant d'un \fBfork\fP(2) hérite de l'état de la gestion MPX. Pendant un \fBexecve\fP(2), la gestion MPX est réinitialisée à un état tel que si \fBPR_MPX_DISABLE_MANAGEMENT\fP avait été appelé. .IP Pour plus d'informations sur le MPX d'Intel, consultez le fichier \fIDocumentation/x86/intel_mpx.txt\fP dans les sources du noyau. .IP .\" commit f240652b6032b48ad7fa35c5e701cc4c8d697c0b .\" See also https://lkml.kernel.org/r/20190705175321.DB42F0AD@viggo.jf.intel.com .\" prctl PR_SET_NAME Du fait d'un manque de prise en charge de l'ensemble d'outils, \fBPR_MPX_ENABLE_MANAGEMENT\fP et \fBPR_MPX_DISABLE_MANAGEMENT\fP ne sont pas gérés dans Linux 5.4 et ultérieurs. .TP \fBPR_SET_NAME\fP (depuis Linux 2.6.9) .\" TASK_COMM_LEN in include/linux/sched.h .\" prctl PR_GET_NAME Définir le nom du thread appelant, en utilisant la valeur de l'emplacement vers lequel pointe \fI(char\ *) arg2\fP. 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 \fBpthread_setname_np\fP(3) et consulté par \fBpthread_getname_np\fP(3). On peut également y accéder à l’aide de \fI/proc/self/task/\fPtid\fI/comm\fP (voir \fBproc\fP(5)), où \fItid\fP désigne l'identifiant du thread appelant tel que renvoyé par \fBgettid\fP(2). .TP \fBPR_GET_NAME\fP (depuis Linux 2.6.11) .\" prctl PR_SET_NO_NEW_PRIVS Renvoyer le nom du thread appelant, dans le tampon vers lequel pointe \fI(char\ *) arg2\fP. Le tampon doit être suffisamment grand pour contenir jusqu'à 16 octets ; la chaîne sera terminée par un octet NULL. .TP \fBPR_SET_NO_NEW_PRIVS\fP (depuis Linux 3.5) Affecter au bit \fIno_new_privs\fP du processus appelant la valeur dans \fIarg2\fP. Lorsque \fIno_new_privs\fP a la valeur \fB1\fP, \fBexecve\fP(2) promet de ne pas donner de droits à quoi que ce soit qui n'aurait pas pu être fait sans l'appel \fBexecve\fP(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 \fBfork\fP(2) et \fBclone\fP(2) et préservée à travers \fBexecve\fP(2). .IP Depuis Linux 4.10, la valeur de l'attribut \fIno_new_privs\fP d'un thread est visible dans le champ \fINoNewPrivs\fP du fichier \fI/proc/\fPpid\fI/status\fP. .IP .\" commit 40fde647ccb0ae8c11d256d271e24d385eed595b .\" prctl PR_GET_NO_NEW_PRIVS Pour plus d'informations, consultez le fichier \fIDocumentation/userspace\-api/no_new_privs.rst\fP (ou \fIDocumentation/prctl/no_new_privs.txt\fP avant Linux 4.13) dans les sources du noyau. Voir \fBseccomp\fP(2). .TP \fBPR_GET_NO_NEW_PRIVS\fP (depuis Linux 3.5) .\" prctl PR_PAC_RESET_KEYS .\" commit ba830885656414101b2f8ca88786524d4bb5e8c1 Renvoyer (comme résultat de la fonction) la valeur du bit \fIno_new_privs\fP du thread appelant. La valeur \fB0\fP indique le comportement habituel de \fBexecve\fP(2). La valeur \fB1\fP indique que \fBexecve\fP(2) va opérer dans le mode limiteur de droits décrit ci\-dessus. .TP \fBPR_PAC_RESET_KEYS\fP (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. .IP Le jeu de clés à réinitialiser est indiqué avec \fIarg2\fP, qui doit être un OU logique de zéro ou plusieurs des valeurs suivantes : .RS .TP \fBPR_PAC_APIAKEY\fP clé A d'authentification d'instruction .TP \fBPR_PAC_APIBKEY\fP clé B d'authentification d'instruction .TP \fBPR_PAC_APDAKEY\fP clé A d'authentification de données .TP \fBPR_PAC_APDBKEY\fP clé B d'authentification de données .TP \fBPR_PAC_APGAKEY\fP clé \[lq]A\[rq] d'authentification générique .IP (Oui les amis, il n'y a vraiment pas de clé B générique). .RE .IP Il existe un cas particulier où si \fIarg2\fP vaut \fB0\fP, 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 \fBPR_PAC_RESET_KEYS\fP pour préparer un appel \fBexecve\fP(2), puisque \fBexecve\fP(2) réinitialise toutes les clés d'authentification des pointeurs. .IP Les autres arguments \fIarg3\fP, \fIarg4\fP et \fIarg5\fP doivent être nuls. .IP Si les paramètres ne sont pas valables, et notamment si \fIarg2\fP contient des bits non reconnus ou correspondant à une clé indisponible sur cette plateforme, l'appel échoue avec l'erreur \fBEINVAL\fP. .IP \fBAttention :\fP le compilateur ou l'environnement d'exécution pouvant utiliser tout ou partie des clés, un \fBPR_PAC_RESET_KEYS\fP 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. .IP .\"commit b693d0b372afb39432e1c49ad7b3454855bc6bed .\" prctl PR_SET_PDEATHSIG Pour plus d'informations, consultez le fichier \fIDocumentation/arm64/pointer\-authentication.rst\fP (ou \fIDocumentation/arm64/pointer\-authentication.txt\fP avant Linux 5.3) dans les sources du noyau. .TP \fBPR_SET_PDEATHSIG\fP (depuis Linux 2.1.57) Configurer le signal de mort du parent du processus appelant avec la valeur \fIarg2\fP (qui peut être un numéro de signal dans l'intervalle [\fB1\fP, \fINSIG\ \-\ 1\fP] ou \fB0\fP pour effacer le signal). Il s'agit du numéro du signal que le processus appelant recevra si son parent meurt. .IP .\" https://bugzilla.kernel.org/show_bug.cgi?id=43300 \fIAttention :\fP c'est le \fIthread\fP 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 \fBpthread_exit\fP(3), par exemple) et non après que tous les threads du processus parent ne se soient terminés. .IP 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 \fBPR_SET_CHILD_SUBREAPER\fP 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 \fBPR_SET_PDEATHSIG\fP, aucun signal de la mort du parent n'est envoyé à l'appelant. .IP Le signal de la mort du parent est envoyé au processus (voir \fBsignal\fP(7)) et, si l'enfant installe un gestionnaire en utilisant l'attribut \fBSA_SIGINFO\fP de \fBsigaction\fP(2), le champ \fIsi_pid\fP du paramètre \fIsiginfo_t\fP du gestionnaire contient l'identifiant du processus parent qui se termine. .IP .\" commit d2d56c5f51028cb9f3d800882eb6f4cbd3f9099f .\" FIXME capability changes can also trigger this; see .\" kernel/cred.c::commit_creds in the Linux 5.6 source. .\" prctl PR_GET_PDEATHSIG Le paramétrage de signal de mort du parent est vidé pour l'enfant d'un \fBfork\fP(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 \fBcapabilities\fP(7)) ; sinon cette valeur est préservée par \fBexecve\fP(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. .TP \fBPR_GET_PDEATHSIG\fP (depuis Linux 2.3.15) .\" prctl PR_SET_PTRACER Renvoyer la valeur actuelle du signal de mort du processus parent, dans l'emplacement vers lequel pointe \fI(int\ *) arg2\fP. .TP \fBPR_SET_PTRACER\fP (depuis Linux 3.4) .\" commit 2d514487faf188938a4ee4fb3464eeecfbdcf8eb .\" commit bf06189e4d14641c0148bea16e9dd24943862215 Cela n'a de sens que lorsque le LSM Yama est actif et en mode 1 ("restricted ptrace", visible dans \fI/proc/sys/kernel/yama/ptrace_scope\fP). Lorsqu'un identifiant de processus ptracer (« ptracer process ID ») est passé en argument \fIarg2\fP, le composant appelant déclare que le processus ptracer peut appeler la fonction \fBptrace\fP(2) appliquée au processus appelant, comme si celui\-ci était un ancêtre direct. Chaque opération \fBPR_SET_PTRACER\fP remplace l'identifiant du processus ptracer précédent. L'emploi de \fBPR_SET_PTRACER\fP avec l'argument \fIarg2\fP égal à \fB0\fP supprime tous les identifiants de processus ptracer de l'appelant. Si \fIarg2\fP est égal à \fBPR_SET_PTRACER_ANY\fP, les restrictions ptrace apportées par Yama sont de fait désactivées pour le processus appelant. .IP .\" commit 90bb766440f2147486a2acc3e793d7b8348b0c22 .\" prctl PR_SET_SECCOMP Pour plus d'informations, consultez le fichier \fIDocumentation/admin\-guide/LSM/Yama.rst\fP dans les sources du noyau (ou \fIDocumentation/security/Yama.txt\fP avant Linux 4.13). .TP \fBPR_SET_SECCOMP\fP (depuis Linux 2.6.23) .\" See http://thread.gmane.org/gmane.linux.kernel/542632 .\" [PATCH 0 of 2] seccomp updates .\" andrea@cpushare.com 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 \fBseccomp\fP(2) fournit un superensemble de fonctions de \fBPR_SET_SECCOMP\fP et il est l'interface privilégiée pour les nouvelles applications. .IP Le mode de traitement sécurisé est sélectionné par \fIarg2\fP (les constantes du mode de traitement sécurisé sont définies dans \fI\fP). Les valeurs suivantes peuvent être indiquées : .RS .TP \fBSECCOMP_MODE_STRICT\fP (depuis Linux 2.6.23) Voir la description de \fBSECCOMP_SET_MODE_STRICT\fP dans \fBseccomp\fP(2). .IP Cette fonctionnalité n'est disponible que si le noyau a été construit avec l'option \fBCONFIG_SECCOMP\fP activée. .TP \fBSECCOMP_MODE_FILTER\fP (depuis Linux 3.5) Les appels système autorisés sont définis par un pointeur vers un filtre de paquets Berkeley passé en \fIarg3\fP. Cet argument est un pointeur vers \fIstruct sock_fprog\fP ; il peut être conçu pour filtrer des appels système arbitraires et les arguments des appels système. Consulter la description de \fBSECCOMP_SET_MODE_FILTER\fP dans \fBseccomp\fP(2). .IP Cette fonctionnalité n'est disponible que si le noyau a été construit avec l'option \fBCONFIG_SECCOMP_FILTER\fP activée. .RE .IP .\" prctl PR_GET_SECCOMP Pour plus de détails sur le filtrage seccomp, voir \fBseccomp\fP(2). .TP \fBPR_GET_SECCOMP\fP (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 \fB0\fP ; si l'appelant est dans le mode de traitement sécurisé strict, alors l'appel \fBprctl\fP() provoquera l'envoi d'un signal \fBSIGKILL\fP 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 \fB2\fP ; sinon le processus est tué avec un signal \fBSIGKILL\fP. .IP Cette fonctionnalité n'est disponible que si le noyau a été construit avec l'option \fBCONFIG_SECCOMP\fP activée. .IP .\" prctl PR_SET_SECUREBITS Depuis Linux 3.8, le champ \fISeccomp\fP du fichier \fI/proc/\fPpid\fI/status\fP offre une méthode pour obtenir la même information sans risquer que le processus ne soit tué ; voir \fBproc\fP(5). .TP \fBPR_SET_SECUREBITS\fP (depuis Linux 2.6.26) .\" prctl PR_GET_SECUREBITS Configurer l'attribut « securebits » du thread appelant à la valeur fournie par \fIarg2\fP. Consultez \fBcapabilities\fP(7). .TP \fBPR_GET_SECUREBITS\fP (depuis Linux 2.6.26) .\" prctl PR_GET_SPECULATION_CTRL Renvoyer (en résultat de fonction) l'état actuel de l'attribut « securebits » du thread appelant. Consultez \fBcapabilities\fP(7). .TP \fBPR_GET_SPECULATION_CTRL\fP (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 \fIarg2\fP. Actuellement, la seule valeur autorisée pour ce paramètre est \fBPR_SPEC_STORE_BYPASS\fP (sans quoi l'appel échoue avec l'erreur \fBENODEV\fP). .IP Le code de retour utilise les bits \fB0\fP à \fB3\fP ayant la signification suivante : .RS .TP \fBPR_SPEC_PRCTL\fP L'atténuation peut être contrôlée par thread via \fBPR_SET_SPECULATION_CTRL\fP. .TP \fBPR_SPEC_ENABLE\fP La fonction de spéculation est activée, l'atténuation est désactivée. .TP \fBPR_SPEC_DISABLE\fP La fonction de spéculation est désactivée, l'atténuation est activée. .TP \fBPR_SPEC_FORCE_DISABLE\fP Identique à \fBPR_SPEC_DISABLE\fP mais ne peut pas être annulé. .TP \fBPR_SPEC_DISABLE_NOEXEC\fP (depuis Linux 5.1) Identique à \fBPR_SPEC_DISABLE\fP, mais l'état sera vidé pendant un \fBexecve\fP(2). .RE .IP Si tous les bits valent \fB0\fP, le processeur n'est pas concerné par la fonction défectueuse de spéculation. .IP Si \fBPR_SPEC_PRCTL\fP est positionné, le contrôle par thread de l'atténuation est disponible. Sinon, \fBprctl\fP() échouera pour la fonction défectueuse de spéculation. .IP .\" prctl PR_SET_SPECULATION_CTRL Les paramètres \fIarg3\fP, \fIarg4\fP et \fIarg5\fP doivent être indiqués en tant que \fB0\fP ; sinon l'appel échoue avec l'erreur \fBEINVAL\fP. .TP \fBPR_SET_SPECULATION_CTRL\fP (depuis Linux 4.17) .\" commit b617cfc858161140d69cc0b5cc211996b557a1c7 .\" commit 356e4bfff2c5489e016fdb925adbf12a1e3950ee Définir l'état de la fonction défectueuse de spéculation indiqué dans \fIarg2\fP. Ces paramètres sont des attributs par thread. .IP Actuellement, \fIarg2\fP doit valoir une des valeurs suivantes : .RS .TP \fBPR_SPEC_STORE_BYPASS\fP .\" commit 9137bb27e60e554dab694eafa4cca241fa3a694f Définir l'état de la fonction défectueuse de contournement de stockage spéculatif. .TP \fBPR_SPEC_INDIRECT_BRANCH\fP (depuis Linux 4.20) Positionner l'état de la fonction défectueuse de spéculation de branche indirecte. .RE .IP Si \fIarg2\fP n'a pas une des valeurs ci\-dessus, l'appel échoue avec l'erreur \fBENODEV\fP. .IP Le paramètre \fIarg3\fP est utilisé pour récupérer le code de contrôle, qui peut être un des suivants : .RS .TP \fBPR_SPEC_ENABLE\fP La fonction de spéculation est activée, l'atténuation est désactivée. .TP \fBPR_SPEC_DISABLE\fP La fonction de spéculation est désactivée, l'atténuation est activée. .TP \fBPR_SPEC_FORCE_DISABLE\fP .\" commit 71368af9027f18fe5d1c6f372cfdff7e4bde8b48 Identique à \fBPR_SPEC_DISABLE\fP, mais ne peut pas être annulé. Un \fBprctl\fP( \fIarg2\fP, \fBPR_SPEC_ENABLE\fP) ultérieur avec la même valeur pour \fIarg2\fP échouera avec l'erreur \fBEPERM\fP. .TP \fBPR_SPEC_DISABLE_NOEXEC\fP (depuis Linux 5.1) Identique à \fBPR_SPEC_DISABLE\fP, mais l'état sera vidé lors d'un \fBexecve\fP(2). Actuellement, seul \fIarg2\fP égal à \fBPR_SPEC_STORE_BYPASS\fP est pris en charge. .RE .IP Toute valeur non valable de \fIarg3\fP fera échouer l'appel avec l'erreur \fBERANGE\fP. .IP Les paramètres \fIarg4\fP et \fIarg5\fP doivent être indiqués en tant que \fB0\fP ; sinon l'appel échoue avec l'erreur \fBEINVAL\fP. .IP .\" prctl PR_SVE_SET_VL .\" commit 2d2123bc7c7f843aa9db87720de159a049839862 .\" linux-5.6/Documentation/arm64/sve.rst La fonctionnalité de spéculation peut aussi être gérée par l'option d'amorçage \fBspec_store_bypass_disable\fP. Ce paramètre applique une règle de lecture seule qui fera échouer un appel \fBprctl\fP() avec une erreur \fBENXIO\fP. Pour de plus amples détails, voir le fichier \fIDocumentation/admin\-guide/kernel\-parameters.txt\fP des sources du noyau. .TP \fBPR_SVE_SET_VL\fP (depuis Linux 4.15, seulement sur arm64) Configurer la taille du vecteur SVE du thread comme indiqué dans \fI(int) arg2\fP. Les paramètres \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Les bits de \fIarg2\fP correspondant à \fBPR_SVE_VL_LEN_MASK\fP 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 \fBSVE_VL_MAX\fP (défini dans \fI)\fP pour les bits \fBPR_SVE_VL_LEN_MASK\fP exige la taille maximale de vecteur prise en charge. .IP En outre, les autres bits de \fIarg2\fP doivent être positionnés sur une des combinaisons suivantes d'attributs : .RS .TP \fB0\fP Effectuer les modifications immédiatement. Lors du prochain \fBexecve\fP(2) dans le thread, la taille du vecteur sera réinitialisée à celle configurée dans \fI/proc/sys/abi/sve_default_vector_length\fP. .TP \fBPR_SVE_VL_INHERIT\fP Effectuer les changements immédiatement. Les prochains appels \fBexecve\fP(2) préserveront la nouvelle taille du vecteur. .TP \fBPR_SVE_SET_VL_ONEXEC\fP Différer la modification pour qu'elle soit effectuée au prochain \fBexecve\fP(2) dans le thread. Les appels \fBexecve\fP(2) suivants réinitialiseront la taille du vecteur à la valeur configurée dans \fI/proc/sys/abi/sve_default_vector_length\fP. .TP \fBPR_SVE_SET_VL_ONEXEC | PR_SVE_VL_INHERIT\fP Différer la modification pour qu'elle soit effectuée au prochain \fBexecve\fP(2) dans le thread. Les prochains appels \fBexecve\fP(2) préserveront la nouvelle taille du vecteur. .RE .IP Dans tous les cas, toute modification précédemment différée et en attente sera annulée. .IP L'appel échoue avec l'erreur \fBEINVAL\fP si SVE n'est pas géré par la plateforme, si \fIarg2\fP n'est pas reconnu ou n'est pas valable, ou si la valeur des bits de \fIarg2\fP correspondant à \fBPR_SVE_VL_LEN_MASK\fP dépasse la plage \fBSVE_VL_MIN\fP..\fBSVE_VL_MAX\fP ou n'est pas un multiple de \fB16\fP. .IP En cas de succès, une valeur non négative est renvoyée décrivant la configuration de \fIselected\fP. Si \fBPR_SVE_SET_VL_ONEXEC\fP faisait partie de \fIarg2\fP, la configuration décrite par le code de retour prendra effet au prochain \fBexecve\fP(). Sinon, la configuration s'applique déjà quand l'appel \fBPR_SVE_SET_VL\fP renvoie. Dans les deux cas, la valeur est encodée de la même façon que le code de retour de \fBPR_SVE_GET_VL\fP. Remarquez qu'il n'y a pas d'attribut explicite dans le code de retour correspondant à \fBPR_SVE_SET_VL_ONEXEC\fP. .IP La configuration (y compris les modifications différées en attente) est récupérée lors d'un \fBfork\fP(2) et d'un \fBclone\fP(2). .IP .\"commit b693d0b372afb39432e1c49ad7b3454855bc6bed Pour plus d'informations, consultez le fichier \fIDocumentation/arm64/sve.rst\fP dans les sources du noyau (ou \fIDocumentation/arm64/sve.txt\fP avant Linux 5.3). .IP .\" prctl PR_SVE_GET_VL \fBAttention :\fP le compilateur ou l'environnement d'exécution pouvant utiliser SVE, l'utilisation de cet appel sans l'attribut \fBPR_SVE_SET_VL_ONEXEC\fP 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. .TP \fBPR_SVE_GET_VL\fP (depuis Linux 4.15, seulement sur arm64) Récupérer la configuration de la taille du vecteur SVE du thread actuel. .IP Les paramètres \fIarg2\fP, \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .IP 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 \fIactuelle\fP. Les bits correspondant à \fBPR_SVE_VL_LEN_MASK\fP contiennent la taille du vecteur actuellement configuré en octets. Le bit correspondant à \fBPR_SVE_VL_INHERIT\fP indique si la taille du vecteur sera récupérée à travers \fBexecve\fP(2). .IP 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é. .IP .\"commit b693d0b372afb39432e1c49ad7b3454855bc6bed Pour plus d'informations, consultez le fichier \fIDocumentation/arm64/sve.rst\fP dans les sources du noyau (ou \fIDocumentation/arm64/sve.txt\fP avant Linux 5.3). .TP .\" prctl PR_SET_SYSCALL_USER_DISPATCH .\" commit 1446e1df9eb183fdf81c3f0715402f1d7595d4 \fBPR_SET_SYSCALL_USER_DISPATCH\fP (depuis Linux 5.11, seulement sur x86) Configurer le mécanisme « Syscall User Dispatch » pour le thread appelant. Ce mécanisme permet à une application d'intercepter de manière sélective les appels système pour qu'elle puisse les gérer elle\-même. L'interception prend la forme d'un signal \fBSIGSYS\fP envoyé au thread quand il effectue un appel système. S'il est intercepté, l'appel système n'est pas exécuté par le noyau. .IP Pour activer ce mécanisme, \fIarg2\fP doit être positionné sur \fBPR_SYS_DISPATCH_ON\fP. Les prochains appels système seront alors sélectivement interceptés selon la valeur d'une variable de contrôle fournie dans l'espace utilisateur. Dans ce cas, \fIarg3\fP et \fIarg4\fP identifient respectivement la \fIposition\fP et la \fItaille\fP d'une zone de mémoire continue dans l'espace d'adressage du processus où les appels système sont toujours autorisés à être exécutés, quelle que soit la valeur de la variable de contrôle (cette zone inclut généralement la zone de mémoire contenant la bibliothèque C). .IP \fIarg5\fP pointe vers une variable de taille caractère qui représente un paramètre rapide pour autoriser/empêcher l'exécution d'un appel système sans la contrainte de faire un autre appel système visant à reconfigurer Syscall User Dispatch. Cette variable de contrôle peut être positionnée soit sur \fBSYSCALL_DISPATCH_FILTER_BLOCK\fP pour empêcher les appels système de s'exécuter, soit sur \fBSYSCALL_DISPATCH_FILTER_ALLOW\fP pour les autoriser temporairement à s'exécuter. Cette valeur est vérifiée par le noyau à chaque nouvelle entrée d'un appel système et toute valeur inattendue provoquera un \fBSIGSYS\fP insaisissable à cet instant, ce qui tuera l'application. .IP Lorsqu'un appel système est intercepté, le noyau envoie un signal \fBSIGSYS\fP adressé au thread différé. Divers champs seront définis dans la structure \fIsiginfo_t\fP (voir \fBsigaction\fP(2)) associée au signal : .RS .IP \- 3 \fIsi_signo\fP contiendra \fBSIGSYS\fP. .IP \- \fIsi_call_addr\fP affichera l'adresse de l'instruction de l'appel système. .IP \- \fIsi_syscall\fP et \fIsi_arch\fP indiqueront l'appel système qui a été tenté. .IP \- \fIsi_code\fP contiendra \fBSYS_USER_DISPATCH\fP. .IP \- \fIsi_errno\fP sera positionné à \fB0\fP. .RE .IP Le compteur du programme sera comme si l'appel système se produisait (c'est\-à\-dire que le compteur du programme ne pointera pas vers l'instruction de l'appel système). .IP Quand le gestionnaire de signal rend la main au noyau, l'appel système se termine immédiatement et rend la main au thread appelant, sans être réellement exécuté. Si nécessaire (c'est\-à\-dire lors de l'émulation de l'appel système dans l'espace utilisateur), le gestionnaire de signal doit positionner le code de retour de l'appel système sur une valeur adéquate, en modifiant le contexte du registre stocké dans le paramètre \fIucontext\fP du gestionnaire de signal. Voir \fBsigaction\fP(2), \fBsigreturn\fP(2) et \fBgetcontext\fP(3) pour plus d'informations. .IP Si \fIarg2\fP est positionné sur \fBPR_SYS_DISPATCH_OFF\fP, Syscall User Dispatch est désactivé pour ce thread. Les autres arguments doivent être positionnés à \fB0\fP. .IP Le paramètre n'est pas préservé à travers un \fBfork\fP(2), un \fBclone\fP(2) ou un \fBexecve\fP(2). .IP .\" prctl PR_SET_TAGGED_ADDR_CTRL .\" commit 63f0c60379650d82250f22e4cf4137ef3dc4f43d Pour plus d'informations, consultez le fichier \fIDocumentation/admin\-guide/syscall\-user\-dispatch.rst\fP dans les sources du noyau. .TP \fBPR_SET_TAGGED_ADDR_CTRL\fP (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\[em]63 ne valent pas \fB0\fP). .IP Le niveau de prise en charge est sélectionné par \fIarg2\fP, qui peut prendre une des valeurs suivantes : .RS .TP \fB0\fP Les adresses qui sont passées pour être déréférencées par le noyau doivent être non labellisées. .TP \fBPR_TAGGED_ADDR_ENABLE\fP 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. .RE .IP .\" Enforcement added in .\" commit 3e91ec89f527b9870fe42dcbdb74fd389d123a95 Les autres arguments \fIarg3\fP, \fIarg4\fP et \fIarg5\fP doivent être nuls. .IP En cas de succès, le mode indiqué dans \fIarg2\fP est positionné sur le thread appelant et le code de retour est \fB0\fP. Si les paramètres ne sont pas valables, le mode indiqué dans \fIarg2\fP 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 \fI/proc/sys/abi/tagged_addr_disabled\fP, l'appel échoue avec l'erreur \fBEINVAL\fP. .IP En particulier, si \fBprctl\fP(\fBPR_SET_TAGGED_ADDR_CTRL\fP, 0, 0, 0, 0) échoue avec \fBEINVAL\fP, toutes les adresses transmises au noyau doivent être non labellisées. .IP Indépendamment du mode défini, les adresses transmises à certaines interfaces doivent toujours être non labellisées : .RS .IP \- 3 \fBbrk\fP(2), \fBmmap\fP(2), \fBshmat\fP(2), \fBshmdt\fP(2) et le paramètre \fInew_address\fP de \fBmremap\fP(2). .IP (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). .IP \- Les interfaces « polymorphic » (polymorphes) qui acceptent les pointeurs vers des types arbitraires changent à \fIvoid *\fP ou un autre type générique, en particulier \fBprctl\fP(), \fBioctl\fP(2) et généralement \fBsetsockopt\fP(2) (seules certaines options spécifiques de \fBsetsockopt\fP(2) acceptent les adresses labellisées). .RE .IP 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. .IP Le mode défini par cet appel est récupéré à travers \fBfork\fP(2) et \fBclone\fP(2). Le mode est remis à \fB0\fP par \fBexecve\fP(2) (c'est\-à\-dire les adresses labellisées ne sont pas autorisées dans l'ABI de l'utilisateur ou du noyau). .IP Pour plus d'informations, consultez le fichier \fIDocumentation/arm64/tagged\-address\-abi.rst\fP dans les sources du noyau. .IP .\" prctl PR_GET_TAGGED_ADDR_CTRL .\" commit 63f0c60379650d82250f22e4cf4137ef3dc4f43d \fBAttention :\fP cet appel est d'abord conçu pour une utilisation par un environnement d'exécution. Un appel \fBPR_SET_TAGGED_ADDR_CTRL\fP 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. .TP \fBPR_GET_TAGGED_ADDR_CTRL\fP (depuis Linux 5.4, seulement sur arm64) Renvoyer le mode d'adressage étiqueté actuel du thread appelant. .IP Les paramètres \fIarg2\fP, \fIarg3\fP, \fIarg4\fP et \fIarg5\fP doivent être nuls. .IP 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 \fBEINVAL\fP. En particulier, si \fBprctl\fP(\fBPR_GET_TAGGED_ADDR_CTRL\fP, 0, 0, 0, 0) échoue avec \fBEINVAL\fP, cette fonction n'est clairement pas prise en charge ou désactivée avec \fI/proc/sys/abi/tagged_addr_disabled\fP. Dans ce cas, toutes les adresses transmises au noyau doivent être non labellisées. .IP 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 \fIarg2\fP de \fBPR_SET_TAGGED_ADDR_CTRL\fP. .IP .\" .\" prctl PR_TASK_PERF_EVENTS_DISABLE Pour plus d'informations, consultez le fichier \fIDocumentation/arm64/tagged\-address\-abi.rst\fP dans les sources du noyau. .TP \fBPR_TASK_PERF_EVENTS_DISABLE\fP (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 \fItools/perf/design.txt\fP des sources du noyau Linux. .IP .\" commit 1d1c7ddbfab358445a542715551301b7fc363e28 .\" .\" prctl PR_TASK_PERF_EVENTS_ENABLE Initialement appelé \fBPR_TASK_PERF_COUNTERS_DISABLE\fP. Renommé (avec la même valeur numérique) dans Linux 2.6.32. .TP \fBPR_TASK_PERF_EVENTS_ENABLE\fP (depuis Linux 2.6.31) L'inverse de \fBPR_TASK_PERF_EVENTS_DISABLE\fP. Activer les compteurs de performance attachés au processus appelant. .IP .\" commit 1d1c7ddbfab358445a542715551301b7fc363e28 .\" commit cdd6c482c9ff9c55475ee7392ec8f672eddb7be6 .\" .\" prctl PR_SET_THP_DISABLE Initialement appelé \fBPR_TASK_PERF_COUNTERS_ENABLE\fP. Renommé dans Linux 2.6.32. .TP \fBPR_SET_THP_DISABLE\fP (depuis Linux 3.15) .\" commit a0715cc22601e8830ace98366c0c2bd8da52af52 .\" prctl PR_GET_THP_DISABLE Affecter l'état de l'attribut « THP disable » pour le thread appelant. Si \fIarg2\fP a une valeur différente de zéro, 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 \fBmadvise\fP(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 \fBfork\fP(2) et est conservé lors d'un appel à \fBexecve\fP(2). .TP \fBPR_GET_THP_DISABLE\fP (depuis Linux 3.15) .\" prctl PR_GET_TID_ADDRESS Renvoyer (en résultat de fonction) le réglage actuel de l'attribut « THP disable » du thread appelant, c'est à dire \fB1\fP si l'attribut est activé et \fB0\fP dans le cas contraire. .TP \fBPR_GET_TID_ADDRESS\fP (depuis Linux 3.5) .\" commit 300f786b2683f8bb1ec0afb6e1851183a479c86d .\" prctl PR_SET_TIMERSLACK Renvoyer l'adresse \fIclear_child_tid\fP configurée par \fBset_tid_address\fP(2) et par l'attribut \fBCLONE_CHILD_CLEARTID\fP de \fBclone\fP(2), à l'emplacement vers lequel pointe \fI(int\ **)\ arg2\fP. Cette option n'est disponible que si le noyau est construit avec l'option \fBCONFIG_CHECKPOINT_RESTORE\fP. Notez que comme l'appel système \fBprctl\fP() n'a pas d'implémentation compatible pour les ABI AMD64 x32 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. .TP \fBPR_SET_TIMERSLACK\fP (depuis Linux 2.6.28) .\" See https://lwn.net/Articles/369549/ .\" commit 6976675d94042fbd446231d1bd8b7de71a980ada 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. \fIarg2\fP est un entier long non signé, la valeur « current » maximale est donc ULONG_MAX et celle minimale est \fB1\fP. Si la valeur en nanoseconde fournie dans \fIarg2\fP est supérieure à zéro, la valeur « current » est positionnée sur cette valeur. Si \fIarg2\fP est égal à zéro, la temporisation « current » est réinitialisée à la valeur « default » du thread. .IP 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. .IP .\" List obtained by grepping for futex usage in glibc source Les délais d'expiration affectés par la temporisation relâchée sont ceux définis par \fBselect\fP(2), \fBpselect\fP(2), \fBpoll\fP(2), \fBppoll\fP(2), \fBepoll_wait\fP(2), \fBepoll_pwait\fP(2), \fBclock_nanosleep\fP(2), \fBnanosleep\fP(2) et \fBfutex\fP(2) (et donc les fonctions de bibliothèque implémentées par futex, y compris \fBpthread_cond_timedwait\fP(3), \fBpthread_mutex_timedlock\fP(3), \fBpthread_rwlock_timedrdlock\fP(3), \fBpthread_rwlock_timedwrlock\fP(3) et \fBsem_timedwait\fP(3)). .IP 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 \fBsched_setscheduler\fP(2)). .IP 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 \fBPR_SET_TIMERSLACK\fP. La valeur « default » ne peut pas être modifiée. Les valeurs de temporisation relâchée d'\fIinit\fP (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 \fBfork\fP(2) et sont préservées à travers \fBexecve\fP(2). .IP .\" prctl PR_GET_TIMERSLACK 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 \fI/proc/\fPpid\fI/timerslack_ns\fP. Voir \fBproc\fP(5). .TP \fBPR_GET_TIMERSLACK\fP (depuis Linux 2.6.28) .\" prctl PR_SET_TIMING Renvoyer (comme résultat de la fonction) la valeur « current » de temporisation relâchée du thread appelant. .TP \fBPR_SET_TIMING\fP (depuis Linux 2.6.0) .\" Precisely: Linux 2.6.0-test4 .\" 0 .\" 1 .\" PR_TIMING_TIMESTAMP doesn't do anything in Linux 2.6.26-rc8, .\" and looking at the patch history, it appears .\" that it never did anything. .\" prctl PR_GET_TIMING Permettre de choisir la méthode de mesure du temps du processus à utiliser, en passant dans \fIarg2\fP soit \fBPR_TIMING_STATISTICAL\fP (méthode statistique traditionnelle) ou \fBPR_TIMING_TIMESTAMP\fP (méthode exacte utilisant des horodatages). \fBPR_TIMING_TIMESTAMP\fP n'est pas implémenté pour l'instant (l'utilisation de ce mode renverra l'erreur \fBEINVAL\fP). .TP \fBPR_GET_TIMING\fP (depuis Linux 2.6.0) .\" Precisely: Linux 2.6.0-test4 .\" prctl PR_SET_TSC Renvoyer (en résultat de fonction) quelle méthode de mesure du temps du processus est utilisée actuellement. .TP \fBPR_SET_TSC\fP (depuis Linux 2.6.26, seulement sur x86) .\" prctl PR_GET_TSC Configurer l'état de l'attribut qui indique si le compteur d'horodatage peut être lu par le processus. Utiliser \fBPR_TSC_ENABLE\fP pour \fIarg2\fP permet d'autoriser les lectures ou \fBPR_TSC_SIGSEGV\fP pour produire un \fBSIGSEGV\fP quand le processus essaie de lire le compteur d'horodatage. .TP \fBPR_GET_TSC\fP (depuis Linux 2.6.26, seulement sur x86) .\" prctl PR_SET_UNALIGN Renvoyer, dans l'emplacement vers lequel pointe \fI(int\ *) arg2\fP, l'état de l'attribut qui indique si le compteur d'horodatage peut être lu. .TP \fBPR_SET_UNALIGN\fP .\" sh: 94ea5e449ae834af058ef005d16a8ad44fcf13d6 .\" tile: 2f9ac29eec71a696cb0dcc5fb82c0f8d4dac28c9 .\" prctl PR_GET_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 à \fIarg2\fP. La valeur \fBPR_UNALIGN_NOPRINT\fP signifie que les accès non alignés en espace utilisateur sont silencieusement corrigés, et \fBPR_UNALIGN_SIGBUS\fP cause l'envoi de \fBSIGBUS\fP lors d'un accès utilisateur non aligné. Alpha gère aussi un attribut supplémentaire dont la valeur est \fB4\fP 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 \fBUAC_NOFIX\fP dans l'opération \fBSSI_NVPAIRS\fP de l'appel système \fBsetsysinfo\fP() sur Tru64). .TP \fBPR_GET_UNALIGN\fP .\" prctl PR_GET_AUXV (Consultez \fBPR_SET_UNALIGN\fP pour les informations sur les versions et les architectures). Renvoyer les bits de contrôle des accès non alignés dans l'emplacement vers lequel pointe \fI(unsigned int\ *) arg2\fP. .TP \fBPR_GET_AUXV\fP (depuis Linux 6.4) Récupérer le vecteur auxiliaire (auxv) dans le tampon vers lequel pointe \fI(void\ *) arg2\fP et dont la longueur est donnée par \fIarg3\fP. Si le tampon n'est pas suffisamment long pour le vecteur auxiliaire complet, la copie sera tronquée. Renvoyer (comme résultat de la fonction) la longueur totale du vecteur auxiliaire. \fIarg4\fP et \fIarg5\fP doivent être 0. .TP \fBPR_SET_MDWE\fP (depuis Linux 6.3) .\" commit b507808ebce23561d4ff8c2aa1fb949fe402bc61 Configurer le masque de protection « Memory\-Deny\-Write\-Execute » (MDWE) du processus appelant. Une fois les bits de protection définis, ils ne peuvent plus être modifiés. \fIarg2\fP doit être un masque de bits de : .RS .TP \fBPR_MDWE_REFUSE_EXEC_GAIN\fP Les nouvelles protections de mappage mémoire ne peuvent pas être accessibles en écriture et exécutables. Les mappages non exécutables ne peuvent pas devenir exécutables. .TP \fBPR_MDWE_NO_INHERIT (depuis Linux 6.6)\fP .\" commit 2a87e5520554034e8c423479740f95bea4a086a0 Ne pas propager la protection MDWE aux processus enfant sur \fBfork\fP(2). Définir ce bit nécessite de définir également \fBPR_MDWE_REFUSE_EXEC_GAIN\fP. .RE .TP \fBPR_GET_MDWE\fP (depuis Linux 6.3) .\" commit b507808ebce23561d4ff8c2aa1fb949fe402bc61 Renvoyer (comme résultat de la fonction) le masque de protection « Memory\-Deny\-Write\-Execute » du processus appelent. Consultez \fBPR_SET_MDWE\fP pour des informations sur les bits de masque de protection. .SH "VALEUR RENVOYÉE" En cas de réussite, \fBPR_CAP_AMBIENT\fP+\fBPR_CAP_AMBIENT_IS_SET\fP, \fBPR_CAPBSET_READ\fP, \fBPR_GET_DUMPABLE\fP, \fBPR_GET_FP_MODE\fP, \fBPR_GET_IO_FLUSHER\fP, \fBPR_GET_KEEPCAPS\fP, \fBPR_MCE_KILL_GET\fP, \fBPR_GET_NO_NEW_PRIVS\fP, \fBPR_GET_SECUREBITS\fP, \fBPR_GET_SPECULATION_CTRL\fP, \fBPR_SVE_GET_VL\fP, \fBPR_SVE_SET_VL\fP, \fBPR_GET_TAGGED_ADDR_CTRL\fP, \fBPR_GET_THP_DISABLE\fP, \fBPR_GET_TIMING\fP, \fBPR_GET_TIMERSLACK\fP, \fBPR_GET_AUXV\fP et (s'il rend la main) \fBPR_GET_SECCOMP\fP renvoient les valeurs positives décrites ci\-dessus. Toute autre valeur d'\fIop\fP renvoie \fB0\fP en cas de succès. En cas d'erreur, \fB\-1\fP est renvoyé et \fIerrno\fP est positionné pour indiquer l'erreur. .SH ERREURS .TP \fBEACCES\fP \fIop\fP vaut \fBPR_SET_SECCOMP\fP et \fIarg2\fP vaut \fBSECCOMP_MODE_FILTER\fP, mais le processus n'a pas la capacité \fBCAP_SYS_ADMIN\fP ou n'a pas positionné l'attribut \fIno_new_privs\fP (voir le point sur \fBPR_SET_NO_NEW_PRIVS\fP ci\-dessus). .TP \fBEACCES\fP \fIop\fP vaut \fBPR_SET_MM\fP, et \fIarg3\fP vaut \fBPR_SET_MM_EXE_FILE\fP, le fichier n'est pas exécutable. .TP \fBEBADF\fP \fIop\fP vaut \fBPR_SET_MM\fP, \fIarg3\fP vaut \fBPR_SET_MM_EXE_FILE\fP, et le descripteur de fichier passé dans le paramètre \fIarg4\fP n'est pas valable. .TP \fBEBUSY\fP \fIop\fP vaut \fBPR_SET_MM\fP, \fIarg3\fP vaut \fBPR_SET_MM_EXE_FILE\fP, et il s'agit de la seconde tentative de modification du lien symbolique \fI/proc/\fPpid\fI/exe\fP, ce qui n'est pas autorisé. .TP \fBEFAULT\fP \fIarg2\fP est une adresse non valable. .TP \fBEFAULT\fP \fIop\fP vaut \fBPR_SET_SECCOMP\fP, \fIarg2\fP vaut \fBSECCOMP_MODE_FILTER\fP, le système a été construit avec \fBCONFIG_SECCOMP_FILTER\fP et \fIarg2\fP n'est pas une adresse valable. .TP \fBEFAULT\fP \fIop\fP vaut \fBPR_SET_SYSCALL_USER_DISPATCH\fP et \fIarg5\fP a une adresse non valable. .TP \fBEINVAL\fP La valeur de \fIop\fP n'est pas reconnue ou n'est pas prise en charge sur ce système. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_MCE_KILL\fP, \fBPR_MCE_KILL_GET\fP ou \fBPR_SET_MM\fP, et les paramètres non utilisés de \fBprctl\fP() n'ont pas été réglés à zéro. .TP \fBEINVAL\fP \fIarg2\fP n'est pas une valeur valable pour cette \fIop\fP. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_SECCOMP\fP ou \fBPR_GET_SECCOMP\fP et le noyau n'a pas été configuré avec \fBCONFIG_SECCOMP\fP. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_SECCOMP\fP, \fIarg2\fP vaut \fBSECCOMP_MODE_FILTER\fP et le noyau n'a pas été configuré avec \fBCONFIG_SECCOMP_FILTER\fP. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_MM\fP, et l'une des assertions suivantes est vraie : .RS .IP \- 3 \fIarg4\fP ou \fIarg5\fP est différent de 0 ; .IP \- \fIarg3\fP est strictement plus grand que \fBTASK_SIZE\fP (la limite sur la taille de l'espace d'adressage utilisateur pour cette architecture) ; .IP \- \fIarg2\fP vaut \fBPR_SET_MM_START_CODE\fP, \fBPR_SET_MM_END_CODE\fP, \fBPR_SET_MM_START_DATA\fP, \fBPR_SET_MM_END_DATA\fP ou \fBPR_SET_MM_START_STACK\fP, et les permissions pour la zone de mémoire correspondante ne satisfont pas les conditions requises ; .IP \- \fIarg2\fP vaut \fBPR_SET_MM_START_BRK\fP ou \fBPR_SET_MM_BRK\fP, et \fIarg3\fP 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 \fBRLIMIT_DATA\fP. .RE .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_PTRACER\fP et \fIarg2\fP ne vaut ni \fB0\fP, ni \fBPR_SET_PTRACER_ANY\fP, ni le PID d'un processus existant. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_PDEATHSIG\fP et \fIarg2\fP n'est pas un numéro de signal valable. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_DUMPABLE\fP et \fIarg2\fP ne vaut ni \fBSUID_DUMP_DISABLE\fP, ni \fBSUID_DUMP_USER\fP. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_TIMING\fP et \fIarg2\fP n'a pas la valeur \fBPR_TIMING_STATISTICAL\fP. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_NO_NEW_PRIVS\fP et \fIarg2\fP ne vaut pas \fB1\fP, ou \fIarg3\fP, \fIarg4\fP ou \fIarg5\fP est différent de zéro. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_GET_NO_NEW_PRIVS\fP et \fIarg2\fP, \fIarg3\fP, \fIarg4\fP ou \fIarg5\fP est différent de zéro. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_THP_DISABLE\fP et \fIarg3\fP, \fIarg4\fP ou \fIarg5\fP est différent de zéro. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_GET_THP_DISABLE\fP et \fIarg2\fP, \fIarg3\fP, \fIarg4\fP ou \fIarg5\fP est différent de zéro. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_CAP_AMBIENT\fP et un paramètre inutilisé (\fIarg4\fP, \fIarg5\fP ou, dans le cas de \fBPR_CAP_AMBIENT_CLEAR_ALL\fP, \fIarg3\fP) ne vaut pas zéro ; ou bien \fIarg2\fP a une valeur non valable ; ou \fIarg2\fP vaut \fBPR_CAP_AMBIENT_LOWER\fP, \fBPR_CAP_AMBIENT_RAISE\fP ou \fBPR_CAP_AMBIENT_IS_SET\fP et \fIarg3\fP n'indique pas de capacité valable. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_SPECULATION_CTRL\fP ou \fBPR_SET_SPECULATION_CTRL\fP et des paramètres inutilisés de \fBprctl\fP() ne valent pas \fB0\fP. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_PAC_RESET_KEYS\fP et les paramètres ne sont pas valables ou ne sont pas pris en charge. Voir la description de \fBPR_PAC_RESET_KEYS\fP ci\-dessus pour des détails. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SVE_SET_VL\fP 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 \fBPR_SVE_SET_VL\fP ci\-dessus pour des détails. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SVE_GET_VL\fP et SVE n'est pas disponible sur cette plateforme. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_SYSCALL_USER_DISPATCH\fP et l'une des assertions suivantes est vraie : .RS .IP \- 3 \fIarg2\fP vaut \fBPR_SYS_DISPATCH_OFF\fP et les autres paramètres ne sont pas à \fB0\fP ; .IP \- \fIarg2\fP vaut \fBPR_SYS_DISPATCH_ON\fP et la plage de mémoire indiquée dépasse l'espace d'adressage du processus. .IP \- \fIarg2\fP n'est pas valable. .RE .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_SET_TAGGED_ADDR_CTRL\fP et les paramètres ne sont pas valables ou ne sont pas pris en charge. Voir la description de \fBPR_SET_TAGGED_ADDR_CTRL\fP ci\-dessus pour des détails. .TP \fBEINVAL\fP \fIop\fP vaut \fBPR_GET_TAGGED_ADDR_CTRL\fP et les paramètres ne sont pas valables ou ne sont pas pris en charge. Voir la description de \fBPR_GET_TAGGED_ADDR_CTRL\fP pour des détails. .TP \fBENODEV\fP \fIop\fP vaut \fBPR_SET_SPECULATION_CTRL\fP et le noyau ou le processeur ne gère pas la fonction défectueuse de spéculation demandée. .TP \fBENXIO\fP \fIop\fP vaut \fBPR_MPX_ENABLE_MANAGEMENT\fP ou \fBPR_MPX_DISABLE_MANAGEMENT\fP 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. .TP \fBENXIO\fP \fIopt\fP vaut \fBPR_SET_SPECULATION_CTRL\fP, 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 \fBPR_GET_SPECULATION_CTRL\fP pour savoir les options disponibles. .TP \fBEOPNOTSUPP\fP \fIop\fP vaut \fBPR_SET_FP_MODE\fP et \fIarg2\fP a une valeur non prise en charge ou non valable. .TP \fBEPERM\fP \fIop\fP vaut \fBPR_SET_SECUREBITS\fP et l'appelant n'a pas la capacité \fBCAP_SETPCAP\fP, a essayé d'enlever un attribut de « verrouillage » ou a essayé de positionner un attribut pour lequel l'attribut de verrouillage était positionné (consultez \fBcapabilities\fP(7)). .TP \fBEPERM\fP \fIop\fP vaut \fBPR_SET_SPECULATION_CTRL\fP alors que la spéculation est désactivée avec \fBPR_SPEC_FORCE_DISABLE\fP et l'appelant a essayé de la réactiver. .TP \fBEPERM\fP \fIop\fP vaut \fBPR_SET_KEEPCAPS\fP et l'attribut \fBSECBIT_KEEP_CAPS_LOCKED\fP de l'appelant est positionné (consultez \fBcapabilities\fP(7)). .TP \fBEPERM\fP \fIop\fP vaut \fBPR_CAPBSET_DROP\fP et l'appelant n'a pas la capacité \fBCAP_SETPCAP\fP. .TP \fBEPERM\fP \fIop\fP vaut \fBPR_SET_MM\fP et l'appelant n'a pas la capacité \fBCAP_SYS_RESOURCE\fP. .TP \fBEPERM\fP \fIop\fP vaut \fBPR_CAP_AMBIENT\fP et \fIarg2\fP vaut \fBPR_CAP_AMBIENT_RAISE\fP, mais soit la capacité indiquée dans \fIarg3\fP n'est pas présente dans les capacités autorisées et récupérables du processus, ou bien le bit de sécurité \fBPR_CAP_AMBIENT_LOWER\fP a été positionné. .TP \fBERANGE\fP \fIop\fP vaut \fBPR_SET_SPECULATION_CTRL\fP et \fIarg3\fP ne vaut ni \fBPR_SPEC_ENABLE\fP, ni \fBPR_SPEC_DISABLE\fP, ni \fBPR_SPEC_FORCE_DISABLE\fP, ni \fBPR_SPEC_DISABLE_NOEXEC\fP. .SH VERSIONS IRIX dispose d'un appel système \fBprctl\fP() (également introduit dans Linux 2.1.44 sur l'architecture MIPS sous le nom irix_prctl), dont le prototype est .P .in +4n .EX \fBptrdiff_t prctl(int \fP\fIop\fP\fB, int \fP\fIarg2\fP\fB, int \fP\fIarg3\fP\fB);\fP .EE .in .P et les opérations 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. .SH STANDARDS Linux. .SH HISTORIQUE Linux 2.1.57, glibc 2.0.6 .SH "VOIR AUSSI" \fBsignal\fP(2), \fBcore\fP(5) .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Christophe Blaess , Stéphan Rafin , Thierry Vignaud , François Micaux, Alain Portal , Jean-Philippe Guérard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas François , Florentin Duneau , Simon Paillard , Denis Barbier , David Prévot , Cédric Boutillier , Frédéric Hantrais et Jean-Philippe MENGUAL . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .