Scroll to navigation

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

Note : il n'y a pas de fonctions d'enrobage pour ces appels système. Consultez les NOTES.

DESCRIPTION

The ioprio_get() and ioprio_set() system calls get and set the I/O scheduling class and priority of one or more threads.

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.

See the NOTES section for more information on scheduling classes and priorities, as well as the meaning of specifying ioprio as 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 DE RETOUR

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.

If no I/O scheduler has been set for a thread, then by default the I/O priority will follow the CPU nice value (setpriority(2)). In Linux kernels before version 2.6.24, once an I/O priority had been set using ioprio_set(), there was no way to reset the I/O scheduling behavior to the default. Since Linux 2.6.24, specifying ioprio as 0 can be used to reset to the default I/O scheduling behavior.

Choisir un ordonnanceur d'E/S

I/O schedulers are selected on a per-device basis via the special file /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]


The scheduler surrounded by brackets is the one actually in use for the device (sda in the example). Setting another scheduler is done by writing the name of the new scheduler to this file. For example, the following command will set the scheduler for the sda device to cfq:


$ su
Password:
# echo cfq > /sys/block/sda/queue/scheduler


L'ordonnanceur d'E/S « Completely Fair Queuing » (CFQ)

Since version 3 (also known as CFQ Time Sliced), CFQ implements I/O nice levels similar to those of CPU scheduling. These nice levels are grouped into three scheduling classes, each one containing one or more priority levels:
IOPRIO_CLASS_RT (1)
This is the real-time I/O class. This scheduling class is given higher priority than any other class: processes from this class are given first access to the disk every time. Thus, this I/O class needs to be used with some care: one I/O real-time process can starve the entire system. Within the real-time class, there are 8 levels of class data (priority) that determine exactly how much time this process needs the disk for on each service. The highest real-time priority level is 0; the lowest is 7. In the future, this might change to be more directly mappable to performance, by passing in a desired data rate instead.
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)
This is the idle scheduling class. Processes running at this level get I/O time only when no one else needs the disk. The idle class has no class data. Attention is required when assigning this priority class to a process, since it may become starved if higher priority processes are constantly accessing the disk.

Refer to the kernel source file Documentation/block/ioprio.txt for more information on the CFQ I/O Scheduler and an example program.

Permissions nécessaires pour définir les priorités d'E/S

Permission to change a process's priority is granted or denied based on two criteria:
Propriétaire du processus
An unprivileged process may set the I/O priority only for a process whose real UID matches the real or effective UID of the calling process. A process which has the CAP_SYS_NICE capability can change the priority of any process.
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.05 du projet man-pages Linux. Une description du projet et des instructions pour signaler des anomalies 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 <http://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> et Frédéric Hantrais <fhantrais@gmail.com>

Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 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>.

6 mars 2019 Linux