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.57 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> ».