Provided by: manpages-fr-dev_3.17.1-1_all bug

NOM

       ioprio_get,   ioprio_set   -  Lire/é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);

DESCRIPTION

       Les appels système ioprio_get() et ioprio_set() lisent et  écrivent  la
       classe  et  la  priorité  d’ordonnancement des E/S pour un ou plusieurs
       processus.

       Les arguments which et who identifient  le(s)  processus  auxquels  les
       appels système s’appliquent. L’argument which détermine comment who est
       interprété, et prend l’une des valeurs suivantes :

       IOPRIO_WHO_PROCESS
              who contient le PID d’un processus.

       IOPRIO_WHO_PGRP
              who est l’identifiant d’un groupe de processus, et se  réfère  à
              tous les membres de ce groupe.

       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.

       Voir 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. Voir 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). Voir
              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 autour de ces appels système ;
       appelez‐les avec syscall(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 dE/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és  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
       fixe l’ordonnanceur pour le périphérique hda à cfq :

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

   Lordonnanceur dE/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 (voir 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.

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

   Permissions nécessaires pour fixer les priorités dE/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 fixer 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

       getpriority(2), open(2), capabilities(7)

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

COLOPHON

       Cette page fait partie de  la  publication  3.17  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

       Cette page de manuel a été traduite et est maintenue par Julien Cristau
       <julien.cristau@ens-lyon.org> et l’équipe francophone de traduction  de
       Debian.

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