4 * Copyright (C) 2004 Jens Axboe <axboe@kernel.dk>
6 * Helper functions for setting/querying io priorities of processes. The
7 * system calls closely mimmick getpriority/setpriority, see the man page for
8 * those. The prio argument is a composite of prio class and prio data, where
9 * the data argument has meaning within that class. The standard scheduling
10 * classes have 8 distinct prio levels, with 0 being the highest prio and 7
13 * IOW, setting BE scheduling class with prio 2 is done ala:
15 * unsigned int prio = (IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT) | 2;
17 * ioprio_set(PRIO_PROCESS, pid, prio);
19 * See also Documentation/block/ioprio.txt
22 #include <linux/gfp.h>
23 #include <linux/kernel.h>
24 #include <linux/ioprio.h>
25 #include <linux/blkdev.h>
26 #include <linux/capability.h>
27 #include <linux/syscalls.h>
28 #include <linux/security.h>
29 #include <linux/pid_namespace.h>
31 int set_task_ioprio(struct task_struct
*task
, int ioprio
)
34 struct io_context
*ioc
;
35 const struct cred
*cred
= current_cred(), *tcred
;
38 tcred
= __task_cred(task
);
39 if (tcred
->uid
!= cred
->euid
&&
40 tcred
->uid
!= cred
->uid
&& !capable(CAP_SYS_NICE
)) {
46 err
= security_task_setioprio(task
, ioprio
);
52 ioc
= task
->io_context
;
53 /* see wmb() in current_io_context() */
54 smp_read_barrier_depends();
58 ioc
= alloc_io_context(GFP_ATOMIC
, -1);
63 task
->io_context
= ioc
;
68 ioc
->ioprio_changed
= 1;
74 EXPORT_SYMBOL_GPL(set_task_ioprio
);
76 SYSCALL_DEFINE3(ioprio_set
, int, which
, int, who
, int, ioprio
)
78 int class = IOPRIO_PRIO_CLASS(ioprio
);
79 int data
= IOPRIO_PRIO_DATA(ioprio
);
80 struct task_struct
*p
, *g
;
81 struct user_struct
*user
;
87 if (!capable(CAP_SYS_ADMIN
))
89 /* fall through, rt has prio field too */
91 if (data
>= IOPRIO_BE_NR
|| data
< 0)
95 case IOPRIO_CLASS_IDLE
:
97 case IOPRIO_CLASS_NONE
:
107 * We want IOPRIO_WHO_PGRP/IOPRIO_WHO_USER to be "atomic",
108 * so we can't use rcu_read_lock(). See re-copy of ->ioprio
111 read_lock(&tasklist_lock
);
113 case IOPRIO_WHO_PROCESS
:
117 p
= find_task_by_vpid(who
);
119 ret
= set_task_ioprio(p
, ioprio
);
121 case IOPRIO_WHO_PGRP
:
123 pgrp
= task_pgrp(current
);
125 pgrp
= find_vpid(who
);
126 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
127 ret
= set_task_ioprio(p
, ioprio
);
130 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
132 case IOPRIO_WHO_USER
:
134 user
= current_user();
136 user
= find_user(who
);
141 do_each_thread(g
, p
) {
142 if (__task_cred(p
)->uid
!= who
)
144 ret
= set_task_ioprio(p
, ioprio
);
147 } while_each_thread(g
, p
);
156 read_unlock(&tasklist_lock
);
160 static int get_task_ioprio(struct task_struct
*p
)
164 ret
= security_task_getioprio(p
);
167 ret
= IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE
, IOPRIO_NORM
);
169 ret
= p
->io_context
->ioprio
;
174 int ioprio_best(unsigned short aprio
, unsigned short bprio
)
176 unsigned short aclass
= IOPRIO_PRIO_CLASS(aprio
);
177 unsigned short bclass
= IOPRIO_PRIO_CLASS(bprio
);
179 if (aclass
== IOPRIO_CLASS_NONE
)
180 aclass
= IOPRIO_CLASS_BE
;
181 if (bclass
== IOPRIO_CLASS_NONE
)
182 bclass
= IOPRIO_CLASS_BE
;
184 if (aclass
== bclass
)
185 return min(aprio
, bprio
);
192 SYSCALL_DEFINE2(ioprio_get
, int, which
, int, who
)
194 struct task_struct
*g
, *p
;
195 struct user_struct
*user
;
200 read_lock(&tasklist_lock
);
202 case IOPRIO_WHO_PROCESS
:
206 p
= find_task_by_vpid(who
);
208 ret
= get_task_ioprio(p
);
210 case IOPRIO_WHO_PGRP
:
212 pgrp
= task_pgrp(current
);
214 pgrp
= find_vpid(who
);
215 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
216 tmpio
= get_task_ioprio(p
);
222 ret
= ioprio_best(ret
, tmpio
);
223 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
225 case IOPRIO_WHO_USER
:
227 user
= current_user();
229 user
= find_user(who
);
234 do_each_thread(g
, p
) {
235 if (__task_cred(p
)->uid
!= user
->uid
)
237 tmpio
= get_task_ioprio(p
);
243 ret
= ioprio_best(ret
, tmpio
);
244 } while_each_thread(g
, p
);
253 read_unlock(&tasklist_lock
);
This page took 0.035602 seconds and 5 git commands to generate.