blob: 32a456b458049f45baf30be663cdfe63bcde2a55 [file] [log] [blame]
Christoph Hellwig3dcf60bc2019-04-30 14:42:43 -04001// SPDX-License-Identifier: GPL-2.0
Jens Axboe22e2c502005-06-27 10:55:12 +02002/*
3 * fs/ioprio.c
4 *
Jens Axboe0fe23472006-09-04 15:41:16 +02005 * Copyright (C) 2004 Jens Axboe <axboe@kernel.dk>
Jens Axboe22e2c502005-06-27 10:55:12 +02006 *
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
12 * being the lowest.
13 *
14 * IOW, setting BE scheduling class with prio 2 is done ala:
15 *
16 * unsigned int prio = (IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT) | 2;
17 *
18 * ioprio_set(PRIO_PROCESS, pid, prio);
19 *
Mauro Carvalho Chehab898bd372019-04-18 19:45:00 -030020 * See also Documentation/block/ioprio.rst
Jens Axboe22e2c502005-06-27 10:55:12 +020021 *
22 */
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/gfp.h>
Jens Axboe22e2c502005-06-27 10:55:12 +020024#include <linux/kernel.h>
25#include <linux/ioprio.h>
Ingo Molnar5b825c32017-02-02 17:54:15 +010026#include <linux/cred.h>
Jens Axboe22e2c502005-06-27 10:55:12 +020027#include <linux/blkdev.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080028#include <linux/capability.h>
Adrian Bunk9abdc4c2005-11-08 16:57:02 +010029#include <linux/syscalls.h>
James Morris03e68062006-06-23 02:03:58 -070030#include <linux/security.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -070031#include <linux/pid_namespace.h>
Jens Axboe22e2c502005-06-27 10:55:12 +020032
Adam Manzanaresaa434572018-05-22 10:52:17 -070033int ioprio_check_cap(int ioprio)
Jens Axboe22e2c502005-06-27 10:55:12 +020034{
35 int class = IOPRIO_PRIO_CLASS(ioprio);
36 int data = IOPRIO_PRIO_DATA(ioprio);
Jens Axboe22e2c502005-06-27 10:55:12 +020037
38 switch (class) {
39 case IOPRIO_CLASS_RT:
Alistair Delva94c4b4fd2021-11-15 18:16:55 +000040 /*
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.
46 */
47 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_NICE))
Jens Axboe22e2c502005-06-27 10:55:12 +020048 return -EPERM;
Gustavo A. R. Silvadf561f662020-08-23 17:36:59 -050049 fallthrough;
Bart Van Asschee29387e2017-06-21 09:40:11 -070050 /* rt has prio field too */
Jens Axboe22e2c502005-06-27 10:55:12 +020051 case IOPRIO_CLASS_BE:
Damien Le Moal202bc942021-08-11 12:37:01 +090052 if (data >= IOPRIO_NR_LEVELS || data < 0)
Jens Axboe22e2c502005-06-27 10:55:12 +020053 return -EINVAL;
Jens Axboe22e2c502005-06-27 10:55:12 +020054 break;
55 case IOPRIO_CLASS_IDLE:
56 break;
Jens Axboe8ec680e2007-11-07 13:54:07 +010057 case IOPRIO_CLASS_NONE:
58 if (data)
59 return -EINVAL;
60 break;
Jens Axboe22e2c502005-06-27 10:55:12 +020061 default:
62 return -EINVAL;
63 }
64
Adam Manzanaresaa434572018-05-22 10:52:17 -070065 return 0;
66}
67
68SYSCALL_DEFINE3(ioprio_set, int, which, int, who, int, ioprio)
69{
70 struct task_struct *p, *g;
71 struct user_struct *user;
72 struct pid *pgrp;
73 kuid_t uid;
74 int ret;
75
76 ret = ioprio_check_cap(ioprio);
77 if (ret)
78 return ret;
79
Jens Axboe22e2c502005-06-27 10:55:12 +020080 ret = -ESRCH;
Greg Thelend69b78b2010-11-15 10:20:52 +010081 rcu_read_lock();
Jens Axboe22e2c502005-06-27 10:55:12 +020082 switch (which) {
83 case IOPRIO_WHO_PROCESS:
84 if (!who)
85 p = current;
86 else
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -070087 p = find_task_by_vpid(who);
Jens Axboe22e2c502005-06-27 10:55:12 +020088 if (p)
89 ret = set_task_ioprio(p, ioprio);
90 break;
91 case IOPRIO_WHO_PGRP:
92 if (!who)
Eric W. Biederman41487c62007-02-12 00:53:01 -080093 pgrp = task_pgrp(current);
94 else
Pavel Emelyanovb4888932007-10-18 23:40:14 -070095 pgrp = find_vpid(who);
Peter Zijlstra40c7fd32021-04-08 11:46:12 +020096
97 read_lock(&tasklist_lock);
Ken Chen2d70b682008-08-20 14:09:17 -070098 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
Jens Axboe22e2c502005-06-27 10:55:12 +020099 ret = set_task_ioprio(p, ioprio);
Peter Zijlstra40c7fd32021-04-08 11:46:12 +0200100 if (ret) {
101 read_unlock(&tasklist_lock);
102 goto out;
103 }
Ken Chen2d70b682008-08-20 14:09:17 -0700104 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
Peter Zijlstra40c7fd32021-04-08 11:46:12 +0200105 read_unlock(&tasklist_lock);
106
Jens Axboe22e2c502005-06-27 10:55:12 +0200107 break;
108 case IOPRIO_WHO_USER:
Eric W. Biederman7b44ab92011-11-16 23:20:58 -0800109 uid = make_kuid(current_user_ns(), who);
110 if (!uid_valid(uid))
111 break;
Jens Axboe22e2c502005-06-27 10:55:12 +0200112 if (!who)
David Howells86a264a2008-11-14 10:39:18 +1100113 user = current_user();
Jens Axboe22e2c502005-06-27 10:55:12 +0200114 else
Eric W. Biederman7b44ab92011-11-16 23:20:58 -0800115 user = find_user(uid);
Jens Axboe22e2c502005-06-27 10:55:12 +0200116
117 if (!user)
118 break;
119
Tetsuo Handa612dafa2017-02-22 15:40:50 -0800120 for_each_process_thread(g, p) {
Ben Segall8639b462015-11-06 16:32:48 -0800121 if (!uid_eq(task_uid(p), uid) ||
122 !task_pid_vnr(p))
Jens Axboe22e2c502005-06-27 10:55:12 +0200123 continue;
124 ret = set_task_ioprio(p, ioprio);
125 if (ret)
Oleg Nesterov78bd4d42006-08-21 08:33:23 +0200126 goto free_uid;
Tetsuo Handa612dafa2017-02-22 15:40:50 -0800127 }
Oleg Nesterov78bd4d42006-08-21 08:33:23 +0200128free_uid:
Jens Axboe22e2c502005-06-27 10:55:12 +0200129 if (who)
130 free_uid(user);
131 break;
132 default:
133 ret = -EINVAL;
134 }
135
Peter Zijlstra40c7fd32021-04-08 11:46:12 +0200136out:
Greg Thelend69b78b2010-11-15 10:20:52 +0100137 rcu_read_unlock();
Jens Axboe22e2c502005-06-27 10:55:12 +0200138 return ret;
139}
140
Jan Kara893e5d32022-06-23 09:48:28 +0200141/*
142 * If the task has set an I/O priority, use that. Otherwise, return
143 * the default I/O priority.
144 *
145 * Expected to be called for current task or with task_lock() held to keep
146 * io_context stable.
147 */
148int __get_task_ioprio(struct task_struct *p)
149{
150 struct io_context *ioc = p->io_context;
151 int prio;
152
153 if (p != current)
154 lockdep_assert_held(&p->alloc_lock);
155 if (ioc)
156 prio = ioc->ioprio;
157 else
158 prio = IOPRIO_DEFAULT;
159
160 if (IOPRIO_PRIO_CLASS(prio) == IOPRIO_CLASS_NONE)
161 prio = IOPRIO_PRIO_VALUE(task_nice_ioclass(p),
162 task_nice_ioprio(p));
163 return prio;
164}
165EXPORT_SYMBOL_GPL(__get_task_ioprio);
166
David Quigleya1836a42006-06-30 01:55:49 -0700167static int get_task_ioprio(struct task_struct *p)
168{
169 int ret;
170
171 ret = security_task_getioprio(p);
172 if (ret)
173 goto out;
Jan Kara4b838d92022-06-23 09:48:30 +0200174 task_lock(p);
175 ret = __get_task_ioprio(p);
176 task_unlock(p);
177out:
178 return ret;
179}
180
181/*
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.
186 */
187static int get_task_raw_ioprio(struct task_struct *p)
188{
189 int ret;
190
191 ret = security_task_getioprio(p);
192 if (ret)
193 goto out;
Omar Sandoval8ba86822016-07-01 00:39:35 -0700194 task_lock(p);
Jens Axboefd0928d2008-01-24 08:52:45 +0100195 if (p->io_context)
196 ret = p->io_context->ioprio;
Jan Kara4b838d92022-06-23 09:48:30 +0200197 else
198 ret = IOPRIO_DEFAULT;
Omar Sandoval8ba86822016-07-01 00:39:35 -0700199 task_unlock(p);
David Quigleya1836a42006-06-30 01:55:49 -0700200out:
201 return ret;
202}
203
Jan Karafc255452022-06-23 09:48:29 +0200204static int ioprio_best(unsigned short aprio, unsigned short bprio)
Oleg Nesterove014ff82006-08-21 10:02:50 +0200205{
Bart Van Assche9a871822017-04-19 14:01:28 -0700206 return min(aprio, bprio);
Oleg Nesterove014ff82006-08-21 10:02:50 +0200207}
208
Heiko Carstens938bb9f2009-01-14 14:14:30 +0100209SYSCALL_DEFINE2(ioprio_get, int, which, int, who)
Jens Axboe22e2c502005-06-27 10:55:12 +0200210{
211 struct task_struct *g, *p;
212 struct user_struct *user;
Eric W. Biederman41487c62007-02-12 00:53:01 -0800213 struct pid *pgrp;
Eric W. Biederman7b44ab92011-11-16 23:20:58 -0800214 kuid_t uid;
Jens Axboe22e2c502005-06-27 10:55:12 +0200215 int ret = -ESRCH;
David Quigleya1836a42006-06-30 01:55:49 -0700216 int tmpio;
Jens Axboe22e2c502005-06-27 10:55:12 +0200217
Greg Thelend69b78b2010-11-15 10:20:52 +0100218 rcu_read_lock();
Jens Axboe22e2c502005-06-27 10:55:12 +0200219 switch (which) {
220 case IOPRIO_WHO_PROCESS:
221 if (!who)
222 p = current;
223 else
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -0700224 p = find_task_by_vpid(who);
Jens Axboe22e2c502005-06-27 10:55:12 +0200225 if (p)
Jan Kara4b838d92022-06-23 09:48:30 +0200226 ret = get_task_raw_ioprio(p);
Jens Axboe22e2c502005-06-27 10:55:12 +0200227 break;
228 case IOPRIO_WHO_PGRP:
229 if (!who)
Eric W. Biederman41487c62007-02-12 00:53:01 -0800230 pgrp = task_pgrp(current);
231 else
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700232 pgrp = find_vpid(who);
Davidlohr Buesoe6a59aa2021-12-10 10:20:58 -0800233 read_lock(&tasklist_lock);
Ken Chen2d70b682008-08-20 14:09:17 -0700234 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
David Quigleya1836a42006-06-30 01:55:49 -0700235 tmpio = get_task_ioprio(p);
236 if (tmpio < 0)
237 continue;
Jens Axboe22e2c502005-06-27 10:55:12 +0200238 if (ret == -ESRCH)
David Quigleya1836a42006-06-30 01:55:49 -0700239 ret = tmpio;
Jens Axboe22e2c502005-06-27 10:55:12 +0200240 else
David Quigleya1836a42006-06-30 01:55:49 -0700241 ret = ioprio_best(ret, tmpio);
Ken Chen2d70b682008-08-20 14:09:17 -0700242 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
Davidlohr Buesoe6a59aa2021-12-10 10:20:58 -0800243 read_unlock(&tasklist_lock);
244
Jens Axboe22e2c502005-06-27 10:55:12 +0200245 break;
246 case IOPRIO_WHO_USER:
Eric W. Biederman7b44ab92011-11-16 23:20:58 -0800247 uid = make_kuid(current_user_ns(), who);
Jens Axboe22e2c502005-06-27 10:55:12 +0200248 if (!who)
David Howells86a264a2008-11-14 10:39:18 +1100249 user = current_user();
Jens Axboe22e2c502005-06-27 10:55:12 +0200250 else
Eric W. Biederman7b44ab92011-11-16 23:20:58 -0800251 user = find_user(uid);
Jens Axboe22e2c502005-06-27 10:55:12 +0200252
253 if (!user)
254 break;
255
Tetsuo Handa612dafa2017-02-22 15:40:50 -0800256 for_each_process_thread(g, p) {
Ben Segall8639b462015-11-06 16:32:48 -0800257 if (!uid_eq(task_uid(p), user->uid) ||
258 !task_pid_vnr(p))
Jens Axboe22e2c502005-06-27 10:55:12 +0200259 continue;
David Quigleya1836a42006-06-30 01:55:49 -0700260 tmpio = get_task_ioprio(p);
261 if (tmpio < 0)
262 continue;
Jens Axboe22e2c502005-06-27 10:55:12 +0200263 if (ret == -ESRCH)
David Quigleya1836a42006-06-30 01:55:49 -0700264 ret = tmpio;
Jens Axboe22e2c502005-06-27 10:55:12 +0200265 else
David Quigleya1836a42006-06-30 01:55:49 -0700266 ret = ioprio_best(ret, tmpio);
Tetsuo Handa612dafa2017-02-22 15:40:50 -0800267 }
Jens Axboe22e2c502005-06-27 10:55:12 +0200268
269 if (who)
270 free_uid(user);
271 break;
272 default:
273 ret = -EINVAL;
274 }
275
Greg Thelend69b78b2010-11-15 10:20:52 +0100276 rcu_read_unlock();
Jens Axboe22e2c502005-06-27 10:55:12 +0200277 return ret;
278}