SYNOPSIS

#include <sys/prctl.h>

---

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

DESCRIPTION

prctl() est invoqué avec un premier paramètre indiquant ce qu'il faut faire, (ses valeurs sont définies dans <linux/prctl.h>), et des paramètres supplémentaires dont la signification dépend du premier paramètre. Celui-ci peut être :

PR_CAPBSET_READ (depuis Linux 2.6.25)

Renvoyer (en résultat de fonction) 1 si la capacité indiquée par arg2 est présente dans la limitation de capacités du thread appelant ou 0 si elle ne l'est pas. Les constantes des capacités sont définies dans <linux/capability.h>. L'ensemble des capacités liées contrôle si le processus peut recevoir la capacité par un ensemble de capacités autorisées pour un fichier lors d'un appel futur à execve(2).

Si la capacité indiquée dans arg2 n'est pas valable, alors l'appel échoue avec l'erreur EINVAL.

PR_CAPBSET_DROP (depuis Linux 2.6.25)

Si le thread appelant a la capacité CAP_SETPCAP, alors enlever la capacité indiquée par arg2 dans l'ensemble de limitation de capacités du thread appelant. Les fils du thread appelant hériteront de cette nouvelle limitation de capacités réduite.

L'appel échoue avec l'erreur EPERM si le thread appelant n'a pas la capacité CAP_SETPCAP ; ou avec l'erreur EINVAL si arg2 ne représente pas une capacité correcte ; ou avec l'erreur EINVAL si les capacités de fichier ne sont pas activée dans le noyau, auquel cas les limitations ne sont pas prises en charge par le noyau.

PR_SET_CHILD_SUBREAPER (depuis Linux 3.4)

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

PR_GET_CHILD_SUBREAPER (depuis Linux 3.4)

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

PR_SET_DUMPABLE (depuis Linux 2.3.20)

Définir l'attribut déterminant si un fichier core est produit lorsque le processus appelant reçoit un signal dont le comportement par défaut est de produire un fichier core. (Normalement cet attribut est par défaut validé pour un processus, mais est effacé à l'exécution d'un programme Set-UID ou Set-GID ainsi que par divers appels système manipulant des UID et GID). Dans les noyaux jusqu'à 2.6.12 inclus, arg2 doit valoir 0 (pas de fichier core) ou 1 (fichier core possible). Entre les noyaux 2.6.13 et 2.6.17, la valeur 2 était également autorisée ; elle permettait à un binaire qui ne produirait normalement pas de fichier core d'en créer un lisible uniquement par root ; cette fonctionnalité a été supprimée pour des raisons de sécurité. (Consultez aussi la description de /proc/sys/fs/suid_dumpable dans proc(5).) La commande ptrace(2) PTRACE_ATTACH ne permet pas d'attacher des processus qui ne produisent pas normalement de fichier core.

PR_GET_DUMPABLE (depuis Linux 2.3.20)

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

PR_SET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC)

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

PR_GET_ENDIAN (depuis Linux 2.6.18, seulement sur PowerPC)

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

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

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

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

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

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

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

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

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

PR_SET_KEEPCAPS (depuis Linux 2.2.18)

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

PR_GET_KEEPCAPS (depuis Linux 2.2.18)

Renvoyer (en résultat de fonction) l'état actuel de l'attribut de conservation des capacités du thread appelant.

PR_SET_NAME (depuis Linux 2.6.9)

Définir le nom du thread appelant, en utilisant la valeur de l'emplacement pointé par (char *) arg2. Le nom peut avoir jusqu'à 16 octets de long et doit être terminé par un caractère nul s'il est plus petit. Ce même attribut peut être défini par pthread_setname_np(3) et consulté par pthread_getname_np(3). On peut également y accéder via /proc/self/task/[tid]/comm, où tid désigne le nom du thread appelant.

PR_GET_NAME (depuis Linux 2.6.11)

Renvoyer le nom du thread appelant, dans le tampon pointé par (char *) arg2. Le tampon doit être suffisamment grand pour contenir jusqu'à 16 octets ; la chaîne sera terminée par un caractère nul si elle est plus petite.

PR_SET_NO_NEW_PRIVS (depuis Linux 3.5)

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

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

PR_GET_NO_NEW_PRIVS (depuis Linux 3.5)

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

