Provided by: manpages-fr-dev_3.65d1p1-1_all bug

NOM

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

SYNOPSIS

       int ioprio_get(int which, int who);
       int ioprio_set(int which, int who, int ioprio);

       Note : il n'y a pas de fonctions d'enrobage pour ces appels système. Consultez les NOTES.

DESCRIPTION

       Les  appels  système  ioprio_get()  et  ioprio_set()  respectivement  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.

       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.

CONFORMITÉ

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

NOTES

       La  glibc  ne  fournit  pas  de  fonction  d'enrobage  autour  de  ces  appels système ; appelez-les avec
       syscall(2).

       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.

   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/hda/queue/scheduler
              noop anticipatory deadline [cfq]

       L'ordonnanceur  entre  crochets est celui qui est utilisé pour le périphérique (hda 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 hda à cfq :

              $ su
              Password:
              # echo cfq > /sys/block/hda/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

       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)

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

COLOPHON

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

TRADUCTION

       Depuis 2010, cette traduction est maintenue à l'aide de l'outil po4a <http://po4a.alioth.debian.org/> par
       l'équipe de traduction francophone au sein du projet perkamon <http://perkamon.alioth.debian.org/>.

       Julien Cristau et l'équipe francophone de traduction de Debian (2006-2009).

       Veuillez  signaler  toute erreur de traduction en écrivant à <debian-l10n-french@lists.debian.org> ou par
       un rapport de bogue sur le paquet manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de ce document en utilisant la commande « man -L C
       <section> <page_de_man> ».