Provided by: manpages-fr-dev_4.19.0-7_all 
NOM
prctl - Opérations sur un processus ou un thread
BIBLIOTHÈQUE
Bibliothèque C standard (libc, -lc)
SYNOPSIS
#include <sys/prctl.h>
int prctl(int option, unsigned long arg2, unsigned long arg3,
unsigned long arg4, unsigned long arg5);
DESCRIPTION
prctl() gère divers aspects du comportement du thread ou du processus appelant.
Notez qu'une utilisation peu soigneuse de certaines opérations de prctl() peut perdre
l'environnement d’exécution de l'espace utilisateur, donc il faut les utiliser avec
rigueur.
prctl() est invoqué avec un premier paramètre indiquant ce qu'il faut faire, (ses valeurs
sont définies dans <linux/prctl.h>), et des paramètres supplémentaires dont la
signification dépend du premier paramètre. Celui-ci peut être :
PR_CAP_AMBIENT (depuis Linux 4.3)
Lire ou modifier l'ensemble environnant des capacités paramétrées sur le thread
appelant, en fonction de la valeur de arg2, qui doit être une des suivantes :
PR_CAP_AMBIENT_RAISE
La capacité indiquée dans arg3 est ajoutée à l'ensemble environnant. Elle
doit être déjà présente dans les ensembles environnants autorisés et hérités
du processus. Cette opération n'est pas autorisée si le bit de sécurité
SECBIT_NO_CAP_AMBIENT_RAISE est positionné.
PR_CAP_AMBIENT_LOWER
La capacité indiquée dans arg3 est supprimée de l'ensemble environnant.
PR_CAP_AMBIENT_IS_SET
L'appel prctl() renvoie 1 si la capacité indiquée dans arg3 est dans
l'ensemble environnant et, sinon, 0.
PR_CAP_AMBIENT_CLEAR_ALL
Toutes les capacités seront supprimées de l'ensemble environnant. Cette
opération implique que arg3 soit positionné sur zéro.
Dans toutes les opérations ci-dessus, arg4 et arg5 doivent valoir 0.
Des interfaces de plus haut niveau qui constituent la couche au-dessus des
opérations ci-dessus sont fournies dans la bibliothèque libcap(3) sous la forme
cap_get_ambient(3), cap_set_ambient(3), et cap_reset_ambient(3).
PR_CAPBSET_READ (depuis Linux 2.6.25)
Renvoyer (en résultat de fonction) 1 si la capacité indiquée par arg2 est présente
dans l’ensemble limitant de capacités du thread appelant ou 0 si elle ne l'est pas.
Les constantes des capacités sont définies dans <linux/capability.h>. L'ensemble
limitant les capacités contrôle si le processus peut recevoir la capacité par un
ensemble de capacités autorisées pour un fichier lors d'un appel futur à execve(2).
Si la capacité indiquée dans arg2 n'est pas valable, alors l'appel échoue avec
l'erreur EINVAL.
Une interface de plus haut niveau constituant la couche par-dessus cette opération
est fournie dans la bibliothèque libcap(3) sous la forme cap_get_bound(3).
PR_CAPBSET_DROP (depuis Linux 2.6.25)
Si le thread appelant a la capacité CAP_SETPCAP dans son espace de noms
utilisateur, alors enlever la capacité indiquée par arg2 dans l'ensemble de
limitation de capacités du thread appelant. Les enfants du thread appelant
hériteront de cette nouvelle limitation de capacités réduite.
L'appel échoue avec l'erreur EPERM si le thread appelant n'a pas la capacité
CAP_SETPCAP ; ou avec l'erreur EINVAL si arg2 ne représente pas une capacité
correcte ; ou avec l'erreur EINVAL si les capacités de fichier ne sont pas activées
dans le noyau, auquel cas les limitations ne sont pas prises en charge par le
noyau.
Une interface de plus haut niveau constituant la couche au-dessus de cette
opération est fournie par la bibliothèque libcap(3) sous la forme
cap_drop_bound(3).
PR_SET_CHILD_SUBREAPER (depuis Linux 3.4)
Si arg2 ne vaut pas zéro, positionner l'attribut « child subreaper » du processus
appelant ; si arg2 vaut zéro, déconfigurer l'attribut.
Un subreaper (suppresseur) joue le rôle de init(1) pour ses processus enfants.
Quand un processus devient orphelin (c'est-à-dire, que son parent le plus proche se
termine), ce processus sera adopté par le subreaper parent toujours vivant le plus
proche. Par conséquent, les appels getppid(2) dans le processus orphelin renverront
désormais l'identifiant de processus du subreaper et quand l'orphelin se terminera,
c'est le processus subreaper qui recevra le signal SIGCHLD et pourra surveiller
(wait(2)) le processus pour détecter son état de fin.
Le paramètre de l'attribut « child subreaper » n'est pas récupéré par les enfants
créés par fork(2) et clone(2). Le paramètre est préservé lors d'un execve(2).
Establishing a subreaper process is useful in session management frameworks where a
hierarchical group of processes is managed by a subreaper process that needs to be
informed when one of the processes—for example, a double-forked daemon—terminates
(perhaps so that it can restart that process). Some init(1) frameworks (e.g.,
systemd(1)) employ a subreaper process for similar reasons.
PR_GET_CHILD_SUBREAPER (depuis Linux 3.4)
Return the "child subreaper" setting of the caller, in the location pointed to by
(int *) arg2.
PR_SET_DUMPABLE (depuis Linux 2.3.20)
Définir l'état de l'attribut « dumpable » qui détermine si les fichiers de vidages
mémoire (core dump) sont produits pour le processus appelant lors de l'envoi du
signal, dont le comportement par défaut est de produire un fichier d’image mémoire.
Up to and including Linux 2.6.12, arg2 must be either 0 (SUID_DUMP_DISABLE, process
is not dumpable) or 1 (SUID_DUMP_USER, process is dumpable). Between Linux 2.6.13
and Linux 2.6.17, the value 2 was also permitted, which caused any binary which
normally would not be dumped to be dumped readable by root only; for security
reasons, this feature has been removed. (See also the description of /proc/sys/fs/
suid_dumpable in proc(5).)
Normalement, l'attribut « dumpable » est positionné sur 1. Cependant, il est
positionné sur la valeur actuelle du fichier /proc/sys/fs/suid_dumpable (qui a une
valeur de 0 par défaut), dans les circonstances suivantes :
• L'identifiant d'utilisateur ou de groupe effectif du processus a été modifié.
• L'identifiant d'utilisateur ou de groupe du système de fichiers du processus a
été modifié (voir credentials(7)).
• Le processus exécute (execve(2)) un programme set-user-ID ou set-group-ID, ce
qui fait changer l'identifiant d'utilisateur ou de groupe effectif.
• Le processus exécute (execve(2)) un programme qui a les capacités de fichier
(voir capabilities(7)), mais seulement si les capacités acquises ainsi
autorisées dépassent celles autorisées pour le processus.
Les processus qui ne génèrent pas de fichier de vidage ne peuvent pas être
rattachés à l'aide de PTRACE_ATTACH de ptrace(2) ; voir ptrace(2) pour plus de
détails.
If a process is not dumpable, the ownership of files in the process's /proc/pid
directory is affected as described in proc(5).
PR_GET_DUMPABLE (depuis Linux 2.3.20)
Renvoyer (en résultat de fonction) l'état actuel de l'attribut de création de
fichier de vidage du processus appelant.
PR_SET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC)
Définir le boutisme (endianness) du processus appelant à la valeur donnée dans
arg2, qui doit être l'une des valeurs suivantes : PR_ENDIAN_BIG, PR_ENDIAN_LITTLE,
ou PR_ENDIAN_PPC_LITTLE (PowerPC pseudo petit boutiste).
PR_GET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC)
Return the endian-ness of the calling process, in the location pointed to by
(int *) arg2.
PR_SET_FP_MODE (depuis Linux 4.0, seulement sur MIPS)
Sur l'architecture MIPS, le code en espace utilisateur peut être construit en
utilisant une ABI qui permet l'édition de liens avec du code ayant des exigences de
virgule flottante (FP) plus restrictives. Par exemple, un code en espace
utilisateur peut être construit pour cibler l'ABI FPXX O32 et lié au code construit
pour une ou plusieurs ABI plus restrictives FP32 ou FP64. Quand du code plus
restrictif est lié, l'exigence supplémentaire du processus est d'utiliser le mode
de virgule flottante plus restrictif.
Le noyau n'ayant aucun moyen de savoir à l'avance le mode dans lequel doit être
exécuté le processus, et ces restrictions pouvant changer durant la vie du
processus, l'opération PR_SET_FP_MODE est fournie pour permettre un contrôle du
mode de virgule flottante à partir de l'espace utilisateur.
L'argument (unsigned int) arg2 est un masque de bits décrivant le mode de virgule
flottante utilisé :
PR_FP_MODE_FR
Quand le bit est unset (ce qui est appelé le mode FR=0 ou FR0), les
registres 32 de virgule flottante ont une taille de 32 bits et ceux 64 bits
sont représentés sous forme de paire de registres (numérotés par un nombre
pair ou impair, avec le registre pair contenant les 32 bits de poids faible
et celui impair contenant les 32 bits de poids fort).
Quand ce bit est set (sur le matériel pris en charge), les registres 32 de
virgule flottante ont une taille de 64 bits (ce qui est appelé le mode FR=1
ou FR1). Remarquez que les implémentations MIPS modernes (MIPS R6 et plus
récentes) ne gèrent que le mode FR=1.
Applications that use the O32 FP32 ABI can operate only when this bit is
unset (FR=0; or they can be used with FRE enabled, see below). Applications
that use the O32 FP64 ABI (and the O32 FP64A ABI, which exists to provide
the ability to operate with existing FP32 code; see below) can operate only
when this bit is set (FR=1). Applications that use the O32 FPXX ABI can
operate with either FR=0 or FR=1 .
PR_FP_MODE_FRE
Activer l'émulation du mode flottant 32 bits. Quand ce mode est activé, il
émule les opérations de virgule flottante 32 bits en plaçant une exception
d'instruction réservée sur chaque instruction utilisant les formats 32 bits
et le noyau prend alors en charge l'instruction au niveau logiciel (c'est le
problème du décalage entre la gestion des registres aux numéros pairs , qui
sont les 32 bits supérieurs des registres 64 bits ayant les numéros impairs
en mode FR=0, et les parties 32 bits de poids faible des registres 64 bits
de numéros impairs en mode FR=1). L'activation de ce bit est nécessaire pour
du code dont l'ABI O32 FP3 doit agir sur du code ayant des ABI compatibles
O32 FPXX ou O32 FP64A (ce qui implique le mode FR=1 FPU), ou lorsqu'il est
exécuté sur du matériel plus récent (après MIPS R6) qui ne prend pas en
charge le mode FR=0 quand un binaire avec l'ABI FP32 est utilisé.
Remarquez que ce mode n'a de sens que lorsque le FPU est en mode 64 bits
(FR=1).
Remarquez que l'utilisation de l'émulation a par nature des conséquences en
termes de performance et qu’elle doit être évitée si possible.
Dans l'ABI N32/N64, le mode de virgule flottante 64 bits est toujours utilisé,
l'émulation FPU n'est donc pas nécessaire et le mode FPU agit toujours en mode
FR=1.
Cette option vise principalement les éditeurs de liens dynamiques (ld.so(8)).
Les paramètres arg3, arg4 et arg5 sont ignorés.
PR_GET_FP_MODE (depuis Linux 4.0, seulement sur MIPS)
Renvoyer (comme résultat de la fonction) le mode de virgule flottante actuel (voir
la description de PR_SET_FP_MODE pour les détails).
En cas de succès, l'appel renvoie un masque de bits qui représente le mode de
virgule flottante actuel.
Les paramètres arg2, arg3, arg4 et arg5 sont ignorés.
PR_SET_FPEMU (depuis Linux 2.4.18, 2.5.9, seulement sur ia64)
Définir les bits de contrôle de l'émulation de virgule flottante à arg2. Passer
PR_FPEMU_NOPRINT pour émuler silencieusement les opérations de virgule flottante,
ou PR_FPEMU_SIGFPE pour ne pas émuler ces opérations et envoyer SIGFPE.
PR_GET_FPEMU (depuis Linux 2.4.18, 2.5.9, seulement sur ia64)
Return floating-point emulation control bits, in the location pointed to by (int *)
arg2.
PR_SET_FPEXC (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC)
Définir le mode d'exception de virgule flottante à arg2. Passer la valeur
PR_FP_EXC_SW_ENABLE pour utiliser FPEXC pour activer les exceptions de flottant,
PR_FP_EXC_DIV pour les divisions de flottant par zéro, PR_FP_EXC_OVF pour les
dépassements de capacité vers le haut, PR_FP_EXC_UND pour les dépassements de
capacité vers le bas, PR_FP_EXC_RES pour les résultats de flottant inexacts,
PR_FP_EXC_INV pour les opérations de flottant non valables, PR_FP_EXC_DISABLED pour
désactiver les exceptions de flottant, PR_FP_EXC_NONRECOV pour le mode d'exception
asynchrone non récupérable, PR_FP_EXC_ASYNC pour le mode d'exception asynchrone
récupérable, PR_FP_EXC_PRECISE pour le mode d'exception de précision.
PR_GET_FPEXC (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC)
Return floating-point exception mode, in the location pointed to by (int *) arg2.
PR_SET_IO_FLUSHER (depuis Linux 5.6)
Si le processus d'un utilisateur est impliqué dans la couche de blocs ou le chemin
d'E/S du système de fichiers, et s'il peut allouer de la mémoire en traitant les
requêtes E/S, il doit positionner arg2 sur 1. Cela mettra le processus en état
IO_FLUSHER, ce qui lui accorde un traitement spécial pour progresser lors de
l'allocation de la mémoire. Si arg2 vaut 0, le processus effacera l'état IO_FLUSHER
et le comportement par défaut sera utilisé.
Le processus appelant doit avoir la capacité CAP_SYS_RESOURCE.
arg3, arg4 et arg5 doivent valoir 0.
L'état IO_FLUSHER est récupéré par un processus enfant créé à l'aide de fork(2) et
il est préservé pendant un execve(2).
Des exemples d'applications IO_FLUSHER sont les démons FUSE, ceux d'émulation de
périphériques SCSI et ceux gérant des erreurs comme les applications de
récupération de chemins multipath.
PR_GET_IO_FLUSHER (depuis Linux 5.6)
Renvoyer (en tant que résultat de la fonction) l'état IO_FLUSHER de l'appelant. Une
valeur de 1 indique que l'appelant est dans l'état IO_FLUSHER ; 0 indique qu'il
n'est pas dans cet état.
Le processus appelant doit avoir la capacité CAP_SYS_RESOURCE.
arg2, arg3, arg4 et arg5 doivent valoir zéro.
PR_SET_KEEPCAPS (depuis Linux 2.2.18)
Définir l'état de l'attribut « keep capabilities » du thread appelant. L'effet de
cet attribut est décrit dans capabilities(7). arg2 doit valoir soit 0 (effacer
l'attribut), soit 1 (positionner l'attribut). La valeur de « keep capabilities »
sera remise à 0 lors des prochains appels à execve(2).
PR_GET_KEEPCAPS (depuis Linux 2.2.18)
Renvoyer (en résultat de fonction) l'état actuel de l'attribut de conservation des
capacités du thread appelant. Voir capabilities(7) pour une description de cet
attribut.
PR_MCE_KILL (depuis Linux 2.6.32)
Définir la politique de suppression de mémoire corrompue de la machine pour le
thread actuel. Si arg2 vaut PR_MCE_KILL_CLEAR, effacer la politique de suppression
de mémoire corrompue et utiliser la valeur par défaut du système (qui est définie
dans /proc/sys/vm/memory_failure_early_kill, consultez proc(5)). Si arg2 vaut
PR_MCE_KILL_SET, utiliser une politique de suppression de mémoire corrompue
spécifique au thread. Dans ce cas, arg3 définit si la politique est immédiate
(early kill avec PR_MCE_KILL_EARLY), différée (late kill avec PR_MCE_KILL_LATE), ou
la valeur par défaut du système (PR_MCE_KILL_DEFAULT). Une suppression immédiate
signifie que le thread reçoit un signal SIGBUS dès que la corruption mémoire
matérielle est détectée à l'intérieur de son espace d'adressage. En mode différé,
le processus n'est tué que lorsqu'il accède à une page corrompue. Consultez
sigaction(2) pour plus d'informations sur le signal SIGBUS. Cette politique est
héritée par les enfants. Les arguments restants de prctl(), non utilisés, doivent
être mis à zéro pour préparer la future compatibilité.
PR_MCE_KILL_GET (depuis Linux 2.6.32)
Renvoyer (comme résultat de la fonction) la politique actuelle par processus de
suppression de mémoire corrompue. Tous les arguments de prctl() non utilisés
doivent être zéro
PR_SET_MM (depuis Linux 3.3)
Modifier certains champs du descripteur de projection de mémoire du noyau pour le
processus appelant. D'habitude, ces champs sont déterminés par le noyau et le
chargeur de liens dynamiques (consultez ld.so(8) pour plus d'informations) et une
application normale ne devrait pas utiliser cette fonctionnalité. En revanche, dans
certaines situations, telles que celles de programmes se modifiant eux-mêmes, un
programme pourra trouver utile de pouvoir changer sa propre projection en mémoire.
Le processus appelant doit avoir la capacité CAP_SYS_RESOURCE. La valeur de arg2
est une des options ci-dessous, tandis que arg3 fournit la nouvelle valeur pour
l'option. Les paramètres de arg4 et de arg5 doivent être de 0 s'ils ne sont pas
utilisés.
Avant Linux 3.10, cette fonctionnalité n'est disponible que si le noyau est
construit avec l'option CONFIG_CHECKPOINT_RESTORE.
PR_SET_MM_START_CODE
Définir l'adresse au dessus de laquelle le texte du programme peut être
exécuté. La zone de mémoire correspondante doit être accessible en lecture
et en exécution, mais pas en écriture et ne doit pas pouvoir être partagée
(consultez mprotect(2) et mmap(2) pour plus d'informations).
PR_SET_MM_END_CODE
Définir l'adresse en dessous de laquelle le texte du programme peut être
exécuté. La zone de mémoire correspondante doit être accessible en lecture
et en exécution, mais pas en écriture et ne doit pas pouvoir être partagée.
PR_SET_MM_START_DATA
Définir l'adresse au-dessus de laquelle les données initialisées et non
initialisées (bss) sont placées. La zone de mémoire correspondante doit être
accessible en lecture et en écriture, mais pas en exécution et ne doit pas
pouvoir être partagée.
PR_SET_MM_END_DATA
Définir l'adresse en dessous de laquelle les données initialisées et non
initialisées (bss) sont placées. La zone de mémoire correspondante doit être
accessible en lecture et en écriture, mais pas en exécution et ne doit pas
pouvoir être partagée.
PR_SET_MM_START_STACK
Sélectionner l'adresse du début de la pile. La région de mémoire
correspondante doit être accessible en lecture et en écriture.
PR_SET_MM_START_BRK
Sélectionner l'adresse au-dessus de laquelle le tas du programme peut être
étendu avec l'appel brk(2). L'adresse doit être au-dessus de l'adresse
terminant le segment de données actuel du programme. De plus, la taille
combinée du tas obtenu et du segment de données ne peut pas dépasser la
limite de ressource RLIMIT_DATA (consultez setrlimit(2)).
PR_SET_MM_BRK
Sélectionnez la valeur actuelle de brk(2). Les conditions pour l'adresse
sont les mêmes que pour l'option PR_SET_MM_START_BRK.
Les options suivantes sont disponibles depuis Linux 3.5.
PR_SET_MM_ARG_START
Sélectionner l'adresse au-dessus de laquelle la ligne de commande du
programme est placée.
PR_SET_MM_ARG_END
Sélectionner l'adresse en dessous de laquelle la ligne de commande du
programme est placée.
PR_SET_MM_ENV_START
Sélectionner l'adresse au-dessus de laquelle l'environnement du programme
est placé.
PR_SET_MM_ENV_END
Sélectionner l'adresse en dessous de laquelle l'environnement du programme
est placé.
L'adresse transmise au moyen de PR_SET_MM_ARG_START, PR_SET_MM_ARG_END,
PR_SET_MM_ENV_START et de PR_SET_MM_ENV_END doit appartenir à l'espace
mémoire d'une pile de processus. Par conséquent, l'espace mémoire
correspondant doit être accessible en lecture, en écriture et (selon la
configuration du noyau) disposer de l'attribut MAP_GROWSDOWN défini
(consultez mmap(2)).
PR_SET_MM_AUXV
Sélectionner le nouveau vecteur auxiliaire. Le paramètre arg3 doit fournir
l'adresse du vecteur. Le paramètre arg4 est la taille du vecteur.
PR_SET_MM_EXE_FILE
Supersede the /proc/pid/exe symbolic link with a new one pointing to a new
executable file identified by the file descriptor provided in arg3 argument.
The file descriptor should be obtained with a regular open(2) call.
Pour changer le lien symbolique, il faut supprimer tous les espaces alloués
en mémoire et contenant du code exécutable, y compris ceux créés par le
noyau (par exemple, le noyau crée en général au moins un espace mémoire
d'exécutable pour la section ELF .text).
Sur Linux 4.9 et antérieurs, l'opération PR_SET_MM_EXE_FILE ne peut être
effectuée qu'une fois dans la vie d'un processus ; si on l'effectue une
seconde fois, elle donnera l'erreur EPERM. Cette restriction a été renforcée
pour des raisons de sécurité jugées plus tard curieuses, donc la restriction
a été supprimée dans Linux 4.10 car certaines applications en espace
utilisateur avaient besoin d'effectuer cette opération plus d'une fois.
Les options suivantes sont disponibles depuis Linux 3.18.
PR_SET_MM_MAP
Fournir un accès unique à toutes les adresses en passant une struct
prctl_mm_map (comme défini dans <linux/prctl.h>). Le paramètre arg4 doit
fournir la taille de la structure.
Cette fonctionnalité n'est disponible que si le noyau a été construit avec
l'option CONFIG_CHECKPOINT_RESTORE activée.
PR_SET_MM_MAP_SIZE
Renvoyer la taille attendue par le noyau de la struct prctl_mm_map. Cela
permet à l'espace utilisateur de trouver une structure compatible. Le
paramètre arg4 doit être un pointeur vers un entier non signé.
Cette fonctionnalité n'est disponible que si le noyau a été construit avec
l'option CONFIG_CHECKPOINT_RESTORE activée.
PR_SET_VMA (since Linux 5.17)
Sets an attribute specified in arg2 for virtual memory areas starting from the
address specified in arg3 and spanning the size specified in arg4. arg5 specifies
the value of the attribute to be set.
Note that assigning an attribute to a virtual memory area might prevent it from
being merged with adjacent virtual memory areas due to the difference in that
attribute's value.
Actuellement, arg2 doit valoir une des valeurs suivantes :
PR_SET_VMA_ANON_NAME
Set a name for anonymous virtual memory areas. arg5 should be a pointer to a
null-terminated string containing the name. The name length including null
byte cannot exceed 80 bytes. If arg5 is NULL, the name of the appropriate
anonymous virtual memory areas will be reset. The name can contain only
printable ascii characters (including space), except '[', ']', '\', '$', and
'`'.
PR_MPX_ENABLE_MANAGEMENT, PR_MPX_DISABLE_MANAGEMENT (depuis Linux 3.19, supprimée dans
Linux 5.4 ; seulement sur x86)
Activer ou désactiver la gestion par le noyau des tables de limitations Memory
Protection eXtensions (MPX). Les paramètres arg2, arg3, arg4 et arg5 doivent valoir
zéro.
MPX est un mécanisme assisté par le matériel pour effectuer des contrôles de
limites sur les pointeurs. Il consiste dans un ensemble de registres stockant les
informations des limites et un ensemble de préfixes d'instruction spéciaux qui
disent au processeur sur quelle instruction il doit poser des limites renforcées.
Il existe un nombre limité de ces registres et quand il y a plus de pointeurs que
de registres, leur contenu doit être « déversé » (spilled) dans un ensemble de
tables. Ces tables s'appellent des « bounds tables » et les opérations prctl() de
MPX décident si le noyau gère leur allocation ou leur libération.
Quand la gestion est activée, le noyau prendra en charge l'allocation et la
libération des tables de limites. Il le fait en piégeant les exceptions #BR qui
conduisent d’abord à l'utilisation de tables de limites manquantes, et au lieu
d'envoyer l'exception à l'espace utilisateur, il alloue la table et remplit le
répertoire des limites avec l'emplacement de la nouvelle table. Pour la libération,
le noyau vérifie dans les tables de limites la présence de mémoire non allouée et
les libère.
Avant d'activer la gestion MPX en utilisant PR_MPX_ENABLE_MANAGEMENT, l'application
doit d'abord avoir alloué un tampon dans l'espace utilisateur pour le répertoire de
limites, et placé l'emplacement de ce répertoire dans le registre bndcfgu.
Ces appels échouent si le processeur ou le noyau ne gèrent pas MPX. La prise en
charge par le noyau de MPX s'active avec l'option de configuration
CONFIG_X86_INTEL_MPX. Vous pouvez vérifier que le processeur prend en charge MPX en
recherchant le bit de CPUID mpx, avec une commande telle que :
cat /proc/cpuinfo | grep ' mpx '
Il se peut qu'un thread ne bascule pas en ou hors du mode long (64 bits) quand MPX
est activé.
Tous les threads d'un processus sont concernés par ces appels.
L'enfant d'un fork(2) hérite de l'état de la gestion MPX. Pendant un execve(2), la
gestion MPX est réinitialisée à un état tel que si PR_MPX_DISABLE_MANAGEMENT avait
été appelé.
Pour plus d'informations sur le MPX d'Intel, consultez le fichier
Documentation/x86/intel_mpx.txt dans les sources du noyau.
Du fait d'un manque de prise en charge de l'ensemble d'outils,
PR_MPX_ENABLE_MANAGEMENT et PR_MPX_DISABLE_MANAGEMENT ne sont pas gérés dans
Linux 5.4 et ultérieurs.
PR_SET_NAME (depuis Linux 2.6.9)
Set the name of the calling thread, using the value in the location pointed to by
(char *) arg2. The name can be up to 16 bytes long, including the terminating null
byte. (If the length of the string, including the terminating null byte, exceeds 16
bytes, the string is silently truncated.) This is the same attribute that can be
set via pthread_setname_np(3) and retrieved using pthread_getname_np(3). The
attribute is likewise accessible via /proc/self/task/tid/comm (see proc(5)), where
tid is the thread ID of the calling thread, as returned by gettid(2).
PR_GET_NAME (depuis Linux 2.6.11)
Return the name of the calling thread, in the buffer pointed to by (char *) arg2.
The buffer should allow space for up to 16 bytes; the returned string will be
null-terminated.
PR_SET_NO_NEW_PRIVS (depuis Linux 3.5)
Affecter au bit no_new_privs du processus appelant la valeur dans arg2. Lorsque
no_new_privs a la valeur 1, execve(2) promet de ne pas donner de droits à quoi que
ce soit qui n'aurait pas pu être fait sans l'appel execve(2) (par exemple, rendre
non fonctionnels les bits de permission set-user-ID et set-group-ID, ou bien les
capacités de fichiers). Une fois affecté, le bit ne peut pas être réinitialisé.
L'affectation de ce bit est héritée par les enfants créés par fork(2) et clone(2)
et préservée à travers execve(2).
Since Linux 4.10, the value of a thread's no_new_privs attribute can be viewed via
the NoNewPrivs field in the /proc/pid/status file.
Pour plus d'informations, consultez le fichier
Documentation/userspace-api/no_new_privs.rst (ou
Documentation/prctl/no_new_privs.txt avant Linux 4.13) dans les sources du noyau.
Voir seccomp(2).
PR_GET_NO_NEW_PRIVS (depuis Linux 3.5)
Renvoyer (comme résultat de la fonction) la valeur du bit no_new_privs du thread
appelant. La valeur 0 indique le comportement habituel de execve(2). La valeur 1
indique que execve(2) va opérer dans le mode limiteur de droits décrit ci-dessus.
PR_PAC_RESET_KEYS (depuis Linux 5.0, seulement sur arm64)
Réinitialiser de manière sûre les clés d'authentification du pointeur du thread
pour rafraîchir les valeurs aléatoires générées par le noyau.
Le jeu de clés à réinitialiser est indiqué avec arg2, qui doit être un OU logique
de zéro ou plusieurs des valeurs suivantes :
PR_PAC_APIAKEY
clé A d'authentification d'instruction
PR_PAC_APIBKEY
clé B d'authentification d'instruction
PR_PAC_APDAKEY
clé A d'authentification de données
PR_PAC_APDBKEY
clé B d'authentification de données
PR_PAC_APGAKEY
generic authentication “A” key.
(Oui les amis, il n'y a vraiment pas de clé B générique).
Il existe un cas particulier où si arg2 vaut 0, toutes les clés sont
réinitialisées. Comme de nouvelles clés pourraient être ajoutées dans le futur,
c'est la manière recommandée pour nettoyer les clés existantes pour créer un
contexte d'exécution propre. Remarquez qu'il n'est pas nécessaire d'utiliser
PR_PAC_RESET_KEYS pour préparer un appel execve(2), puisque execve(2) réinitialise
toutes les clés d'authentification des pointeurs.
Les autres arguments arg3, arg4 et arg5 doivent être nuls.
Si les paramètres ne sont pas valables, et notamment si arg2 contient des bits non
reconnus ou correspondant à une clé indisponible sur cette plateforme, l'appel
échoue avec l'erreur EINVAL.
Attention : le compilateur ou l'environnement d'exécution pouvant utiliser tout ou
partie des clés, un PR_PAC_RESET_KEYS réussi peut faire planter le processus
appelant. Les conditions pour l'utiliser en toute sécurité sont complexes et
dépendent du système. Ne l'utilisez pas sauf si vous savez ce que vous faites.
Pour plus d'informations, consultez le fichier
Documentation/arm64/pointer-authentication.rst (ou
Documentation/arm64/pointer-authentication.txt avant Linux 5.3) dans les sources du
noyau.
PR_SET_PDEATHSIG (depuis Linux 2.1.57)
Configurer le signal de mort du parent du processus appelant avec la valeur arg2
(qui peut être un numéro de signal dans l'intervalle 1..NSIG-1, ou être nul pour
effacer le signal). Il s'agit du numéro du signal que le processus appelant recevra
si son parent meurt.
Attention : c'est le thread qui est, dans ce cas, considéré comme le « parent » qui
a créé ce processus. Autrement dit, le signal sera envoyé quand ce thread se
terminera (à l'aide de pthread_exit(3), par exemple) et non après que tous les
threads du processus parent ne se soient terminés.
Le signal de la mort du parent est envoyé lors de la fin ultérieure du thread
parent et lors de la fin de chaque processus subreaper (voir la description de
PR_SET_CHILD_SUBREAPER ci-dessus) auquel l'appelant est alors affilié. Si le thread
parent et tous les subreapers ancêtres sont déjà terminés au moment de l'opération
PR_SET_PDEATHSIG, aucun signal de la mort du parent n'est envoyé à l'appelant.
Le signal de la mort du parent est envoyé au processus (voir signal(7)) et, si
l'enfant installe un gestionnaire en utilisant l'attribut SA_SIGINFO de
sigaction(2), le champ si_pid du paramètre siginfo_t du gestionnaire contient
l'identifiant du processus parent qui se termine.
Le paramétrage de signal de mort du parent est vidé pour l'enfant d'un fork(2). Il
est également vidé (depuis Linux 2.4.36/2.6.23) lors de l'exécution d'un binaire
Set-UID ou Set-GID ou d'un binaire qui a des capacités associées (voir
capabilities(7)) ; sinon cette valeur est préservée par execve(2). Le paramétrage
du signal de mort du parent est aussi vidé lors du changement des droits suivants
d'un thread : l'identifiant utilisateur ou de groupe effectif, l'identifiant
utilisateur ou groupe du système de fichiers.
PR_GET_PDEATHSIG (depuis Linux 2.3.15)
Return the current value of the parent process death signal, in the location
pointed to by (int *) arg2.
PR_SET_PTRACER (depuis Linux 3.4)
Cela n'a de sens que lorsque le LSM Yama est actif et en mode 1 ("restricted
ptrace", visible dans /proc/sys/kernel/yama/ptrace_scope). Lorsqu'un identifiant de
processus ptracer (« ptracer process ID ») est passé en argument arg2, le composant
appelant déclare que le processus ptracer peut appeler la fonction ptrace(2)
appliquée au processus appelant, comme si celui-ci était un ancêtre direct. Chaque
opération PR_SET_PTRACER remplace l'identifiant du processus ptracer précédent.
L'emploi de PR_SET_PTRACER avec l'argument arg2 égal à 0 supprime tous les
identifiants de processus ptracer de l'appelant. Si arg2 est égal à
PR_SET_PTRACER_ANY, les restrictions ptrace apportées par Yama sont de fait
désactivées pour le processus appelant.
Pour plus d'informations, consultez le fichier
Documentation/admin-guide/LSM/Yama.rst dans les sources du noyau (ou
Documentation/security/Yama.txt avant Linux 4.13).
PR_SET_SECCOMP (depuis Linux 2.6.23)
Set the secure computing (seccomp) mode for the calling thread, to limit the
available system calls. The more recent seccomp(2) system call provides a superset
of the functionality of PR_SET_SECCOMP, and is the preferred interface for new
applications.
The seccomp mode is selected via arg2. (The seccomp constants are defined in
<linux/seccomp.h>.) The following values can be specified:
SECCOMP_MODE_STRICT (since Linux 2.6.23)
See the description of SECCOMP_SET_MODE_STRICT in seccomp(2).
This operation is available only if the kernel is configured with
CONFIG_SECCOMP enabled.
SECCOMP_MODE_FILTER (since Linux 3.5)
The allowed system calls are defined by a pointer to a Berkeley Packet
Filter passed in arg3. This argument is a pointer to struct sock_fprog; it
can be designed to filter arbitrary system calls and system call arguments.
See the description of SECCOMP_SET_MODE_FILTER in seccomp(2).
This operation is available only if the kernel is configured with
CONFIG_SECCOMP_FILTER enabled.
For further details on seccomp filtering, see seccomp(2).
PR_GET_SECCOMP (depuis Linux 2.6.23)
Return (as the function result) the secure computing mode of the calling thread.
If the caller is not in secure computing mode, this operation returns 0; if the
caller is in strict secure computing mode, then the prctl() call will cause a
SIGKILL signal to be sent to the process. If the caller is in filter mode, and this
system call is allowed by the seccomp filters, it returns 2; otherwise, the process
is killed with a SIGKILL signal.
This operation is available only if the kernel is configured with CONFIG_SECCOMP
enabled.
Since Linux 3.8, the Seccomp field of the /proc/pid/status file provides a method
of obtaining the same information, without the risk that the process is killed; see
proc(5).
PR_SET_SECUREBITS (depuis Linux 2.6.26)
Configurer l'attribut « securebits » du thread appelant à la valeur fournie par
arg2. Consultez capabilities(7).
PR_GET_SECUREBITS (depuis Linux 2.6.26)
Renvoyer (en résultat de fonction) l'état actuel de l'attribut « securebits » du
thread appelant. Consultez capabilities(7).
PR_GET_SPECULATION_CTRL (depuis Linux 4.17)
Renvoyer (en tant que résultat de la fonction) l'état de la fonction défectueuse de
spéculation indiquée dans arg2. Actuellement, la seule valeur autorisée pour ce
paramètre est PR_SPEC_STORE_BYPASS (sans quoi l'appel échoue avec l'erreur ENODEV).
Le code de retour utilise les bits 0 à 3 ayant la signification suivante :
PR_SPEC_PRCTL
L'atténuation peut être contrôlée par thread via PR_SET_SPECULATION_CTRL.
PR_SPEC_ENABLE
La fonction de spéculation est activée, l'atténuation est désactivée.
PR_SPEC_DISABLE
La fonction de spéculation est désactivée, l'atténuation est activée.
PR_SPEC_FORCE_DISABLE
Identique à PR_SPEC_DISABLE mais ne peut pas être annulé.
PR_SPEC_DISABLE_NOEXEC (depuis Linux 5.1)
Identique à PR_SPEC_DISABLE, mais l'état sera vidé pendant un execve(2).
Si tous les bits valent 0, le processeur n'est pas concerné par la fonction
défectueuse de spéculation.
Si PR_SPEC_PRCTL est positionné, le contrôle par thread de l'atténuation est
disponible. Sinon, prctl() échouera pour la fonction défectueuse de spéculation.
Les paramètres arg3, arg4 et arg5 doivent être indiqués en tant que 0 ; sinon
l'appel échoue avec l'erreur EINVAL.
PR_SET_SPECULATION_CTRL (depuis Linux 4.17)
Définir l'état de la fonction défectueuse de spéculation indiqué dans arg2. Ces
paramètres sont des attributs par thread.
Actuellement, arg2 doit valoir une des valeurs suivantes :
PR_SPEC_STORE_BYPASS
Définir l'état de la fonction défectueuse de contournement de stockage
spéculatif.
PR_SPEC_INDIRECT_BRANCH (depuis Linux 4.20)
Positionner l'état de la fonction défectueuse de spéculation de branche
indirecte.
Si arg2 n'a pas une des valeurs ci-dessus, l'appel échoue avec l'erreur ENODEV.
Le paramètre arg3 est utilisé pour récupérer le code de contrôle, qui peut être un
des suivants :
PR_SPEC_ENABLE
La fonction de spéculation est activée, l'atténuation est désactivée.
PR_SPEC_DISABLE
La fonction de spéculation est désactivée, l'atténuation est activée.
PR_SPEC_FORCE_DISABLE
Identique à PR_SPEC_DISABLE, mais ne peut pas être annulé. Un prctl(arg2,
PR_SPEC_ENABLE) ultérieur avec la même valeur pour arg2 échouera avec
l'erreur EPERM.
PR_SPEC_DISABLE_NOEXEC (depuis Linux 5.1)
Identique à PR_SPEC_DISABLE, mais l'état sera vidé lors d'un execve(2).
Actuellement, seul arg2 égal à PR_SPEC_STORE_BYPASS est pris en charge.
Toute valeur non valable de arg3 fera échouer l'appel avec l'erreur ERANGE.
Les paramètres arg4 et arg5 doivent être indiqués en tant que 0 ; sinon l'appel
échoue avec l'erreur EINVAL.
La fonctionnalité de spéculation peut aussi être gérée par l'option d'amorçage
spec_store_bypass_disable. Ce paramètre applique une règle de lecture seule qui
fera échouer un appel prctl() avec une erreur ENXIO. Pour de plus amples détails,
voir le fichier Documentation/admin-guide/kernel-parameters.txt des sources du
noyau.
PR_SVE_SET_VL (depuis Linux 4.15, seulement sur arm64)
Configurer la taille du vecteur SVE du thread comme indiqué dans (int) arg2. Les
paramètres arg3, arg4 et arg5 sont ignorés.
Les bits de arg2 correspondant à PR_SVE_VL_LEN_MASK doivent être positionnés sur la
taille souhaitée du vecteur en octets. Elle est interprétée comme une limite
supérieure : le noyau sélectionnera la taille de vecteur disponible la plus grande
qui ne dépasse pas celle indiquée. En particulier, indiquer SVE_VL_MAX (défini dans
<asm/sigcontext.h>) pour les bits PR_SVE_VL_LEN_MASK exige la taille maximale de
vecteur prise en charge.
En outre, les autres bits de arg2 doivent être positionnés sur une des combinaisons
suivantes d'attributs :
0 Effectuer les modifications immédiatement. Lors du prochain execve(2) dans
le thread, la taille du vecteur sera réinitialisée à celle configurée dans
/proc/sys/abi/sve_default_vector_length.
PR_SVE_VL_INHERIT
Effectuer les changements immédiatement. Les prochains appels execve(2)
préserveront la nouvelle taille du vecteur.
PR_SVE_SET_VL_ONEXEC
Différer la modification pour qu'elle soit effectuée au prochain execve(2)
dans le thread. Les appels execve(2) suivants réinitialiseront la taille du
vecteur à la valeur configurée dans /proc/sys/abi/sve_default_vector_length.
PR_SVE_SET_VL_ONEXEC | PR_SVE_VL_INHERIT
Différer la modification pour qu'elle soit effectuée au prochain execve(2)
dans le thread. Les prochains appels execve(2) préserveront la nouvelle
taille du vecteur.
Dans tous les cas, toute modification précédemment différée et en attente sera
annulée.
L'appel échoue avec l'erreur EINVAL si SVE n'est pas géré par la plateforme, si
arg2 n'est pas reconnu ou n'est pas valable, ou si la valeur des bits de arg2
correspondant à PR_SVE_VL_LEN_MASK dépasse la plage SVE_VL_MIN..SVE_VL_MAX ou n'est
pas un multiple de 16.
On success, a nonnegative value is returned that describes the selected
configuration. If PR_SVE_SET_VL_ONEXEC was included in arg2, then the configuration
described by the return value will take effect at the next execve(2). Otherwise,
the configuration is already in effect when the PR_SVE_SET_VL call returns. In
either case, the value is encoded in the same way as the return value of
PR_SVE_GET_VL. Note that there is no explicit flag in the return value
corresponding to PR_SVE_SET_VL_ONEXEC.
La configuration (y compris les modifications différées en attente) est récupérée
lors d'un fork(2) et d'un clone(2).
Pour plus d'informations, consultez le fichier Documentation/arm64/sve.rst dans les
sources du noyau (ou Documentation/arm64/sve.txt avant Linux 5.3).
Attention : le compilateur ou l'environnement d'exécution pouvant utiliser SVE,
l'utilisation de cet appel sans l'attribut PR_SVE_SET_VL_ONEXEC peut faire planter
le processus appelant. Les conditions nécessaires pour une utilisation sûre sont
complexes et dépendent du système. Ne l'utilisez pas sauf si vous savez vraiment ce
que vous faites.
PR_SVE_GET_VL (depuis Linux 4.15, seulement sur arm64)
Récupérer la configuration de la taille du vecteur SVE du thread actuel.
Les paramètres arg2, arg3, arg4 et arg5 sont ignorés.
Si le noyau et la plateforme gèrent SVE, cette opération réussit toujours, en
renvoyant une valeur non négative qui décrit la configuration actuelle. Les bits
correspondant à PR_SVE_VL_LEN_MASK contiennent la taille du vecteur actuellement
configuré en octets. Le bit correspondant à PR_SVE_VL_INHERIT indique si la taille
du vecteur sera récupérée à travers execve(2).
Remarquez qu'il n'y a aucun moyen de savoir s'il y a un changement de taille de
vecteur en attente non encore appliqué.
Pour plus d'informations, consultez le fichier Documentation/arm64/sve.rst dans les
sources du noyau (ou Documentation/arm64/sve.txt avant Linux 5.3).
PR_SET_SYSCALL_USER_DISPATCH (since Linux 5.11, x86 only)
Configure the Syscall User Dispatch mechanism for the calling thread. This
mechanism allows an application to selectively intercept system calls so that they
can be handled within the application itself. Interception takes the form of a
thread-directed SIGSYS signal that is delivered to the thread when it makes a
system call. If intercepted, the system call is not executed by the kernel.
To enable this mechanism, arg2 should be set to PR_SYS_DISPATCH_ON. Once enabled,
further system calls will be selectively intercepted, depending on a control
variable provided by user space. In this case, arg3 and arg4 respectively identify
the offset and length of a single contiguous memory region in the process address
space from where system calls are always allowed to be executed, regardless of the
control variable. (Typically, this area would include the area of memory containing
the C library.)
arg5 points to a char-sized variable that is a fast switch to allow/block system
call execution without the overhead of doing another system call to re-configure
Syscall User Dispatch. This control variable can either be set to
SYSCALL_DISPATCH_FILTER_BLOCK to block system calls from executing or to
SYSCALL_DISPATCH_FILTER_ALLOW to temporarily allow them to be executed. This value
is checked by the kernel on every system call entry, and any unexpected value will
raise an uncatchable SIGSYS at that time, killing the application.
When a system call is intercepted, the kernel sends a thread-directed SIGSYS signal
to the triggering thread. Various fields will be set in the siginfo_t structure
(see sigaction(2)) associated with the signal:
• si_signo will contain SIGSYS.
• si_call_addr will show the address of the system call instruction.
• si_syscall and si_arch will indicate which system call was attempted.
• si_code will contain SYS_USER_DISPATCH.
• si_errno will be set to 0.
The program counter will be as though the system call happened (i.e., the program
counter will not point to the system call instruction).
When the signal handler returns to the kernel, the system call completes
immediately and returns to the calling thread, without actually being executed. If
necessary (i.e., when emulating the system call on user space.), the signal handler
should set the system call return value to a sane value, by modifying the register
context stored in the ucontext argument of the signal handler. See sigaction(2),
sigreturn(2), and getcontext(3) for more information.
If arg2 is set to PR_SYS_DISPATCH_OFF, Syscall User Dispatch is disabled for that
thread. the remaining arguments must be set to 0.
The setting is not preserved across fork(2), clone(2), or execve(2).
For more information, see the kernel source file
Documentation/admin-guide/syscall-user-dispatch.rst
PR_SET_TAGGED_ADDR_CTRL (depuis Linux 5.4, seulement sur arm64)
Controls support for passing tagged user-space addresses to the kernel (i.e.,
addresses where bits 56—63 are not all zero).
Le niveau de prise en charge est sélectionné par arg2, qui peut prendre une des
valeurs suivantes :
0 Les adresses qui sont passées pour être déréférencées par le noyau doivent
être non labellisées.
PR_TAGGED_ADDR_ENABLE
Les adresses qui sont passées pour être déréférencées par le noyau doivent
être labellisées, sauf celles résumées ci-dessous.
Les autres arguments arg3, arg4 et arg5 doivent être nuls.
En cas de succès, le mode indiqué dans arg2 est positionné sur le thread appelant
et le code de retour est 0. Si les paramètres ne sont pas valables, le mode indiqué
dans arg2 n'est pas reconnu, ou si la fonctionnalité n'est pas prise en charge par
le noyau ou bien si elle est désactivée à l'aide de
/proc/sys/abi/tagged_addr_disabled, l'appel échoue avec l'erreur EINVAL.
En particulier, si prctl(PR_SET_TAGGED_ADDR_CTRL, 0, 0, 0, 0) échoue avec EINVAL,
toutes les adresses transmises au noyau doivent être non labellisées.
Indépendamment du mode défini, les adresses transmises à certaines interfaces
doivent toujours être non labellisées :
• brk(2), mmap(2), shmat(2), shmdt(2) et le paramètre new_address de mremap(2).
(avant Linux 5.6, ils acceptaient les adresses labellisées mais cela peut
entraîner un comportement non prévu. Ne vous y fiez pas).
• ‘polymorphic’ interfaces that accept pointers to arbitrary types cast to a void
* or other generic type, specifically prctl(), ioctl(2), and in general
setsockopt(2) (only certain specific setsockopt(2) options allow tagged
addresses).
Cette liste d'exceptions peut diminuer au fil des versions du noyau. Si le noyau
peut garantir une rétrocompatibilité, les effets de la transmission d'adresses
labellisées à ces interfaces ne sont pas spécifiés pour les nouveaux logiciels.
Le mode défini par cet appel est récupéré à travers fork(2) et clone(2). Le mode
est remis à 0 par execve(2) (c'est-à-dire les adresses labellisées ne sont pas
autorisées dans l'ABI de l'utilisateur ou du noyau).
Pour plus d'informations, consultez le fichier
Documentation/arm64/tagged-address-abi.rst dans les sources du noyau.
Attention : cet appel est d'abord conçu pour une utilisation par un environnement
d'exécution. Un appel PR_SET_TAGGED_ADDR_CTRL réussi peut, ailleurs, faire planter
le processus appelant. Les conditions pour une utilisation sûre sont complexes et
dépendantes du système. Ne l'utilisez pas sauf si vous savez ce que vous faites.
PR_GET_TAGGED_ADDR_CTRL (depuis Linux 5.4, seulement sur arm64)
Renvoyer le mode d'adressage étiqueté actuel du thread appelant.
Les paramètres arg2, arg3, arg4 et arg5 doivent être nuls.
Si les paramètres ne sont pas valables ou si cette fonctionnalité est désactivée ou
non prise en charge par le noyau, l'appel échoue avec EINVAL. En particulier, si
prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0) échoue avec EINVAL, cette fonction n'est
clairement pas prise en charge ou désactivée avec
/proc/sys/abi/tagged_addr_disabled. Dans ce cas, toutes les adresses transmises au
noyau doivent être non labellisées.
Sinon, l'appel renvoie une valeur non négative décrivant le mode d'adressage
labellisé actuel, encodé de la même manière que le paramètre arg2 de
PR_SET_TAGGED_ADDR_CTRL.
Pour plus d'informations, consultez le fichier
Documentation/arm64/tagged-address-abi.rst dans les sources du noyau.
PR_TASK_PERF_EVENTS_DISABLE (depuis Linux 2.6.31)
Désactiver tous les compteurs de performance attachés au processus appelant,
indépendamment du fait que ces compteurs ont été créés par ce processus ou par un
autre. Les compteurs de performance créés par le processus appelant pour d'autres
processus ne sont pas concernés. Pour plus d'informations sur les compteurs de
performance, consultez le fichier tools/perf/design.txt des sources du noyau Linux.
Initialement appelé PR_TASK_PERF_COUNTERS_DISABLE. Renommé (avec la même valeur
numérique) dans Linux 2.6.32.
PR_TASK_PERF_EVENTS_ENABLE (depuis Linux 2.6.31)
L'inverse de PR_TASK_PERF_EVENTS_DISABLE. Activer les compteurs de performance
attachés au processus appelant.
Initialement appelé PR_TASK_PERF_COUNTERS_ENABLE. Renommé dans Linux 2.6.32.
PR_SET_THP_DISABLE (depuis Linux 3.15)
Affecter l'état de l'attribut « THP disable » pour le thread appelant. Si arg2 a
une valeur non nulle, l'attribut est activé ; dans le cas contraire, il est
désactivé. L'utilisation de cet attribut fournit un moyen de supprimer les pages de
très grande taille correspondant à des travaux pour lesquels le code ne peut pas
être modifié, et dans les cas où le recours à des routines malloc associées à des
appels madvise(2) n'offre pas de solution (c'est-à-dire pour des données allouées
statiquement). L'activation de l'attribut « THP disable » est transmis aux enfants
créés au moyen de fork(2) et est conservé lors d'un appel à execve(2).
PR_GET_THP_DISABLE (depuis Linux 3.15)
Renvoyer (en résultat de fonction) le réglage actuel de l'attribut « THP disable »
du thread appelant, c'est à dire 1 si l'attribut est activé et 0 dans le cas
contraire.
PR_GET_TID_ADDRESS (depuis Linux 3.5)
Return the clear_child_tid address set by set_tid_address(2) and the clone(2)
CLONE_CHILD_CLEARTID flag, in the location pointed to by (int **) arg2. This
feature is available only if the kernel is built with the CONFIG_CHECKPOINT_RESTORE
option enabled. Note that since the prctl() system call does not have a compat
implementation for the AMD64 x32 and MIPS n32 ABIs, and the kernel writes out a
pointer using the kernel's pointer size, this operation expects a user-space buffer
of 8 (not 4) bytes on these ABIs.
PR_SET_TIMERSLACK (depuis Linux 2.6.28)
Chaque thread comporte deux valeurs de temporisation relâchée : une valeur
« default » et une valeur « current ». Cette opération positionne la valeur
« current » du temporisateur du thread appelant. arg2 est un entier long non signé,
la valeur « current » maximale est donc ULONG_MAX et celle minimale est 1. Si la
valeur en nanoseconde fournie dans arg2 est supérieure à zéro, la valeur
« current » est positionnée sur cette valeur. Si arg2 est égal à zéro, la
temporisation « current » est réinitialisée à la valeur « default » du thread.
La valeur « current » (actuelle) de temporisation relâchée est utilisée par le
noyau pour grouper les délais d'expiration des threads appelants qui sont proches
les uns des autres. Par conséquent, les délais d'expiration des threads pourraient
être en retard jusqu'au nombre de nanosecondes indiqué (mais jamais en avance). Le
groupement des délais d'expiration permet de réduire la consommation d'énergie du
système en minimisant les réveils du processeur.
Les délais d'expiration affectés par la temporisation relâchée sont ceux définis
par select(2), pselect(2), poll(2), ppoll(2), epoll_wait(2), epoll_pwait(2),
clock_nanosleep(2), nanosleep(2) et futex(2) (et donc les fonctions de bibliothèque
implémentées par futex, y compris pthread_cond_timedwait(3),
pthread_mutex_timedlock(3), pthread_rwlock_timedrdlock(3),
pthread_rwlock_timedwrlock(3) et sem_timedwait(3)).
La temporisation relâchée ne s'applique pas aux threads qui sont programmés avec
une stratégie d'ordonnancement en temps réel (consultez sched_setscheduler(2)).
Quand un nouveau thread est créé, les deux valeurs de temporisation relâchée sont
rendues identiques à la valeur « current » du thread qui l'a créé. Ensuite, un
thread peut ajuster sa valeur de temporisation relâchée « current » à l'aide de
PR_SET_TIMERSLACK. La valeur « default » ne peut pas être modifiée. Les valeurs de
temporisation relâchée d'init (PID 1), l'ancêtre de tous les processus, sont de
50 000 nanosecondes (50 microsecondes). Les valeurs de temporisation relâchée sont
transmises aux enfants créés avec fork(2) et sont préservées à travers execve(2).
Since Linux 4.6, the "current" timer slack value of any process can be examined and
changed via the file /proc/pid/timerslack_ns. See proc(5).
PR_GET_TIMERSLACK (depuis Linux 2.6.28)
Renvoyer (comme résultat de la fonction) la valeur « current » de temporisation
relâchée du thread appelant.
PR_SET_TIMING (depuis Linux 2.6.0)
Permettre de choisir la méthode de mesure du temps du processus à utiliser, en
passant dans arg2 soit PR_TIMING_STATISTICAL (méthode statistique traditionnelle)
ou PR_TIMING_TIMESTAMP (méthode exacte utilisant des horodatages).
PR_TIMING_TIMESTAMP n'est pas implémenté pour l'instant (l'utilisation de ce mode
renverra l'erreur EINVAL).
PR_GET_TIMING (depuis Linux 2.6.0)
Renvoyer (en résultat de fonction) quelle méthode de mesure du temps du processus
est utilisée actuellement.
PR_SET_TSC (depuis Linux 2.6.26, seulement sur x86)
Configurer l'état de l'attribut qui indique si le compteur d'horodatage peut être
lu par le processus. Utiliser PR_TSC_ENABLE pour arg2 permet d'autoriser les
lectures ou PR_TSC_SIGSEGV pour produire un SIGSEGV quand le processus essaie de
lire le compteur d'horodatage.
PR_GET_TSC (depuis Linux 2.6.26, seulement sur x86)
Return the state of the flag determining whether the timestamp counter can be read,
in the location pointed to by (int *) arg2.
PR_SET_UNALIGN
(Seulement sur : ia64, depuis Linux 2.3.48 ; parisc, depuis Linux 2.6.15 ; PowerPC,
depuis Linux 2.6.18 ; Alpha, depuis Linux 2.6.22 ; sh, depuis Linux 2.6.34 ; tile,
depuis Linux 3.12). Définir les bits de contrôle pour les accès non alignés à arg2.
La valeur PR_UNALIGN_NOPRINT signifie que les accès non alignés en espace
utilisateur sont silencieusement corrigés, et PR_UNALIGN_SIGBUS cause l'envoi de
SIGBUS lors d'un accès utilisateur non aligné. Alpha gère aussi un attribut
supplémentaire dont la valeur est 4 et qui n'a pas de constante correspondante
nommée, qui demande au noyau de corriger les accès non alignés (il revient à
utiliser l'attribut UAC_NOFIX dans l'opération SSI_NVPAIRS de l'appel système
setsysinfo() sur Tru64).
PR_GET_UNALIGN
(See PR_SET_UNALIGN for information on versions and architectures.) Return
unaligned access control bits, in the location pointed to by (unsigned int *) arg2.
VALEUR RENVOYÉE
On success, PR_CAP_AMBIENT+PR_CAP_AMBIENT_IS_SET, PR_CAPBSET_READ, PR_GET_DUMPABLE,
PR_GET_FP_MODE, PR_GET_IO_FLUSHER, PR_GET_KEEPCAPS, PR_MCE_KILL_GET, PR_GET_NO_NEW_PRIVS,
PR_GET_SECUREBITS, PR_GET_SPECULATION_CTRL, PR_SVE_GET_VL, PR_SVE_SET_VL,
PR_GET_TAGGED_ADDR_CTRL, PR_GET_THP_DISABLE, PR_GET_TIMING, PR_GET_TIMERSLACK, and (if it
returns) PR_GET_SECCOMP return the nonnegative values described above. All other option
values return 0 on success. On error, -1 is returned, and errno is set to indicate the
error.
ERREURS
EACCES option vaut PR_SET_SECCOMP et arg2 vaut SECCOMP_MODE_FILTER, mais le processus n'a
pas la capacité CAP_SYS_ADMIN ou n'a pas positionné l'attribut no_new_privs (voir
le point sur PR_SET_NO_NEW_PRIVS ci-dessus).
EACCES option vaut PR_SET_MM, et arg3 vaut PR_SET_MM_EXE_FILE, le fichier n'est pas
exécutable.
EBADF option vaut PR_SET_MM, arg3 vaut PR_SET_MM_EXE_FILE, et le descripteur de fichier
passé dans le paramètre arg4 n'est pas valable.
EBUSY option is PR_SET_MM, arg3 is PR_SET_MM_EXE_FILE, and this the second attempt to
change the /proc/pid/exe symbolic link, which is prohibited.
EFAULT arg2 est une adresse non valable.
EFAULT option vaut PR_SET_SECCOMP,, arg2 vaut SECCOMP_MODE_FILTER, le système a été
construit avec CONFIG_SECCOMP_FILTER et arg2 n'est pas une adresse valable.
EFAULT option is PR_SET_SYSCALL_USER_DISPATCH and arg5 has an invalid address.
EINVAL La valeur de option n'est pas reconnue ou n'est pas prise en charge sur ce système.
EINVAL option vaut PR_MCE_KILL, PR_MCE_KILL_GET ou PR_SET_MM, et les paramètres non
utilisés de prctl() n'ont pas été réglés à zéro.
EINVAL arg2 n'est pas une valeur valable pour cette option.
EINVAL option vaut PR_SET_SECCOMP ou PR_GET_SECCOMP et le noyau n'a pas été configuré avec
CONFIG_SECCOMP.
EINVAL option vaut PR_SET_SECCOMP, arg2 vaut SECCOMP_MODE_FILTER et le noyau n'a pas été
configuré avec CONFIG_SECCOMP_FILTER.
EINVAL option vaut PR_SET_MM, et l'une des assertions suivantes est vraie :
• arg4 ou arg5 est non nul ;
• arg3 est strictement plus grand que TASK_SIZE (la limite sur la taille de
l'espace d'adressage utilisateur pour cette architecture) ;
• arg2 vaut PR_SET_MM_START_CODE, PR_SET_MM_END_CODE, PR_SET_MM_START_DATA,
PR_SET_MM_END_DATA ou PR_SET_MM_START_STACK, et les permissions pour la zone de
mémoire correspondante ne satisfont pas les conditions requises ;
• arg2 vaut PR_SET_MM_START_BRK ou PR_SET_MM_BRK, et arg3 est inférieur ou égal à
la fin du segment de données, ou indique une valeur qui causerait le dépassement
de la limite de ressource RLIMIT_DATA.
EINVAL option vaut PR_SET_PTRACER et arg2 ne vaut ni 0, ni PR_SET_PTRACER_ANY, ni le PID
d'un processus existant.
EINVAL option vaut PR_SET_PDEATHSIG et arg2 n'est pas un numéro de signal valable.
EINVAL option vaut PR_SET_DUMPABLE et arg2 ne vaut ni SUID_DUMP_DISABLE, ni
SUID_DUMP_USER.
EINVAL option vaut PR_SET_TIMING et arg2 n'a pas la valeur PR_TIMING_STATISTICAL.
EINVAL option vaut PR_SET_NO_NEW_PRIVS et arg2 ne vaut pas 1, ou arg3, arg4 ou arg5 est
non nul.
EINVAL option vaut PR_GET_NO_NEW_PRIVS et arg2, arg3, arg4 ou arg5 est non nul.
EINVAL option vaut PR_SET_THP_DISABLE et arg3, arg4 ou arg5 est non nul.
EINVAL option vaut PR_GET_THP_DISABLE et arg2, arg3, arg4 ou arg5 est non nul.
EINVAL option vaut PR_CAP_AMBIENT et un paramètre inutilisé (arg4, arg5 ou, dans le cas de
PR_CAP_AMBIENT_CLEAR_ALL, arg3) ne vaut pas zéro ; ou bien arg2 a une valeur non
valable ; ou arg2 vaut PR_CAP_AMBIENT_LOWER, PR_CAP_AMBIENT_RAISE ou
PR_CAP_AMBIENT_IS_SET et arg3 n'indique pas de capacité valable.
EINVAL option valait PR_GET_SPECULATION_CTRL ou PR_SET_SPECULATION_CTRL et des paramètres
inutilisés de prctl() ne valent pas 0. EINVAL option vaut PR_PAC_RESET_KEYS et les
paramètres ne sont pas valables ou non pris en charge. Voir la description de
PR_PAC_RESET_KEYS ci-dessus pour des détails.
EINVAL option vaut PR_SVE_SET_VL et les paramètres ne sont pas valables ou ne sont pas
pris en charge, ou bien SVE n'est pas disponible sur cette plateforme. Voir la
description de PR_SVE_SET_VL ci-dessus pour des détails.
EINVAL option vaut PR_SVE_GET_VL et SVE n'est pas disponible sur cette plateforme.
EINVAL option is PR_SET_SYSCALL_USER_DISPATCH and one of the following is true:
• arg2 is PR_SYS_DISPATCH_OFF and the remaining arguments are not 0;
• arg2 is PR_SYS_DISPATCH_ON and the memory range specified is outside the address
space of the process.
• arg2 is invalid.
EINVAL option vaut PR_SET_TAGGED_ADDR_CTRL et les paramètres ne sont pas valables ou ne
sont pas pris en charge. Voir la description de PR_SET_TAGGED_ADDR_CTRL ci-dessus
pour des détails.
EINVAL option vaut PR_GET_TAGGED_ADDR_CTRL et les paramètres ne sont pas valables ou ne
sont pas pris en charge. Voir la description de PR_GET_TAGGED_ADDR_CTRL pour des
détails.
ENODEV option vaut PR_SET_SPECULATION_CTRL et le noyau ou le processeur ne gère pas la
fonction défectueuse de spéculation demandée.
ENXIO option vaut PR_MPX_ENABLE_MANAGEMENT ou PR_MPX_DISABLE_MANAGEMENT et le noyau ou le
processeur ne prennent pas en charge la gestion de MPX. Vérifiez que le noyau et le
processeur gèrent le MPX.
ENXIO option vaut PR_SET_SPECULATION_CTRL, impliquant que le contrôle de la fonction
défectueuse de spéculation sélectionnée n'est pas possible. Voir les champs de bit
de PR_GET_SPECULATION_CTRL pour savoir les options disponibles.
EOPNOTSUPP
option vaut PR_SET_FP_MODE et arg2 a une valeur non prise en charge ou non valable.
EPERM option vaut PR_SET_SECUREBITS et l'appelant n'a pas la capacité CAP_SETPCAP, a
essayé d'enlever un attribut de « verrouillage » ou a essayé de positionner un
attribut pour lequel l'attribut de verrouillage était positionné (consultez
capabilities(7)).
EPERM option vaut PR_SET_SPECULATION_CTRL alors que la spéculation est désactivée avec
PR_SPEC_FORCE_DISABLE et l'appelant a essayé de la réactiver.
EPERM option vaut PR_SET_KEEPCAPS et l'attribut SECBIT_KEEP_CAPS_LOCKED de l'appelant est
positionné (consultez capabilities(7)).
EPERM option vaut PR_CAPBSET_DROP et l'appelant n'a pas la capacité CAP_SETPCAP.
EPERM option vaut PR_SET_MM et l'appelant n'a pas la capacité CAP_SYS_RESOURCE.
EPERM option vaut PR_CAP_AMBIENT et arg2 vaut PR_CAP_AMBIENT_RAISE, mais soit la capacité
indiquée dans arg3 n'est pas présente dans les capacités autorisées et récupérables
du processus, ou bien le bit de sécurité PR_CAP_AMBIENT_LOWER a été positionné.
ERANGE option vaut PR_SET_SPECULATION_CTRL et arg3 ne vaut ni PR_SPEC_ENABLE, ni
PR_SPEC_DISABLE, ni PR_SPEC_FORCE_DISABLE, ni PR_SPEC_DISABLE_NOEXEC.
VERSIONS
L'appel système prctl() a été introduit dans Linux 2.1.57.
STANDARDS
Cet appel système est spécifique à Linux. IRIX dispose d'un appel système prctl()
(également introduit dans Linux 2.1.44 sur l'architecture MIPS sous le nom irix_prctl),
dont le prototype est
ptrdiff_t prctl(int option, int arg2, int arg3);
et les options permettent de d'obtenir le nombre maximal de processus par utilisateur,
d’obtenir le nombre maximal de processeurs utilisables par un processus, de vérifier si un
processus est bloqué, d’obtenir ou de définir la taille maximale de la pile, etc.
VOIR AUSSI
signal(2), core(5)
TRADUCTION
La traduction française de cette page de manuel a été créée par Christophe Blaess
<https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry
Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>,
Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-
luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux
<thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
Barbier <barbier@debian.org>, David Prévot <david@tilapin.org>, Cédric Boutillier
<cedric.boutillier@gmail.com>, Frédéric Hantrais <fhantrais@gmail.com> et Jean-Philippe
MENGUAL <jpmengual@debian.org>
Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General
Public License version 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les
conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
message à ⟨debian-l10n-french@lists.debian.org⟩.