]>
git.ipfire.org Git - thirdparty/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 level
= IOPRIO_PRIO_LEVEL(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 (level
>= IOPRIO_NR_LEVELS
)
55 case IOPRIO_CLASS_IDLE
:
57 case IOPRIO_CLASS_NONE
:
61 case IOPRIO_CLASS_INVALID
:
69 SYSCALL_DEFINE3(ioprio_set
, int, which
, int, who
, int, ioprio
)
71 struct task_struct
*p
, *g
;
72 struct user_struct
*user
;
77 ret
= ioprio_check_cap(ioprio
);
84 case IOPRIO_WHO_PROCESS
:
88 p
= find_task_by_vpid(who
);
90 ret
= set_task_ioprio(p
, ioprio
);
94 pgrp
= task_pgrp(current
);
96 pgrp
= find_vpid(who
);
98 read_lock(&tasklist_lock
);
99 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
100 ret
= set_task_ioprio(p
, ioprio
);
102 read_unlock(&tasklist_lock
);
105 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
106 read_unlock(&tasklist_lock
);
109 case IOPRIO_WHO_USER
:
110 uid
= make_kuid(current_user_ns(), who
);
114 user
= current_user();
116 user
= find_user(uid
);
121 for_each_process_thread(g
, p
) {
122 if (!uid_eq(task_uid(p
), uid
) ||
125 ret
= set_task_ioprio(p
, ioprio
);
143 * If the task has set an I/O priority, use that. Otherwise, return
144 * the default I/O priority.
146 * Expected to be called for current task or with task_lock() held to keep
149 int __get_task_ioprio(struct task_struct
*p
)
151 struct io_context
*ioc
= p
->io_context
;
155 lockdep_assert_held(&p
->alloc_lock
);
159 prio
= IOPRIO_DEFAULT
;
161 if (IOPRIO_PRIO_CLASS(prio
) == IOPRIO_CLASS_NONE
)
162 prio
= IOPRIO_PRIO_VALUE(task_nice_ioclass(p
),
163 task_nice_ioprio(p
));
166 EXPORT_SYMBOL_GPL(__get_task_ioprio
);
168 static int get_task_ioprio(struct task_struct
*p
)
172 ret
= security_task_getioprio(p
);
176 ret
= __get_task_ioprio(p
);
183 * Return raw IO priority value as set by userspace. We use this for
184 * ioprio_get(pid, IOPRIO_WHO_PROCESS) so that we keep historical behavior and
185 * also so that userspace can distinguish unset IO priority (which just gets
186 * overriden based on task's nice value) from IO priority set to some value.
188 static int get_task_raw_ioprio(struct task_struct
*p
)
192 ret
= security_task_getioprio(p
);
197 ret
= p
->io_context
->ioprio
;
199 ret
= IOPRIO_DEFAULT
;
205 static int ioprio_best(unsigned short aprio
, unsigned short bprio
)
207 return min(aprio
, bprio
);
210 SYSCALL_DEFINE2(ioprio_get
, int, which
, int, who
)
212 struct task_struct
*g
, *p
;
213 struct user_struct
*user
;
221 case IOPRIO_WHO_PROCESS
:
225 p
= find_task_by_vpid(who
);
227 ret
= get_task_raw_ioprio(p
);
229 case IOPRIO_WHO_PGRP
:
231 pgrp
= task_pgrp(current
);
233 pgrp
= find_vpid(who
);
234 read_lock(&tasklist_lock
);
235 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
236 tmpio
= get_task_ioprio(p
);
242 ret
= ioprio_best(ret
, tmpio
);
243 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
244 read_unlock(&tasklist_lock
);
247 case IOPRIO_WHO_USER
:
248 uid
= make_kuid(current_user_ns(), who
);
250 user
= current_user();
252 user
= find_user(uid
);
257 for_each_process_thread(g
, p
) {
258 if (!uid_eq(task_uid(p
), user
->uid
) ||
261 tmpio
= get_task_ioprio(p
);
267 ret
= ioprio_best(ret
, tmpio
);