prctl(2) System Calls Manual prctl(2) NOM prctl - Operations sur un processus ou un thread BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include int prctl(int op, ... /* unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5 */ ); DESCRIPTION prctl() gere divers aspects du comportement du thread ou du processus appelant. Notez qu'une utilisation peu soigneuse de certaines operations de prctl() peut perdre l'environnement d'execution de l'espace utilisateur, donc il faut les utiliser avec rigueur. prctl() est invoque avec un premier parametre indiquant ce qu'il faut faire, (ses valeurs sont definies dans ), et des parametres supplementaires dont la signification depend du premier parametre. Celui-ci peut etre : PR_CAP_AMBIENT (depuis Linux 4.3) Lire ou modifier l'ensemble environnant des capacites parametrees sur le thread appelant, en fonction de la valeur de arg2, qui doit etre une des suivantes : PR_CAP_AMBIENT_RAISE La capacite indiquee dans arg3 est ajoutee a l'ensemble environnant. Elle doit etre deja presente dans les ensembles environnants autorises et herites du processus. Cette operation n'est pas autorisee si le bit de securite SECBIT_NO_CAP_AMBIENT_RAISE est positionne. PR_CAP_AMBIENT_LOWER La capacite indiquee dans arg3 est supprimee de l'ensemble environnant. PR_CAP_AMBIENT_IS_SET L'appel prctl() renvoie 1 si la capacite indiquee dans arg3 est dans l'ensemble environnant et, sinon, 0. PR_CAP_AMBIENT_CLEAR_ALL Toutes les capacites seront supprimees de l'ensemble environnant. Cette operation implique que arg3 soit positionne sur zero. Dans toutes les operations ci-dessus, arg4 et arg5 doivent valoir 0. Des interfaces de plus haut niveau qui constituent la couche au-dessus des operations ci-dessus sont fournies dans la bibliotheque 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 resultat de fonction) 1 si la capacite indiquee par arg2 est presente dans l'ensemble limitant de capacites du thread appelant ou 0 si elle ne l'est pas. Les constantes des capacites sont definies dans . L'ensemble limitant les capacites controle si le processus peut recevoir la capacite par un ensemble de capacites autorisees pour un fichier lors d'un appel futur a execve(2). Si la capacite indiquee dans arg2 n'est pas valable, alors l'appel echoue avec l'erreur EINVAL. Une interface de plus haut niveau constituant la couche par-dessus cette operation est fournie dans la bibliotheque libcap(3) sous la forme cap_get_bound(3). PR_CAPBSET_DROP (depuis Linux 2.6.25) Si le thread appelant a la capacite CAP_SETPCAP dans son espace de noms utilisateur, alors enlever la capacite indiquee par arg2 dans l'ensemble de limitation de capacites du thread appelant. Les enfants du thread appelant heriteront de cette nouvelle limitation de capacites reduite. L'appel echoue avec l'erreur EPERM si le thread appelant n'a pas la capacite CAP_SETPCAP ; ou avec l'erreur EINVAL si arg2 ne represente pas une capacite correcte ; ou avec l'erreur EINVAL si les capacites de fichier ne sont pas activees 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 operation est fournie par la bibliotheque libcap(3) sous la forme cap_drop_bound(3). PR_SET_CHILD_SUBREAPER (depuis Linux 3.4) Si arg2 ne vaut pas zero, positionner l'attribut << child subreaper >> du processus appelant ; si arg2 vaut zero, deconfigurer l'attribut. Un subreaper (suppresseur) joue le role de init(1) pour ses processus enfants. Quand un processus devient orphelin (c'est-a-dire, que son parent le plus proche se termine), ce processus sera adopte par le subreaper parent toujours vivant le plus proche. Par consequent, les appels getppid(2) dans le processus orphelin renverront desormais 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 detecter son etat de fin. Le parametre de l'attribut << child subreaper >> n'est pas recupere par les enfants crees par fork(2) et clone(2). Le parametre est preserve lors d'un execve(2). Etablir un processus subreaper est utile dans les environnements de gestion de sessions ou un groupe hierarchique de processus est gere par un processus subreaper qui a besoin de savoir quand un des processus -- par exemple, un demon forke deux fois -- se termine (pour pouvoir peut-etre redemarrer ce processus). Certains environnements init(1) (comme systemd(1)) utilisent un processus subreaper pour les memes raisons. PR_GET_CHILD_SUBREAPER (depuis Linux 3.4) Renvoyer l'etat << child subreaper >> du processus appelant, dans l'emplacement pointe par (int *) arg2. PR_SET_DUMPABLE (depuis Linux 2.3.20) Definir l'etat de l'attribut << dumpable >> qui determine si les fichiers de vidages memoire (core dump) sont produits pour le processus appelant lors de l'envoi du signal, dont le comportement par defaut est de produire un fichier d'image memoire. Dans les noyaux jusqu'a 2.6.12 inclus, arg2 doit valoir 0 (SUID_DUMP_DISABLE, pas de vidage memoire) ou 1 (SUID_DUMP_USER, vidage possible). Entre les noyaux 2.6.13 et 2.6.17, la valeur 2 etait egalement autorisee ; elle permettait a un binaire qui ne produirait normalement pas de fichier de vidage d'en creer un lisible uniquement par root ; cette fonctionnalite a ete supprimee pour des raisons de securite (consultez aussi la description de /proc/sys/fs/suid_dumpable dans proc(5)). Normalement, l'attribut << dumpable >> est positionne sur 1. Cependant, il est positionne sur la valeur actuelle du fichier /proc/sys/fs/suid_dumpable (qui a une valeur de 0 par defaut), dans les circonstances suivantes : - L'identifiant d'utilisateur ou de groupe effectif du processus a ete modifie. - L'identifiant d'utilisateur ou de groupe du systeme de fichiers du processus a ete modifie (voir credentials(7)). - Le processus execute (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 execute (execve(2)) un programme qui a les capacites de fichier (voir capabilities(7)), mais seulement si les capacites acquises ainsi autorisees depassent celles autorisees pour le processus. Les processus qui ne generent pas de fichier de vidage ne peuvent pas etre rattaches a l'aide de PTRACE_ATTACH de ptrace(2) ; voir ptrace(2) pour plus de details. Si un processus ne genere pas de fichier de vidage, l'appartenance des fichiers du repertoire /proc/pid du processus est modifiee comme le decrit proc(5). PR_GET_DUMPABLE (depuis Linux 2.3.20) Renvoyer (en resultat de fonction) l'etat actuel de l'attribut de creation de fichier de vidage du processus appelant. PR_SET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC) Definir le boutisme (endianness) du processus appelant a la valeur donnee dans arg2, qui doit etre l'une des valeurs suivantes : PR_ENDIAN_BIG, PR_ENDIAN_LITTLE, ou PR_ENDIAN_PPC_LITTLE (PowerPC pseudo petit boutiste). PR_GET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC) Renvoyer le boutisme (endianness) du processus appelant, dans l'emplacement pointe par (int *) arg2. PR_SET_FP_MODE (depuis Linux 4.0, seulement sur MIPS) Sur l'architecture MIPS, le code en espace utilisateur peut etre construit en utilisant une ABI qui permet l'edition de liens avec du code ayant des exigences de virgule flottante (FP) plus restrictives. Par exemple, un code en espace utilisateur peut etre construit pour cibler l'ABI FPXX O32 et lie au code construit pour une ou plusieurs ABI plus restrictives FP32 ou FP64. Quand du code plus restrictif est lie, l'exigence supplementaire du processus est d'utiliser le mode de virgule flottante plus restrictif. Le noyau n'ayant aucun moyen de savoir a l'avance le mode dans lequel doit etre execute le processus, et ces restrictions pouvant changer durant la vie du processus, l'operation PR_SET_FP_MODE est fournie pour permettre un controle du mode de virgule flottante a partir de l'espace utilisateur. L'argument (unsigned int) arg2 est un masque de bits decrivant le mode de virgule flottante utilise : PR_FP_MODE_FR Quand le bit est unset (ce qui est appele le mode FR=0 ou FR0), les registres 32 de virgule flottante ont une taille de 32 bits et ceux 64 bits sont representes sous forme de paire de registres (numerotes 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 materiel pris en charge), les registres 32 de virgule flottante ont une taille de 64 bits (ce qui est appele le mode FR=1 ou FR1). Remarquez que les implementations MIPS modernes (MIPS R6 et plus recentes) ne gerent que le mode FR=1. Les applications qui utilisent l'ABI O32 FP32 ne peuvent fonctionner que lorsque ce bit est unset (FR=0 ; ou elles peuvent etre utilisees avec FRE active, voir ci-dessous). Les applications qui utilisent l'ABI O32 FP64 (et l'ABI O32 FP64A qui existe pour offrir la capacite d'agir avec le code FP32 existant ; voir ci-dessous) ne peuvent agir que quand ce bit est set (FR=1). Les applications qui utilisent l'ABI O32 FPXX peuvent agir avec FR=0 ou FR=1. PR_FP_MODE_FRE Activer l'emulation du mode flottant 32 bits. Quand ce mode est active, il emule les operations de virgule flottante 32 bits en placant une exception d'instruction reservee sur chaque instruction utilisant les formats 32 bits et le noyau prend alors en charge l'instruction au niveau logiciel (c'est le probleme du decalage entre la gestion des registres aux numeros pairs , qui sont les 32 bits superieurs des registres 64 bits ayant les numeros impairs en mode FR=0, et les parties 32 bits de poids faible des registres 64 bits de numeros impairs en mode FR=1). L'activation de ce bit est necessaire 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 execute sur du materiel plus recent (apres MIPS R6) qui ne prend pas en charge le mode FR=0 quand un binaire avec l'ABI FP32 est utilise. 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'emulation a par nature des consequences en termes de performance et qu'elle doit etre evitee si possible. Dans l'ABI N32/N64, le mode de virgule flottante 64 bits est toujours utilise, l'emulation FPU n'est donc pas necessaire et le mode FPU agit toujours en mode FR=1. Cette operation vise principalement les editeurs de liens dynamiques (ld.so(8)). Les parametres arg3, arg4 et arg5 sont ignores. PR_GET_FP_MODE (depuis Linux 4.0, seulement sur MIPS) Renvoyer (comme resultat de la fonction) le mode de virgule flottante actuel (voir la description de PR_SET_FP_MODE pour les details). En cas de succes, l'appel renvoie un masque de bits qui represente le mode de virgule flottante actuel. Les parametres arg2, arg3, arg4 et arg5 sont ignores. PR_SET_FPEMU (depuis Linux 2.4.18, 2.5.9, seulement sur ia64) Definir les bits de controle de l'emulation de virgule flottante a arg2. Passer PR_FPEMU_NOPRINT pour emuler silencieusement les operations de virgule flottante, ou PR_FPEMU_SIGFPE pour ne pas emuler ces operations et envoyer SIGFPE. PR_GET_FPEMU (depuis Linux 2.4.18, 2.5.9, seulement sur ia64) Renvoyer les bits de controle de l'emulation de FPU dans l'emplacement vers lequel pointe (int *) arg2. PR_SET_FPEXC (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC) Definir le mode d'exception de virgule flottante a 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 zero, PR_FP_EXC_OVF pour les depassements de capacite vers le haut, PR_FP_EXC_UND pour les depassements de capacite vers le bas, PR_FP_EXC_RES pour les resultats de flottant inexacts, PR_FP_EXC_INV pour les operations de flottant non valables, PR_FP_EXC_DISABLED pour desactiver les exceptions de flottant, PR_FP_EXC_NONRECOV pour le mode d'exception asynchrone non recuperable, PR_FP_EXC_ASYNC pour le mode d'exception asynchrone recuperable, PR_FP_EXC_PRECISE pour le mode d'exception de precision. PR_GET_FPEXC (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC) Renvoyer le mode d'exception de virgule flottante dans l'emplacement vers lequel pointe (int *) arg2. PR_SET_IO_FLUSHER (depuis Linux 5.6) Si le processus d'un utilisateur est implique dans la couche de blocs ou le chemin d'E/S du systeme de fichiers, et s'il peut allouer de la memoire en traitant les requetes E/S, il doit positionner arg2 sur 1. Cela mettra le processus en etat IO_FLUSHER, ce qui lui accorde un traitement special pour progresser lors de l'allocation de la memoire. Si arg2 vaut 0, le processus effacera l'etat IO_FLUSHER et le comportement par defaut sera utilise. Le processus appelant doit avoir la capacite CAP_SYS_RESOURCE. arg3, arg4 et arg5 doivent valoir 0. L'etat IO_FLUSHER est recupere par un processus enfant cree a l'aide de fork(2) et il est preserve pendant un execve(2). Des exemples d'applications IO_FLUSHER sont les demons FUSE, ceux d'emulation de peripheriques SCSI et ceux gerant des erreurs comme les applications de recuperation de chemins multipath. PR_GET_IO_FLUSHER (depuis Linux 5.6) Renvoyer (en tant que resultat de la fonction) l'etat IO_FLUSHER de l'appelant. Une valeur de 1 indique que l'appelant est dans l'etat IO_FLUSHER ; 0 indique qu'il n'est pas dans cet etat. Le processus appelant doit avoir la capacite CAP_SYS_RESOURCE. arg2, arg3, arg4 et arg5 doivent valoir zero. PR_SET_KEEPCAPS (depuis Linux 2.2.18) Definir l'etat de l'attribut << keep capabilities >> du thread appelant. L'effet de cet attribut est decrit dans capabilities(7). arg2 doit valoir soit 0 (effacer l'attribut), soit 1 (positionner l'attribut). La valeur de << keep capabilities >> sera remise a 0 lors des prochains appels a execve(2). PR_GET_KEEPCAPS (depuis Linux 2.2.18) Renvoyer (en resultat de fonction) l'etat actuel de l'attribut de conservation des capacites du thread appelant. Voir capabilities(7) pour une description de cet attribut. PR_MCE_KILL (depuis Linux 2.6.32) Definir la politique de suppression de memoire corrompue de la machine pour le thread actuel. Si arg2 vaut PR_MCE_KILL_CLEAR, effacer la politique de suppression de memoire corrompue et utiliser la valeur par defaut du systeme (qui est definie dans /proc/sys/vm/memory_failure_early_kill, consultez proc(5)). Si arg2 vaut PR_MCE_KILL_SET, utiliser une politique de suppression de memoire corrompue specifique au thread. Dans ce cas, arg3 definit si la politique est immediate (early kill avec PR_MCE_KILL_EARLY), differee (late kill avec PR_MCE_KILL_LATE), ou la valeur par defaut du systeme (PR_MCE_KILL_DEFAULT). Une suppression immediate signifie que le thread recoit un signal SIGBUS des que la corruption memoire materielle est detectee a l'interieur de son espace d'adressage. En mode differe, le processus n'est tue que lorsqu'il accede a une page corrompue. Consultez sigaction(2) pour plus d'informations sur le signal SIGBUS. Cette politique est heritee par les enfants. Les arguments restants de prctl(), non utilises, doivent etre mis a zero pour preparer la future compatibilite. PR_MCE_KILL_GET (depuis Linux 2.6.32) Renvoyer (comme resultat de la fonction) la politique actuelle par processus de suppression de memoire corrompue. Tous les arguments de prctl() non utilises doivent etre zero PR_SET_MM (depuis Linux 3.3) Modifier certains champs du descripteur de projection de memoire du noyau pour le processus appelant. D'habitude, ces champs sont determines 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 fonctionnalite. En revanche, dans certaines situations, telles que celles de programmes se modifiant eux-memes, un programme pourra trouver utile de pouvoir changer sa propre projection en memoire. Le processus appelant doit avoir la capacite CAP_SYS_RESOURCE. La valeur de arg2 est une des options ci-dessous, tandis que arg3 fournit la nouvelle valeur pour l'option. Les parametres de arg4 et de arg5 doivent etre de 0 s'ils ne sont pas utilises. Avant Linux 3.10, cette fonctionnalite n'est disponible que si le noyau est construit avec l'option CONFIG_CHECKPOINT_RESTORE. PR_SET_MM_START_CODE Definir l'adresse au dessus de laquelle le texte du programme peut etre execute. La zone de memoire correspondante doit etre accessible en lecture et en execution, mais pas en ecriture et ne doit pas pouvoir etre partagee (consultez mprotect(2) et mmap(2) pour plus d'informations). PR_SET_MM_END_CODE Definir l'adresse en dessous de laquelle le texte du programme peut etre execute. La zone de memoire correspondante doit etre accessible en lecture et en execution, mais pas en ecriture et ne doit pas pouvoir etre partagee. PR_SET_MM_START_DATA Definir l'adresse au-dessus de laquelle les donnees initialisees et non initialisees (bss) sont placees. La zone de memoire correspondante doit etre accessible en lecture et en ecriture, mais pas en execution et ne doit pas pouvoir etre partagee. PR_SET_MM_END_DATA Definir l'adresse en dessous de laquelle les donnees initialisees et non initialisees (bss) sont placees. La zone de memoire correspondante doit etre accessible en lecture et en ecriture, mais pas en execution et ne doit pas pouvoir etre partagee. PR_SET_MM_START_STACK Selectionner l'adresse du debut de la pile. La region de memoire correspondante doit etre accessible en lecture et en ecriture. PR_SET_MM_START_BRK Selectionner l'adresse au-dessus de laquelle le tas du programme peut etre etendu avec l'appel brk(2). L'adresse doit etre au-dessus de l'adresse terminant le segment de donnees actuel du programme. De plus, la taille combinee du tas obtenu et du segment de donnees ne peut pas depasser la limite de ressource RLIMIT_DATA (consultez setrlimit(2)). PR_SET_MM_BRK Selectionnez la valeur actuelle de brk(2). Les conditions pour l'adresse sont les memes que pour l'option PR_SET_MM_START_BRK. Les options suivantes sont disponibles depuis Linux 3.5. PR_SET_MM_ARG_START Selectionner l'adresse au-dessus de laquelle la ligne de commande du programme est placee. PR_SET_MM_ARG_END Selectionner l'adresse en dessous de laquelle la ligne de commande du programme est placee. PR_SET_MM_ENV_START Selectionner l'adresse au-dessus de laquelle l'environnement du programme est place. PR_SET_MM_ENV_END Selectionner l'adresse en dessous de laquelle l'environnement du programme est place. 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 a l'espace memoire d'une pile de processus. Par consequent, l'espace memoire correspondant doit etre accessible en lecture, en ecriture et (selon la configuration du noyau) disposer de l'attribut MAP_GROWSDOWN defini (consultez mmap(2)). PR_SET_MM_AUXV Selectionner le nouveau vecteur auxiliaire. Le parametre arg3 doit fournir l'adresse du vecteur. Le parametre arg4 est la taille du vecteur. PR_SET_MM_EXE_FILE Remplacer le lien symbolique /proc/pid/exe par un nouveau lien pointant vers un nouveau fichier executable identifie par le descripteur de fichier fourni a l'aide du parametre arg3. Le descripteur de fichier peut etre obtenu au moyen d'un appel a open(2). Pour changer le lien symbolique, il faut supprimer tous les espaces alloues en memoire et contenant du code executable, y compris ceux crees par le noyau (par exemple, le noyau cree en general au moins un espace memoire d'executable pour la section ELF .text). Sur Linux 4.9 et anterieurs, l'operation PR_SET_MM_EXE_FILE ne peut etre effectuee qu'une fois dans la vie d'un processus ; si on l'effectue une seconde fois, elle donnera l'erreur EPERM. Cette restriction a ete renforcee pour des raisons de securite jugees plus tard curieuses, donc la restriction a ete supprimee dans Linux 4.10 car certaines applications en espace utilisateur avaient besoin d'effectuer cette operation plus d'une fois. Les options suivantes sont disponibles depuis Linux 3.18. PR_SET_MM_MAP Fournir un acces unique a toutes les adresses en passant une struct prctl_mm_map (comme defini dans ). Le parametre arg4 doit fournir la taille de la structure. Cette fonctionnalite n'est disponible que si le noyau a ete construit avec l'option CONFIG_CHECKPOINT_RESTORE activee. PR_SET_MM_MAP_SIZE Renvoyer la taille attendue par le noyau de la struct prctl_mm_map. Cela permet a l'espace utilisateur de trouver une structure compatible. Le parametre arg4 doit etre un pointeur vers un entier non signe. Cette fonctionnalite n'est disponible que si le noyau a ete construit avec l'option CONFIG_CHECKPOINT_RESTORE activee. PR_SET_VMA (depuis Linux 5.17) Positionner un attribut indique dans arg2 pour les zones de memoire virtuelles commencant a l'adresse indiquee dans arg3 et couvrant la taille indiquee dans arg4. arg5 indique la valeur de l'attribut a positionner. Remarquez que l'affectation d'un attribut a une zone de memoire virtuelle pourrait l'empecher de se fusionner avec les zones adjacentes du fait d'une difference de valeur de cet attribut. Actuellement, arg2 doit valoir une des valeurs suivantes : PR_SET_VMA_ANON_NAME Definir un nom pour les zones de memoire virtuelle anonymes. arg5 doit etre un pointeur vers une chaine se terminant par l'octet NULL contenant le nom. La taille du nom, y compris l'octet NULL, ne peut pas depasser 80 octets. Si arg5 vaut NULL, le nom des zones de memoire virtuelle anonymes adequat sera reinitialise. Le nom ne peut contenir que des caracteres ASCII imprimables (dont des espaces), sauf << [ >>, << ] >>, << \ >>, << $ >> et << ` >>. PR_MPX_ENABLE_MANAGEMENT PR_MPX_DISABLE_MANAGEMENT (depuis Linux 3.19, supprimee dans Linux 5.4 ; seulement sur x86) Activer ou desactiver la gestion par le noyau des tables de limitations Memory Protection eXtensions (MPX). Les parametres arg2, arg3, arg4 et arg5 doivent valoir zero. MPX est un mecanisme assiste par le materiel pour effectuer des controles de limites sur les pointeurs. Il consiste dans un ensemble de registres stockant les informations des limites et un ensemble de prefixes d'instruction speciaux qui disent au processeur sur quelle instruction il doit poser des limites renforcees. Il existe un nombre limite de ces registres et quand il y a plus de pointeurs que de registres, leur contenu doit etre << deverse >> (spilled) dans un ensemble de tables. Ces tables s'appellent des << bounds tables >> et les operations prctl() de MPX decident si le noyau gere leur allocation ou leur liberation. Quand la gestion est activee, le noyau prendra en charge l'allocation et la liberation des tables de limites. Il le fait en piegeant les exceptions #BR qui conduisent d'abord a l'utilisation de tables de limites manquantes, et au lieu d'envoyer l'exception a l'espace utilisateur, il alloue la table et remplit le repertoire des limites avec l'emplacement de la nouvelle table. Pour la liberation, le noyau verifie dans les tables de limites la presence de memoire non allouee et les libere. Avant d'activer la gestion MPX en utilisant PR_MPX_ENABLE_MANAGEMENT, l'application doit d'abord avoir alloue un tampon dans l'espace utilisateur pour le repertoire de limites, et place l'emplacement de ce repertoire dans le registre bndcfgu. Ces appels echouent si le processeur ou le noyau ne gerent pas MPX. La prise en charge par le noyau de MPX s'active avec l'option de configuration CONFIG_X86_INTEL_MPX. Vous pouvez verifier 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 active. Tous les threads d'un processus sont concernes par ces appels. L'enfant d'un fork(2) herite de l'etat de la gestion MPX. Pendant un execve(2), la gestion MPX est reinitialisee a un etat tel que si PR_MPX_DISABLE_MANAGEMENT avait ete appele. 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 geres dans Linux 5.4 et ulterieurs. PR_SET_NAME (depuis Linux 2.6.9) Definir le nom du thread appelant, en utilisant la valeur de l'emplacement vers lequel pointe (char *) arg2. Le nom peut avoir jusqu'a 16 octets de long, y compris l'octet NULL final (en cas de depassement, octet NULL final inclus, la chaine est tronquee silencieusement). C'est le meme attribut qui peut etre defini par pthread_setname_np(3) et consulte par pthread_getname_np(3). On peut egalement y acceder a l'aide de /proc/self/task/tid/comm (voir proc(5)), ou tid designe l'identifiant du thread appelant tel que renvoye par gettid(2). PR_GET_NAME (depuis Linux 2.6.11) Renvoyer le nom du thread appelant, dans le tampon vers lequel pointe (char *) arg2. Le tampon doit etre suffisamment grand pour contenir jusqu'a 16 octets ; la chaine sera terminee par un octet NULL. PR_SET_NO_NEW_PRIVS (depuis Linux 3.5) Affecter au bit no_new_privs du processus appelant la valeur dans arg2. Lorsque no_new_privs a la valeur 1, execve(2) promet de ne pas donner de droits a quoi que ce soit qui n'aurait pas pu etre 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 capacites de fichiers). Une fois affecte, le bit ne peut pas etre reinitialise. L'affectation de ce bit est heritee par les enfants crees par fork(2) et clone(2) et preservee a travers execve(2). Depuis Linux 4.10, la valeur de l'attribut no_new_privs d'un thread est visible dans le champ NoNewPrivs du fichier /proc/pid/status. Pour plus d'informations, consultez le fichier Documentation/userspace-api/no_new_privs.rst (ou Documentation/prctl/no_new_privs.txt avant Linux 4.13) dans les sources du noyau. Voir seccomp(2). PR_GET_NO_NEW_PRIVS (depuis Linux 3.5) Renvoyer (comme resultat 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 operer dans le mode limiteur de droits decrit ci-dessus. PR_PAC_RESET_KEYS (depuis Linux 5.0, seulement sur arm64) Reinitialiser de maniere sure les cles d'authentification du pointeur du thread pour rafraichir les valeurs aleatoires generees par le noyau. Le jeu de cles a reinitialiser est indique avec arg2, qui doit etre un OU logique de zero ou plusieurs des valeurs suivantes : PR_PAC_APIAKEY cle A d'authentification d'instruction PR_PAC_APIBKEY cle B d'authentification d'instruction PR_PAC_APDAKEY cle A d'authentification de donnees PR_PAC_APDBKEY cle B d'authentification de donnees PR_PAC_APGAKEY cle "A" d'authentification generique (Oui les amis, il n'y a vraiment pas de cle B generique). Il existe un cas particulier ou si arg2 vaut 0, toutes les cles sont reinitialisees. Comme de nouvelles cles pourraient etre ajoutees dans le futur, c'est la maniere recommandee pour nettoyer les cles existantes pour creer un contexte d'execution propre. Remarquez qu'il n'est pas necessaire d'utiliser PR_PAC_RESET_KEYS pour preparer un appel execve(2), puisque execve(2) reinitialise toutes les cles d'authentification des pointeurs. Les autres arguments arg3, arg4 et arg5 doivent etre nuls. Si les parametres ne sont pas valables, et notamment si arg2 contient des bits non reconnus ou correspondant a une cle indisponible sur cette plateforme, l'appel echoue avec l'erreur EINVAL. Attention : le compilateur ou l'environnement d'execution pouvant utiliser tout ou partie des cles, un PR_PAC_RESET_KEYS reussi peut faire planter le processus appelant. Les conditions pour l'utiliser en toute securite sont complexes et dependent du systeme. 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 etre un numero de signal dans l'intervalle [1, NSIG - 1] ou 0 pour effacer le signal). Il s'agit du numero du signal que le processus appelant recevra si son parent meurt. Attention : c'est le thread qui est, dans ce cas, considere comme le << parent >> qui a cree ce processus. Autrement dit, le signal sera envoye quand ce thread se terminera (a l'aide de pthread_exit(3), par exemple) et non apres que tous les threads du processus parent ne se soient termines. Le signal de la mort du parent est envoye lors de la fin ulterieure 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 affilie. Si le thread parent et tous les subreapers ancetres sont deja termines au moment de l'operation PR_SET_PDEATHSIG, aucun signal de la mort du parent n'est envoye a l'appelant. Le signal de la mort du parent est envoye 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 parametre siginfo_t du gestionnaire contient l'identifiant du processus parent qui se termine. Le parametrage de signal de mort du parent est vide pour l'enfant d'un fork(2). Il est egalement vide (depuis Linux 2.4.36/2.6.23) lors de l'execution d'un binaire Set-UID ou Set-GID ou d'un binaire qui a des capacites associees (voir capabilities(7)) ; sinon cette valeur est preservee par execve(2). Le parametrage du signal de mort du parent est aussi vide lors du changement des droits suivants d'un thread : l'identifiant utilisateur ou de groupe effectif, l'identifiant utilisateur ou groupe du systeme de fichiers. PR_GET_PDEATHSIG (depuis Linux 2.3.15) Renvoyer la valeur actuelle du signal de mort du processus parent, dans l'emplacement vers lequel pointe (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 passe en argument arg2, le composant appelant declare que le processus ptracer peut appeler la fonction ptrace(2) appliquee au processus appelant, comme si celui-ci etait un ancetre direct. Chaque operation PR_SET_PTRACER remplace l'identifiant du processus ptracer precedent. L'emploi de PR_SET_PTRACER avec l'argument arg2 egal a 0 supprime tous les identifiants de processus ptracer de l'appelant. Si arg2 est egal a PR_SET_PTRACER_ANY, les restrictions ptrace apportees par Yama sont de fait desactivees 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) Selectionner le mode de traitement securise (seccomp) pour le thread appelant, afin de limiter les appels systeme disponibles. L'appel systeme plus recent seccomp(2) fournit un superensemble de fonctions de PR_SET_SECCOMP et il est l'interface privilegiee pour les nouvelles applications. Le mode de traitement securise est selectionne par arg2 (les constantes du mode de traitement securise sont definies dans ). Les valeurs suivantes peuvent etre indiquees : SECCOMP_MODE_STRICT (depuis Linux 2.6.23) Voir la description de SECCOMP_SET_MODE_STRICT dans seccomp(2). Cette fonctionnalite n'est disponible que si le noyau a ete construit avec l'option CONFIG_SECCOMP activee. SECCOMP_MODE_FILTER (depuis Linux 3.5) Les appels systeme autorises sont definis par un pointeur vers un filtre de paquets Berkeley passe en arg3. Cet argument est un pointeur vers struct sock_fprog ; il peut etre concu pour filtrer des appels systeme arbitraires et les arguments des appels systeme. Consulter la description de SECCOMP_SET_MODE_FILTER dans seccomp(2). Cette fonctionnalite n'est disponible que si le noyau a ete construit avec l'option CONFIG_SECCOMP_FILTER activee. Pour plus de details sur le filtrage seccomp, voir seccomp(2). PR_GET_SECCOMP (depuis Linux 2.6.23) Renvoyer (comme resultat de la fonction) le mode de traitement securise du thread appelant. Si l'appelant n'est pas dans un mode de traitement securise, cette operation renvoie 0 ; si l'appelant est dans le mode de traitement securise strict, alors l'appel prctl() provoquera l'envoi d'un signal SIGKILL au processus. Si l'appelant est dans le mode filtre et que cet appel systeme est autorise par les filtres seccomp, cette operation renvoie 2 ; sinon le processus est tue avec un signal SIGKILL. Cette fonctionnalite n'est disponible que si le noyau a ete construit avec l'option CONFIG_SECCOMP activee. Depuis Linux 3.8, le champ Seccomp du fichier /proc/pid/status offre une methode pour obtenir la meme information sans risquer que le processus ne soit tue ; voir proc(5). PR_SET_SECUREBITS (depuis Linux 2.6.26) Configurer l'attribut << securebits >> du thread appelant a la valeur fournie par arg2. Consultez capabilities(7). PR_GET_SECUREBITS (depuis Linux 2.6.26) Renvoyer (en resultat de fonction) l'etat actuel de l'attribut << securebits >> du thread appelant. Consultez capabilities(7). PR_GET_SPECULATION_CTRL (depuis Linux 4.17) Renvoyer (en tant que resultat de la fonction) l'etat de la fonction defectueuse de speculation indiquee dans arg2. Actuellement, la seule valeur autorisee pour ce parametre est PR_SPEC_STORE_BYPASS (sans quoi l'appel echoue avec l'erreur ENODEV). Le code de retour utilise les bits 0 a 3 ayant la signification suivante : PR_SPEC_PRCTL L'attenuation peut etre controlee par thread via PR_SET_SPECULATION_CTRL. PR_SPEC_ENABLE La fonction de speculation est activee, l'attenuation est desactivee. PR_SPEC_DISABLE La fonction de speculation est desactivee, l'attenuation est activee. PR_SPEC_FORCE_DISABLE Identique a PR_SPEC_DISABLE mais ne peut pas etre annule. PR_SPEC_DISABLE_NOEXEC (depuis Linux 5.1) Identique a PR_SPEC_DISABLE, mais l'etat sera vide pendant un execve(2). Si tous les bits valent 0, le processeur n'est pas concerne par la fonction defectueuse de speculation. Si PR_SPEC_PRCTL est positionne, le controle par thread de l'attenuation est disponible. Sinon, prctl() echouera pour la fonction defectueuse de speculation. Les parametres arg3, arg4 et arg5 doivent etre indiques en tant que 0 ; sinon l'appel echoue avec l'erreur EINVAL. PR_SET_SPECULATION_CTRL (depuis Linux 4.17) Definir l'etat de la fonction defectueuse de speculation indique dans arg2. Ces parametres sont des attributs par thread. Actuellement, arg2 doit valoir une des valeurs suivantes : PR_SPEC_STORE_BYPASS Definir l'etat de la fonction defectueuse de contournement de stockage speculatif. PR_SPEC_INDIRECT_BRANCH (depuis Linux 4.20) Positionner l'etat de la fonction defectueuse de speculation de branche indirecte. Si arg2 n'a pas une des valeurs ci-dessus, l'appel echoue avec l'erreur ENODEV. Le parametre arg3 est utilise pour recuperer le code de controle, qui peut etre un des suivants : PR_SPEC_ENABLE La fonction de speculation est activee, l'attenuation est desactivee. PR_SPEC_DISABLE La fonction de speculation est desactivee, l'attenuation est activee. PR_SPEC_FORCE_DISABLE Identique a PR_SPEC_DISABLE, mais ne peut pas etre annule. Un prctl( arg2, PR_SPEC_ENABLE) ulterieur avec la meme valeur pour arg2 echouera avec l'erreur EPERM. PR_SPEC_DISABLE_NOEXEC (depuis Linux 5.1) Identique a PR_SPEC_DISABLE, mais l'etat sera vide lors d'un execve(2). Actuellement, seul arg2 egal a PR_SPEC_STORE_BYPASS est pris en charge. Toute valeur non valable de arg3 fera echouer l'appel avec l'erreur ERANGE. Les parametres arg4 et arg5 doivent etre indiques en tant que 0 ; sinon l'appel echoue avec l'erreur EINVAL. La fonctionnalite de speculation peut aussi etre geree par l'option d'amorcage spec_store_bypass_disable. Ce parametre applique une regle de lecture seule qui fera echouer un appel prctl() avec une erreur ENXIO. Pour de plus amples details, 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 indique dans (int) arg2. Les parametres arg3, arg4 et arg5 sont ignores. Les bits de arg2 correspondant a PR_SVE_VL_LEN_MASK doivent etre positionnes sur la taille souhaitee du vecteur en octets. Elle est interpretee comme une limite superieure : le noyau selectionnera la taille de vecteur disponible la plus grande qui ne depasse pas celle indiquee. En particulier, indiquer SVE_VL_MAX (defini dans ) 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 etre positionnes sur une des combinaisons suivantes d'attributs : 0 Effectuer les modifications immediatement. Lors du prochain execve(2) dans le thread, la taille du vecteur sera reinitialisee a celle configuree dans /proc/sys/abi/sve_default_vector_length. PR_SVE_VL_INHERIT Effectuer les changements immediatement. Les prochains appels execve(2) preserveront la nouvelle taille du vecteur. PR_SVE_SET_VL_ONEXEC Differer la modification pour qu'elle soit effectuee au prochain execve(2) dans le thread. Les appels execve(2) suivants reinitialiseront la taille du vecteur a la valeur configuree dans /proc/sys/abi/sve_default_vector_length. PR_SVE_SET_VL_ONEXEC | PR_SVE_VL_INHERIT Differer la modification pour qu'elle soit effectuee au prochain execve(2) dans le thread. Les prochains appels execve(2) preserveront la nouvelle taille du vecteur. Dans tous les cas, toute modification precedemment differee et en attente sera annulee. L'appel echoue avec l'erreur EINVAL si SVE n'est pas gere par la plateforme, si arg2 n'est pas reconnu ou n'est pas valable, ou si la valeur des bits de arg2 correspondant a PR_SVE_VL_LEN_MASK depasse la plage SVE_VL_MIN..SVE_VL_MAX ou n'est pas un multiple de 16. En cas de succes, une valeur non negative est renvoyee decrivant la configuration de selected. Si PR_SVE_SET_VL_ONEXEC faisait partie de arg2, la configuration decrite par le code de retour prendra effet au prochain execve(). Sinon, la configuration s'applique deja quand l'appel PR_SVE_SET_VL renvoie. Dans les deux cas, la valeur est encodee de la meme facon que le code de retour de PR_SVE_GET_VL. Remarquez qu'il n'y a pas d'attribut explicite dans le code de retour correspondant a PR_SVE_SET_VL_ONEXEC. La configuration (y compris les modifications differees en attente) est recuperee 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'execution pouvant utiliser SVE, l'utilisation de cet appel sans l'attribut PR_SVE_SET_VL_ONEXEC peut faire planter le processus appelant. Les conditions necessaires pour une utilisation sure sont complexes et dependent du systeme. Ne l'utilisez pas sauf si vous savez vraiment ce que vous faites. PR_SVE_GET_VL (depuis Linux 4.15, seulement sur arm64) Recuperer la configuration de la taille du vecteur SVE du thread actuel. Les parametres arg2, arg3, arg4 et arg5 sont ignores. Si le noyau et la plateforme gerent SVE, cette operation reussit toujours, en renvoyant une valeur non negative qui decrit la configuration actuelle. Les bits correspondant a PR_SVE_VL_LEN_MASK contiennent la taille du vecteur actuellement configure en octets. Le bit correspondant a PR_SVE_VL_INHERIT indique si la taille du vecteur sera recuperee a 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 applique. 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 (depuis Linux 5.11, seulement sur x86) Configurer le mecanisme << Syscall User Dispatch >> pour le thread appelant. Ce mecanisme permet a une application d'intercepter de maniere selective les appels systeme pour qu'elle puisse les gerer elle-meme. L'interception prend la forme d'un signal SIGSYS envoye au thread quand il effectue un appel systeme. S'il est intercepte, l'appel systeme n'est pas execute par le noyau. Pour activer ce mecanisme, arg2 doit etre positionne sur PR_SYS_DISPATCH_ON. Les prochains appels systeme seront alors selectivement interceptes selon la valeur d'une variable de controle fournie dans l'espace utilisateur. Dans ce cas, arg3 et arg4 identifient respectivement la position et la taille d'une zone de memoire continue dans l'espace d'adressage du processus ou les appels systeme sont toujours autorises a etre executes, quelle que soit la valeur de la variable de controle (cette zone inclut generalement la zone de memoire contenant la bibliotheque C). arg5 pointe vers une variable de taille caractere qui represente un parametre rapide pour autoriser/empecher l'execution d'un appel systeme sans la contrainte de faire un autre appel systeme visant a reconfigurer Syscall User Dispatch. Cette variable de controle peut etre positionnee soit sur SYSCALL_DISPATCH_FILTER_BLOCK pour empecher les appels systeme de s'executer, soit sur SYSCALL_DISPATCH_FILTER_ALLOW pour les autoriser temporairement a s'executer. Cette valeur est verifiee par le noyau a chaque nouvelle entree d'un appel systeme et toute valeur inattendue provoquera un SIGSYS insaisissable a cet instant, ce qui tuera l'application. Lorsqu'un appel systeme est intercepte, le noyau envoie un signal SIGSYS adresse au thread differe. Divers champs seront definis dans la structure siginfo_t (voir sigaction(2)) associee au signal : - si_signo contiendra SIGSYS. - si_call_addr affichera l'adresse de l'instruction de l'appel systeme. - si_syscall et si_arch indiqueront l'appel systeme qui a ete tente. - si_code contiendra SYS_USER_DISPATCH. - si_errno sera positionne a 0. Le compteur du programme sera comme si l'appel systeme se produisait (c'est-a-dire que le compteur du programme ne pointera pas vers l'instruction de l'appel systeme). Quand le gestionnaire de signal rend la main au noyau, l'appel systeme se termine immediatement et rend la main au thread appelant, sans etre reellement execute. Si necessaire (c'est-a-dire lors de l'emulation de l'appel systeme dans l'espace utilisateur), le gestionnaire de signal doit positionner le code de retour de l'appel systeme sur une valeur adequate, en modifiant le contexte du registre stocke dans le parametre ucontext du gestionnaire de signal. Voir sigaction(2), sigreturn(2) et getcontext(3) pour plus d'informations. Si arg2 est positionne sur PR_SYS_DISPATCH_OFF, Syscall User Dispatch est desactive pour ce thread. Les autres arguments doivent etre positionnes a 0. Le parametre n'est pas preserve a travers un fork(2), un clone(2) ou un execve(2). Pour plus d'informations, consultez le fichier Documentation/admin-guide/syscall-user-dispatch.rst dans les sources du noyau. PR_SET_TAGGED_ADDR_CTRL (depuis Linux 5.4, seulement sur arm64) Controler la gestion du passage d'adresses labellisees de l'espace utilisateur au noyau (c'est-a-dire des adresses ou les bits 56--63 ne valent pas 0). Le niveau de prise en charge est selectionne par arg2, qui peut prendre une des valeurs suivantes : 0 Les adresses qui sont passees pour etre dereferencees par le noyau doivent etre non labellisees. PR_TAGGED_ADDR_ENABLE Les adresses qui sont passees pour etre dereferencees par le noyau doivent etre labellisees, sauf celles resumees ci-dessous. Les autres arguments arg3, arg4 et arg5 doivent etre nuls. En cas de succes, le mode indique dans arg2 est positionne sur le thread appelant et le code de retour est 0. Si les parametres ne sont pas valables, le mode indique dans arg2 n'est pas reconnu, ou si la fonctionnalite n'est pas prise en charge par le noyau ou bien si elle est desactivee a l'aide de /proc/sys/abi/tagged_addr_disabled, l'appel echoue avec l'erreur EINVAL. En particulier, si prctl(PR_SET_TAGGED_ADDR_CTRL, 0, 0, 0, 0) echoue avec EINVAL, toutes les adresses transmises au noyau doivent etre non labellisees. Independamment du mode defini, les adresses transmises a certaines interfaces doivent toujours etre non labellisees : - brk(2), mmap(2), shmat(2), shmdt(2) et le parametre new_address de mremap(2). (avant Linux 5.6, ils acceptaient les adresses labellisees mais cela peut entrainer un comportement non prevu. Ne vous y fiez pas). - Les interfaces << polymorphic >> (polymorphes) qui acceptent les pointeurs vers des types arbitraires changent a void * ou un autre type generique, en particulier prctl(), ioctl(2) et generalement setsockopt(2) (seules certaines options specifiques de setsockopt(2) acceptent les adresses labellisees). Cette liste d'exceptions peut diminuer au fil des versions du noyau. Si le noyau peut garantir une retrocompatibilite, les effets de la transmission d'adresses labellisees a ces interfaces ne sont pas specifies pour les nouveaux logiciels. Le mode defini par cet appel est recupere a travers fork(2) et clone(2). Le mode est remis a 0 par execve(2) (c'est-a-dire les adresses labellisees ne sont pas autorisees 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 concu pour une utilisation par un environnement d'execution. Un appel PR_SET_TAGGED_ADDR_CTRL reussi peut, ailleurs, faire planter le processus appelant. Les conditions pour une utilisation sure sont complexes et dependantes du systeme. 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 etiquete actuel du thread appelant. Les parametres arg2, arg3, arg4 et arg5 doivent etre nuls. Si les parametres ne sont pas valables ou si cette fonctionnalite est desactivee ou non prise en charge par le noyau, l'appel echoue avec EINVAL. En particulier, si prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0) echoue avec EINVAL, cette fonction n'est clairement pas prise en charge ou desactivee avec /proc/sys/abi/tagged_addr_disabled. Dans ce cas, toutes les adresses transmises au noyau doivent etre non labellisees. Sinon, l'appel renvoie une valeur non negative decrivant le mode d'adressage labellise actuel, encode de la meme maniere que le parametre 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) Desactiver tous les compteurs de performance attaches au processus appelant, independamment du fait que ces compteurs ont ete crees par ce processus ou par un autre. Les compteurs de performance crees par le processus appelant pour d'autres processus ne sont pas concernes. Pour plus d'informations sur les compteurs de performance, consultez le fichier tools/perf/design.txt des sources du noyau Linux. Initialement appele PR_TASK_PERF_COUNTERS_DISABLE. Renomme (avec la meme valeur numerique) 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 attaches au processus appelant. Initialement appele PR_TASK_PERF_COUNTERS_ENABLE. Renomme dans Linux 2.6.32. PR_SET_THP_DISABLE (depuis Linux 3.15) Affecter l'etat de l'attribut << THP disable >> pour le thread appelant. Si arg2 a une valeur differente de zero, l'attribut est active ; dans le cas contraire, il est desactive. L'utilisation de cet attribut fournit un moyen de supprimer les pages de tres grande taille correspondant a des travaux pour lesquels le code ne peut pas etre modifie, et dans les cas ou le recours a des routines malloc associees a des appels madvise(2) n'offre pas de solution (c'est-a-dire pour des donnees allouees statiquement). L'activation de l'attribut << THP disable >> est transmis aux enfants crees au moyen de fork(2) et est conserve lors d'un appel a execve(2). PR_GET_THP_DISABLE (depuis Linux 3.15) Renvoyer (en resultat de fonction) le reglage actuel de l'attribut << THP disable >> du thread appelant, c'est a dire 1 si l'attribut est active et 0 dans le cas contraire. PR_GET_TID_ADDRESS (depuis Linux 3.5) Renvoyer l'adresse clear_child_tid configuree par set_tid_address(2) et par l'attribut CLONE_CHILD_CLEARTID de clone(2), a l'emplacement vers lequel pointe (int **) arg2. Cette option n'est disponible que si le noyau est construit avec l'option CONFIG_CHECKPOINT_RESTORE. Notez que comme l'appel systeme prctl() n'a pas d'implementation compatible pour les ABI AMD64 x32 et MIPS n32, et comme le noyau ecrit un pointeur en utilisant la taille du pointeur du noyau, cette operation attend un tampon en espace utilisateur de 8 octets (et non 4) sur ces ABI. PR_SET_TIMERSLACK (depuis Linux 2.6.28) Chaque thread comporte deux valeurs de temporisation relachee : une valeur << default >> et une valeur << current >>. Cette operation positionne la valeur << current >> du temporisateur du thread appelant. arg2 est un entier long non signe, la valeur << current >> maximale est donc ULONG_MAX et celle minimale est 1. Si la valeur en nanoseconde fournie dans arg2 est superieure a zero, la valeur << current >> est positionnee sur cette valeur. Si arg2 est egal a zero, la temporisation << current >> est reinitialisee a la valeur << default >> du thread. La valeur << current >> (actuelle) de temporisation relachee est utilisee par le noyau pour grouper les delais d'expiration des threads appelants qui sont proches les uns des autres. Par consequent, les delais d'expiration des threads pourraient etre en retard jusqu'au nombre de nanosecondes indique (mais jamais en avance). Le groupement des delais d'expiration permet de reduire la consommation d'energie du systeme en minimisant les reveils du processeur. Les delais d'expiration affectes par la temporisation relachee sont ceux definis 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 bibliotheque implementees 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 relachee ne s'applique pas aux threads qui sont programmes avec une strategie d'ordonnancement en temps reel (consultez sched_setscheduler(2)). Quand un nouveau thread est cree, les deux valeurs de temporisation relachee sont rendues identiques a la valeur << current >> du thread qui l'a cree. Ensuite, un thread peut ajuster sa valeur de temporisation relachee << current >> a l'aide de PR_SET_TIMERSLACK. La valeur << default >> ne peut pas etre modifiee. Les valeurs de temporisation relachee d'init (PID 1), l'ancetre de tous les processus, sont de 50 000 nanosecondes (50 microsecondes). Les valeurs de temporisation relachee sont transmises aux enfants crees avec fork(2) et sont preservees a travers execve(2). Depuis Linux 4.6, la valeur << current >> de temporisation relachee d'un processus peut etre visualisee et modifiee a l'aide du fichier /proc/pid/timerslack_ns. Voir proc(5). PR_GET_TIMERSLACK (depuis Linux 2.6.28) Renvoyer (comme resultat de la fonction) la valeur << current >> de temporisation relachee du thread appelant. PR_SET_TIMING (depuis Linux 2.6.0) Permettre de choisir la methode de mesure du temps du processus a utiliser, en passant dans arg2 soit PR_TIMING_STATISTICAL (methode statistique traditionnelle) ou PR_TIMING_TIMESTAMP (methode exacte utilisant des horodatages). PR_TIMING_TIMESTAMP n'est pas implemente pour l'instant (l'utilisation de ce mode renverra l'erreur EINVAL). PR_GET_TIMING (depuis Linux 2.6.0) Renvoyer (en resultat de fonction) quelle methode de mesure du temps du processus est utilisee actuellement. PR_SET_TSC (depuis Linux 2.6.26, seulement sur x86) Configurer l'etat de l'attribut qui indique si le compteur d'horodatage peut etre lu par le processus. Utiliser PR_TSC_ENABLE pour arg2 permet d'autoriser les lectures ou PR_TSC_SIGSEGV pour produire un SIGSEGV quand le processus essaie de lire le compteur d'horodatage. PR_GET_TSC (depuis Linux 2.6.26, seulement sur x86) Renvoyer, dans l'emplacement vers lequel pointe (int *) arg2, l'etat de l'attribut qui indique si le compteur d'horodatage peut etre lu. PR_SET_UNALIGN (Seulement sur : ia64, depuis Linux 2.3.48 ; parisc, depuis Linux 2.6.15 ; PowerPC, depuis Linux 2.6.18 ; Alpha, depuis Linux 2.6.22 ; sh, depuis Linux 2.6.34 ; tile, depuis Linux 3.12). Definir les bits de controle pour les acces non alignes a arg2. La valeur PR_UNALIGN_NOPRINT signifie que les acces non alignes en espace utilisateur sont silencieusement corriges, et PR_UNALIGN_SIGBUS cause l'envoi de SIGBUS lors d'un acces utilisateur non aligne. Alpha gere aussi un attribut supplementaire dont la valeur est 4 et qui n'a pas de constante correspondante nommee, qui demande au noyau de corriger les acces non alignes (il revient a utiliser l'attribut UAC_NOFIX dans l'operation SSI_NVPAIRS de l'appel systeme setsysinfo() sur Tru64). PR_GET_UNALIGN (Consultez PR_SET_UNALIGN pour les informations sur les versions et les architectures). Renvoyer les bits de controle des acces non alignes dans l'emplacement vers lequel pointe (unsigned int *) arg2. PR_GET_AUXV (depuis Linux 6.4) Recuperer le vecteur auxiliaire (auxv) dans le tampon vers lequel pointe (void *) arg2 et dont la longueur est donnee par arg3. Si le tampon n'est pas suffisamment long pour le vecteur auxiliaire complet, la copie sera tronquee. Renvoyer (comme resultat de la fonction) la longueur totale du vecteur auxiliaire. arg4 et arg5 doivent etre 0. PR_SET_MDWE (depuis Linux 6.3) Configurer le masque de protection << Memory-Deny-Write-Execute >> (MDWE) du processus appelant. Une fois les bits de protection definis, ils ne peuvent plus etre modifies. arg2 doit etre un masque de bits de : PR_MDWE_REFUSE_EXEC_GAIN Les nouvelles protections de mappage memoire ne peuvent pas etre accessibles en ecriture et executables. Les mappages non executables ne peuvent pas devenir executables. PR_MDWE_NO_INHERIT (depuis Linux 6.6) Ne pas propager la protection MDWE aux processus enfant sur fork(2). Definir ce bit necessite de definir egalement PR_MDWE_REFUSE_EXEC_GAIN. PR_GET_MDWE (depuis Linux 6.3) Renvoyer (comme resultat de la fonction) le masque de protection << Memory-Deny-Write-Execute >> du processus appelent. Consultez PR_SET_MDWE pour des informations sur les bits de masque de protection. VALEUR RENVOYEE En cas de reussite, 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, PR_GET_AUXV et (s'il rend la main) PR_GET_SECCOMP renvoient les valeurs positives decrites ci-dessus. Toute autre valeur d'op renvoie 0 en cas de succes. En cas d'erreur, -1 est renvoye et errno est positionne pour indiquer l'erreur. ERREURS EACCES op vaut PR_SET_SECCOMP et arg2 vaut SECCOMP_MODE_FILTER, mais le processus n'a pas la capacite CAP_SYS_ADMIN ou n'a pas positionne l'attribut no_new_privs (voir le point sur PR_SET_NO_NEW_PRIVS ci-dessus). EACCES op vaut PR_SET_MM, et arg3 vaut PR_SET_MM_EXE_FILE, le fichier n'est pas executable. EBADF op vaut PR_SET_MM, arg3 vaut PR_SET_MM_EXE_FILE, et le descripteur de fichier passe dans le parametre arg4 n'est pas valable. EBUSY op vaut PR_SET_MM, arg3 vaut PR_SET_MM_EXE_FILE, et il s'agit de la seconde tentative de modification du lien symbolique /proc/pid/exe, ce qui n'est pas autorise. EFAULT arg2 est une adresse non valable. EFAULT op vaut PR_SET_SECCOMP, arg2 vaut SECCOMP_MODE_FILTER, le systeme a ete construit avec CONFIG_SECCOMP_FILTER et arg2 n'est pas une adresse valable. EFAULT op vaut PR_SET_SYSCALL_USER_DISPATCH et arg5 a une adresse non valable. EINVAL La valeur de op n'est pas reconnue ou n'est pas prise en charge sur ce systeme. EINVAL op vaut PR_MCE_KILL, PR_MCE_KILL_GET ou PR_SET_MM, et les parametres non utilises de prctl() n'ont pas ete regles a zero. EINVAL arg2 n'est pas une valeur valable pour cette op. EINVAL op vaut PR_SET_SECCOMP ou PR_GET_SECCOMP et le noyau n'a pas ete configure avec CONFIG_SECCOMP. EINVAL op vaut PR_SET_SECCOMP, arg2 vaut SECCOMP_MODE_FILTER et le noyau n'a pas ete configure avec CONFIG_SECCOMP_FILTER. EINVAL op vaut PR_SET_MM, et l'une des assertions suivantes est vraie : - arg4 ou arg5 est different de 0 ; - 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 memoire correspondante ne satisfont pas les conditions requises ; - arg2 vaut PR_SET_MM_START_BRK ou PR_SET_MM_BRK, et arg3 est inferieur ou egal a la fin du segment de donnees, ou indique une valeur qui causerait le depassement de la limite de ressource RLIMIT_DATA. EINVAL op vaut PR_SET_PTRACER et arg2 ne vaut ni 0, ni PR_SET_PTRACER_ANY, ni le PID d'un processus existant. EINVAL op vaut PR_SET_PDEATHSIG et arg2 n'est pas un numero de signal valable. EINVAL op vaut PR_SET_DUMPABLE et arg2 ne vaut ni SUID_DUMP_DISABLE, ni SUID_DUMP_USER. EINVAL op vaut PR_SET_TIMING et arg2 n'a pas la valeur PR_TIMING_STATISTICAL. EINVAL op vaut PR_SET_NO_NEW_PRIVS et arg2 ne vaut pas 1, ou arg3, arg4 ou arg5 est different de zero. EINVAL op vaut PR_GET_NO_NEW_PRIVS et arg2, arg3, arg4 ou arg5 est different de zero. EINVAL op vaut PR_SET_THP_DISABLE et arg3, arg4 ou arg5 est different de zero. EINVAL op vaut PR_GET_THP_DISABLE et arg2, arg3, arg4 ou arg5 est different de zero. EINVAL op vaut PR_CAP_AMBIENT et un parametre inutilise (arg4, arg5 ou, dans le cas de PR_CAP_AMBIENT_CLEAR_ALL, arg3) ne vaut pas zero ; 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 capacite valable. EINVAL op vaut PR_SET_SPECULATION_CTRL ou PR_SET_SPECULATION_CTRL et des parametres inutilises de prctl() ne valent pas 0. EINVAL op vaut PR_PAC_RESET_KEYS et les parametres ne sont pas valables ou ne sont pas pris en charge. Voir la description de PR_PAC_RESET_KEYS ci-dessus pour des details. EINVAL op vaut PR_SVE_SET_VL et les parametres 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 details. EINVAL op vaut PR_SVE_GET_VL et SVE n'est pas disponible sur cette plateforme. EINVAL op vaut PR_SET_SYSCALL_USER_DISPATCH et l'une des assertions suivantes est vraie : - arg2 vaut PR_SYS_DISPATCH_OFF et les autres parametres ne sont pas a 0 ; - arg2 vaut PR_SYS_DISPATCH_ON et la plage de memoire indiquee depasse l'espace d'adressage du processus. - arg2 n'est pas valable. EINVAL op vaut PR_SET_TAGGED_ADDR_CTRL et les parametres ne sont pas valables ou ne sont pas pris en charge. Voir la description de PR_SET_TAGGED_ADDR_CTRL ci-dessus pour des details. EINVAL op vaut PR_GET_TAGGED_ADDR_CTRL et les parametres ne sont pas valables ou ne sont pas pris en charge. Voir la description de PR_GET_TAGGED_ADDR_CTRL pour des details. ENODEV op vaut PR_SET_SPECULATION_CTRL et le noyau ou le processeur ne gere pas la fonction defectueuse de speculation demandee. ENXIO op 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. Verifiez que le noyau et le processeur gerent le MPX. ENXIO opt vaut PR_SET_SPECULATION_CTRL, impliquant que le controle de la fonction defectueuse de speculation selectionnee n'est pas possible. Voir les champs de bit de PR_GET_SPECULATION_CTRL pour savoir les options disponibles. EOPNOTSUPP op vaut PR_SET_FP_MODE et arg2 a une valeur non prise en charge ou non valable. EPERM op vaut PR_SET_SECUREBITS et l'appelant n'a pas la capacite CAP_SETPCAP, a essaye d'enlever un attribut de << verrouillage >> ou a essaye de positionner un attribut pour lequel l'attribut de verrouillage etait positionne (consultez capabilities(7)). EPERM op vaut PR_SET_SPECULATION_CTRL alors que la speculation est desactivee avec PR_SPEC_FORCE_DISABLE et l'appelant a essaye de la reactiver. EPERM op vaut PR_SET_KEEPCAPS et l'attribut SECBIT_KEEP_CAPS_LOCKED de l'appelant est positionne (consultez capabilities(7)). EPERM op vaut PR_CAPBSET_DROP et l'appelant n'a pas la capacite CAP_SETPCAP. EPERM op vaut PR_SET_MM et l'appelant n'a pas la capacite CAP_SYS_RESOURCE. EPERM op vaut PR_CAP_AMBIENT et arg2 vaut PR_CAP_AMBIENT_RAISE, mais soit la capacite indiquee dans arg3 n'est pas presente dans les capacites autorisees et recuperables du processus, ou bien le bit de securite PR_CAP_AMBIENT_LOWER a ete positionne. ERANGE op 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 IRIX dispose d'un appel systeme prctl() (egalement introduit dans Linux 2.1.44 sur l'architecture MIPS sous le nom irix_prctl), dont le prototype est ptrdiff_t prctl(int op, int arg2, int arg3); et les operations permettent de d'obtenir le nombre maximal de processus par utilisateur, d'obtenir le nombre maximal de processeurs utilisables par un processus, de verifier si un processus est bloque, d'obtenir ou de definir la taille maximale de la pile, etc. STANDARDS Linux. HISTORIQUE Linux 2.1.57, glibc 2.0.6 VOIR AUSSI signal(2), core(5) TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot , Cedric Boutillier , Frederic Hantrais et Jean-Philippe MENGUAL Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.8 2 mai 2024 prctl(2)