1 | /* |
2 | * Copyright (c) 2000-2007 Apple Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | /* |
29 | * @OSF_COPYRIGHT@ |
30 | * |
31 | */ |
32 | |
33 | /* The routines in this module are all obsolete */ |
34 | |
35 | #include <mach/boolean.h> |
36 | #include <mach/thread_switch.h> |
37 | #include <ipc/ipc_port.h> |
38 | #include <ipc/ipc_space.h> |
39 | #include <kern/ipc_kobject.h> |
40 | #include <kern/processor.h> |
41 | #include <kern/sched.h> |
42 | #include <kern/sched_prim.h> |
43 | #include <kern/spl.h> |
44 | #include <kern/task.h> |
45 | #include <kern/thread.h> |
46 | #include <mach/policy.h> |
47 | #include <kern/policy_internal.h> |
48 | |
49 | #include <kern/syscall_subr.h> |
50 | #include <mach/mach_host_server.h> |
51 | #include <mach/mach_syscalls.h> |
52 | |
53 | #include <kern/misc_protos.h> |
54 | #include <kern/spl.h> |
55 | #include <kern/sched.h> |
56 | #include <kern/sched_prim.h> |
57 | #include <kern/assert.h> |
58 | #include <kern/thread.h> |
59 | #include <mach/mach_host_server.h> |
60 | #include <mach/thread_act_server.h> |
61 | #include <mach/host_priv_server.h> |
62 | |
63 | |
64 | /* |
65 | * thread_set_policy |
66 | * |
67 | * Set scheduling policy and parameters, both base and limit, for |
68 | * the given thread. Policy can be any policy implemented by the |
69 | * processor set, whether enabled or not. |
70 | */ |
71 | kern_return_t |
72 | thread_set_policy( |
73 | thread_t thread, |
74 | processor_set_t pset, |
75 | policy_t policy, |
76 | policy_base_t base, |
77 | mach_msg_type_number_t base_count, |
78 | policy_limit_t limit, |
79 | mach_msg_type_number_t limit_count) |
80 | { |
81 | int max, bas; |
82 | kern_return_t result = KERN_SUCCESS; |
83 | |
84 | if (thread == THREAD_NULL || |
85 | pset == PROCESSOR_SET_NULL || pset != &pset0) { |
86 | return KERN_INVALID_ARGUMENT; |
87 | } |
88 | |
89 | if (invalid_policy(policy)) { |
90 | return KERN_INVALID_ARGUMENT; |
91 | } |
92 | |
93 | switch (policy) { |
94 | case POLICY_RR: |
95 | { |
96 | policy_rr_base_t rr_base = (policy_rr_base_t) base; |
97 | policy_rr_limit_t rr_limit = (policy_rr_limit_t) limit; |
98 | |
99 | if (base_count != POLICY_RR_BASE_COUNT || |
100 | limit_count != POLICY_RR_LIMIT_COUNT) { |
101 | result = KERN_INVALID_ARGUMENT; |
102 | break; |
103 | } |
104 | |
105 | bas = rr_base->base_priority; |
106 | max = rr_limit->max_priority; |
107 | if (invalid_pri(bas) || invalid_pri(max)) { |
108 | result = KERN_INVALID_ARGUMENT; |
109 | break; |
110 | } |
111 | |
112 | break; |
113 | } |
114 | |
115 | case POLICY_FIFO: |
116 | { |
117 | policy_fifo_base_t fifo_base = (policy_fifo_base_t) base; |
118 | policy_fifo_limit_t fifo_limit = (policy_fifo_limit_t) limit; |
119 | |
120 | if (base_count != POLICY_FIFO_BASE_COUNT || |
121 | limit_count != POLICY_FIFO_LIMIT_COUNT) { |
122 | result = KERN_INVALID_ARGUMENT; |
123 | break; |
124 | } |
125 | |
126 | bas = fifo_base->base_priority; |
127 | max = fifo_limit->max_priority; |
128 | if (invalid_pri(bas) || invalid_pri(max)) { |
129 | result = KERN_INVALID_ARGUMENT; |
130 | break; |
131 | } |
132 | |
133 | break; |
134 | } |
135 | |
136 | case POLICY_TIMESHARE: |
137 | { |
138 | policy_timeshare_base_t ts_base = (policy_timeshare_base_t) base; |
139 | policy_timeshare_limit_t ts_limit = |
140 | (policy_timeshare_limit_t) limit; |
141 | |
142 | if (base_count != POLICY_TIMESHARE_BASE_COUNT || |
143 | limit_count != POLICY_TIMESHARE_LIMIT_COUNT) { |
144 | result = KERN_INVALID_ARGUMENT; |
145 | break; |
146 | } |
147 | |
148 | bas = ts_base->base_priority; |
149 | max = ts_limit->max_priority; |
150 | if (invalid_pri(bas) || invalid_pri(max)) { |
151 | result = KERN_INVALID_ARGUMENT; |
152 | break; |
153 | } |
154 | |
155 | break; |
156 | } |
157 | |
158 | default: |
159 | result = KERN_INVALID_POLICY; |
160 | } |
161 | |
162 | if (result != KERN_SUCCESS) { |
163 | return result; |
164 | } |
165 | |
166 | /* Note that we do not pass on max priority. */ |
167 | if (result == KERN_SUCCESS) { |
168 | result = thread_set_mode_and_absolute_pri(thread, policy, priority: bas); |
169 | } |
170 | |
171 | return result; |
172 | } |
173 | |
174 | |
175 | /* |
176 | * thread_policy |
177 | * |
178 | * Set scheduling policy and parameters, both base and limit, for |
179 | * the given thread. Policy must be a policy which is enabled for the |
180 | * processor set. Change contained threads if requested. |
181 | */ |
182 | kern_return_t |
183 | thread_policy( |
184 | thread_t thread, |
185 | policy_t policy, |
186 | policy_base_t base, |
187 | mach_msg_type_number_t count, |
188 | boolean_t set_limit) |
189 | { |
190 | kern_return_t result = KERN_SUCCESS; |
191 | processor_set_t pset = &pset0; |
192 | policy_limit_t limit = NULL; |
193 | int limcount = 0; |
194 | policy_rr_limit_data_t rr_limit; |
195 | policy_fifo_limit_data_t fifo_limit; |
196 | policy_timeshare_limit_data_t ts_limit; |
197 | |
198 | if (thread == THREAD_NULL) { |
199 | return KERN_INVALID_ARGUMENT; |
200 | } |
201 | |
202 | thread_mtx_lock(thread); |
203 | |
204 | if (invalid_policy(policy) || |
205 | ((POLICY_TIMESHARE | POLICY_RR | POLICY_FIFO) & policy) == 0) { |
206 | thread_mtx_unlock(thread); |
207 | |
208 | return KERN_INVALID_POLICY; |
209 | } |
210 | |
211 | if (set_limit) { |
212 | /* |
213 | * Set scheduling limits to base priority. |
214 | */ |
215 | switch (policy) { |
216 | case POLICY_RR: |
217 | { |
218 | policy_rr_base_t rr_base; |
219 | |
220 | if (count != POLICY_RR_BASE_COUNT) { |
221 | result = KERN_INVALID_ARGUMENT; |
222 | break; |
223 | } |
224 | |
225 | limcount = POLICY_RR_LIMIT_COUNT; |
226 | rr_base = (policy_rr_base_t) base; |
227 | rr_limit.max_priority = rr_base->base_priority; |
228 | limit = (policy_limit_t) &rr_limit; |
229 | |
230 | break; |
231 | } |
232 | |
233 | case POLICY_FIFO: |
234 | { |
235 | policy_fifo_base_t fifo_base; |
236 | |
237 | if (count != POLICY_FIFO_BASE_COUNT) { |
238 | result = KERN_INVALID_ARGUMENT; |
239 | break; |
240 | } |
241 | |
242 | limcount = POLICY_FIFO_LIMIT_COUNT; |
243 | fifo_base = (policy_fifo_base_t) base; |
244 | fifo_limit.max_priority = fifo_base->base_priority; |
245 | limit = (policy_limit_t) &fifo_limit; |
246 | |
247 | break; |
248 | } |
249 | |
250 | case POLICY_TIMESHARE: |
251 | { |
252 | policy_timeshare_base_t ts_base; |
253 | |
254 | if (count != POLICY_TIMESHARE_BASE_COUNT) { |
255 | result = KERN_INVALID_ARGUMENT; |
256 | break; |
257 | } |
258 | |
259 | limcount = POLICY_TIMESHARE_LIMIT_COUNT; |
260 | ts_base = (policy_timeshare_base_t) base; |
261 | ts_limit.max_priority = ts_base->base_priority; |
262 | limit = (policy_limit_t) &ts_limit; |
263 | |
264 | break; |
265 | } |
266 | |
267 | default: |
268 | result = KERN_INVALID_POLICY; |
269 | break; |
270 | } |
271 | } else { |
272 | /* |
273 | * Use current scheduling limits. Ensure that the |
274 | * new base priority will not exceed current limits. |
275 | */ |
276 | switch (policy) { |
277 | case POLICY_RR: |
278 | { |
279 | policy_rr_base_t rr_base; |
280 | |
281 | if (count != POLICY_RR_BASE_COUNT) { |
282 | result = KERN_INVALID_ARGUMENT; |
283 | break; |
284 | } |
285 | |
286 | limcount = POLICY_RR_LIMIT_COUNT; |
287 | rr_base = (policy_rr_base_t) base; |
288 | if (rr_base->base_priority > thread->max_priority) { |
289 | result = KERN_POLICY_LIMIT; |
290 | break; |
291 | } |
292 | |
293 | rr_limit.max_priority = thread->max_priority; |
294 | limit = (policy_limit_t) &rr_limit; |
295 | |
296 | break; |
297 | } |
298 | |
299 | case POLICY_FIFO: |
300 | { |
301 | policy_fifo_base_t fifo_base; |
302 | |
303 | if (count != POLICY_FIFO_BASE_COUNT) { |
304 | result = KERN_INVALID_ARGUMENT; |
305 | break; |
306 | } |
307 | |
308 | limcount = POLICY_FIFO_LIMIT_COUNT; |
309 | fifo_base = (policy_fifo_base_t) base; |
310 | if (fifo_base->base_priority > thread->max_priority) { |
311 | result = KERN_POLICY_LIMIT; |
312 | break; |
313 | } |
314 | |
315 | fifo_limit.max_priority = thread->max_priority; |
316 | limit = (policy_limit_t) &fifo_limit; |
317 | |
318 | break; |
319 | } |
320 | |
321 | case POLICY_TIMESHARE: |
322 | { |
323 | policy_timeshare_base_t ts_base; |
324 | |
325 | if (count != POLICY_TIMESHARE_BASE_COUNT) { |
326 | result = KERN_INVALID_ARGUMENT; |
327 | break; |
328 | } |
329 | |
330 | limcount = POLICY_TIMESHARE_LIMIT_COUNT; |
331 | ts_base = (policy_timeshare_base_t) base; |
332 | if (ts_base->base_priority > thread->max_priority) { |
333 | result = KERN_POLICY_LIMIT; |
334 | break; |
335 | } |
336 | |
337 | ts_limit.max_priority = thread->max_priority; |
338 | limit = (policy_limit_t) &ts_limit; |
339 | |
340 | break; |
341 | } |
342 | |
343 | default: |
344 | result = KERN_INVALID_POLICY; |
345 | break; |
346 | } |
347 | } |
348 | |
349 | thread_mtx_unlock(thread); |
350 | |
351 | if (result == KERN_SUCCESS) { |
352 | result = thread_set_policy(thread, pset, |
353 | policy, base, base_count: count, limit, limit_count: limcount); |
354 | } |
355 | |
356 | return result; |
357 | } |
358 | |