PR_SET_PDEATHSIG (depuis Linux 2.1.57)

Configurer le signal de mort du père du processus appelant avec la valeur arg2 (qui peut être un numéro de signal dans l'intervalle 1..maxsig, ou être nul pour effacer le signal). Il s'agit du numéro du signal que le processus appelant recevra si son père se termine. Cette valeur est effacée pour le fils d'un fork(2), et (depuis Linux 2.4.36 et 2.6.23) lors de l'exécution d'un binaire Set-UID ou Set-GID. Cette valeur est préservée par execve(2).

PR_GET_PDEATHSIG (depuis Linux 2.3.15)

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

PR_SET_PTRACER (depuis Linux 3.4)

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

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

PR_SET_SECCOMP (depuis Linux 2.6.23)

Sélectionner le mode de traitement sécurisé (seccomp) pour le thread appelant, afin de limiter les appels système disponibles. Le mode de traitement sécurisé est sélectionné par arg2 (les constantes du mode de traitement sécurisé sont définies dans <linux/seccomp.h>).

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

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

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

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

PR_GET_SECCOMP (depuis Linux 2.6.23)

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

PR_SET_SECUREBITS (depuis Linux 2.6.26)

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

PR_GET_SECUREBITS (depuis Linux 2.6.26)

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

PR_SET_THP_DISABLE (depuis Linux 3.15)

Affecter l'état de l'attribut « THP disable » pour le thread appelant. Si arg2 a une valeur non nulle, l'attribut est activé ; dans le cas contraire, il est désactivé. L'utilisation de cet attribut fournit un moyen de supprimer les pages de très grande taille correspondant à des jobs pour lesquels le code ne peut pas être modifié, et dans les cas où le recours à des routines malloc associées à des appels madvise(2) n'offre pas de solution (c'est-à-dire pour des données allouées statiquement). L'activation de l'attribut « THP disable » est transmis aux fils créés au moyen de fork(2) et est conservé lors d'un appel à execve(2).

PR_GET_THP_DISABLE (depuis Linux 3.15)

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

PR_GET_TID_ADDRESS (depuis Linux 3.5)

Récupérer l'adresse clear_child_tid configurée par set_tid_address(2) et par l'attribut CLONE_CHILD_CLEARTID de clone(2), à l'emplacement que pointe (int **) arg2. Cette option n'est disponible que si le noyau est construit avec l'option CONFIG_CHECKPOINT_RESTORE.

PR_SET_TIMERSLACK (depuis Linux 2.6.28)

Définir la valeur actuelle de temporisation relâchée pour le thread appelant à la valeur fournie par arg2 en nanoseconde. Si arg2 est inférieur ou égal à zéro, réinitialiser la temporisation relâchée actuelle à la valeur de temporisation relâchée par défaut du thread. La temporisation relâchée est utilisée par le noyau pour grouper les délais d'expiration des threads appelants qui sont proches les uns des autres. Par conséquent, les délais d'expiration des threads pourraient être en retard jusqu'au nombre de nanosecondes indiqué (mais jamais en avance). Le groupement des délais d'expiration permet de réduire la consommation d'énergie du système en minimisant les réveils du processeur.

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

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

