X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/d7e50217d7adf6e52786a38bcaa4cd698cb9a79e..b0d623f7f2ae71ed96e60569f61f9a9a27016e80:/osfmk/kern/ast.c diff --git a/osfmk/kern/ast.c b/osfmk/kern/ast.c index 0764da904..b6540f92d 100644 --- a/osfmk/kern/ast.c +++ b/osfmk/kern/ast.c @@ -1,16 +1,19 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2009 Apple Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ - * - * Copyright (c) 1999-2003 Apple Computer, 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. 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 @@ -20,7 +23,7 @@ * 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@ @@ -63,7 +66,6 @@ */ #include -#include #include #include @@ -73,112 +75,108 @@ #include #include #include -#include -#include #include #include +#include #include +#include // for CHUD AST hook -volatile ast_t need_ast[NCPUS]; void ast_init(void) { -#ifndef MACHINE_AST - register int i; - - for (i=0; istate & TH_IDLE) - goto enable_and_return; + boolean_t preempt_trap = (reasons == AST_PREEMPTION); + ast_t *myast = ast_pending(); + thread_t thread = current_thread(); + perfCallback perf_hook = perfASTHook; /* - * Check for urgent preemption + * CHUD hook - all threads including idle processor threads */ - if ((reasons & AST_URGENT) && wait_queue_assert_possible(self)) { - if (reasons & AST_BLOCK) { - counter(c_ast_taken_block++); - thread_block_reason((void (*)(void))0, AST_BLOCK); + if (perf_hook) { + if (*myast & AST_CHUD_ALL) { + (*perf_hook)(0, NULL, 0, 0); + + if (*myast == AST_NONE) + return; } - - reasons &= ~AST_PREEMPT; - if (reasons == 0) - goto enable_and_return; } + else + *myast &= ~AST_CHUD_ALL; - if (preempt_trap) - goto enable_and_return; + reasons &= *myast; + *myast &= ~reasons; - ml_set_interrupts_enabled(enable); - -#ifdef MACH_BSD /* - * Check for BSD hook + * Handle ASTs for all threads + * except idle processor threads. */ - if (reasons & AST_BSD) { - extern void bsd_ast(thread_act_t act); - thread_act_t act = self->top_act; + if (!(thread->state & TH_IDLE)) { + /* + * Check for urgent preemption. + */ + if ( (reasons & AST_URGENT) && + wait_queue_assert_possible(thread) ) { + if (reasons & AST_PREEMPT) { + counter(c_ast_taken_block++); + thread_block_reason(THREAD_CONTINUE_NULL, NULL, + AST_PREEMPT | AST_URGENT); + } + + reasons &= ~AST_PREEMPTION; + } - thread_ast_clear(act, AST_BSD); - bsd_ast(act); - } -#endif + /* + * The kernel preempt traps + * skip all other ASTs. + */ + if (!preempt_trap) { + ml_set_interrupts_enabled(enable); - /* - * migration APC hook - */ - if (reasons & AST_APC) { - act_execute_returnhandlers(); - } +#ifdef MACH_BSD + /* + * Handle BSD hook. + */ + if (reasons & AST_BSD) { + thread_ast_clear(thread, AST_BSD); + bsd_ast(thread); + } +#endif - /* - * Check for normal preemption - */ - reasons &= AST_BLOCK; - if (reasons == 0) { - disable_preemption(); - myprocessor = current_processor(); - if (csw_needed(self, myprocessor)) - reasons = AST_BLOCK; - enable_preemption(); - } - if ( (reasons & AST_BLOCK) && - wait_queue_assert_possible(self) ) { - counter(c_ast_taken_block++); - thread_block_reason(thread_exception_return, AST_BLOCK); + /* + * Thread APC hook. + */ + if (reasons & AST_APC) + act_execute_returnhandlers(); + + ml_set_interrupts_enabled(FALSE); + + /* + * Check for preemption. + */ + if (reasons & AST_PREEMPT) + reasons = csw_check(current_processor()); + + if ( (reasons & AST_PREEMPT) && + wait_queue_assert_possible(thread) ) { + counter(c_ast_taken_block++); + thread_block_reason((thread_continue_t)thread_exception_return, NULL, AST_PREEMPT); + } + } } - goto just_return; - -enable_and_return: - ml_set_interrupts_enabled(enable); - -just_return: - return; + ml_set_interrupts_enabled(enable); } /* @@ -188,33 +186,22 @@ void ast_check( processor_t processor) { - register thread_t self = processor->cpu_data->active_thread; + thread_t thread = processor->active_thread; - processor->current_pri = self->sched_pri; - if (processor->state == PROCESSOR_RUNNING) { - register ast_t preempt; -processor_running: + processor->current_pri = thread->sched_pri; + if ( processor->state == PROCESSOR_RUNNING || + processor->state == PROCESSOR_SHUTDOWN ) { + ast_t preempt; /* * Propagate thread ast to processor. */ - ast_propagate(self->top_act->ast); + ast_propagate(thread->ast); /* * Context switch check. */ - if ((preempt = csw_check(self, processor)) != AST_NONE) + if ((preempt = csw_check(processor)) != AST_NONE) ast_on(preempt); } - else - if ( processor->state == PROCESSOR_DISPATCHING || - processor->state == PROCESSOR_IDLE ) { - return; - } - else - if (processor->state == PROCESSOR_SHUTDOWN) - goto processor_running; - else - if (processor->state == PROCESSOR_ASSIGN) - ast_on(AST_BLOCK); }