perkamon - en to fr translation catalogue (61 entries)

note: type: TH
en: 2018-04-30
fr: 30 avril 2018

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: getrlimit, setrlimit, prlimit - get/set resource limits
fr: getrlimit, setrlimit, prlimit - Lire et écrire les limites et utilisations des ressources

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: struct rlimit {
        rlim_t rlim_cur;  /* Soft limit */
        rlim_t rlim_max;  /* Hard limit (ceiling for rlim_cur) */
    };
fr: struct rlimit {
      rlim_t rlim_cur; /* limite souple */
      rlim_t rlim_max; /* limite stricte (plafond
                          de rlim_cur) */
    };

note: type: Plain text
en: The value B<RLIM_INFINITY> denotes no limit on a resource (both in the structure returned by B<getrlimit>()  and in the structure passed to B<setrlimit>()).
fr: La valeur B<RLIM_INFINITY> indique une limite infinie pour la ressource (aussi bien pour B<getrlimit>() que pour B<setrlimit>()).

note: type: Plain text
en: The I<resource> argument must be one of:
fr: Le paramètre I<resource> doit être l'un des éléments suivants\ :

note: type: TP
en: B<RLIMIT_MSGQUEUE> (since Linux 2.6.8)
fr: B<RLIMIT_MSGQUEUE> (depuis Linux 2.6.8)

note: type: Plain text
en: where I<attr> is the I<mq_attr> structure specified as the fourth argument to B<mq_open>(3), and the I<msg_msg> and I<posix_msg_tree_node> structures are kernel-internal structures.
fr: où I<attr> est la structure I<mq_attr> passée comme quatrième argument à B<mq_open>(3), et I<msg_msg> et I<posix_msg_tree_node> sont les structures internes du noyau.

note: type: Plain text
en: The "overhead" addend in the formula accounts for overhead bytes required by the implementation and ensures that the user cannot create an unlimited number of zero-length messages (such messages nevertheless each consume some system memory for bookkeeping overhead).
fr: 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).

note: type: TP
en: B<RLIMIT_NICE> (since Linux 2.6.12, but see BUGS below)
fr: B<RLIMIT_NICE> (depuis Linux 2.6.12, consultez la section BOGUES ci\(hydessous)

note: type: TP
en: B<RLIMIT_RTPRIO> (since Linux 2.6.12, but see BUGS)
fr: B<RLIMIT_RTPRIO> (depuis Linux 2.6.12, mais consultez BOGUES)

note: type: TP
en: B<RLIMIT_RTTIME> (since Linux 2.6.25)
fr: B<RLIMIT_RTTIME> (depuis Linux 2.6.25)

note: type: Plain text
en: Upon reaching the soft limit, the process is sent a B<SIGXCPU> signal.  If the process catches or ignores this signal and continues consuming CPU time, then B<SIGXCPU> will be generated once each second until the hard limit is reached, at which point the process is sent a B<SIGKILL> signal.
fr: Quand la limite douce est atteinte, un signal B<SIGXCPU> est envoyé au processus. Si le processus attrape ou ignore ce signal et continue à consommer du temps CPU, alors un signal B<SIGXCPU> sera généré une fois par seconde jusqu'à ce que la limite dure soit atteinte, ce qui provoque l'envoie d'un signal B<SIGKILL> au processus.

note: type: Plain text
en: The intended use of this limit is to stop a runaway real-time process from locking up the system.
fr: L'objectif de cette limite est d'empêcher un processus temps réel fou de bloquer le système.

note: type: TP
en: B<RLIMIT_SIGPENDING> (since Linux 2.6.8)
fr: B<RLIMIT_SIGPENDING> (depuis Linux 2.6.8)

note: type: Plain text
en: Since Linux 2.6.23, this limit also determines the amount of space used for the process's command-line arguments and environment variables; for details, see B<execve>(2).
fr: 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 B<execve>(2) pour plus de détails.

note: commit c022a0acad534fd5f5d5f17280f6d4d135e74e81 Author: Jiri Slaby <jslaby@suse.cz> Date:   Tue May 4 18:03:50 2010 +0200 rlimits: implement prlimit64 syscall commit 6a1d5e2c85d06da35cdfd93f1a27675bfdc3ad8c Date:   Wed Mar 24 17:06:58 2010 +0100 rlimits: add rlimit64 structure type: Plain text
en: The Linux-specific B<prlimit>()  system call combines and extends the functionality of B<setrlimit>()  and B<getrlimit>().  It can be used to both set and get the resource limits of an arbitrary process.
fr: L'appel système B<prlimit>()  spécifique à Linux combine et étend les fonctionnalités de B<setrlimit>()  et B<getrlimit>(). Il peut être utilisé pour affecter ou récupérer les limites de ressources de tout processus.

note: type: Plain text
en: The I<resource> argument has the same meaning as for B<setrlimit>()  and B<getrlimit>().
fr: Le paramètre I<resource> a le même sens que dans B<setrlimit>()  et B<getrlimit>().

note: type: Plain text
en: If the I<new_limit> argument is a not NULL, then the I<rlimit> structure to which it points is used to set new values for the soft and hard limits for I<resource>.  If the I<old_limit> argument is a not NULL, then a successful call to B<prlimit>()  places the previous soft and hard limits for I<resource> in the I<rlimit> structure pointed to by I<old_limit>.
fr: Si le paramètre I<new_limit> ne vaut pas NULL, alors la structure I<rlimit> vers laquelle il pointe est utilisée pour affecter de nouvelles valeurs aux limites souples et strictes pour I<resource>. Si le paramètres I<old_limit> ne vaut pas NULL, alors un appel à B<prlimit>()  qui réussit place les limites antérieures souples et strictes pour I<resource> dans la structure I<rlimit> pointée par I<old_limit>.

note: type: SH
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: type: Plain text
en: On success, these system calls return 0.  On error, -1 is returned, and I<errno> is set appropriately.
fr: Ces appels système renvoient 0 en cas de succès, ou -1 en cas d'échec, auquel cas I<errno> contient le code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: A pointer argument points to a location outside the accessible address space.
fr: L'un des arguments pointe en\(hydehors de l'espace d'adressage accessible.

note: type: Plain text
en: The value specified in I<resource> is not valid; or, for B<setrlimit>()  or B<prlimit>(): I<rlim-E<gt>rlim_cur> was greater than I<rlim-E<gt>rlim_max>.
fr: La valeur spécifiée dans I<resource> n'est pas valide\ ; ou, pour B<setrlimit>()  ou B<prlimit>(), I<rlim-E<gt>rlim_cur> est plus grand que I<rlim-E<gt>rlim_max>.

note: type: Plain text
en: Could not find a process with the ID specified in I<pid>.
fr: Impossible de trouver un processus dont l'identifiant est indiqué par I<pid>.

note: type: Plain text
en: The B<prlimit>()  system call is available since Linux 2.6.36.  Library support is available since glibc 2.13.
fr: L'appel système B<prlimit>() est disponible depuis Linux 2.6.36 ; la prise en charge dans la glibc est disponible depuis la version\ 2.13.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: tbl table
en: Value
fr: Valeur

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: B<prlimit>(): Linux-specific.
fr: B<prlimit>() : spécifique à Linux.

note: type: Plain text
en: A child process created via B<fork>(2)  inherits its parent's resource limits.  Resource limits are preserved across B<execve>(2).
fr: Un processus fils créé avec B<fork>(2) hérite des limites de ressource de son père. Les limites de ressource sont préservées à travers un B<execve>(2).

note: type: Plain text
en: Lowering the soft limit for a resource below the process's current consumption of that resource will succeed (but will prevent the process from further increasing its consumption of the resource).
fr: 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).

note: type: Plain text
en: One can set the resource limits of the shell using the built-in I<ulimit> command (I<limit> in B<csh>(1)).  The shell's resource limits are inherited by the processes that it creates to execute commands.
fr: On peut définir les limites de ressources de l'interpréteur de commandes en utilisant la commande interne I<ulimit> (I<limit> dans B<csh>(1)). Les limites de ressources de l'interpréteur de commandes sont héritées par les processus qu'il crée pour exécuter les commandes.

note: type: Plain text
en: Since Linux 2.6.24, the resource limits of any process can be inspected via I</proc/[pid]/limits>; see B<proc>(5).
fr: À partir de Linux 2.6.24, les limites de ressource de n'importe quel processus peuvent être examinées en consultant I</proc/[pid]/limits> ; consultez B<proc>(5).