Tous les threads ont deux valeurs de temporisation relâchée associées : une valeur par défaut (« default », et une actuelle (« current »). La valeur actuelle est celle qui gouverne le groupement des délais d'expiration. Quand un nouveau thread est créé, les deux valeurs de temporisation relâchée sont rendues identiques à la valeur actuelle du thread qui l'a créé. Ensuite, un thread peut ajuster sa valeur de temporisation relâchée actuelle à l'aide de PR_SET_TIMERSLACK (la valeur par défaut peut être modifiée). Les valeurs de temporisation relâchée d'init (PID 1), l'ancêtre de tous les processus, sont de 50 000 nanosecondes (50 microsecondes). Les valeurs de temporisation relâchée sont préservées à travers execve(2).

PR_GET_TIMERSLACK (depuis Linux 2.6.28)

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

PR_SET_TIMING (depuis Linux 2.6.0-test4)

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

PR_GET_TIMING (depuis Linux 2.6.0-test4)

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

PR_TASK_PERF_EVENTS_DISABLE (depuis Linux 2.6.31)

Désactiver tous les compteurs de performance attachés au processus appelant, indépendamment du fait que ces compteurs ont été créés par ce processus ou par un autre. Les compteurs de performance créés par le processus appelant pour d'autres processus ne sont pas concernés. Pour plus d'informations sur les compteurs de performance, consultez le fichier source tools/perf/design.txt du noyau Linux.

Initialement appelé PR_TASK_PERF_COUNTERS_DISABLE. Renommé (avec la même valeur numérique) dans Linux 2.6.32.

PR_TASK_PERF_EVENTS_ENABLE (depuis Linux 2.6.31)

L'inverse de PR_TASK_PERF_EVENTS_DISABLE. Activer les compteurs de performance attachés au processus appelant.

Initialement appelé PR_TASK_PERF_COUNTERS_ENABLE. Renommé dans Linux 2.6.32.

PR_SET_TSC (depuis Linux 2.6.26, seulement sur x86)

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

PR_GET_TSC (depuis Linux 2.6.26, seulement sur x86)

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

PR_SET_UNALIGN

(Seulement sur : ia64, depuis Linux 2.3.48 ; parisc, depuis Linux 2.6.15 ; PowerPC, depuis Linux 2.6.18 ; Alpha, depuis Linux 2.6.22) Définir les bits de contrôle pour les accès non alignés à arg2. La valeur PR_UNALIGN_NOPRINT signifie que les accès non alignés en espace utilisateurs sont silencieusement corrigés, et PR_UNALIGN_SIGBUS cause l'envoi de SIGBUS lors d'un accès non aligné.

PR_GET_UNALIGN

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

PR_MCE_KILL (depuis Linux 2.6.32)

Définir la politique de suppression de mémoire corrompue de la machine pour le thread actuel. Si arg2 vaut PR_MCE_KILL_CLEAR, effacer la politique de suppression de mémoire corrompue et utiliser la valeur par défaut du système (qui est définie dans /proc/sys/vm/memory_failure_early_kill, consultez proc(5)). Si arg2 vaut PR_MCE_KILL_SET, utiliser une politique de suppression de mémoire corrompue spécifique au thread. Dans ce cas, arg3 définit si la politique est immédiate (early kill avec PR_MCE_KILL_EARLY), différée (late kill avec PR_MCE_KILL_LATE), ou la valeur par défaut du système (PR_MCE_KILL_DEFAULT). Une suppression immédiate signifie que le thread reçoit un signal SIGBUS dès que la corruption mémoire matérielle est détectée à l'intérieur de son espace d'adressage. En mode retardé, le processus n'est tué que lorsqu'il accède à une page corrompue. Consultez sigaction(2) pour plus d'informations sur le signal SIGBUS. Cette politique est héritée par les fils. Les arguments restants de prctl(), non utilisés, doivent être mis à zéro pour préparer la future compatibilité.

PR_MCE_KILL_GET (depuis Linux 2.6.32)

Renvoyer la politique actuelle (par processus) de suppression des processus empoisonnés. Tous les arguments non utilisés de prctl() doivent être nuls.

PR_SET_MM (depuis Linux 3.3)

Modifier certains champs du descripteur de projection de mémoire du noyau pour le processus appelant. D'habitude, ces champs sont déterminés par le noyau et le chargeur de liens dynamique (consultez ld.so(8) pour plus d'informations) et une application normale ne devrait pas utiliser cette fonctionnalité. En revanche, dans certaines situations, telles que celle de programmes se modifiant eux-mêmes, un programme pourra trouver utile de pouvoir changer sa propre projection de mémoire. Cette fonctionnalité n'est disponible que si le noyau est construit avec l'option CONFIG_CHECKPOINT_RESTORE activée. Le processus appelant doit avoir la capacité CAP_SYS_RESOURCE. La valeur d'arg2 est l'une des options ci-dessous, alors qu'arg3 fournit une nouvelle valeur pour l'option.

PR_SET_MM_START_CODE

Sélectionner l'adresse au dessus de laquelle le texte du programme peut être exécuté. La zone de mémoire correspondante doit être accessible en lecture et en exécution, mais pas en écriture et doit ne pas pouvoir être partagée (consultez mprotect(2) et mmap(2) pour plus d'informations).

PR_SET_MM_END_CODE

Sélectionner l'adresse en dessous de laquelle le texte du programme peut être exécuté. La zone de mémoire correspondante doit être accessible en lecture et en exécution, mais pas en écriture et doit ne pas pouvoir être partagée.

