.\" -*- coding: UTF-8 -*- '\" t .\" Copyright (c) 1992 Drew Eckhardt, March 28, 1992 .\" and Copyright (c) 2002, 2004, 2005, 2008, 2010 Michael Kerrisk .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\" Modified by Michael Haardt .\" Modified 1993-07-23 by Rik Faith .\" Modified 1996-01-13 by Arnt Gulbrandsen .\" Modified 1996-01-22 by aeb, following a remark by .\" Tigran Aivazian .\" Modified 1996-04-14 by aeb, following a remark by .\" Robert Bihlmeyer .\" Modified 1996-10-22 by Eric S. Raymond .\" Modified 2001-05-04 by aeb, following a remark by .\" Håvard Lygre .\" Modified 2001-04-17 by Michael Kerrisk .\" Modified 2002-06-13 by Michael Kerrisk .\" Added note on nonstandard behavior when SIGCHLD is ignored. .\" Modified 2002-07-09 by Michael Kerrisk .\" Enhanced descriptions of 'resource' values .\" Modified 2003-11-28 by aeb, added RLIMIT_CORE .\" Modified 2004-03-26 by aeb, added RLIMIT_AS .\" Modified 2004-06-16 by Michael Kerrisk .\" Added notes on CAP_SYS_RESOURCE .\" .\" 2004-11-16 -- mtk: the getrlimit.2 page, which formally included .\" coverage of getrusage(2), has been split, so that the latter .\" is now covered in its own getrusage.2. .\" .\" Modified 2004-11-16, mtk: A few other minor changes .\" Modified 2004-11-23, mtk .\" Added notes on RLIMIT_MEMLOCK, RLIMIT_NPROC, and RLIMIT_RSS .\" to "CONFORMING TO" .\" Modified 2004-11-25, mtk .\" Rewrote discussion on RLIMIT_MEMLOCK to incorporate kernel .\" 2.6.9 changes. .\" Added note on RLIMIT_CPU error in older kernels .\" 2004-11-03, mtk, Added RLIMIT_SIGPENDING .\" 2005-07-13, mtk, documented RLIMIT_MSGQUEUE limit. .\" 2005-07-28, mtk, Added descriptions of RLIMIT_NICE and RLIMIT_RTPRIO .\" 2008-05-07, mtk / Peter Zijlstra, Added description of RLIMIT_RTTIME .\" 2010-11-06, mtk: Added documentation of prlimit() .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH getrlimit 2 "2 mai 2024" "Pages du manuel de Linux 6.8" .SH NOM getrlimit, setrlimit, prlimit \- Lire et écrire les limites et utilisations des ressources .SH BIBLIOTHÈQUE Bibliothèque C standard (\fIlibc\fP, \fI\-lc\fP) .SH SYNOPSIS .nf \fB#include \fP .P \fBint getrlimit(int \fP\fIresource\fP\fB, struct rlimit *\fP\fIrlim\fP\fB);\fP \fBint setrlimit(int \fP\fIresource\fP\fB, const struct rlimit *\fP\fIrlim\fP\fB);\fP .P \fBint prlimit(pid_t \fP\fIpid\fP\fB, int \fP\fIresource\fP\fB,\fP \fB const struct rlimit *_Nullable \fP\fInew_limit\fP\fB,\fP \fB struct rlimit *_Nullable \fP\fIold_limit\fP\fB);\fP .fi .P .RS -4 Exigences de macros de test de fonctionnalités pour la glibc (consulter \fBfeature_test_macros\fP(7)) : .RE .P \fBprlimit\fP() : .nf _GNU_SOURCE .fi .SH DESCRIPTION Les appels système \fBgetrlimit\fP() et \fBsetrlimit\fP() lisent ou écrivent les limites des ressources système. Chaque ressource a une limite souple et une limite stricte définies par la structure \fIrlimit\fP\ : .P .in +4n .EX struct rlimit { rlim_t rlim_cur; /* limite souple */ rlim_t rlim_max; /* limite stricte (plafond de rlim_cur) */ }; .EE .in .P La limite souple est la valeur que le noyau prend en compte pour la ressource correspondante. La limite stricte agit comme un plafond pour la limite souple\ : un processus non privilégié peut seulement modifier sa limite souple dans l'intervalle entre zéro et la limite stricte, et diminuer (de manière irréversible) sa limite stricte. Un processus privilégié (sous Linux\ : un processus ayant la capacité \fBCAP_SYS_RESOURCE\fP dans l'espace de noms initial de l'utilisateur) peut modifier ses deux limites à sa guise. .P La valeur \fBRLIM_INFINITY\fP indique une limite infinie pour la ressource (aussi bien pour \fBgetrlimit\fP() que pour \fBsetrlimit\fP()). .P Le paramètre \fIresource\fP doit être l'un des éléments suivants\ : .TP \fBRLIMIT_AS\fP .\" since Linux 2.0.27 / Linux 2.1.12 Taille maximale de la mémoire virtuelle du processus (espace d'adressage). Cette limite est exprimée en octets et est arrondie à la taille inférieure de la page système. Cette limite affecte les appels à \fBbrk\fP(2), \fBmmap\fP(2) et \fBmremap\fP(2), qui échouent avec l'erreur \fBENOMEM\fP en cas de dépassement de cette limite. De même, l'extension automatique de la pile échouera (et générera un \fBSIGSEGV\fP qui tuera le processus si aucune pile alternative n'a été définie par un appel à \fBsigaltstack\fP(2)). Comme cette valeur est de type \fIlong\fP, sur les machines où le type \fIlong\fP est sur 32 bits, soit cette limite est au plus 2 GiB, soit cette ressource est illimitée. .TP \fBRLIMIT_CORE\fP Taille maximale d'un fichier \fIcore\fP (consulter \fBcore\fP(5)) qu'un processus peut générer. Lorsqu'elle vaut zéro, aucun fichier d'image noyau (Ndt\ : core dump) n'est créé. Lorsqu'elle ne vaut pas zéro, les fichiers d'image noyau plus grands sont tronqués à cette taille. .TP \fBRLIMIT_CPU\fP Limite de temps CPU en secondes consommable par le processus. Lorsqu'un processus atteint cette limite souple, il reçoit le signal \fBSIGXCPU\fP. L'action par défaut pour ce signal est la terminaison du processus. Mais le signal peut être capturé et le gestionnaire peut rendre le contrôle au programme principal. Si le processus continue à consommer du temps CPU, il recevra \fBSIGXCPU\fP toutes les secondes jusqu'à atteindre la limite stricte, où il recevra \fBSIGKILL\fP. (Ce dernier point décrit le comportement de Linux. Les implémentations varient sur la façon de traiter le processus qui continue à consommer du temps CPU après dépassement de sa limite souple. Les applications portables qui doivent capturer ce signal devraient prévoir une terminaison propre dès la première réception de \fBSIGXCPU\fP.) .TP \fBRLIMIT_DATA\fP .\" commits 84638335900f1995495838fe1bd4870c43ec1f67 .\" ("mm: rework virtual memory accounting"), .\" f4fcd55841fc9e46daac553b39361572453c2b88 .\" (mm: enable RLIMIT_DATA by default with workaround for valgrind). Taille maximale du segment de données d'un processus (données initialisées, non initialisées, et tas). Cette limite est indiquée en octets et arrondie à la taille inférieure de la page système. Cette limite affecte les appels \fBbrk\fP(2), \fBsbrk\fP(2) et (depuis Linux 4.7) \fBmmap\fP(2)) qui échouent avec l'erreur \fBENOMEM\fP si la limite souple est dépassée. .TP \fBRLIMIT_FSIZE\fP Taille maximale, en octets, d'un fichier que le processus peut créer. Les tentatives d'extension d'un fichier au\(hydelà de cette limite aboutissent à un signal \fBSIGXFSZ\fP. Par défaut ce signal termine le processus, mais il peut être capturé, et dans ce cas l'appel système concerné (par exemple \fBwrite\fP(2), \fBtruncate\fP(2)) échoue avec l'erreur \fBEFBIG\fP. .TP \fBRLIMIT_LOCKS\fP (de Linux 2.4.0 à Linux 2.4.24) .\" to be precise: Linux 2.4.0-test9; no longer in Linux 2.4.25 / Linux 2.5.65 Limite pour le nombre combiné de verrous \fBflock\fP(2) et \fBfcntl\fP(2) que le processus peut établir. .TP \fBRLIMIT_MEMLOCK\fP Le nombre maximal d'octets de mémoire que le processus peut verrouiller en RAM. En pratique cette limite est arrondie vers le bas au multiple de la taille de page le plus proche. Cette limite affecte \fBmlock\fP(2) et \fBmlockall\fP(2) ainsi que l'opération \fBMAP_LOCKED\fP de \fBmmap\fP(2). Depuis Linux 2.6.9, elle affecte aussi l'opération \fBSHM_LOCK\fP de \fBshmctl\fP(2), où elle limite le nombre total d'octets dans des segments de mémoire partagée (consultez \fBshmget\fP(2)) que l'UID réel du processus appelant peut verrouiller. Les verrous \fBSHM_LOCK\fP de \fBshmctl\fP(2) sont comptés séparément des verrous de mémoire par processus établis par \fBMAP_LOCKED\fP de \fBmlock\fP(2), \fBmlockall\fP(2) et \fBmmap\fP(2)\ ; un processus peut verrouiller des octets jusqu'à cette limite dans ces deux catégories. .IP Avant Linux 2.6.9, cette limite contrôlait la quantité de mémoire qui pouvait être verrouillée par un processus privilégié. Depuis Linux 2.6.9, il n'existe plus de limite de quantité de mémoire verrouillable par un processus privilégié, cette limite gère donc plutôt la quantité de mémoire qu'un processus non privilégié peut verrouiller. .TP \fBRLIMIT_MSGQUEUE\fP (depuis Linux 2.6.8) Indique la limite du nombre d'octets pouvant être alloués pour les files de messages POSIX pour l'UID réel du processus appelant. Cette limite est appliquée pour \fBmq_open\fP(3). Chaque file de message créée par l'utilisateur se calcule (jusqu'à sa destruction) par rapport à la limite via la formule suivante\ : .RS 4 .IP Depuis Linux 3.5 : .IP .in +4n .EX bytes = attr.mq_maxmsg * sizeof(struct msg_msg) + MIN(attr.mq_maxmsg, MQ_PRIO_MAX) * sizeof(struct posix_msg_tree_node)+ /* Pour le dépassement */ attr.mq_maxmsg * attr.mq_msgsize; /* Pour les données du message */ .EE .in .IP Linux 3.4 et antérieurs : .IP .in +4n .EX bytes = attr.mq_maxmsg * sizeof(struct msg_msg *) + /* Pour le dépassement */ attr.mq_maxmsg * attr.mq_msgsize; /* Pour les données du message */ .EE .in .RE .IP où \fIattr\fP est la structure \fImq_attr\fP passée comme quatrième argument à \fBmq_open\fP(3), et \fImsg_msg\fP et \fIposix_msg_tree_node\fP sont les structures internes du noyau. .IP Le terme de « dépassement » de la formule représente les octets de dépassement nécessaires à l'implémentation. Ce dépassement assure que l'utilisateur ne peut pas créer un nombre illimité de messages vides (ces messages consomment tout de même de la mémoire système). .TP \fBRLIMIT_NICE\fP (depuis Linux 2.6.12, consultez la section BOGUES ci\(hydessous) Indique un plafond pour la valeur de politesse du processus pouvant être définie par \fBsetpriority\fP(2) ou \fBnice\fP(2). Le plafond réel pour la valeur de politesse est calculé par la formule \fI20\ \-\ rlim_cur\fP. La plage utile pour cette limite est ainsi de \fB1\fP (pour une valeur de politesse de 19) à \fB40\fP (pour une valeur de politesse de \-20). Cette bizarrerie est nécessaire car des nombres négatifs ne peuvent pas être utilisés comme limite de ressource, en raison de leur signification souvent particulière. Par exemple, \fBRLIM_INFINITY\fP est souvent la même chose que \fB\-1\fP. Pour plus de détails sur la valeur de politesse, consultez \fBsched\fP(7). .TP \fBRLIMIT_NOFILE\fP Valeur supérieure de \fB1\fP au nombre maximal de descripteurs de fichier que peut ouvrir ce processus. Les tentatives d'ouverture (\fBopen\fP(2), \fBpipe\fP(2), \fBdup\fP(2), etc) dépassant cette limite renverront l'erreur \fBEMFILE\fP (historiquement, cette limite était appelée \fBRLIMIT_OFILE\fP sur les BSD). .IP Depuis Linux 4.5, cette limite définit également le nombre maximal de descripteurs de fichier qu'un processus non privilégié (sans la capacité \fBCAP_SYS_RESOURCE\fP) peut détenir « en vol » sur les autres processus, en les passant à travers des sockets du domaine UNIX. Cette limite s'applique à l'appel système \fBsendmsg\fP(2). Pour plus de détails, voir \fBunix\fP(7). .TP \fBRLIMIT_NPROC\fP Limite du nombre de processus étendus (ou, plus précisément, sur Linux, de threads) pour l'identifiant de l'utilisateur réel du processus appelant. Tant que le nombre en cours de processus appartenant à l'identifiant de l'utilisateur réel du processus est supérieur ou égal à cette limite, \fBfork\fP(2) échoue avec l'erreur \fBEAGAIN\fP. .IP La limite \fBRLIMIT_NPROC\fP n'est pas gérée pour les processus qui ont la capacité \fBCAP_SYS_ADMIN\fP ou \fBCAP_SYS_RESOURCE\fP, ou bien qui fonctionnent avec l'identifiant réel de l'utilisateur \fB0\fP.. .TP \fBRLIMIT_RSS\fP .\" As at Linux 2.6.12, this limit still does nothing in Linux 2.6 though .\" talk of making it do something has surfaced from time to time in LKML .\" -- MTK, Jul 05 Indique la limite (en octets) pour la taille de l'ensemble résident du processus (le nombre de pages de mémoire virtuelle en RAM). Cette limite n'a d'effet que sous Linux 2.4.x où x\ <\ 30, et n'affecte que les appels \fBmadvise\fP(2) indiquant \fBMADV_WILLNEED\fP. .TP \fBRLIMIT_RTPRIO\fP (depuis Linux 2.6.12, mais consultez BOGUES) Indique un plafond pour la priorité temps\(hyréel pouvant être appliquée au processus par \fBsched_setscheduler\fP(2) et \fBsched_setparam\fP(2). .IP Pour plus de détails sur les règles d'ordonnancement en temps réel, voir \fBsched\fP(7) .TP \fBRLIMIT_RTTIME\fP (depuis Linux 2.6.25) Indique une limite de la quantité de temps (en microsecondes) CPU qu'un processus ordonnancé par une politique d'ordonnancement temps réel peut consommer sans provoquer un appel système bloquant. Pour les besoins de cette limite, le décompte du temps CPU qu'il a consommé est remis à zéro à chaque fois qu'un processus exécute un appel système bloquant. Le décompte du temps CPU n'est pas remis à zéro si le processus continue d'essayer d'utiliser le CPU mais est préempté, ou si sa tranche de temps expire, ou s'il appelle \fBsched_yield\fP(2). .IP Quand la limite douce est atteinte, un signal \fBSIGXCPU\fP est envoyé au processus. Si le processus attrape ou ignore ce signal et continue à consommer du temps CPU, alors un signal \fBSIGXCPU\fP sera généré une fois par seconde jusqu'à ce que la limite stricte soit atteinte, ce qui provoque l'envoi d'un signal \fBSIGKILL\fP au processus. .IP L'objectif de cette limite est d'empêcher un processus temps réel fou de bloquer le système. .IP Pour plus de détails sur les règles d'ordonnancement en temps réel, voir \fBsched\fP(7) .TP \fBRLIMIT_SIGPENDING\fP (depuis Linux 2.6.8) .\" This replaces the /proc/sys/kernel/rtsig-max system-wide limit .\" that was present in Linux <= 2.6.7. MTK Dec 04 Spécifie la limite du nombre de signaux pouvant être mis en attente pour l'identifiant utilisateur réel du processus appelant. La vérification de cette limite prend en compte à la fois les signaux classiques et les signaux temps\(hyréel. Cependant, cette limite n'est appliquée que pour \fBsigqueue\fP(3)\ ; il est toujours possible d'utiliser \fBkill\fP(2) pour mettre en attente une instance de tout signal qui n'est pas déjà en attente pour le processus. .TP \fBRLIMIT_STACK\fP La taille maximale de la pile du processus, en octets. Une fois cette limite atteinte, un signal \fBSIGSEGV\fP est déclenché. Pour gérer ce signal, le processus doit utiliser une pile spécifique pour signaux (\fBsigaltstack\fP(2)). .IP Depuis Linux 2.6.23, cette limite détermine également la quantité d'espace utilisé pour les paramètres et les variables d'environnement du processus ; consultez \fBexecve\fP(2) pour plus de détails. .SS prlimit() .\" commit c022a0acad534fd5f5d5f17280f6d4d135e74e81 .\" Author: Jiri Slaby .\" Date: Tue May 4 18:03:50 2010 +0200 .\" .\" rlimits: implement prlimit64 syscall .\" .\" commit 6a1d5e2c85d06da35cdfd93f1a27675bfdc3ad8c .\" Author: Jiri Slaby .\" Date: Wed Mar 24 17:06:58 2010 +0100 .\" .\" rlimits: add rlimit64 structure .\" L'appel système \fBprlimit\fP() spécifique à Linux combine et étend les fonctionnalités de \fBsetrlimit\fP() et \fBgetrlimit\fP(). Il peut être utilisé pour affecter ou récupérer les limites de ressources de tout processus. .P Le paramètre \fIresource\fP a le même sens que dans \fBsetrlimit\fP() et \fBgetrlimit\fP(). .P Si le paramètre \fInew_limit\fP ne vaut pas NULL, alors la structure \fIrlimit\fP vers laquelle il pointe est utilisée pour affecter de nouvelles valeurs aux limites souples et strictes pour \fIresource\fP. Si le paramètres \fIold_limit\fP ne vaut pas NULL, alors un appel à \fBprlimit\fP() qui réussit place les limites antérieures souples et strictes pour \fIresource\fP dans la structure \fIrlimit\fP pointée par \fIold_limit\fP. .P .\" FIXME . this permission check is strange .\" Asked about this on LKML, 7 Nov 2010 .\" "Inconsistent credential checking in prlimit() syscall" L'argument \fIpid\fP spécifie l'identifiant du processus sur lequel l'appel agit. Si \fIpid\fP vaut \fB0\fP, alors l'appel s'applique au processus appelant. Pour positionner ou interroger les ressources d'un processus autre que lui\-même, l'appelant doit avoir la capacité \fBCAP_SYS_RESOURCE\fP dans l'espace de noms utilisateur du processus dont les limites de ressources vont être modifiées ou bien les identifiants d'utilisateur réel, effectif et le set\-UID sauvé du processus cible doivent correspondre à l'identifiant d'utilisateur réel de l'appelant \fIet\fP les identifiants de groupe réel et effectif et le set\-GID sauvé du processus cible doivent correspondre à l'identifiant de groupe réel de l'appelant. .SH "VALEUR RENVOYÉE" Ces appels système renvoient \fB0\fP en cas de succès ou \fB\-1\fP en cas d'échec, auquel cas \fIerrno\fP est positionné pour indiquer l'erreur. .SH ERREURS .TP \fBEFAULT\fP L'un des arguments pointe en dehors de l'espace d'adressage accessible. .TP \fBEINVAL\fP La valeur spécifiée dans \fIresource\fP n'est pas autorisée\ ; ou, pour \fBsetrlimit\fP() ou \fBprlimit\fP(), \fIrlim\->rlim_cur\fP est plus grand que \fIrlim\->rlim_max\fP. .TP \fBEPERM\fP Un processus non privilégié a essayé d’augmenter la limite stricte ; la capacité \fBCAP_SYS_RESOURCE\fP est nécessaire pour faire cela. .TP \fBEPERM\fP L'appelant a essayé d'augmenter la limite stricte \fBRLIMIT_NOFILE\fP au\-delà de celle maximale définie dans \fI/proc/sys/fs/nr_open\fP (voir \fBproc\fP(5)) .TP \fBEPERM\fP (\fBprlimit\fP()) Le processus appelant n'avait pas les droits pour fixer des limites au processus indiqué par \fIpid\fP. .TP \fBESRCH\fP Impossible de trouver un processus dont l'identifiant est indiqué par \fIpid\fP. .SH ATTRIBUTS Pour une explication des termes utilisés dans cette section, consulter \fBattributes\fP(7). .TS allbox; lbx lb lb l l l. Interface Attribut Valeur T{ .na .nh \fBgetrlimit\fP(), \fBsetrlimit\fP(), \fBprlimit\fP() T} Sécurité des threads MT\-Safe .TE .SH STANDARDS .TP \fBgetrlimit\fP() .TQ \fBsetrlimit\fP() POSIX.1\-2008. .TP \fBprlimit\fP() Linux. .P \fBRLIMIT_MEMLOCK\fP et \fBRLIMIT_NPROC\fP proviennent de BSD et ne sont pas définis dans POSIX.1\ ; ils sont présents dans les BSD et Linux, mais dans peu d'autres implémentations. \fBRLIMIT_RSS\fP vient de BSD et n'est pas défini dans POSIX.1\ ; cependant, il est présent sur la plupart des implémentations. \fB\%RLIMIT_MSGQUEUE\fP, \fBRLIMIT_NICE\fP, \fBRLIMIT_RTPRIO\fP, \fBRLIMIT_RTTIME\fP et \fB\%RLIMIT_SIGPENDING\fP sont spécifiques à Linux. .SH HISTORIQUE .TP \fBgetrlimit\fP() .TQ \fBsetrlimit\fP() POSIX.1\-2001, SVr4, 4.3BSD. .TP \fBprlimit\fP() Linux 2.6.36, glibc 2.13. .SH NOTES Un processus enfant créé avec \fBfork\fP(2) hérite des limites de ressource de son parent. Les limites de ressource sont préservées à travers un \fBexecve\fP(2). .P Les limites de ressource sont des attributs par processus partagés par tous les threads d'un processus. .P Descendre la limite souple d'une ressource en dessous de l'actuelle utilisation par le processus de cette ressource fonctionne (mais cela empêchera le processus d'augmenter ultérieurement sa consommation de cette ressource). .P On peut définir les limites de ressource de l'interpréteur de commandes en utilisant la commande interne \fIulimit\fP (\fIlimit\fP dans \fBcsh\fP(1)). Les limites de ressource de l'interpréteur de commandes sont héritées par les processus qu'il crée pour exécuter les commandes. .P À partir de Linux 2.6.24, les limites de ressource de n'importe quel processus peuvent être examinées en consultant \fI/proc/\fPpid\fI/limits\fP ; consultez \fBproc\fP(5). .P Les systèmes anciens fournissent une fonction \fBvlimit\fP() qui remplit le même rôle que \fBsetrlimit\fP(). Pour des raisons de compatibilité ascendante, la glibc fournit aussi une fonction \fBvlimit\fP(), mais toutes les nouvelles applications devraient utiliser \fBsetrlimit\fP(). .SS "Différences entre la bibliothèque C et l'ABI du noyau" A partir de la glibc 2.13, les fonctions d'enveloppe \fBgetrlimit\fP() et \fBsetrlimit\fP() de la glibc n'appellent plus les appels systèmes correspondant, mais utilisent \fBprlimit\fP(), pour les raisons indiquées dans BUGS. .P Le nom de la fonction enveloppe dans la glibc est \fBprlimit\fP() ; l'appel système sous\-jacent est \fBprlimit64\fP(). .SH BOGUES Dans les noyaux Linux plus anciens, les signaux \fBSIGXCPU\fP et \fBSIGKILL\fP envoyés lorsqu'un processus dépassait les limites souples et strictes pour \fBRLIMIT_CPU\fP étaient envoyés une seconde (CPU) plus tard qu'ils n'auraient dû l'être. Cela a été corrigé dans Linux 2.6.8. .P .\" see http://marc.theaimsgroup.com/?l=linux-kernel&m=114008066530167&w=2 Dans les noyaux Linux de la série 2.6 antérieurs à Linux 2.6.17, une limite \fBRLIMIT_CPU\fP à 0 est interprétée par erreur comme «\ pas de limite\ » (comme \fBRLIM_INFINITY\fP). Depuis Linux 2.6.17, définir la limite à 0 a un effet, mais la limite est en fait d'une seconde. .P .\" See https://lwn.net/Articles/145008/ En raison d'un bogue du noyau, \fBRLIMIT_RTPRIO\fP ne marche pas dans Linux 2.6.12\ ; le problème a été corrigé dans Linux 2.6.13. .P .\" see http://marc.theaimsgroup.com/?l=linux-kernel&m=112256338703880&w=2 Dans Linux 2.6.12, il y avait une différence de 1 entre les valeurs de priorité renvoyées par \fBgetpriority\fP(2) et \fBRLIMIT_NICE\fP. Du coup, la limite réelle pour la valeur de politesse était calculée comme \fI19\ \-\ rlim_cur\fP. Cela est corrigé depuis Linux 2.6.13. .P .\" The relevant patch, sent to LKML, seems to be .\" http://thread.gmane.org/gmane.linux.kernel/273462 .\" From: Roland McGrath redhat.com> .\" Subject: [PATCH 7/7] make RLIMIT_CPU/SIGXCPU per-process .\" Date: 2005-01-23 23:27:46 GMT .\" Tested Solaris 10, FreeBSD 9, OpenBSD 5.0 .\" FIXME . https://bugzilla.kernel.org/show_bug.cgi?id=50951 A partir de Linux 2.6.12, si un processus atteint sa limite souple \fBRLIMIT_CPU\fP et qu'il dispose d'un gestionnaire pour \fBSIGXCPU\fP, alors en plus d'invoquer le gestionnaire de signal, le noyau augmente la limite souple d'une seconde. Ce comportement se répète si le processus continue de consommer du temps processeur, jusqu'à ce que la limite stricte soit atteinte, auquel cas le processus est tué. D'autres implémentations ne modifient pas la limite souple \fBRLIMIT_CPU\fP de cette façon, et le comportement de Linux n'est alors probablement pas conforme aux standards ; pour cette raison, les applications portables doivent éviter de tabler sur ce comportement. La limite propre à Linux \fBRLIMIT_RTTIME\fP se comporte de façon analogue lorsque la limite souple est atteinte. .P .\" d3561f78fd379a7110e46c87964ba7aa4120235c Les noyaux antérieurs à Linux 2.4.22 ne détectaient pas l'erreur \fBEINVAL\fP pour \fBsetrlimit\fP() quand \fIrlim\->rlim_cur\fP était plus grand que \fIrlim\->rlim_max\fP. .P .\" Pour des raisons de compatibilité, Linux ne renvoie pas d'erreur quand une tentative de positionnement de \fBRLIMIT_CPU\fP a échoué. .SS "Représentation des limites de ressources de grande taille sur les plate\-formes 32 bits" .\" Linux still uses long for limits internally: .\" c022a0acad534fd5f5d5f17280f6d4d135e74e81 .\" kernel/sys.c:do_prlimit() still uses struct rlimit which .\" uses kernel_ulong_t for its members, i.e. 32-bit on 32-bit kernel. .\" https://bugzilla.kernel.org/show_bug.cgi?id=5042 .\" https://www.sourceware.org/bugzilla/show_bug.cgi?id=12201 Les fonctions d'enrobage de la glibc \fBgetrlimit\fP() et \fBsetrlimit\fP() utilisent un type 64 bits \fIrlim_t\fP, et ce même sur les plateformes 32 bits. Cependant, le type \fIrlim_t\fP utilisé dans les appels systèmes \fBgetrlimit\fP() et \fBsetrlimit\fP() est en fait un \fIunsigned long\fP (de 32 bits). De plus, sur Linux, le noyau traite les limites de ressources sur les systèmes 32 bits au moyen du type \fIunsigned long\fP. Un type 32 bits n'est pourtant pas assez grand. Dans le cas présent, la limite la plus pertinente est \fB\%RLIMIT_FSIZE\fP, qui indique la taille maximum que peut atteindre un fichier : pour être utilisable, cette limite doit être représentée par un type de la même taille que celui utilisé pour représenter les positions de curseur dans le fichier \[em] c'est à dire, de la taille d'un \fBoff_t\fP 64 bits (en considérant que le programme a été compilé avec l'option \fI_FILE_OFFSET_BITS=64\fP). .P Pour contourner cette limitation du noyau, si un programme tente d'affecter à une limite de ressource une valeur trop grande pour être représentée par un type \fIunsigned long\fP de 32 bits, la fonction d'enrobage de la glibc \fBsetrlimit\fP() change implicitement la valeur de la limite en \fBRLIM_INFINITY\fP. Autrement dit, l'affectation de la limite de ressource n'est pas prise en compte, et cela sans aucune notification. .P .\" https://www.sourceware.org/bugzilla/show_bug.cgi?id=12201 Depuis la glibc 2.13, la glibc contourne ces limitations des appels système \fB\%getrlimit\fP() et \fBsetrlimit\fP() en implémentant les fonctions \fBsetrlimit\fP() et \fB\%getrlimit\fP() qui font appel à \fBprlimit\fP(). .SH EXEMPLES Le programme ci\-dessous démontre l'utilisation de \fBprlimit\fP(). .P .\" SRC BEGIN (getrlimit.c) .EX #define _GNU_SOURCE #define _FILE_OFFSET_BITS 64 #include #include #include #include #include #include \& int main(int argc, char *argv[]) { pid_t pid; struct rlimit old, new; struct rlimit *newp; \& if (!(argc == 2 || argc == 4)) { fprintf(stderr, "Usage: %s [ " "]\en", argv[0]); exit(EXIT_FAILURE); } \& pid = atoi(argv[1]); /* PID du processus cible */ \& newp = NULL; if (argc == 4) { new.rlim_cur = atoi(argv[2]); new.rlim_max = atoi(argv[3]); newp = &new; } \& /* Définir la limite de temps CPU du processus cible ; récupérer et afficher la limite de temps CPU antérieure */ \& if (prlimit(pid, RLIMIT_CPU, newp, &old) == \-1) err(EXIT_FAILURE, "prlimit\-1"); printf("Limites précédentes : souple=%jd; stricte=%jd\en", (intmax_t) old.rlim_cur, (intmax_t) old.rlim_max); \& /* Récupérer et afficher la nouvelle limite de temps CPU */ \& if (prlimit(pid, RLIMIT_CPU, NULL, &old) == \-1) err(EXIT_FAILURE, "prlimit\-2"); printf("Nouvelles limites : souple=%jd; stricte=%jd\en", (intmax_t) old.rlim_cur, (intmax_t) old.rlim_max); \& exit(EXIT_SUCCESS); } .EE .\" SRC END .SH "VOIR AUSSI" \fBprlimit\fP(1), \fBdup\fP(2), \fBfcntl\fP(2), \fBfork\fP(2), \fBgetrusage\fP(2), \fBmlock\fP(2), \fBmmap\fP(2), \fBopen\fP(2), \fBquotactl\fP(2), \fBsbrk\fP(2), \fBshmctl\fP(2), \fBmalloc\fP(3), \fBsigqueue\fP (3), \fBulimit\fP(3), \fBcore\fP(5), \fBcapabilities\fP(7), \fBcgroups\fP(7), \fBcredentials\fP(7), \fBsignal\fP(7) .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Christophe Blaess , Stéphan Rafin , Thierry Vignaud , François Micaux, Alain Portal , Jean-Philippe Guérard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas François , Florentin Duneau , Simon Paillard , Denis Barbier , David Prévot , Cédric Boutillier , Frédéric Hantrais et Jean-Philippe MENGUAL . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .