Provided by: manpages-fr-dev_4.13-4_all bug

NOM

       getitimer, setitimer - Lire/écrire la valeur d'une temporisation

SYNOPSIS

       #include <sys/time.h>

       int getitimer(int which, struct itimerval *curr_value);
       int setitimer(int which, const struct itimerval *new_value,
                     struct itimerval *old_value);

DESCRIPTION

       Ces  appels  système donnent accès à des temporisations d'intervalle, c'est-à-dire des temporisations qui
       expirent en premier à un moment du futur et (éventuellement)  à  des  intervalles  réguliers  après  lui.
       Lorsqu'une  temporisation  expire,  un  signal  est  envoyé au processus appelant et la temporisation est
       réinitialisée à l'intervalle spécifié (s'il n'est pas nul).

       Trois types de minuteries — indiquées par le paramètre which — sont fournis, chacun comptant par  rapport
       à une horloge différente et générant un signal différent à l'expiration de la minuterie :

       ITIMER_REAL
              Cette  minuterie  compte en temps réel (à savoir celui de la pendule murale). À chaque expiration,
              un signal SIGALRM est généré.

       ITIMER_VIRTUAL
              Cette minuterie compte par rapport au temps du processeur en  mode  utilisateur  consommé  par  le
              processus  (la  mesure comprend le temps processeur consommé par tous les threads du processus). À
              chaque expiration, un signal SIGVTALRM est généré.

       ITIMER_PROF
              Cette minuterie compte par rapport au temps total de processeur (à savoir celui  de  l'utilisateur
              et du système) consommé par le processus (la mesure comprend le temps processeur consommé par tous
              les threads du processus). À chaque expiration, un signal SIGPROF est généré.

              Conjuguée  à ITIMER_VIRTUAL, cette minuterie peut être utilisée pour tracer le temps processeur du
              système et de l'utilisateur consommé par le processus.

       Un processus n'a qu'un des trois types de minuterie.

       Les valeurs des temporisations sont définies avec les structures suivantes :

           struct itimerval {
               struct timeval it_interval;  /* Intervalle pour les
                                                minuteries périodiques */
               struct timeval it_value;     /* Délai jusqu'à la prochaine
                                                expiration */
           };

           struct timeval {
               time_t tv_sec;                /* secondes        */
               suseconds_t tv_usec;          /* microsecondes   */
           };

   getitimer()
       La fonction getitimer() met la valeur actuelle de la temporisation indiquée dans  which  dans  le  tampon
       vers lequel pointe curr_value.

       La  sous-structure it_value est peuplée par la quantité de temps restant avant la prochaine expiration de
       la minuterie indiquée. Cette valeur change pendant le décompte de la minuterie et  sera  réinitialisée  à
       it_interval  quand  la  minuterie expirera. Si les deux champs de it_value sont nuls, cette minuterie est
       alors désarmée (inactive).

       La sous-structure it_interval est peuplée par l'intervalle de la temporisation. Si  les  deux  champs  de
       it_interval sont nuls, il s'agit d'une minuterie à un temps (c'est-à-dire qu'elle n'expire qu'une fois).

   setitimer()
       La  fonction  setitimer() arme ou désarme la temporisation indiquée dans which, en positionnant la valeur
       de la temporisation sur la valeur indiquée par new_value. Si old_value n'est pas  NULL,  le  tampon  vers
       lequel il pointe est utilisé pour renvoyer la valeur précédente de la temporisation (c'est-à-dire la même
       information renvoyée par getitimer()).

       Si  un  champ  new_value.it_value  est  positif, la minuterie est armée pour expirer en premier au moment
       spécifié. Si les deux champs de new_value.it_value valent zéro, la minuterie est désarmée.

       Le champ new_value.it_interval indique le nouvel intervalle de la minuterie ;  si  ses  deux  sous-champs
       sont nuls, la minuterie est configurée pour n'expirer qu'une seule fois.

VALEUR RENVOYÉE

       En cas de succès, zéro est renvoyé. En cas d'erreur, -1 est renvoyé et errno reçoit une valeur adéquate.

ERREURS

       EFAULT new_value, old_value ou curr_value n'est pas un pointeur valable.

       EINVAL which  n'est  ni  ITIMER_REAL, ni ITIMER_VIRTUAL, ni ITIMER_PROF ; ou (depuis Linux 2.6.22) un des
              champs tv_usec dans la structure pointée par new_value contient une valeur hors de l'intervalle  0
              à 999999.

CONFORMITÉ

       POSIX.1-2001,  SVr4,  4.4BSD  (cet  appel  est  apparu  dans  4.2BSD). POSIX.1-2008 marque getitimer() et
       setitimer() comme étant obsolètes, en recommandant d'utiliser à la place l'API des  temporisations  POSIX
       (timer_gettime(2), timer_settime(2), etc.).

