]>
git.ipfire.org Git - people/ms/linux.git/blob - block/ioprio.c
1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (C) 2004 Jens Axboe <axboe@kernel.dk>
7 * Helper functions for setting/querying io priorities of processes. The
8 * system calls closely mimmick getpriority/setpriority, see the man page for
9 * those. The prio argument is a composite of prio class and prio data, where
10 * the data argument has meaning within that class. The standard scheduling
11 * classes have 8 distinct prio levels, with 0 being the highest prio and 7
14 * IOW, setting BE scheduling class with prio 2 is done ala:
16 * unsigned int prio = (IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT) | 2;
18 * ioprio_set(PRIO_PROCESS, pid, prio);
20 * See also Documentation/block/ioprio.rst
23 #include <linux/gfp.h>
24 #include <linux/kernel.h>
25 #include <linux/ioprio.h>
26 #include <linux/cred.h>
27 #include <linux/blkdev.h>
28 #include <linux/capability.h>
29 #include <linux/syscalls.h>
30 #include <linux/security.h>
31 #include <linux/pid_namespace.h>
33 int ioprio_check_cap(int ioprio
)
35 int class = IOPRIO_PRIO_CLASS(ioprio
);
36 int data
= IOPRIO_PRIO_DATA(ioprio
);
41 * Originally this only checked for CAP_SYS_ADMIN,
42 * which was implicitly allowed for pid 0 by security
43 * modules such as SELinux. Make sure we check
44 * CAP_SYS_ADMIN first to avoid a denial/avc for
45 * possibly missing CAP_SYS_NICE permission.
47 if (!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_NICE
))
50 /* rt has prio field too */
52 if (data
>= IOPRIO_NR_LEVELS
|| data
< 0)
55 case IOPRIO_CLASS_IDLE
:
57 case IOPRIO_CLASS_NONE
:
68 SYSCALL_DEFINE3(ioprio_set
, int, which
, int, who
, int, ioprio
)
70 struct task_struct
*p
, *g
;
71 struct user_struct
*user
;
76 ret
= ioprio_check_cap(ioprio
);
83 case IOPRIO_WHO_PROCESS
:
87 p
= find_task_by_vpid(who
);
89 ret
= set_task_ioprio(p
, ioprio
);
93 pgrp
= task_pgrp(current
);
95 pgrp
= find_vpid(who
);
97 read_lock(&tasklist_lock
);
98 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
99 ret
= set_task_ioprio(p
, ioprio
);
101 read_unlock(&tasklist_lock
);
104 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
105 read_unlock(&tasklist_lock
);
108 case IOPRIO_WHO_USER
:
109 uid
= make_kuid(current_user_ns(), who
);
113 user
= current_user();
115 user
= find_user(uid
);
120 for_each_process_thread(g
, p
) {
121 if (!uid_eq(task_uid(p
), uid
) ||
124 ret
= set_task_ioprio(p
, ioprio
);
142 * If the task has set an I/O priority, use that. Otherwise, return
143 * the default I/O priority.
145 * Expected to be called for current task or with task_lock() held to keep
148 int __get_task_ioprio(struct task_struct
*p
)
150 struct io_context
*ioc
= p
->io_context
;
154 lockdep_assert_held(&p
->alloc_lock
);
158 prio
= IOPRIO_DEFAULT
;
160 if (IOPRIO_PRIO_CLASS(prio
) == IOPRIO_CLASS_NONE
)
161 prio
= IOPRIO_PRIO_VALUE(task_nice_ioclass(p
),
162 task_nice_ioprio(p
));
165 EXPORT_SYMBOL_GPL(__get_task_ioprio
);
167 static int get_task_ioprio(struct task_struct
*p
)
171 ret
= security_task_getioprio(p
);
175 ret
= __get_task_ioprio(p
);
182 * Return raw IO priority value as set by userspace. We use this for
183 * ioprio_get(pid, IOPRIO_WHO_PROCESS) so that we keep historical behavior and
184 * also so that userspace can distinguish unset IO priority (which just gets
185 * overriden based on task's nice value) from IO priority set to some value.
187 static int get_task_raw_ioprio(struct task_struct
*p
)
191 ret
= security_task_getioprio(p
);
196 ret
= p
->io_context
->ioprio
;
198 ret
= IOPRIO_DEFAULT
;
204 static int ioprio_best(unsigned short aprio
, unsigned short bprio
)
206 return min(aprio
, bprio
);
209 SYSCALL_DEFINE2(ioprio_get
, int, which
, int, who
)
211 struct task_struct
*g
, *p
;
212 struct user_struct
*user
;
220 case IOPRIO_WHO_PROCESS
:
224 p
= find_task_by_vpid(who
);
226 ret
= get_task_raw_ioprio(p
);
228 case IOPRIO_WHO_PGRP
:
230 pgrp
= task_pgrp(current
);
232 pgrp
= find_vpid(who
);
233 read_lock(&tasklist_lock
);
234 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
235 tmpio
= get_task_ioprio(p
);
241 ret
= ioprio_best(ret
, tmpio
);
242 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
243 read_unlock(&tasklist_lock
);
246 case IOPRIO_WHO_USER
:
247 uid
= make_kuid(current_user_ns(), who
);
249 user
= current_user();
251 user
= find_user(uid
);
256 for_each_process_thread(g
, p
) {
257 if (!uid_eq(task_uid(p
), user
->uid
) ||
260 tmpio
= get_task_ioprio(p
);
266 ret
= ioprio_best(ret
, tmpio
);