Provided by: manpages-fr-dev_3.32d0.2p4-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.

       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  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 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 fixe 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 fixer 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 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.32 du projet man-pages Linux. Une description
       du projet et des  instructions  pour  signaler  des  anomalies  peuvent  être  trouvées  à
       l'adresse <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

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