ioprio_set(2) System Calls Manual ioprio_set(2) NOM ioprio_get, ioprio_set - Lire et ecrire la classe et la priorite d'ordonnancement des E/S BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include /* Definition des constantes IOPRIO_* */ #include /* Definition des constantes SYS_* */ #include int syscall(SYS_ioprio_get, int which, int who); int syscall(SYS_ioprio_set, int which, int who, int ioprio); Note : la glibc ne fournit pas de fonction autour de cet appel systeme, l'utilisation de syscall(2) est requise. DESCRIPTION Les appels systeme ioprio_get() et ioprio_set() lisent et ecrivent la classe et la priorite d'ordonnancement des entrees et sorties pour un ou plusieurs processus. Les arguments which et who identifient le(s) thread(s) sur lesquels les appels systeme agissent. L'argument which determine comment who est interprete, 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 refere a 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 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 ainsi que sur le sens de positionner ioprio a 0. 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 RENVOYEE 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. STANDARDS Linux. HISTORIQUE Linux 2.6.13. NOTES Plusieurs processus ou threads peuvent partager un contexte d'entrees-sorties. Cela est le cas lorsque clone(2) a ete appele avec l'attribut CLONE_IO. Cependant, par defaut, les threads distincts d'un processus ne partagent pas le meme contexte d'entrees-sorties. Cela signifie que si vous voulez changer la priorite d'entrees-sortie de tous les threads d'un processus, il peut etre necessaire d'appeler ioprio_set() sur chacun de ces threads. L'identifiant du thread necessaire pour cette operation est renvoye par gettid(2) ou clone(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. Si aucun ordonnanceur d'E/S n'a ete defini pour un thread, la priorite par defaut suivra la valeur de politesse du processeur ((setpriority(2)). Dans les noyaux Linux anterieurs a la version 2.6.24, une fois qu'une priorite d'E/S avait ete positionnee ioprio_set(), il n'y avait aucun moyen de reinitialiser le comportement de l'ordonnancement E/S a celui par defaut. Depuis Linux 2.6.24, on peut positionner ioprio sur 0 pour reinitialiser le comportement d'ordonnancement des E/S a celui par defaut. 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/sda/queue/scheduler noop anticipatory deadline [cfq] L'ordonnanceur entre crochets est celui qui est utilise pour le peripherique (sda dans l'exemple). Pour choisir un autre ordonnanceur, on ecrit son nom dans ce fichier. Par exemple, la commande suivante definit l'ordonnanceur pour le peripherique sda a 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 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 necessaires pour definir les priorites d'E/S La permission de modifier la priorite d'un processus est accordee ou refusee en fonction de deux criteres : Proprietaire du processus Un processus non privilegie ne peut definir 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. Priorite desiree 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 La 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 ionice(1), getpriority(2), open(2), capabilities(7), cgroups(7) Documentation/block/ioprio.txt dans les sources du noyau Linux TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot , Cedric Boutillier , Frederic Hantrais et Jean-Philippe MENGUAL Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 ioprio_set(2)