getrlimit, getrusage, setrlimit - Lire/écrire les limites et utilisations des ressources.

#include <sys/time.h>

#include <sys/resource.h>

#include <unistd.h> int getrlimit (int resource, struct rlimit *rlim);

int getrusage (int who, struct rusage *usage);

int setrlimit (int resource, const struct rlimit *rlim);

getrlimit et setrlimit lisent ou écrivent les limites des ressources systèmes. Chaque ressource a une limite souple et une limite stricte définies par la structure rlimit (l'argument rlim de getrlimit() et setrlimit()) :

struct rlimit {
  rlim_t rlim_cur; /* limite souple */
  rlim_t rlim_max; /* limite stricte (plafond
                      de rlim_cur) */
};

La valeur RLIM_INFINITY indique une limite infinie pour la ressource (aussi bien pour getrlimit() que pour setrlimit()).

resource doit être l'un des éléments suivants :

RLIMIT_AS

Taille maximum de la mémoire virtuelle du processus en octets. The maximum size of the process's virtual memory (address space) in bytes. Cette limite affecte les appels à brk(2), mmap(2) et mremap(2), qui échouent avec l'erreur ENOMEM en cas de dépassement de cette limite. De même, l'extension de la pile automatique échouera (et génèrera un SIGSEGV qui tuera le processus si aucune pile alternative n'est disponible). Depuis que cette valeur est de type long, sur les machines où le type long est sur 32 bits, soit cette limite est au plus 2 GiB, soit cette ressource est illimitée.

RLIMIT_CORE

Taille maximum du fichier core. 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.

RLIMIT_CPU

Limite de temps CPU en secondes. Si un processus atteint cette limite souple, il reçoit le signal SIGXCPU. L'action par défaut en est la terminaison du processus. Mais le signal peut être capturé et le gestionnaire peut renvoyer le contrôle au programme principal. Si le processus continue à consommer du temps CPU, il recevra SIGXCPU toutes les secondes jusqu'à atteindre sa limite stricte, où il recevra SIGKILL. (Ceci correspond au comportement de Linux 2.2 et 2.4. Les implémentations varient sur le comportement vis-à-vis d'un 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 SIGXCPU).

RLIMIT_DATA

Taille maximale du segment de données d'un processus (données initialisées, non-initialisées, et tas). Cette limite affecte les appels brk() et sbrk(), qui échouent avec l'erreur ENOMEM si la limite souple est dépassée.

RLIMIT_FSIZE

Taille maximale d'un fichier que le processus peut créer. Les tentatives d'extension d'un fichier au-delà de cette limite résultent en un signal SIGXFSZ. Par défaut ce signal termine le processus, mais il peut être capturé, et dans ce cas l'appel-système concerné (par exemple write(), truncate()) échoue avec l'erreur EFBIG.

RLIMIT_LOCKS

Une limite sur le nombre combiné de verrous flock() et fcntl() que le processus peut établir. (Premiers Linux 2.4 seulement).

RLIMIT_MEMLOCK

Le nombre maximal d'octets de mémoire virtuelle que le processus peut verrouiller en RAM à l'aide des appels lock() et mlockall().

RLIMIT_NOFILE

Le nombre maximal de descripteurs de fichiers qu'un processus peut ouvrir simultanément. Les tentatives d'ouverture (open(), pipe(), dup(), etc) dépassant cette limite renverront l'erreur EMFILE.

RLIMIT_NPROC

Le nombre maximum de processus qui peuvent être créés pour l'UID réel du processus appelant. Une fois cette limite atteinte, fork() échoue avec l'erreur EAGAIN.

RLIMIT_RSS

Indique la limite (en pages) pour la taille de l'ensemble résident du processus (le nombre de page de mémoire virtuelle en RAM). Cette limite n'a d'effet que depuis Linux 2.4, et n'affecte que les appels madvise() indiquant MADVISE_WILLNEED.

RLIMIT_STACK

La taille maximale de la pile du processus, en octets. Une fois cette limite atteinte, un signal SIGSEGV est déclenché. Pour gérer ce signal, le processus doit utiliser une pile spécifique pour signaux (sigaltstack(2)).

RLIMIT_OFILE est le nom BSD pour RLIMIT_NOFILE. getrusage renvoie l'utilisation courante des ressources, pour who valant RUSAGE_SELF ou RUSAGE_CHILDREN. Le premier correspond aux ressources consommées par le processus appelant et le second par l'ensemble des processus fils terminés qui ont été attendus par un wait().

struct rusage {
  struct timeval ru_utime; /* Temps utilisateur écoulé         */
  struct timeval ru_stime; /* Temps système écoulé             */
  long  ru_maxrss;         /* Taille résidente maximale        */
  long  ru_ixrss;          /* Taille de mémoire partagée       */
  long  ru_idrss;          /* Taille des données non partagées */
  long  ru_isrss;          /* Taille de pile                   */
  long  ru_minflt;         /* Demandes de pages                */
  long  ru_majflt;         /* Nombre de fautes de pages        */
  long  ru_nswap;          /* Nombre de swaps                  */
  long  ru_inblock;        /* Nombre de lectures de blocs      */
  long  ru_oublock;        /* Nombre d'écritures de blocs      */
  long  ru_msgsnd;         /* Nombre de messages émis          */
  long  ru_msgrcv;         /* Nombre de messages reçus         */
  long  ru_nsignals;       /* Nombre de signaux reçus          */
  long  ru_nvcsw;          /* Chgmnts de contexte volontaires  */
  long  ru_nivcsw;         /* Chgmnts de contexte involontaires*/
};

Ces fonctions renvoient 0 si elles réussissent, ou -1 si elles échouent, auquel cas errno contient le code d'erreur.

EFAULT

rlim ou usage pointe en dehors de l'espace d'adressage disponible.

EINVAL

getrlimit ou setrlimit est appelé avec un mauvais argument resource, ou getrusage est appelé avec un mauvais argument who.

EPERM

Tentative d'utiliser setrlimit()sansêtresuper-utilisateurpour augmenter ses limites, ou alors le super-utilisateur essaye d'augmenter les limites au-dessus des maxima du noyau.

SVr4, BSD 4.3

L'inclusion de <sys/time.h> n'est plus obligatoire mais améliore la portabilité. (En fait, struct timeval est définie dans <sys/time.h>).

Sous Linux, si le traitement de SIGCHLD est configuré avec SIG_IGN, les statistiques d'utilisation des processus enfants sont automatiquement incluses dans les valeurs renvoyées par RUSAGE_CHILDREN, bien que POSIX 1003.1-2001 interdise explicitement cela.

Les structures ci-dessous sont extraites de BSD 4.3 Reno. Tous les champs ne sont pas significatifs sous Linux. Actuellement (Linux 2.4, 2.6) seuls les champs ru_utime, ru_stime, ru_minflt, ru_majflt, et ru_nswap sont remplis.

dup(2), fcntl(2), fork(2), mlock(2), mlockall(2), mmap(2), open(2), quotactl(2), sbrk(2), wait3(2), wait4(2), malloc(3), ulimit(3), signal(7)

Christophe Blaess, 1996-2003.