NOTES

       Les  temporisations  n'expirent jamais avant la fin du temps demandé, mais elles peuvent expirer après un
       court moment après la fin, qui dépend de la résolution de l’horloge système et de la charge du  système ;
       consultez  time(7) (mais consultez la section BOGUES ci‐dessous). Si la temporisation expire alors que le
       processus est actif (toujours vrai avec ITIMER_VIRTUAL), le signal sera délivré  immédiatement  après  sa
       création.

       Un enfant créé avec fork(2) n'hérite pas des temporisations périodiques de son parent. Les temporisations
       périodiques sont conservées au travers d'un execve(2).

       POSIX.1  laisse  indéterminées  les  interactions  entre  setitimer()  et  les trois interfaces alarm(2),
       sleep(3) et usleep(3).

       Les normes ne donnent pas la signification de l'appel :

           setitimer(which, NULL, &old_value);

       De nombreux systèmes d'exploitation (Solaris, les BSD et peut-être  d'autres)  le  traitent  comme  étant
       équivalent à :

           getitimer(which, &old_value);

       Dans  Linux,  il  est  traité  comme étant équivalent à un appel dans lequel les champs de new_value sont
       égaux  à  zéro,  ce  qui  correspondrait  à  une   temporisation   désactivée.   N'utilisez   pas   cette
       non-fonctionnalité de Linux : elle est non portable et inutile.

BOGUES

       Sous  Linux,  l'émission et la réception d'un signal sont distinctes, et une seule instance de chacun des
       signaux peut être en attente pour un processus. Il est ainsi possible qu'avec  une  charge  système  très
       élevée,  une  temporisation  ITIMER_REAL expire avant que le signal d'une expiration précédente n'ait été
       reçu. Le second signal sera alors perdu.

       Sous les noyaux Linux antérieurs au 2.6.16, les valeurs des temporisations sont exprimées en « jiffies ».
       Si une temporisation est initialisée à une valeur en jiffies dépassant  la  constante  MAX_SEC_IN_JIFFIES
       (définie  dans  include/linux/jiffies.h),  la  temporisation  est silencieusement tronquée à cette valeur
       maximale.  Sous  Linux  sur  i386  (où,  depuis  Linux 2.6.13,  un  jiffy  correspond  par  défaut  à   4
       millisecondes),  cela signifie que la valeur maximale d'une temporisation est environ 99,42 jours. Depuis
       Linux 2.6.16, le noyau utilise une représentation interne du temps différente et le plafond est supprimé.

       Sur certains systèmes (y compris i386), les noyaux Linux avant la version 2.6.12 ont un bogue  qui  cause
       des  expirations  prématurées  de  temporisation,  avec  une  avance  pouvant aller jusqu'à un jiffy dans
       certaines circonstances. Ce bogue est corrigé dans Linux 2.6.12.

       Selon POSIX.1-2001, setitimer() devrait échouer si la valeur de tv_usec fournie  n'est  pas  entre  0  et
       999999.  Cependant,  dans  les  noyaux  de  version  inférieure  ou  égale à 2.6.21, Linux ne renvoie pas
       d'erreur, et se contente d'ajuster la valeur de tv_sec correspondante. Depuis le noyau 2.6.22, cette  non
       conformité a été corrigée ; une valeur non valable de tv_usec résulte en une erreur EINVAL.

VOIR AUSSI

       gettimeofday(2), sigaction(2), signal(2), timer_create(2), timerfd_create(2), time(7)

COLOPHON

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

TRADUCTION

       La  traduction  française   de   cette   page   de   manuel   a   été   créée   par   Christophe   Blaess
       <https://www.blaess.fr/christophe/>,   Stéphan   Rafin   <stephan.rafin@laposte.net>,   Thierry   Vignaud
       <tvignaud@mandriva.com>, François Micaux, Alain Portal  <aportal@univ-montp2.fr>,  Jean-Philippe  Guérard
       <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-luc.coulon@wanadoo.fr>,   Julien   Cristau
       <jcristau@debian.org>,     Thomas     Huriaux      <thomas.huriaux@gmail.com>,      Nicolas      François
       <nicolas.francois@centraliens.net>,     Florentin     Duneau    <fduneau@gmail.com>,    Simon    Paillard
       <simon.paillard@resel.enst-bretagne.fr>,    Denis    Barbier    <barbier@debian.org>,    David     Prévot
       <david@tilapin.org>,     Cédric     Boutillier     <cedric.boutillier@gmail.com>,    Frédéric    Hantrais
       <fhantrais@gmail.com> et Jean-Philippe MENGUAL <jpmengual@debian.org>

       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.

Linux                                             11 avril 2020                                     GETITIMER(2)