NOM¶

SYNOPSIS¶

#include <sys/prctl.h>

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

DESCRIPTION¶

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 :

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 joue le rôle de init(1) pour ses processus enfants. Quand un processus devient orphelin (c'est-à-dire que son plus proche parent se termine), ce processus sera réaffilié à son ancêtre le plus proche encore en vie. Par conséquent, les appels à getppid() dans un processus orphelin renverront l'identifiant du processus subreaper et quand l'orphelin se terminera, c'est le processus subreaper qui recevra le signal SIGCHLD et pourra surveiller (wait(2)) le processus et découvrir son état de fin.

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

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

PR_GET_CHILD_SUBREAPER (depuis Linux 3.4)

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

PR_SET_DUMPABLE (depuis Linux 2.3.20)

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

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

En principe, cet attribut est positionné sur 1. Toutefois, il est remis à la valeur actuelle du fichier /proc/sys/fs/suid_dumpable (qui est de 0 par défaut), dans les cas suivants :

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

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

PR_GET_DUMPABLE (depuis Linux 2.3.20)

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

PR_SET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC)

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

PR_GET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC)

Renvoyer le boutisme (endianness) du processus appelant, dans l'emplacement pointé par (int *) arg2.

PR_SET_FP_MODE (depuis Linux 4.0, seulement sur MIPS)

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

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

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

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

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

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

PR_GET_FP_MODE (depuis Linux 4.0, seulement sur MIPS)

Renvoyer (comme résultat de la fonction) le mode de virgule flottante actuel (voir la description de PR_SET_FP_MODE pour les détails).

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

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

PR_SET_FPEMU (depuis Linux 2.4.18, 2.5.9, seulement sur ia64)

Définir les bits de contrôle de l'émulation de virgule flottante à arg2. Passer PR_FPEMU_NOPRINT pour émuler silencieusement les opérations de virgule flottante, ou PR_FPEMU_SIGFPE pour ne pas émuler ces opérations et envoyer SIGFPE.

PR_GET_FPEMU (depuis Linux 2.4.18, 2.5.9, seulement sur ia64)

Renvoyer les bits de contrôle de l'émulation de FPU, dans l'emplacement pointé par (int *) arg2.

PR_SET_FPEXC (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC)

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

PR_GET_FPEXC (depuis Linux 2.4.21, 2.5.32, seulement sur PowerPC)

Renvoyer le mode d'exception de virgule flottante, dans l'emplacement pointé par (int *) arg2.

PR_SET_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_MPX_ENABLE_MANAGEMENT, PR_MPX_DISABLE_MANAGEMENT (depuis Linux 3.19)

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 le MPX. La prise en charge par le noyau de MPX s'active à l'aide de l'option de configuration CONFIG_X86_INTEL_MPX. Vous pouvez vérifier si le processeur gère le MPX en cherchant le bit CPUID « mpx », par exemple avec la commande suivante :

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.

PR_SET_NAME (depuis Linux 2.6.9)

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

PR_GET_NAME (depuis Linux 2.6.11)

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

PR_SET_NO_NEW_PRIVS (depuis Linux 3.5)

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

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

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

PR_GET_NO_NEW_PRIVS (depuis Linux 3.5)

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

PR_SET_PDEATHSIG (depuis Linux 2.1.57)

Configurer le signal de mort du parent du processus appelant avec la valeur arg2 (qui peut être soit un numéro de signal dans l'intervalle 1..maxsig, ou être nul pour effacer le signal). Il s'agit du signal que le processus appelant recevra si son parent se termine.

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

PR_GET_PDEATHSIG (depuis Linux 2.3.15)

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

PR_SET_PTRACER (depuis Linux 3.4)

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

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

PR_SET_SECCOMP (depuis Linux 2.6.23)

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

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

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

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

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

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

PR_GET_SECCOMP (depuis Linux 2.6.23)

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

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

PR_SET_SECUREBITS (depuis Linux 2.6.26)

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

PR_GET_SECUREBITS (depuis Linux 2.6.26)

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

PR_GET_SPECULATION_CTRL (depuis Linux 4.17)

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

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

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)

Positionner l'état de la fonction défectueuse de spéculation indiquée dans arg2. Actuellement, la seule valeur possible de ce paramètre est PR_SPEC_STORE_BYPASS (sans quoi l'appel échoue avec l'erreur ENODEV). Il s'agit d'un attribut par thread. Le paramètre arg3 est utilisé pour saisir la valeur de contrôle, qui peut être une des suivantes :

Toute autre valeur 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_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_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_GET_THP_DISABLE (depuis Linux 3.15)

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

PR_GET_TID_ADDRESS (depuis Linux 3.5)

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

PR_SET_TIMERSLACK (depuis Linux 2.6.28)

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

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

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

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

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

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

PR_GET_TIMERSLACK (depuis Linux 2.6.28)

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

PR_SET_TIMING (depuis Linux 2.6.0)

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

PR_GET_TIMING (depuis Linux 2.6.0)

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

PR_SET_TSC (depuis Linux 2.6.26, seulement sur x86)

Configurer l'état de l'attribut qui indique si le compteur d'horodatage peut être lu par le processus. Utiliser PR_TSC_ENABLE pour arg2 permet d'autoriser les lectures ou PR_TSC_SIGSEGV pour produire un SIGSEGV quand le processus essaie de lire le compteur d'horodatage.

PR_GET_TSC (depuis Linux 2.6.26, seulement sur x86)

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

PR_SET_UNALIGN

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

PR_GET_UNALIGN

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

VALEUR RENVOYÉE¶

ERREURS¶

EACCES

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

EACCES

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

EBADF

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

EBUSY

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

EFAULT

arg2 est une adresse non valable.

EFAULT

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

EINVAL

La valeur de option n'est pas reconnue.

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 :

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 vaut PR_GET_SPECULATION_CTRL ou PR_SET_SPECULATION_CTRL et des paramètres inutilisés dans prctl() ne valent pas 0.

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.

VERSIONS¶

CONFORMITɶ

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¶

COLOPHON¶

TRADUCTION¶

Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 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.