Provided by: manpages-fr-dev_4.18.1-1_all bug

NOM

       ioprio_get, ioprio_set - Lire et écrire la classe et la priorité d'ordonnancement des E/S

BIBLIOTHÈQUE

       Bibliothèque C standard (libc, -lc)

SYNOPSIS

       #include <linux/ioprio.h>    /* Definition des constantes IOPRIO_* */
       #include <sys/syscall.h>     /* Definition des constantes SYS_* */
       #include <unistd.h>

       int syscall(SYS_ioprio_get, int which, int who);
       int syscall(SYS_ioprio_set, int which, int who, int ioprio);

       Note :  la  glibc ne fournit pas de fonction autour de cet appel système, l'utilisation de
       syscall(2) est requise.

DESCRIPTION

       Les appels système ioprio_get() et  ioprio_set()  lisent  et  écrivent  la  classe  et  la
       priorité d'ordonnancement des entrées et sorties pour un ou plusieurs processus.

       Les  arguments  which  et  who identifient le(s) thread(s) sur lesquels les appels système
       agissent. L'argument which détermine comment  who  est  interprété,  et  prend  l'une  des
       valeurs suivantes :

       IOPRIO_WHO_PROCESS
              who  est l'identifiant d'un processus ou d'un thread. Si who vaut 0, alors l'action
              s'applique au thread appelant.

       IOPRIO_WHO_PGRP
              who est l'identifiant d'un groupe de processus et se réfère à tous les  membres  de
              ce  groupe.  Si who vaut 0, alors l'action s'applique au groupe de processus auquel
              l'appelant appartient.

       IOPRIO_WHO_USER
              who est un UID identifiant tous les processus dont l'UID réel correspond.

       Si which vaut IOPRIO_WHO_PGRP ou IOPRIO_WHO_USER à l'appel de  ioprio_get(),  et  si  plus
       d'un  processus  correspond  à who, la priorité renvoyée sera la plus grande des priorités
       des processus correspondants. Une priorité est dite  plus  grande  qu'une  autre  si  elle
       appartient  à  une  classe  de  priorité supérieure (IOPRIO_CLASS_RT est la classe la plus
       haute ; IOPRIO_CLASS_IDLE est la plus basse) ou si elle appartient à la même classe mais a
       un niveau de priorité plus élevé (donc un numéro de priorité plus faible).

       L'argument  ioprio  donné  à  ioprio_set() est un masque de bits indiquant la classe et la
       priorité à donner au(x) processus cible(s). Les macros suivantes  servent  à  créer  et  à
       tester les valeurs ioprio :

       IOPRIO_PRIO_VALUE(class, data)
              Étant  données  une  classe  d'ordonnancement (class) et une priorité (data), cette
              macro combine les deux valeurs pour créer une valeur ioprio, qui est renvoyée comme
              résultat.

       IOPRIO_PRIO_CLASS(mask)
              À  partir  de  mask  (une  valeur  ioprio)  cette  macro  renvoie  sa classe d'E/S,
              c'est-à-dire    une    valeur    parmi    IOPRIO_CLASS_RT,    IOPRIO_CLASS_BE    et
              IOPRIO_CLASS_IDLE.

       IOPRIO_PRIO_DATA(mask)
              Étant donné mask (une valeur ioprio), renvoie la priorité (data) correspondante.

       Consultez  la  section  NOTES  pour  plus  d'informations  sur  les  classes  et priorités
       d'ordonnancement ainsi que sur le sens de positionner ioprio à 0.

       Les priorités d'E/S sont gérées  pour  les  lectures  et  pour  les  écritures  synchrones
       (O_DIRECT,  O_SYNC). Les priorités d'E/S ne sont pas gérées pour les écritures asynchrones
       parce qu'elles sont lancées hors du contexte du programme touchant la mémoire, ce qui fait
       que les priorités spécifiques à chaque programme ne s'appliquent pas.

