zig

fork of https://codeberg.org/ziglang/zig
Log | Files | Refs | README | LICENSE

ioprio.h (4174B) - Raw

      1 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
      2 #ifndef _LINUX_IOPRIO_H
      3 #define _LINUX_IOPRIO_H
      4 
      5 #include <linux/stddef.h>
      6 #include <linux/types.h>
      7 
      8 /*
      9  * Gives us 8 prio classes with 13-bits of data for each class
     10  */
     11 #define IOPRIO_CLASS_SHIFT	13
     12 #define IOPRIO_NR_CLASSES	8
     13 #define IOPRIO_CLASS_MASK	(IOPRIO_NR_CLASSES - 1)
     14 #define IOPRIO_PRIO_MASK	((1UL << IOPRIO_CLASS_SHIFT) - 1)
     15 
     16 #define IOPRIO_PRIO_CLASS(ioprio)	\
     17 	(((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK)
     18 #define IOPRIO_PRIO_DATA(ioprio)	((ioprio) & IOPRIO_PRIO_MASK)
     19 
     20 /*
     21  * These are the io priority classes as implemented by the BFQ and mq-deadline
     22  * schedulers. RT is the realtime class, it always gets premium service. For
     23  * ATA disks supporting NCQ IO priority, RT class IOs will be processed using
     24  * high priority NCQ commands. BE is the best-effort scheduling class, the
     25  * default for any process. IDLE is the idle scheduling class, it is only
     26  * served when no one else is using the disk.
     27  */
     28 enum {
     29 	IOPRIO_CLASS_NONE	= 0,
     30 	IOPRIO_CLASS_RT		= 1,
     31 	IOPRIO_CLASS_BE		= 2,
     32 	IOPRIO_CLASS_IDLE	= 3,
     33 
     34 	/* Special class to indicate an invalid ioprio value */
     35 	IOPRIO_CLASS_INVALID	= 7,
     36 };
     37 
     38 /*
     39  * The RT and BE priority classes both support up to 8 priority levels that
     40  * can be specified using the lower 3-bits of the priority data.
     41  */
     42 #define IOPRIO_LEVEL_NR_BITS		3
     43 #define IOPRIO_NR_LEVELS		(1 << IOPRIO_LEVEL_NR_BITS)
     44 #define IOPRIO_LEVEL_MASK		(IOPRIO_NR_LEVELS - 1)
     45 #define IOPRIO_PRIO_LEVEL(ioprio)	((ioprio) & IOPRIO_LEVEL_MASK)
     46 
     47 #define IOPRIO_BE_NR			IOPRIO_NR_LEVELS
     48 
     49 /*
     50  * Possible values for the "which" argument of the ioprio_get() and
     51  * ioprio_set() system calls (see "man ioprio_set").
     52  */
     53 enum {
     54 	IOPRIO_WHO_PROCESS = 1,
     55 	IOPRIO_WHO_PGRP,
     56 	IOPRIO_WHO_USER,
     57 };
     58 
     59 /*
     60  * Fallback BE class priority level.
     61  */
     62 #define IOPRIO_NORM	4
     63 #define IOPRIO_BE_NORM	IOPRIO_NORM
     64 
     65 /*
     66  * The 10 bits between the priority class and the priority level are used to
     67  * optionally define I/O hints for any combination of I/O priority class and
     68  * level. Depending on the kernel configuration, I/O scheduler being used and
     69  * the target I/O device being used, hints can influence how I/Os are processed
     70  * without affecting the I/O scheduling ordering defined by the I/O priority
     71  * class and level.
     72  */
     73 #define IOPRIO_HINT_SHIFT		IOPRIO_LEVEL_NR_BITS
     74 #define IOPRIO_HINT_NR_BITS		10
     75 #define IOPRIO_NR_HINTS			(1 << IOPRIO_HINT_NR_BITS)
     76 #define IOPRIO_HINT_MASK		(IOPRIO_NR_HINTS - 1)
     77 #define IOPRIO_PRIO_HINT(ioprio)	\
     78 	(((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK)
     79 
     80 /*
     81  * I/O hints.
     82  */
     83 enum {
     84 	/* No hint */
     85 	IOPRIO_HINT_NONE = 0,
     86 
     87 	/*
     88 	 * Device command duration limits: indicate to the device a desired
     89 	 * duration limit for the commands that will be used to process an I/O.
     90 	 * These will currently only be effective for SCSI and ATA devices that
     91 	 * support the command duration limits feature. If this feature is
     92 	 * enabled, then the commands issued to the device to process an I/O with
     93 	 * one of these hints set will have the duration limit index (dld field)
     94 	 * set to the value of the hint.
     95 	 */
     96 	IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1,
     97 	IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2,
     98 	IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3,
     99 	IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4,
    100 	IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5,
    101 	IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6,
    102 	IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7,
    103 };
    104 
    105 #define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max))
    106 
    107 /*
    108  * Return an I/O priority value based on a class, a level and a hint.
    109  */
    110 static __always_inline __u16 ioprio_value(int prioclass, int priolevel,
    111 					  int priohint)
    112 {
    113 	if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) ||
    114 	    IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) ||
    115 	    IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS))
    116 		return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT;
    117 
    118 	return (prioclass << IOPRIO_CLASS_SHIFT) |
    119 		(priohint << IOPRIO_HINT_SHIFT) | priolevel;
    120 }
    121 
    122 #define IOPRIO_PRIO_VALUE(prioclass, priolevel)			\
    123 	ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE)
    124 #define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint)	\
    125 	ioprio_value(prioclass, priolevel, priohint)
    126 
    127 #endif /* _LINUX_IOPRIO_H */