X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/ff6e181ae92fc6f1e89841290f461d1f2f9badd9..HEAD:/osfmk/kern/mk_sp.c diff --git a/osfmk/kern/mk_sp.c b/osfmk/kern/mk_sp.c index bdb81bd12..37181373d 100644 --- a/osfmk/kern/mk_sp.c +++ b/osfmk/kern/mk_sp.c @@ -1,15 +1,20 @@ /* - * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2007 Apple Inc. All rights reserved. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * - * @APPLE_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. Please obtain a copy of the License at - * http://www.opensource.apple.com/apsl/ and read it before using this - * file. - * + * 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, @@ -17,12 +22,12 @@ * 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_LICENSE_HEADER_END@ + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* * @OSF_COPYRIGHT@ - * + * */ /* The routines in this module are all obsolete */ @@ -39,6 +44,7 @@ #include #include #include +#include #include #include @@ -54,123 +60,44 @@ #include #include -/* - * thread_policy_common: - * - * Set scheduling policy & priority for thread. - */ -static kern_return_t -thread_policy_common( - thread_t thread, - integer_t policy, - integer_t priority) -{ - spl_t s; - - if ( thread == THREAD_NULL || - invalid_policy(policy) ) - return(KERN_INVALID_ARGUMENT); - - s = splsched(); - thread_lock(thread); - - if ( !(thread->sched_mode & TH_MODE_REALTIME) && - !(thread->safe_mode & TH_MODE_REALTIME) ) { - if (!(thread->sched_mode & TH_MODE_FAILSAFE)) { - integer_t oldmode = (thread->sched_mode & TH_MODE_TIMESHARE); - - if (policy == POLICY_TIMESHARE && !oldmode) { - thread->sched_mode |= TH_MODE_TIMESHARE; - - if (thread->state & TH_RUN) - pset_share_incr(thread->processor_set); - } - else - if (policy != POLICY_TIMESHARE && oldmode) { - thread->sched_mode &= ~TH_MODE_TIMESHARE; - - if (thread->state & TH_RUN) - pset_share_decr(thread->processor_set); - } - } - else { - if (policy == POLICY_TIMESHARE) - thread->safe_mode |= TH_MODE_TIMESHARE; - else - thread->safe_mode &= ~TH_MODE_TIMESHARE; - } - - if (priority >= thread->max_priority) - priority = thread->max_priority - thread->task_priority; - else - if (priority >= MINPRI_KERNEL) - priority -= MINPRI_KERNEL; - else - if (priority >= MINPRI_RESERVED) - priority -= MINPRI_RESERVED; - else - priority -= BASEPRI_DEFAULT; - - priority += thread->task_priority; - - if (priority > thread->max_priority) - priority = thread->max_priority; - else - if (priority < MINPRI) - priority = MINPRI; - - thread->importance = priority - thread->task_priority; - - set_priority(thread, priority); - } - - thread_unlock(thread); - splx(s); - - return (KERN_SUCCESS); -} /* * thread_set_policy * - * Set scheduling policy and parameters, both base and limit, for + * 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. + * 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) + 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 ) - return (KERN_INVALID_ARGUMENT); + int max, bas; + kern_return_t result = KERN_SUCCESS; - thread_mtx_lock(thread); - - if (pset != thread->processor_set) { - thread_mtx_unlock(thread); + if (thread == THREAD_NULL || + pset == PROCESSOR_SET_NULL || pset != &pset0) { + return KERN_INVALID_ARGUMENT; + } - return (KERN_FAILURE); + if (invalid_policy(policy)) { + return KERN_INVALID_ARGUMENT; } 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; + 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 ) { + if (base_count != POLICY_RR_BASE_COUNT || + limit_count != POLICY_RR_LIMIT_COUNT) { result = KERN_INVALID_ARGUMENT; break; } @@ -187,11 +114,11 @@ thread_set_policy( 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; + 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) { + if (base_count != POLICY_FIFO_BASE_COUNT || + limit_count != POLICY_FIFO_LIMIT_COUNT) { result = KERN_INVALID_ARGUMENT; break; } @@ -208,12 +135,12 @@ thread_set_policy( 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; + 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 ) { + if (base_count != POLICY_TIMESHARE_BASE_COUNT || + limit_count != POLICY_TIMESHARE_LIMIT_COUNT) { result = KERN_INVALID_ARGUMENT; break; } @@ -233,67 +160,59 @@ thread_set_policy( } if (result != KERN_SUCCESS) { - thread_mtx_unlock(thread); - - return (result); + return result; } - result = thread_policy_common(thread, policy, bas); - - thread_mtx_unlock(thread); + /* Note that we do not pass on max priority. */ + if (result == KERN_SUCCESS) { + result = thread_set_mode_and_absolute_pri(thread, policy, bas); + } - return (result); + return result; } /* - * thread_policy + * 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. + * 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) + 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; - policy_limit_t limit; - int limcount; - 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); + 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); - pset = thread->processor_set; - if (pset == PROCESSOR_SET_NULL) { - thread_mtx_unlock(thread); - - return (KERN_INVALID_ARGUMENT); - } - - if ( invalid_policy(policy) || - ((POLICY_TIMESHARE | POLICY_RR | POLICY_FIFO) & policy) == 0 ) { + if (invalid_policy(policy) || + ((POLICY_TIMESHARE | POLICY_RR | POLICY_FIFO) & policy) == 0) { thread_mtx_unlock(thread); - return (KERN_INVALID_POLICY); + return KERN_INVALID_POLICY; } if (set_limit) { /* - * Set scheduling limits to base priority. + * Set scheduling limits to base priority. */ switch (policy) { - case POLICY_RR: { policy_rr_base_t rr_base; @@ -349,15 +268,12 @@ thread_policy( result = KERN_INVALID_POLICY; break; } - - } - else { + } 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; @@ -428,14 +344,14 @@ thread_policy( result = KERN_INVALID_POLICY; break; } - } thread_mtx_unlock(thread); - if (result == KERN_SUCCESS) - result = thread_set_policy(thread, pset, - policy, base, count, limit, limcount); + if (result == KERN_SUCCESS) { + result = thread_set_policy(thread, pset, + policy, base, count, limit, limcount); + } - return(result); + return result; }