Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       ioprio_get,   ioprio_set   -  Lire/ecrire  la  classe  et  la  priorite
       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 systeme ioprio_get() et ioprio_set() lisent et  ecrivent  la
       classe  et  la  priorite  d'ordonnancement des E/S pour un ou plusieurs
       processus.

       Les arguments which et who identifient  le(s)  processus  auxquels  les
       appels systeme s'appliquent. L'argument which determine comment who est
       interprete, 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  refere  a
              tous les membres de ce groupe.

       IOPRIO_WHO_USER
              who  est  un  UID identifiant tous les processus dont l'UID reel
              correspond.

       Si  which  vaut  IOPRIO_WHO_PGRP  ou  IOPRIO_WHO_USER  a   l'appel   de
       ioprio_get(),  et  si plus d'un processus correspond a who, la priorite
       renvoyee  sera   la   plus   grande   des   priorites   des   processus
       correspondants.  Une priorite est dite plus grande qu'une autre si elle
       appartient a une classe de priorite superieure (IOPRIO_CLASS_RT est  la
       classe  la plus haute ; IOPRIO_CLASS_IDLE est la plus basse) ou si elle
       appartient a la meme classe mais a un niveau  de  priorite  plus  eleve
       (donc un numero de priorite plus faible).

       L'argument  ioprio donne a ioprio_set() est un masque de bits indiquant
       la classe et la priorite a donner au(x) processus cible(s). Les  macros
       suivantes servent a creer et a tester les valeurs ioprio :

       IOPRIO_PRIO_VALUE(class, data)
              Etant   donnees  une  classe  d'ordonnancement  (class)  et  une
              priorite (data), cette macro combine les deux valeurs pour creer
              une valeur ioprio, qui est renvoyee comme resultat.

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

       IOPRIO_PRIO_DATA(mask)
              Etant donne mask (une valeur ioprio), renvoie la priorite (data)
              correspondante.

       Consultez la section NOTES pour plus d'informations sur les classes  et
       priorites d'ordonnancement.

       Les priorites d'E/S sont gerees pour les lectures et pour les ecritures
       synchrones (O_DIRECT, O_SYNC). Les priorites d'E/S ne sont  pas  gerees
       pour  les  ecritures  asynchrones  parce  qu'elles sont lancees hors du
       contexte du  programme  touchant  la  memoire,  ce  qui  fait  que  les
       priorites specifiques a chaque programme ne s'appliquent pas.

VALEUR RENVOY'EE

       Lorsqu'il  reussit,  ioprio_get() renvoie la valeur ioprio du processus
       dont  la  priorite  d'E/S  est  la  plus  grande  parmi  les  processus
       correspondant  aux criteres indiques par which et who. En cas d'erreur,
       -1 est renvoye, et errno contient le code d'erreur.

       S'il reussit, ioprio_set() renvoie zero. 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  priorites  d'ordonnancement  disponibles  pour
              ioprio.

       EPERM  Le  processus  appelant  n'a pas les privileges necessaires pour
              attribuer cette  priorite  ioprio  au(x)  processus  indique(s).
              Consultez  la  section  NOTES  pour  plus d'informations sur les
              privileges necessaires pour ioprio_set().

       ESRCH  Aucun processus ne correspond aux criteres indiques par which et
              who.

VERSIONS

       Ces appels systeme sont disponibles sous Linux depuis le noyau 2.6.13.

CONFORMIT'E

       Ces appels systeme sont specifiques a Linux.

