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);
Note : il n'y a pas de fonctions d'enrobage pour ces appels
système. Consultez les NOTES.
DESCRIPTION¶
Les appels système
ioprio_get() et
ioprio_set()
respectivement 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.
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.
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.
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 définit 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 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¶
getpriority(2),
open(2),
capabilities(7)
Documentation/block/ioprio.txt dans les sources du noyau Linux
COLOPHON¶
Cette page fait partie de la publication 3.44 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¶
Depuis 2010, cette traduction est maintenue à l'aide de l'outil po4a
<
http://po4a.alioth.debian.org/> par l'équipe de traduction
francophone au sein du projet perkamon
<
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> ».