[apple/xnu.git] / osfmk / kern / mk_sp.c

/*
 * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 * 
 */

/* The routines in this module are all obsolete */

#include <mach/boolean.h>
#include <mach/thread_switch.h>
#include <ipc/ipc_port.h>
#include <ipc/ipc_space.h>
#include <kern/ipc_kobject.h>
#include <kern/processor.h>
#include <kern/sched.h>
#include <kern/sched_prim.h>
#include <kern/spl.h>
#include <kern/task.h>
#include <kern/thread.h>
#include <mach/policy.h>

#include <kern/syscall_subr.h>
#include <mach/mach_host_server.h>
#include <mach/mach_syscalls.h>

#include <kern/misc_protos.h>
#include <kern/spl.h>
#include <kern/sched.h>
#include <kern/sched_prim.h>
#include <kern/assert.h>
#include <kern/thread.h>
#include <mach/mach_host_server.h>
#include <mach/thread_act_server.h>
#include <mach/host_priv_server.h>


/*
 *	thread_set_policy
 *
 *	Set scheduling policy and parameters, both base and limit, for 
 *	the given thread. Policy can be any policy implemented by the
 *	processor set, whether enabled or not. 
 */
kern_return_t
thread_set_policy(
	thread_t				thread,
	processor_set_t			pset,
	policy_t				policy,
	policy_base_t			base,
	mach_msg_type_number_t	base_count,
	policy_limit_t			limit,
	mach_msg_type_number_t	limit_count)
{
	int 					max, bas;
	kern_return_t			result = KERN_SUCCESS;

	if (	thread == THREAD_NULL			||
			pset == PROCESSOR_SET_NULL || pset != &pset0)
		return (KERN_INVALID_ARGUMENT);

	if (invalid_policy(policy))
		return(KERN_INVALID_ARGUMENT);	

	thread_mtx_lock(thread);

	switch (policy) {

	case POLICY_RR:
	{
		policy_rr_base_t		rr_base = (policy_rr_base_t) base;
		policy_rr_limit_t		rr_limit = (policy_rr_limit_t) limit;

		if (	base_count != POLICY_RR_BASE_COUNT		||
				limit_count != POLICY_RR_LIMIT_COUNT		) {
			result = KERN_INVALID_ARGUMENT;
			break;
		}

		bas = rr_base->base_priority;
		max = rr_limit->max_priority;
		if (invalid_pri(bas) || invalid_pri(max)) {
			result = KERN_INVALID_ARGUMENT;
			break;
		}

		break;
	}

	case POLICY_FIFO:
	{
		policy_fifo_base_t		fifo_base = (policy_fifo_base_t) base;
		policy_fifo_limit_t		fifo_limit = (policy_fifo_limit_t) limit;

		if (	base_count != POLICY_FIFO_BASE_COUNT	||
				limit_count != POLICY_FIFO_LIMIT_COUNT)		{
			result = KERN_INVALID_ARGUMENT;
			break;
		}

		bas = fifo_base->base_priority;
		max = fifo_limit->max_priority;
		if (invalid_pri(bas) || invalid_pri(max)) {
			result = KERN_INVALID_ARGUMENT;
			break;
		}

		break;
	}

	case POLICY_TIMESHARE:
	{
		policy_timeshare_base_t		ts_base = (policy_timeshare_base_t) base;
		policy_timeshare_limit_t	ts_limit =
						(policy_timeshare_limit_t) limit;

		if (	base_count != POLICY_TIMESHARE_BASE_COUNT		||
				limit_count != POLICY_TIMESHARE_LIMIT_COUNT			) {
			result = KERN_INVALID_ARGUMENT;
			break;
		}

		bas = ts_base->base_priority;
		max = ts_limit->max_priority;
		if (invalid_pri(bas) || invalid_pri(max)) {
			result = KERN_INVALID_ARGUMENT;
			break;
		}

		break;
	}

	default:
		result = KERN_INVALID_POLICY;
	}

	if (result != KERN_SUCCESS) {
		thread_mtx_unlock(thread);

		return (result);
	}

	/* Note that we do not pass on max priority. */
	if (result == KERN_SUCCESS) {
	    result = thread_set_mode_and_absolute_pri(thread, policy, bas);
	}

	thread_mtx_unlock(thread);

	return (result);
}


/*
 * 	thread_policy
 *
 *	Set scheduling policy and parameters, both base and limit, for
 *	the given thread. Policy must be a policy which is enabled for the
 *	processor set. Change contained threads if requested. 
 */
