ioprio_set

IOPRIO_SET(2)              Manuel du programmeur Linux             IOPRIO_SET(2)



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);

       Remarque : il n'existe pas de fonctions glibc autour de ces appels
       système ; consultez NOTES.

DESCRIPTION
       Les appels système ioprio_get() et ioprio_set() 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 ainsi que sur le sens de positionner ioprio à
       0.

       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.

       Si aucun ordonnanceur d'E/S n'a été défini pour un thread, la priorité
       par défaut suivra la valeur de politesse du processeur ((setpriority(2)).
       Dans les noyaux Linux antérieurs à la version 2.6.24, une fois qu'une
       priorité d'E/S avait été positionnée ioprio_set(), il n'y avait aucun
       moyen de réinitialiser le comportement de l'ordonnancement E/S à celui
       par défaut. Depuis Linux 2.6.24, on peut positionner ioprio sur 0 pour
       réinitialiser le comportement d'ordonnancement des E/S à celui par
       défaut.

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

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

           $ su
           Password:
           # echo cfq > /sys/block/sda/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), cgroups(7)

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

COLOPHON
       Cette page fait partie de la publication 5.10 du projet man-pages Linux.
       Une description du projet et des instructions pour signaler des anomalies
       et la dernière version de cette page peuvent être trouvées à l'adresse
       https://www.kernel.org/doc/man-pages/.


TRADUCTION
       La traduction française de cette page de manuel a été créée par
       Christophe Blaess <https://www.blaess.fr/christophe/>, Stéphan Rafin
       <stephan.rafin@laposte.net>, Thierry Vignaud <tvignaud@mandriva.com>,
       François Micaux, Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe
       Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-
       luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas
       Huriaux <thomas.huriaux@gmail.com>, Nicolas François
       <nicolas.francois@centraliens.net>, Florentin Duneau <fduneau@gmail.com>,
       Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis Barbier
       <barbier@debian.org>, David Prévot <david@tilapin.org>, Cédric Boutillier
       <cedric.boutillier@gmail.com>, Frédéric Hantrais <fhantrais@gmail.com> et
       Jean-Philippe MENGUAL <jpmengual@debian.org>

       Cette traduction est une documentation libre ; veuillez vous reporter à
       la GNU General Public License version 3
       ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les conditions de
       copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel,
       veuillez envoyer un message à debian-l10n-french@lists.debian.org ⟨⟩.




Linux                              6 mars 2019                     IOPRIO_SET(2)