NOTES

       La  glibc  ne  fournit  pas  de fonction autour de ces appels systeme ;
       appelez-les avec syscall(2).

       Ces appels systeme n'ont d'effet que lorsqu'ils sont utilises  avec  un
       ordonnanceur  d'E/S  qui  gere  les priorites 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 selectionnes pour chaque peripherique par
       le fichier special /sys/block/<device>/queue/scheduler.

       On peut voir quel ordonnanceur d'E/S est actuellement  selectionne  via
       le  systeme de fichiers /sys. Par exemple, la commande suivante affiche
       la liste des ordonnanceurs charges dans le noyau :

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

       L'ordonnanceur entre  crochets  est  celui  qui  est  utilise  pour  le
       peripherique  (hda dans l'exemple). Pour choisir un autre ordonnanceur,
       on ecrit son nom dans ce fichier. Par  exemple,  la  commande  suivante
       fixe l'ordonnanceur pour le peripherique hda a 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 implemente des niveaux
       de politesse d'E/S similaires  a  ceux  de  l'ordonnancement  CPU.  Ces
       niveaux  de  politesse  sont groupes en trois classes d'ordonnancement,
       chacune de ces classes contenant un ou plusieurs niveaux de priorite :

       IOPRIO_CLASS_RT (1)
              Il  s'agit  de  la  classe  d'E/S  temps  reel.   Cette   classe
              d'ordonnancement  a  une  priorite  plus  grande  que toutes les
              autres classes : les processus  de  cette  classe  ont  toujours
              acces  au  disque  en premier. Cette classe d'E/S doit donc etre
              utilisee avec parcimonie : un seul processus avec des E/S  temps
              reel  peut  bloquer  tout le systeme. Au sein de la classe temps
              reel, il y a 8 niveaux de priorite  qui  determinent  exactement
              pendant  combien  de  temps ce processus aura besoin du disque a
              chaque service. La plus haute priorite temps  reel  est  0 ;  la
              plus basse est 7. Dans le futur, ceci pourra changer afin d'etre
              plus directement correle a la performance, en passant  le  debit
              de donnees souhaite a la place de la priorite.

       IOPRIO_CLASS_BE (2)
              Classe  d'ordonnancement << best-effort >>, qui est utilisee par
              defaut pour les processus qui  n'ont  pas  indique  de  priorite
              d'E/S  particuliere.  La priorite de classe determine combien de
              bande passante d'E/S le  processus  obtiendra.  Les  niveaux  de
              priorite  best-effort  sont  similaires aux valeurs de politesse
              CPU (consultez getpriority(2)). Le niveau de priorite  determine
              une  priorite  par  rapport  aux autres processus dans la classe
              d'ordonnancement best-effort. Les niveaux de priorite vont de  0
              (plus prioritaire) a 7 (moins prioritaire).

       IOPRIO_CLASS_IDLE (3)
              Classe  d'ordonnancement << idle >>. Les processus s'executant a
              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 donnee
              (priorite) de classe. Il faut faire attention lorsque  l'on  met
              un  processus  dans  cette  classe de priorite, car il peut etre
              bloque  si  des  processus  de  plus  haute  priorite   accedent
              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'ecessaires pour fixer les priorit'es d'E/S
       La permission de modifier la priorite d'un processus  est  accordee  ou
       refusee en fonction de deux criteres :

       Propri'etaire du processus
              Un  processus non privilegie ne peut fixer la priorite d'E/S que
              des processus dont l'UID reel est egal a l'UID reel ou  effectif
              du   processus   appelant.   Un   processus  ayant  la  capacite
              CAP_SYS_NICE  peut  modifier  la  priorite  de  n'importe   quel
              processus.

       Priorit'e d'esir'ee
              Pour pouvoir definir une priorite tres haute ((IOPRIO_CLASS_RT),
              il faut avoir la capacite CAP_SYS_ADMIN. Les noyaux anterieurs a
              2.6.24   (compris)   necessitent  egalement  CAP_SYS_ADMIN  pour
              definir une  priorite  tres  faible  ((IOPRIO_CLASS_IDLE),  mais
              depuis 2.6.25, ce n'est plus le cas.

       Un  appel  a  ioprio_set()  doit  suivre  ces deux regles, sans quoi il
       echoue avec l'erreur EPERM.

BOGUES

       Glibc ne fournit  pas  encore  de  fichier  d'en-tete  definissant  les
       prototypes  de  fonctions  et  les  macros decrits dans cette page. Les
       definitions 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.27  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      etre       trouvees       a       l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

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

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

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

       Vous  pouvez  toujours avoir acces a la version anglaise de ce document
       en utilisant la commande << man -L C <section> <page_de_man> >>.