note: type: Plain text
en: Ancient systems provided a B<vlimit>()  function with a similar purpose to B<setrlimit>().  For backward compatibility, glibc also provides B<vlimit>().  All new applications should be written using B<setrlimit>().
fr: Des systèmes anciens fournissent une fonction B<vlimit>() qui remplit le même rôle que B<setrlimit>(). Pour des raisons de compatibilité ascendante, la glibc fournit aussi une fonction B<vlimit>(), mais toutes les nouvelles applications devraient utiliser B<setrlimit>().

note: type: SS
en: C library/kernel ABI differences
fr: différences entre la bibliothèque C et l'ABI du noyau

note: type: Plain text
en: Since version 2.13, the glibc B<getrlimit>()  and B<setrlimit>()  wrapper functions no longer invoke the corresponding system calls, but instead employ B<prlimit>(), for the reasons described in BUGS.
fr: A partir de la version 2.13, les fonctions d'enrobage B<getrlimit>() and B<setrlimit>() de glibc n'appellent plus les appels systèmes correspondant, mais utilisent B<prlimit>(), pour les raisons indiquées dans BUGS.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: In older Linux kernels, the B<SIGXCPU> and B<SIGKILL> signals delivered when a process encountered the soft and hard B<RLIMIT_CPU> limits were delivered one (CPU) second later than they should have been.  This was fixed in kernel 2.6.8.
fr: Dans les noyaux Linux plus anciens, les signaux B<SIGXCPU> et B<SIGKILL> envoyés lorsqu'un processus dépassait les limites souple et stricte pour B<RLIMIT_CPU> étaient envoyés une seconde (CPU) plus tard qu'ils n'auraient dû l'être. Cela a été corrigé dans le noyau 2.6.8.

note: see http://marc.theaimsgroup.com/?l=linux-kernel&m=114008066530167&w=2 type: Plain text
en: In 2.6.x kernels before 2.6.17, a B<RLIMIT_CPU> limit of 0 is wrongly treated as "no limit" (like B<RLIM_INFINITY>).  Since Linux 2.6.17, setting a limit of 0 does have an effect, but is actually treated as a limit of 1 second.
fr: Dans les noyaux de la série 2.6 antérieurs à 2.6.17, une limite B<RLIMIT_CPU> à 0 est interprétée par erreur comme «\ pas de limite\ » (comme B<RLIM_INFINITY>). Depuis Linux 2.6.17, définir la limite à 0 a un effet, mais la limite est en fait d'une seconde.

note: See https://lwn.net/Articles/145008/ type: Plain text
en: A kernel bug means that B<RLIMIT_RTPRIO> does not work in kernel 2.6.12; the problem is fixed in kernel 2.6.13.
fr: En raison d'un bogue du noyau, B<RLIMIT_RTPRIO> ne marche pas dans le noyau 2.6.12\ ; le problème a été corrigé dans le noyau 2.6.13.

note: see http://marc.theaimsgroup.com/?l=linux-kernel&m=112256338703880&w=2 type: Plain text
en: In kernel 2.6.12, there was an off-by-one mismatch between the priority ranges returned by B<getpriority>(2)  and B<RLIMIT_NICE>.  This had the effect that the actual ceiling for the nice value was calculated as I<19\ -\ rlim_cur>.  This was fixed in kernel 2.6.13.
fr: Dans le noyau 2.6.12, il y avait une différence de 1 entre les valeurs de priorité renvoyées par B<getpriority>(2) et B<RLIMIT_NICE>. Du coup, la limite réelle pour la valeur de politesse était calculée comme I<19\ -\ rlim_cur>. Ceci est corrigé depuis le noyau 2.6.13.

note: The relevant patch, sent to LKML, seems to be http://thread.gmane.org/gmane.linux.kernel/273462 From: Roland McGrath <roland <at> 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.kern
en: Since Linux 2.6.12, if a process reaches its soft B<RLIMIT_CPU> limit and has a handler installed for B<SIGXCPU>, then, in addition to invoking the signal handler, the kernel increases the soft limit by one second.  This behavior repeats if the process continues to consume CPU time, until the hard limit is reached, at which point the process is killed.  Other implementations do not change the B<RLIMIT_CPU> soft limit in this manner, and the Linux behavior is probably not standards conformant; portable applications should avoid relying on this Linux-specific behavior.  The Linux-specific B<RLIMIT_RTTIME> limit exhibits the same behavior when the soft limit is encountered.
fr: A partir de Linux 2.6.12, si un processus atteint sa limite souple B<RLIMIT_CPU> et qu'il dispose d'un gestionnaire pour B<SIGXCPU>, 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 B<RLIMIT_CPU> 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 B<RLIMIT_RTTIME> se comporte de façon analogue lorsque la limite souple est atteinte.

