Where Online Learning is simpler!

The C and C++ Include Header Files

cat -n /usr/include/linux/ioprio.h

     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 */