VALEUR RENVOYÉE

       Lorsqu'il  réussit,  ioprio_get()  renvoie  la valeur ioprio du processus dont la priorité
       d'E/S est la plus grande parmi les processus correspondant aux critères indiqués par which
       et who. En cas d'erreur, -1 est renvoyé, et errno contient le code d'erreur.

       S'il  réussit,  ioprio_set() renvoie zéro. En cas d'erreur, il renvoie -1 et remplit errno
       avec la valeur d'erreur.

ERREURS

       EINVAL which ou ioprio est invalide. Consultez  la  section  NOTES  pour  les  classes  et
              priorités d'ordonnancement disponibles pour ioprio.

       EPERM  Le  processus  appelant  n'a  pas  les  privilèges nécessaires pour attribuer cette
              priorité ioprio au(x) processus indiqué(s). Consultez la section  NOTES  pour  plus
              d'informations sur les privilèges nécessaires pour ioprio_set().

       ESRCH  Aucun processus ne correspond aux critères indiqués par which et who.

VERSIONS

       Ces appels système sont disponibles sous Linux depuis le noyau 2.6.13.

STANDARDS

       Ces appels système sont spécifiques à Linux.

NOTES

       Plusieurs processus ou threads peuvent partager un contexte d'entrées-sorties. Cela est le
       cas lorsque clone(2) a été appelé avec l'attribut CLONE_IO.  Cependant,  par  défaut,  les
       threads distincts d'un processus ne partagent pas le même contexte d'entrées-sorties. Cela
       signifie que si vous voulez changer la priorité d'entrées-sortie de tous les threads  d'un
       processus,  il  peut  être  nécessaire  d'appeler  ioprio_set() sur chacun de ces threads.
       L'identifiant du thread nécessaire pour cette  opération  est  renvoyé  par  gettid(2)  ou
       clone(2).

       Ces  appels  système n'ont d'effet que lorsqu'ils sont utilisés avec un ordonnanceur d'E/S
       qui gère  les  priorités  d'E/S.  Sous  Linux  2.6.17,  l'ordonnanceur  « Completely  Fair
       Queuing » (CFQ) est le seul ordonnanceur d'E/S de ce type.

       Si  aucun  ordonnanceur d'E/S n'a été défini pour un thread, la priorité par défaut suivra
       la valeur de politesse du processeur ((setpriority(2)). Dans les noyaux Linux antérieurs à
       la  version  2.6.24, une fois qu'une priorité d'E/S avait été positionnée ioprio_set(), il
       n'y avait aucun moyen de réinitialiser le comportement de l'ordonnancement E/S à celui par
       défaut.  Depuis  Linux  2.6.24,  on  peut  positionner  ioprio sur 0 pour réinitialiser le
       comportement d'ordonnancement des E/S à celui par défaut.

   Choisir un ordonnanceur d'E/S
       Les ordonnanceurs d'E/S sont sélectionnés pour chaque périphérique par le fichier  spécial
       /sys/block/<device>/queue/scheduler.

       On  peut  voir  quel  ordonnanceur  d'E/S  est  actuellement sélectionné via le système de
       fichiers /sys. Par exemple, la  commande  suivante  affiche  la  liste  des  ordonnanceurs
       chargés dans le noyau :

           $ cat /sys/block/sda/queue/scheduler
           noop anticipatory deadline [cfq]

       L'ordonnanceur  entre  crochets  est  celui qui est utilisé pour le périphérique (sda dans
       l'exemple). Pour choisir un autre ordonnanceur, on écrit son  nom  dans  ce  fichier.  Par
       exemple, la commande suivante définit l'ordonnanceur pour le périphérique sda à cfq :

           $ su
           Password:
           # echo cfq > /sys/block/sda/queue/scheduler

   L'ordonnanceur d'E/S « Completely Fair Queuing » (CFQ)
       Depuis  la  version 3 (« CFQ Time Sliced »), CFQ implémente des niveaux de politesse d'E/S
       similaires à ceux de l'ordonnancement CPU. Ces niveaux de politesse sont groupés en  trois
       classes  d'ordonnancement,  chacune  de  ces  classes contenant un ou plusieurs niveaux de
       priorité :

       IOPRIO_CLASS_RT (1)
              Il s'agit de la classe d'E/S  temps  réel.  Cette  classe  d'ordonnancement  a  une
              priorité  plus grande que toutes les autres classes : les processus de cette classe
              ont toujours accès au disque en premier. Cette classe d'E/S doit donc être utilisée
              avec  parcimonie :  un  seul processus avec des E/S temps réel peut bloquer tout le
              système. Au sein de la classe temps  réel,  il  y  a  8  niveaux  de  priorité  qui
              déterminent  exactement pendant combien de temps ce processus aura besoin du disque
              à chaque service. La plus haute priorité temps réel est 0 ; la plus  basse  est  7.
              Dans  le  futur,  ceci  pourra  changer  afin  d'être plus directement corrélé à la
              performance, en passant le débit de données souhaité à la place de la priorité.

       IOPRIO_CLASS_BE (2)
              Classe d'ordonnancement « best-effort », qui  est  utilisée  par  défaut  pour  les
              processus  qui  n'ont  pas  indiqué  de priorité d'E/S particulière. La priorité de
              classe détermine combien de  bande  passante  d'E/S  le  processus  obtiendra.  Les
              niveaux  de  priorité  best-effort  sont  similaires  aux  valeurs de politesse CPU
              (consultez getpriority(2)). Le  niveau  de  priorité  détermine  une  priorité  par
              rapport  aux  autres  processus  dans  la  classe d'ordonnancement best-effort. Les
              niveaux de priorité vont de 0 (plus prioritaire) à 7 (moins prioritaire).

       IOPRIO_CLASS_IDLE (3)
              Classe  d'ordonnancement  « idle ».  Les  processus   s'exécutant   à   ce   niveau
              n'obtiennent  du  temps d'E/S que lorsque personne d'autre n'a besoin du disque. La
              classe idle n'a pas de donnée (priorité) de classe. Il faut faire attention lorsque
              l'on met un processus dans cette classe de priorité, car il peut être bloqué si des
              processus de plus haute priorité accèdent constamment au disque.

       Consultez Documentation/block/ioprio.txt pour plus d'informations sur l'ordonnanceur d'E/S
       CFQ et un exemple de programme.

   Permissions nécessaires pour définir les priorités d'E/S
       La  permission  de modifier la priorité d'un processus est accordée ou refusée en fonction
       de deux critères :

       Propriétaire du processus
              Un processus non privilégié ne peut définir la priorité  d'E/S  que  des  processus
              dont  l'UID  réel  est  égal  à  l'UID  réel  ou effectif du processus appelant. Un
              processus ayant la capacité CAP_SYS_NICE peut modifier  la  priorité  de  n'importe
              quel processus.

       Priorité désirée
              Pour  pouvoir  définir une priorité très haute ((IOPRIO_CLASS_RT), il faut avoir la
              capacité CAP_SYS_ADMIN.  Les  noyaux  antérieurs  à  2.6.24  (compris)  nécessitent
              également CAP_SYS_ADMIN pour définir une priorité très faible ((IOPRIO_CLASS_IDLE),
              mais depuis 2.6.25, ce n'est plus le cas.

       Un appel à ioprio_set() doit suivre ces deux règles, sans quoi  il  échoue  avec  l'erreur
       EPERM.

BOGUES

       La  glibc  ne  fournit  pas  encore  de  fichier  d'en‐tête  définissant les prototypes de
       fonctions et les macros  décrits  dans  cette  page.  Les  définitions  se  trouvent  dans
       linux/ioprio.h.

VOIR AUSSI

       ionice(1), getpriority(2), open(2), capabilities(7), cgroups(7)

       Documentation/block/ioprio.txt dans les sources du noyau Linux

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  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  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⟩.