Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * fs/ioprio.c
4 : : *
5 : : * Copyright (C) 2004 Jens Axboe <axboe@kernel.dk>
6 : : *
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 : : *
20 : : * See also Documentation/block/ioprio.rst
21 : : *
22 : : */
23 : : #include <linux/gfp.h>
24 : : #include <linux/kernel.h>
25 : : #include <linux/export.h>
26 : : #include <linux/ioprio.h>
27 : : #include <linux/cred.h>
28 : : #include <linux/blkdev.h>
29 : : #include <linux/capability.h>
30 : : #include <linux/sched/user.h>
31 : : #include <linux/sched/task.h>
32 : : #include <linux/syscalls.h>
33 : : #include <linux/security.h>
34 : : #include <linux/pid_namespace.h>
35 : :
36 : 422 : int set_task_ioprio(struct task_struct *task, int ioprio)
37 : : {
38 : : int err;
39 : : struct io_context *ioc;
40 : 422 : const struct cred *cred = current_cred(), *tcred;
41 : :
42 : : rcu_read_lock();
43 : 422 : tcred = __task_cred(task);
44 [ - + # # ]: 422 : if (!uid_eq(tcred->uid, cred->euid) &&
45 [ # # ]: 0 : !uid_eq(tcred->uid, cred->uid) && !capable(CAP_SYS_NICE)) {
46 : : rcu_read_unlock();
47 : 0 : return -EPERM;
48 : : }
49 : : rcu_read_unlock();
50 : :
51 : 422 : err = security_task_setioprio(task, ioprio);
52 [ + - ]: 422 : if (err)
53 : : return err;
54 : :
55 : 422 : ioc = get_task_io_context(task, GFP_ATOMIC, NUMA_NO_NODE);
56 [ + - ]: 422 : if (ioc) {
57 : 422 : ioc->ioprio = ioprio;
58 : 422 : put_io_context(ioc);
59 : : }
60 : :
61 : 422 : return err;
62 : : }
63 : : EXPORT_SYMBOL_GPL(set_task_ioprio);
64 : :
65 : 8 : int ioprio_check_cap(int ioprio)
66 : : {
67 : 8 : int class = IOPRIO_PRIO_CLASS(ioprio);
68 : 8 : int data = IOPRIO_PRIO_DATA(ioprio);
69 : :
70 [ - + - + : 8 : switch (class) {
- ]
71 : : case IOPRIO_CLASS_RT:
72 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
73 : : return -EPERM;
74 : : /* fall through */
75 : : /* rt has prio field too */
76 : : case IOPRIO_CLASS_BE:
77 [ + - ]: 2 : if (data >= IOPRIO_BE_NR || data < 0)
78 : : return -EINVAL;
79 : :
80 : : break;
81 : : case IOPRIO_CLASS_IDLE:
82 : : break;
83 : : case IOPRIO_CLASS_NONE:
84 [ # # ]: 0 : if (data)
85 : : return -EINVAL;
86 : : break;
87 : : default:
88 : : return -EINVAL;
89 : : }
90 : :
91 : : return 0;
92 : : }
93 : :
94 : 16 : SYSCALL_DEFINE3(ioprio_set, int, which, int, who, int, ioprio)
95 : : {
96 : : struct task_struct *p, *g;
97 : : struct user_struct *user;
98 : : struct pid *pgrp;
99 : : kuid_t uid;
100 : : int ret;
101 : :
102 : 8 : ret = ioprio_check_cap(ioprio);
103 [ + - ]: 8 : if (ret)
104 : : return ret;
105 : :
106 : : ret = -ESRCH;
107 : : rcu_read_lock();
108 [ + - - - ]: 8 : switch (which) {
109 : : case IOPRIO_WHO_PROCESS:
110 [ + - ]: 8 : if (!who)
111 : 8 : p = current;
112 : : else
113 : 0 : p = find_task_by_vpid(who);
114 [ + - ]: 8 : if (p)
115 : 8 : ret = set_task_ioprio(p, ioprio);
116 : : break;
117 : : case IOPRIO_WHO_PGRP:
118 [ # # ]: 0 : if (!who)
119 : 0 : pgrp = task_pgrp(current);
120 : : else
121 : 0 : pgrp = find_vpid(who);
122 [ # # # # : 0 : do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
# # # # #
# ]
123 : 0 : ret = set_task_ioprio(p, ioprio);
124 [ # # ]: 0 : if (ret)
125 : : break;
126 : : } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
127 : : break;
128 : : case IOPRIO_WHO_USER:
129 : 0 : uid = make_kuid(current_user_ns(), who);
130 [ # # ]: 0 : if (!uid_valid(uid))
131 : : break;
132 [ # # ]: 0 : if (!who)
133 : 0 : user = current_user();
134 : : else
135 : 0 : user = find_user(uid);
136 : :
137 [ # # ]: 0 : if (!user)
138 : : break;
139 : :
140 [ # # # # ]: 0 : for_each_process_thread(g, p) {
141 [ # # # # ]: 0 : if (!uid_eq(task_uid(p), uid) ||
142 : : !task_pid_vnr(p))
143 : 0 : continue;
144 : 0 : ret = set_task_ioprio(p, ioprio);
145 [ # # ]: 0 : if (ret)
146 : : goto free_uid;
147 : : }
148 : : free_uid:
149 [ # # ]: 0 : if (who)
150 : 0 : free_uid(user);
151 : : break;
152 : : default:
153 : : ret = -EINVAL;
154 : : }
155 : :
156 : : rcu_read_unlock();
157 : 8 : return ret;
158 : : }
159 : :
160 : 828 : static int get_task_ioprio(struct task_struct *p)
161 : : {
162 : : int ret;
163 : :
164 : 828 : ret = security_task_getioprio(p);
165 [ + - ]: 828 : if (ret)
166 : : goto out;
167 : : ret = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, IOPRIO_NORM);
168 : : task_lock(p);
169 [ + - ]: 828 : if (p->io_context)
170 : 828 : ret = p->io_context->ioprio;
171 : : task_unlock(p);
172 : : out:
173 : 828 : return ret;
174 : : }
175 : :
176 : 0 : int ioprio_best(unsigned short aprio, unsigned short bprio)
177 : : {
178 [ # # # # : 0 : if (!ioprio_valid(aprio))
# # ]
179 : : aprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, IOPRIO_NORM);
180 [ # # # # : 0 : if (!ioprio_valid(bprio))
# # ]
181 : : bprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, IOPRIO_NORM);
182 : :
183 [ # # # # : 0 : return min(aprio, bprio);
# # ]
184 : : }
185 : :
186 : 1656 : SYSCALL_DEFINE2(ioprio_get, int, which, int, who)
187 : : {
188 : : struct task_struct *g, *p;
189 : : struct user_struct *user;
190 : : struct pid *pgrp;
191 : : kuid_t uid;
192 : : int ret = -ESRCH;
193 : : int tmpio;
194 : :
195 : : rcu_read_lock();
196 [ + - - - ]: 828 : switch (which) {
197 : : case IOPRIO_WHO_PROCESS:
198 [ + - ]: 828 : if (!who)
199 : 828 : p = current;
200 : : else
201 : 0 : p = find_task_by_vpid(who);
202 [ + - ]: 828 : if (p)
203 : 828 : ret = get_task_ioprio(p);
204 : : break;
205 : : case IOPRIO_WHO_PGRP:
206 [ # # ]: 0 : if (!who)
207 : 0 : pgrp = task_pgrp(current);
208 : : else
209 : 0 : pgrp = find_vpid(who);
210 [ # # # # : 0 : do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
# # # # #
# ]
211 : 0 : tmpio = get_task_ioprio(p);
212 [ # # ]: 0 : if (tmpio < 0)
213 : 0 : continue;
214 [ # # ]: 0 : if (ret == -ESRCH)
215 : : ret = tmpio;
216 : : else
217 : 0 : ret = ioprio_best(ret, tmpio);
218 : : } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
219 : : break;
220 : : case IOPRIO_WHO_USER:
221 : 0 : uid = make_kuid(current_user_ns(), who);
222 [ # # ]: 0 : if (!who)
223 : 0 : user = current_user();
224 : : else
225 : 0 : user = find_user(uid);
226 : :
227 [ # # ]: 0 : if (!user)
228 : : break;
229 : :
230 [ # # # # ]: 0 : for_each_process_thread(g, p) {
231 [ # # # # ]: 0 : if (!uid_eq(task_uid(p), user->uid) ||
232 : : !task_pid_vnr(p))
233 : 0 : continue;
234 : 0 : tmpio = get_task_ioprio(p);
235 [ # # ]: 0 : if (tmpio < 0)
236 : 0 : continue;
237 [ # # ]: 0 : if (ret == -ESRCH)
238 : : ret = tmpio;
239 : : else
240 : 0 : ret = ioprio_best(ret, tmpio);
241 : : }
242 : :
243 [ # # ]: 0 : if (who)
244 : 0 : free_uid(user);
245 : : break;
246 : : default:
247 : : ret = -EINVAL;
248 : : }
249 : :
250 : : rcu_read_unlock();
251 : 828 : return ret;
252 : : }
|
