Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/fs/ioprio.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 3555 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 3555 byte(s)
Tag kernel26-2.6.12-alx-r9
1 | /* |
2 | * fs/ioprio.c |
3 | * |
4 | * Copyright (C) 2004 Jens Axboe <axboe@suse.de> |
5 | * |
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 |
11 | * being the lowest. |
12 | * |
13 | * IOW, setting BE scheduling class with prio 2 is done ala: |
14 | * |
15 | * unsigned int prio = (IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT) | 2; |
16 | * |
17 | * ioprio_set(PRIO_PROCESS, pid, prio); |
18 | * |
19 | * See also Documentation/block/ioprio.txt |
20 | * |
21 | */ |
22 | #include <linux/kernel.h> |
23 | #include <linux/ioprio.h> |
24 | #include <linux/blkdev.h> |
25 | |
26 | static int set_task_ioprio(struct task_struct *task, int ioprio) |
27 | { |
28 | struct io_context *ioc; |
29 | |
30 | if (task->uid != current->euid && |
31 | task->uid != current->uid && !capable(CAP_SYS_NICE)) |
32 | return -EPERM; |
33 | |
34 | task_lock(task); |
35 | |
36 | task->ioprio = ioprio; |
37 | |
38 | ioc = task->io_context; |
39 | if (ioc && ioc->set_ioprio) |
40 | ioc->set_ioprio(ioc, ioprio); |
41 | |
42 | task_unlock(task); |
43 | return 0; |
44 | } |
45 | |
46 | asmlinkage int sys_ioprio_set(int which, int who, int ioprio) |
47 | { |
48 | int class = IOPRIO_PRIO_CLASS(ioprio); |
49 | int data = IOPRIO_PRIO_DATA(ioprio); |
50 | struct task_struct *p, *g; |
51 | struct user_struct *user; |
52 | int ret; |
53 | |
54 | switch (class) { |
55 | case IOPRIO_CLASS_RT: |
56 | if (!capable(CAP_SYS_ADMIN)) |
57 | return -EPERM; |
58 | /* fall through, rt has prio field too */ |
59 | case IOPRIO_CLASS_BE: |
60 | if (data >= IOPRIO_BE_NR || data < 0) |
61 | return -EINVAL; |
62 | |
63 | break; |
64 | case IOPRIO_CLASS_IDLE: |
65 | break; |
66 | default: |
67 | return -EINVAL; |
68 | } |
69 | |
70 | ret = -ESRCH; |
71 | read_lock_irq(&tasklist_lock); |
72 | switch (which) { |
73 | case IOPRIO_WHO_PROCESS: |
74 | if (!who) |
75 | p = current; |
76 | else |
77 | p = find_task_by_pid(who); |
78 | if (p) |
79 | ret = set_task_ioprio(p, ioprio); |
80 | break; |
81 | case IOPRIO_WHO_PGRP: |
82 | if (!who) |
83 | who = process_group(current); |
84 | do_each_task_pid(who, PIDTYPE_PGID, p) { |
85 | ret = set_task_ioprio(p, ioprio); |
86 | if (ret) |
87 | break; |
88 | } while_each_task_pid(who, PIDTYPE_PGID, p); |
89 | break; |
90 | case IOPRIO_WHO_USER: |
91 | if (!who) |
92 | user = current->user; |
93 | else |
94 | user = find_user(who); |
95 | |
96 | if (!user) |
97 | break; |
98 | |
99 | do_each_thread(g, p) { |
100 | if (p->uid != who) |
101 | continue; |
102 | ret = set_task_ioprio(p, ioprio); |
103 | if (ret) |
104 | break; |
105 | } while_each_thread(g, p); |
106 | |
107 | if (who) |
108 | free_uid(user); |
109 | break; |
110 | default: |
111 | ret = -EINVAL; |
112 | } |
113 | |
114 | read_unlock_irq(&tasklist_lock); |
115 | return ret; |
116 | } |
117 | |
118 | asmlinkage int sys_ioprio_get(int which, int who) |
119 | { |
120 | struct task_struct *g, *p; |
121 | struct user_struct *user; |
122 | int ret = -ESRCH; |
123 | |
124 | read_lock_irq(&tasklist_lock); |
125 | switch (which) { |
126 | case IOPRIO_WHO_PROCESS: |
127 | if (!who) |
128 | p = current; |
129 | else |
130 | p = find_task_by_pid(who); |
131 | if (p) |
132 | ret = p->ioprio; |
133 | break; |
134 | case IOPRIO_WHO_PGRP: |
135 | if (!who) |
136 | who = process_group(current); |
137 | do_each_task_pid(who, PIDTYPE_PGID, p) { |
138 | if (ret == -ESRCH) |
139 | ret = p->ioprio; |
140 | else |
141 | ret = ioprio_best(ret, p->ioprio); |
142 | } while_each_task_pid(who, PIDTYPE_PGID, p); |
143 | break; |
144 | case IOPRIO_WHO_USER: |
145 | if (!who) |
146 | user = current->user; |
147 | else |
148 | user = find_user(who); |
149 | |
150 | if (!user) |
151 | break; |
152 | |
153 | do_each_thread(g, p) { |
154 | if (p->uid != user->uid) |
155 | continue; |
156 | if (ret == -ESRCH) |
157 | ret = p->ioprio; |
158 | else |
159 | ret = ioprio_best(ret, p->ioprio); |
160 | } while_each_thread(g, p); |
161 | |
162 | if (who) |
163 | free_uid(user); |
164 | break; |
165 | default: |
166 | ret = -EINVAL; |
167 | } |
168 | |
169 | read_unlock_irq(&tasklist_lock); |
170 | return ret; |
171 | } |
172 |