PR_SET_MM_START_DATA

Sélectionner l'adresse au dessus de laquelle les données initialisées et non initialisées (bss) sont placées. La zone de mémoire correspondante doit être accessible en lecture et en écriture, mais pas en exécution et doit ne pas pouvoir être partagée.

PR_SET_MM_END_DATA

Sélectionner l'adresse en dessous de laquelle les données initialisées et non initialisées (bss) sont placées. La zone de mémoire correspondante doit être accessible en lecture et en écriture, mais pas en exécution et doit ne pas pouvoir être partagée.

PR_SET_MM_START_STACK

Sélectionner l'adresse du début de la pile. La région de mémoire correspondante doit être accessible en lecture et en écriture.

PR_SET_MM_START_BRK

Sélectionner l'adresse au dessus de laquelle le tas du programme peut être étendu avec l'appel brk(2). L'adresse doit être au dessus de l'adresse terminant le segment de données actuel du programme. De plus, la taille combinée du tas obtenu et la taille du segment de données ne peut dépasser la limite de ressource RLIMIT_DATA (consultez setrlimit(2)).

PR_SET_MM_BRK

Sélectionnez la valeur actuelle de brk(2). Les conditions pour l'adresse sont les mêmes que pour l'option PR_SET_MM_START_BRK.

Les options suivantes sont disponibles depuis Linux 3.5.

PR_SET_MM_ARG_START

Sélectionner l'adresse au dessus de laquelle la ligne de commande du programme est placée.

PR_SET_MM_ARG_END

Sélectionner l'adresse en dessous de laquelle la ligne de commande du programme est placée.

PR_SET_MM_ENV_START

Sélectionner l'adresse au dessus de laquelle l'environnement du programme est placé.

PR_SET_MM_ENV_END

Sélectionner l'adresse en dessous de laquelle l'environnement du programme est placé.

L'adresse transmise au moyen de PR_SET_MM_ARG_START, PR_SET_MM_ARG_END, PR_SET_MM_ENV_START, et de PR_SET_MM_ENV_END doit appartenir à l'espace mémoire d'une pile de processus. Par conséquent, l'espace mémoire correspondant doit être accessible en lecture, en écriture et (selon la configuration du noyau) disposer de l'attribut MAP_GROWSDOWN défini (consultez mmap(2)).

PR_SET_MM_AUXV

Sélectionner le nouveau vecteur auxiliaire. Le paramètre arg3 doit fournir l'adresse du vecteur. Le paramètre arg4 est la taille du vecteur.

PR_SET_MM_EXE_FILE

Remplace le lien symbolique /proc/pid/exe par un nouveau lien pointant vers un nouveau fichier exécutable identifié par le descripteur de fichier fourni via le paramètre arg3. Le descripteur de fichier peut être obtenu au moyen d'un appel à open(2).

Pour changer le lien symbolique, il faut supprimer tous les espaces alloués en mémoire et contenant du code exécutable, y compris ceux créés par le noyau (par example, le noyau crée en général au moins un espace mémoire d'exécutable pour la section ELF .text).

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

VALEUR RENVOYÉE

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

VERSIONS

L'appel système prctl() a été introduit dans Linux 2.1.57.

CONFORMITÉ

Cet appel système est spécifique à Linux. IRIX dispose d'un appel système prctl() (également introduit dans Linux 2.1.44 sur l'architecture MIPS sous le nom irix_prctl), dont le prototype est

ptrdiff_t prctl(int option, int arg2, int arg3);

et les options permettent de d'obtenir le nombre maximal de processus par utilisateur, le nombre maximal de processeurs utilisables par un processus, vérifier si un processus est bloqué, lire ou définir la taille des piles, etc.

COLOPHON

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

TRADUCTION

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

Christophe Blaess <http://www.blaess.fr/christophe/> (1996-2003), Alain Portal <http://manpagesfr.free.fr/> (2003-2006). Julien Cristau et l'équipe francophone de traduction de Debian (2006-2009).

Veuillez signaler toute erreur de traduction en écrivant à <[email protected]> ou par un rapport de bogue sur le paquet manpages-fr.

Vous pouvez toujours avoir accès à la version anglaise de ce document en utilisant la commande « man -L C <section> <page_de_man> ».