kern_return_t
thread_policy(
	thread_t				thread,
	policy_t				policy,
	policy_base_t			base,
	mach_msg_type_number_t	count,
	boolean_t				set_limit)
{
	kern_return_t			result = KERN_SUCCESS;
	processor_set_t			pset = &pset0;
	policy_limit_t			limit = NULL;
	int						limcount = 0;
	policy_rr_limit_data_t			rr_limit;
	policy_fifo_limit_data_t		fifo_limit;
	policy_timeshare_limit_data_t	ts_limit;
	
	if (thread == THREAD_NULL)
		return (KERN_INVALID_ARGUMENT);

	thread_mtx_lock(thread);

	if (	invalid_policy(policy)											||
			((POLICY_TIMESHARE | POLICY_RR | POLICY_FIFO) & policy) == 0	) {
		thread_mtx_unlock(thread);

		return (KERN_INVALID_POLICY);
	}

	if (set_limit) {
		/*
	 	 * 	Set scheduling limits to base priority.
		 */
		switch (policy) {

		case POLICY_RR:
		{
			policy_rr_base_t rr_base;

			if (count != POLICY_RR_BASE_COUNT) {
				result = KERN_INVALID_ARGUMENT;
				break;
			}

			limcount = POLICY_RR_LIMIT_COUNT;
			rr_base = (policy_rr_base_t) base;
			rr_limit.max_priority = rr_base->base_priority;
			limit = (policy_limit_t) &rr_limit;

			break;
		}

		case POLICY_FIFO:
		{
			policy_fifo_base_t fifo_base;

			if (count != POLICY_FIFO_BASE_COUNT) {
				result = KERN_INVALID_ARGUMENT;
				break;
			}

			limcount = POLICY_FIFO_LIMIT_COUNT;
			fifo_base = (policy_fifo_base_t) base;
			fifo_limit.max_priority = fifo_base->base_priority;
			limit = (policy_limit_t) &fifo_limit;

			break;
		}

		case POLICY_TIMESHARE:
		{
			policy_timeshare_base_t ts_base;

			if (count != POLICY_TIMESHARE_BASE_COUNT) {
				result = KERN_INVALID_ARGUMENT;
				break;
			}

			limcount = POLICY_TIMESHARE_LIMIT_COUNT;
			ts_base = (policy_timeshare_base_t) base;
			ts_limit.max_priority = ts_base->base_priority;
			limit = (policy_limit_t) &ts_limit;

			break;
		}

		default:
			result = KERN_INVALID_POLICY;
			break;
		}

	}
	else {
		/*
		 *	Use current scheduling limits. Ensure that the
		 *	new base priority will not exceed current limits.
		 */
		switch (policy) {

		case POLICY_RR:
		{
			policy_rr_base_t rr_base;

			if (count != POLICY_RR_BASE_COUNT) {
				result = KERN_INVALID_ARGUMENT;
				break;
			}

			limcount = POLICY_RR_LIMIT_COUNT;
			rr_base = (policy_rr_base_t) base;
			if (rr_base->base_priority > thread->max_priority) {
				result = KERN_POLICY_LIMIT;
				break;
			}

			rr_limit.max_priority = thread->max_priority;
			limit = (policy_limit_t) &rr_limit;

			break;
		}

		case POLICY_FIFO:
		{
			policy_fifo_base_t fifo_base;

			if (count != POLICY_FIFO_BASE_COUNT) {
				result = KERN_INVALID_ARGUMENT;
				break;
			}

			limcount = POLICY_FIFO_LIMIT_COUNT;
			fifo_base = (policy_fifo_base_t) base;
			if (fifo_base->base_priority > thread->max_priority) {
				result = KERN_POLICY_LIMIT;
				break;
			}

			fifo_limit.max_priority = thread->max_priority;
			limit = (policy_limit_t) &fifo_limit;

			break;
		}

		case POLICY_TIMESHARE:
		{
			policy_timeshare_base_t ts_base;

			if (count != POLICY_TIMESHARE_BASE_COUNT) {
				result = KERN_INVALID_ARGUMENT;
				break;
			}

			limcount = POLICY_TIMESHARE_LIMIT_COUNT;
			ts_base = (policy_timeshare_base_t) base;
			if (ts_base->base_priority > thread->max_priority) {
				result = KERN_POLICY_LIMIT;
				break;
			}

			ts_limit.max_priority = thread->max_priority;
			limit = (policy_limit_t) &ts_limit;

			break;
		}

		default:
			result = KERN_INVALID_POLICY;
			break;
		}

	}

	thread_mtx_unlock(thread);

	if (result == KERN_SUCCESS)
	    result = thread_set_policy(thread, pset,
					 policy, base, count, limit, limcount);

	return(result);
}
Commit	Line	Data
1c79356b	1	/*
2d21ac55	2	* Copyright (c) 2000-2007 Apple Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	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.
8f6c56a5	14	*
2d21ac55 A	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
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	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.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* @OSF_COPYRIGHT@
	30	*
	31	*/
	32
