Provided by: manpages-fr-dev_4.13-4_all 
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 ⟨⟩.