note: d3561f78fd379a7110e46c87964ba7aa4120235c type: Plain text
en: Kernels before 2.4.22 did not diagnose the error B<EINVAL> for B<setrlimit>()  when I<rlim-E<gt>rlim_cur> was greater than I<rlim-E<gt>rlim_max>.
fr: Les noyaux antérieurs à 2.4.22 ne détectaient pas l'erreur B<EINVAL> pour B<setrlimit>() quand I<rlim-E<gt>rlim_cur> était plus grand que I<rlim-E<gt>rlim_max>.

note: type: SS
en: Representation of "large" resource limit values on 32-bit platforms
fr: Représentation des limites de ressources de grande taille sur les plate-formes 32 bits

note: type: Plain text
en: To work around this kernel limitation, if a program tried to set a resource limit to a value larger than can be represented in a 32-bit I<unsigned long>, then the glibc B<setrlimit>()  wrapper function silently converted the limit value to B<RLIM_INFINITY>.  In other words, the requested resource limit setting was silently ignored.
fr: 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 I<unsigned long> de 32 bits, la fonction d'enrobage de glibc B<setrlimit>() change implicitement la valeur de la limite en B<RLIM_INFINITY>. Autrement dit, l'affectation de la limite de ressource n'est pas prise en compte, et cela sans aucune notification.

note: https://www.sourceware.org/bugzilla/show_bug.cgi?id=12201 type: Plain text
en: Since version 2.13, glibc works around the limitations of the B<getrlimit>()  and B<setrlimit>()  system calls by implementing B<setrlimit>()  and B<getrlimit>()  as wrapper functions that call B<prlimit>().
fr: Depuis la version 2.13, glibc contourne ces limitations des appels système B<getrlimit>() et B<setrlimit>() en fournissant les fonctions d'enrobage B<setrlimit>() et B<getrlimit>() qui font appel à B<prlimit>().

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The program below demonstrates the use of B<prlimit>().
fr: Le programme ci-dessous démontre l'utilisation de B<prlimit>().

note: type: Plain text
en:     if (!(argc == 2 || argc == 4)) {
            fprintf(stderr, "Usage: %s E<lt>pidE<gt> [E<lt>new-soft-limitE<gt> "
                    "E<lt>new-hard-limitE<gt>]\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (!(argc == 2 || argc == 4)) {
            fprintf(stderr, "Usage: %s E<lt>pidE<gt> [E<lt>nouvelle-limite-soupleE<gt> "
                    "E<lt>nouvelle-limite-stricteE<gt>]\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     pid = atoi(argv[1]);        /* PID of target process */
fr:     pid = atoi(argv[1]);        /* PID du processus cible */

note: type: Plain text
en:     /* Set CPU time limit of target process; retrieve and display
           previous limit */
fr:     /* Définir la limite de temps CPU du processus cible ;
           récupérer et afficher la limite de temps CPU antérieure */

note: type: Plain text
en:     if (prlimit(pid, RLIMIT_CPU, newp, &old) == -1)
            errExit("prlimit-1");
        printf("Previous limits: soft=%lld; hard=%lld\en",
                (long long) old.rlim_cur, (long long) old.rlim_max);
fr:     if (prlimit(pid, RLIMIT_CPU, newp, &old) == -1)
            errExit("prlimit-1");
        printf("Limites précédentes : souple=%lld; stricte=%lld\en",
                (long long) old.rlim_cur, (long long) old.rlim_max);

note: type: Plain text
en:     /* Retrieve and display new CPU time limit */
fr:     /* Récupérer et afficher la nouvelle limite de temps CPU */

note: type: Plain text
en:     if (prlimit(pid, RLIMIT_CPU, NULL, &old) == -1)
            errExit("prlimit-2");
        printf("New limits: soft=%lld; hard=%lld\en",
                (long long) old.rlim_cur, (long long) old.rlim_max);
fr:     if (prlimit(pid, RLIMIT_CPU, NULL, &old) == -1)
            errExit("prlimit-2");
        printf("Nouvelles limites: souple=%lld; stricte=%lld\en",
                (long long) old.rlim_cur, (long long) old.rlim_max);

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.03 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.02 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.01 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.