91447636	33	/* The routines in this module are all obsolete */
1c79356b A	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>
1c79356b A	46	#include <mach/policy.h>
	47
	48	#include <kern/syscall_subr.h>
	49	#include <mach/mach_host_server.h>
	50	#include <mach/mach_syscalls.h>
	51
1c79356b A	52	#include <kern/misc_protos.h>
	53	#include <kern/spl.h>
	54	#include <kern/sched.h>
	55	#include <kern/sched_prim.h>
	56	#include <kern/assert.h>
	57	#include <kern/thread.h>
	58	#include <mach/mach_host_server.h>
1c79356b A	59	#include <mach/thread_act_server.h>
	60	#include <mach/host_priv_server.h>
	61
1c79356b A	62
	63	/*
	64	* thread_set_policy
	65	*
	66	* Set scheduling policy and parameters, both base and limit, for
	67	* the given thread. Policy can be any policy implemented by the
	68	* processor set, whether enabled or not.
	69	*/
	70	kern_return_t
	71	thread_set_policy(
91447636	72	thread_t thread,
1c79356b A	73	processor_set_t pset,
	74	policy_t policy,
	75	policy_base_t base,
	76	mach_msg_type_number_t base_count,
	77	policy_limit_t limit,
	78	mach_msg_type_number_t limit_count)
	79	{
0b4e3aa0	80	int max, bas;
1c79356b A	81	kern_return_t result = KERN_SUCCESS;
1c79356b A	82
91447636	83	if ( thread == THREAD_NULL \|\|
2d21ac55	84	pset == PROCESSOR_SET_NULL \|\| pset != &pset0)
1c79356b A	85	return (KERN_INVALID_ARGUMENT);
1c79356b A	86
fe8ab488 A	87	if (invalid_policy(policy))
	88	return(KERN_INVALID_ARGUMENT);
	89
91447636	90	thread_mtx_lock(thread);
1c79356b	91
1c79356b A	92	switch (policy) {
	93
	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
1c79356b A	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
1c79356b A	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
1c79356b A	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) {
91447636	163	thread_mtx_unlock(thread);
1c79356b	164
91447636	165	return (result);
1c79356b A	166	}
1c79356b A	167
fe8ab488 A	168	/* Note that we do not pass on max priority. */
	169	if (result == KERN_SUCCESS) {
	170	result = thread_set_mode_and_absolute_pri(thread, policy, bas);
	171	}
1c79356b	172
91447636 A	173	thread_mtx_unlock(thread);
	174
	175	return (result);
1c79356b A	176	}
	177
	178
	179	/*
	180	* thread_policy
	181	*
	182	* Set scheduling policy and parameters, both base and limit, for
	183	* the given thread. Policy must be a policy which is enabled for the
	184	* processor set. Change contained threads if requested.
	185	*/
	186	kern_return_t
	187	thread_policy(
91447636	188	thread_t thread,
1c79356b A	189	policy_t policy,
	190	policy_base_t base,
	191	mach_msg_type_number_t count,
	192	boolean_t set_limit)
	193	{
1c79356b	194	kern_return_t result = KERN_SUCCESS;
2d21ac55 A	195	processor_set_t pset = &pset0;
	196	policy_limit_t limit = NULL;
	197	int limcount = 0;
1c79356b A	198	policy_rr_limit_data_t rr_limit;
	199	policy_fifo_limit_data_t fifo_limit;
	200	policy_timeshare_limit_data_t ts_limit;
	201
91447636	202	if (thread == THREAD_NULL)
1c79356b A	203	return (KERN_INVALID_ARGUMENT);
1c79356b A	204
91447636 A	205	thread_mtx_lock(thread);
91447636 A	206
0b4e3aa0 A	207	if ( invalid_policy(policy) \|\|
0b4e3aa0 A	208	((POLICY_TIMESHARE \| POLICY_RR \| POLICY_FIFO) & policy) == 0 ) {
91447636	209	thread_mtx_unlock(thread);
1c79356b	210
91447636	211	return (KERN_INVALID_POLICY);
1c79356b A	212	}
	213
	214	if (set_limit) {
	215	/*
	216	* Set scheduling limits to base priority.
	217	*/
	218	switch (policy) {
	219
	220	case POLICY_RR:
	221	{
	222	policy_rr_base_t rr_base;
	223
	224	if (count != POLICY_RR_BASE_COUNT) {
	225	result = KERN_INVALID_ARGUMENT;
	226	break;
	227	}
	228
	229	limcount = POLICY_RR_LIMIT_COUNT;
	230	rr_base = (policy_rr_base_t) base;
	231	rr_limit.max_priority = rr_base->base_priority;
	232	limit = (policy_limit_t) &rr_limit;
	233
	234	break;
	235	}
	236
	237	case POLICY_FIFO:
	238	{
	239	policy_fifo_base_t fifo_base;
	240
	241	if (count != POLICY_FIFO_BASE_COUNT) {
	242	result = KERN_INVALID_ARGUMENT;
	243	break;
	244	}
	245
	246	limcount = POLICY_FIFO_LIMIT_COUNT;
	247	fifo_base = (policy_fifo_base_t) base;
	248	fifo_limit.max_priority = fifo_base->base_priority;
	249	limit = (policy_limit_t) &fifo_limit;
	250
	251	break;
	252	}
	253
	254	case POLICY_TIMESHARE:
	255	{
	256	policy_timeshare_base_t ts_base;
	257
	258	if (count != POLICY_TIMESHARE_BASE_COUNT) {
	259	result = KERN_INVALID_ARGUMENT;
	260	break;
	261	}
	262
	263	limcount = POLICY_TIMESHARE_LIMIT_COUNT;
	264	ts_base = (policy_timeshare_base_t) base;
	265	ts_limit.max_priority = ts_base->base_priority;
	266	limit = (policy_limit_t) &ts_limit;
	267
	268	break;
	269	}
	270
	271	default:
	272	result = KERN_INVALID_POLICY;
	273	break;
	274	}
	275
276	}
277	else {
278	/*
279	* Use current scheduling limits. Ensure that the
280	* new base priority will not exceed current limits.
281	*/
282	switch (policy) {
283
284	case POLICY_RR:
285	{
286	policy_rr_base_t rr_base;
287
288	if (count != POLICY_RR_BASE_COUNT) {
289	result = KERN_INVALID_ARGUMENT;
290	break;
291	}
292
293	limcount = POLICY_RR_LIMIT_COUNT;
294	rr_base = (policy_rr_base_t) base;
295	if (rr_base->base_priority > thread->max_priority) {
296	result = KERN_POLICY_LIMIT;
297	break;
298	}
299
300	rr_limit.max_priority = thread->max_priority;
301	limit = (policy_limit_t) &rr_limit;
302
303	break;
304	}
305
306	case POLICY_FIFO:
307	{
308	policy_fifo_base_t fifo_base;
309
310	if (count != POLICY_FIFO_BASE_COUNT) {
311	result = KERN_INVALID_ARGUMENT;
312	break;
313	}
314
315	limcount = POLICY_FIFO_LIMIT_COUNT;
316	fifo_base = (policy_fifo_base_t) base;
317	if (fifo_base->base_priority > thread->max_priority) {
318	result = KERN_POLICY_LIMIT;
319	break;
320	}
321
322	fifo_limit.max_priority = thread->max_priority;
323	limit = (policy_limit_t) &fifo_limit;
324
325	break;
326	}
327
328	case POLICY_TIMESHARE:
329	{
330	policy_timeshare_base_t ts_base;
331
332	if (count != POLICY_TIMESHARE_BASE_COUNT) {
333	result = KERN_INVALID_ARGUMENT;
334	break;
335	}
336
337	limcount = POLICY_TIMESHARE_LIMIT_COUNT;
338	ts_base = (policy_timeshare_base_t) base;
339	if (ts_base->base_priority > thread->max_priority) {
340	result = KERN_POLICY_LIMIT;
341	break;
342	}
343
344	ts_limit.max_priority = thread->max_priority;
345	limit = (policy_limit_t) &ts_limit;
346
347	break;
348	}
349
350	default:
351	result = KERN_INVALID_POLICY;
352	break;
353	}
354
355	}
356
91447636	357	thread_mtx_unlock(thread);
1c79356b A	358
1c79356b A	359	if (result == KERN_SUCCESS)
91447636	360	result = thread_set_policy(thread, pset,
1c79356b A	361	policy, base, count, limit, limcount);
	362
	363	return(result);
	364	}