1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef IOPRIO_H 3 #define IOPRIO_H 4 5 #include <linux/sched.h> 6 #include <linux/sched/rt.h> 7 #include <linux/iocontext.h> 8 9 #include <uapi/linux/ioprio.h> 10 11 /* 12 * Default IO priority. 13 */ 14 #define IOPRIO_DEFAULT IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0) 15 16 /* 17 * Check that a priority value has a valid class. 18 */ ioprio_valid(unsigned short ioprio)19static inline bool ioprio_valid(unsigned short ioprio) 20 { 21 unsigned short class = IOPRIO_PRIO_CLASS(ioprio); 22 23 return class > IOPRIO_CLASS_NONE && class <= IOPRIO_CLASS_IDLE; 24 } 25 26 /* 27 * if process has set io priority explicitly, use that. if not, convert 28 * the cpu scheduler nice value to an io priority 29 */ task_nice_ioprio(struct task_struct * task)30static inline int task_nice_ioprio(struct task_struct *task) 31 { 32 return (task_nice(task) + 20) / 5; 33 } 34 35 /* 36 * This is for the case where the task hasn't asked for a specific IO class. 37 * Check for idle and rt task process, and return appropriate IO class. 38 */ task_nice_ioclass(struct task_struct * task)39static inline int task_nice_ioclass(struct task_struct *task) 40 { 41 if (task->policy == SCHED_IDLE) 42 return IOPRIO_CLASS_IDLE; 43 else if (rt_or_dl_task_policy(task)) 44 return IOPRIO_CLASS_RT; 45 else 46 return IOPRIO_CLASS_BE; 47 } 48 49 #ifdef CONFIG_BLOCK 50 /* 51 * If the task has set an I/O priority, use that. Otherwise, return 52 * the default I/O priority. 53 * 54 * Expected to be called for current task or with task_lock() held to keep 55 * io_context stable. 56 */ __get_task_ioprio(struct task_struct * p)57static inline int __get_task_ioprio(struct task_struct *p) 58 { 59 struct io_context *ioc = p->io_context; 60 int prio; 61 62 if (!ioc) 63 return IOPRIO_DEFAULT; 64 65 if (p != current) 66 lockdep_assert_held(&p->alloc_lock); 67 68 prio = ioc->ioprio; 69 if (IOPRIO_PRIO_CLASS(prio) == IOPRIO_CLASS_NONE) 70 prio = IOPRIO_PRIO_VALUE(task_nice_ioclass(p), 71 task_nice_ioprio(p)); 72 return prio; 73 } 74 #else __get_task_ioprio(struct task_struct * p)75static inline int __get_task_ioprio(struct task_struct *p) 76 { 77 return IOPRIO_DEFAULT; 78 } 79 #endif /* CONFIG_BLOCK */ 80 get_current_ioprio(void)81static inline int get_current_ioprio(void) 82 { 83 return __get_task_ioprio(current); 84 } 85 86 extern int set_task_ioprio(struct task_struct *task, int ioprio); 87 88 #ifdef CONFIG_BLOCK 89 extern int ioprio_check_cap(int ioprio); 90 #else ioprio_check_cap(int ioprio)91static inline int ioprio_check_cap(int ioprio) 92 { 93 return -ENOTBLK; 94 } 95 #endif /* CONFIG_BLOCK */ 96 97 #endif 98