X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/0b4e3aa066abc0728aacb4bbeb86f53f9737156e..8ad349bb6ed4a0be06e34c92be0d98b92e078db4:/osfmk/kern/machine.c diff --git a/osfmk/kern/machine.c b/osfmk/kern/machine.c index b1a1ee73a..fe6ab43ce 100644 --- a/osfmk/kern/machine.c +++ b/osfmk/kern/machine.c @@ -1,23 +1,31 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ + * @APPLE_LICENSE_OSREFERENCE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. - * - * This 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 OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. - * - * @APPLE_LICENSE_HEADER_END@ + * 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_LICENSE_OSREFERENCE_HEADER_END@ */ /* * @OSF_COPYRIGHT@ @@ -57,125 +65,73 @@ * Support for machine independent machine abstraction. */ -#include - #include + +#include #include #include -#include #include #include #include +#include +#include + +#include #include #include #include #include #include #include +#include #include #include #include #include #include -#include -#include -#include +#include /* * Exported variables: */ struct machine_info machine_info; -struct machine_slot machine_slot[NCPUS]; - -static queue_head_t processor_action_queue; -static boolean_t processor_action_active; -static thread_call_t processor_action_call; -static thread_call_data_t processor_action_call_data; -decl_simple_lock_data(static,processor_action_lock) - -thread_t machine_wake_thread; /* Forwards */ -processor_set_t processor_request_action( - processor_t processor, - processor_set_t new_pset); - -void processor_doaction( - processor_t processor); - void processor_doshutdown( processor_t processor); /* - * cpu_up: + * processor_up: * - * Flag specified cpu as up and running. Called when a processor comes - * online. + * Flag processor as up and running, and available + * for scheduling. */ void -cpu_up( - int cpu) +processor_up( + processor_t processor) { - processor_t processor = cpu_to_processor(cpu); - struct machine_slot *ms; - spl_t s; - - /* - * Just twiddle our thumbs; we've got nothing better to do - * yet, anyway. - */ - while (!simple_lock_try(&default_pset.processors_lock)) - continue; + processor_set_t pset = &default_pset; + spl_t s; s = splsched(); processor_lock(processor); init_ast_check(processor); - ms = &machine_slot[cpu]; - ms->running = TRUE; - machine_info.avail_cpus++; - pset_add_processor(&default_pset, processor); + simple_lock(&pset->sched_lock); + pset_add_processor(pset, processor); + enqueue_tail(&pset->active_queue, (queue_entry_t)processor); processor->state = PROCESSOR_RUNNING; - processor_unlock(processor); - splx(s); - - simple_unlock(&default_pset.processors_lock); -} - -/* - * cpu_down: - * - * Flag specified cpu as down. Called when a processor is about to - * go offline. - */ -void -cpu_down( - int cpu) -{ - processor_t processor; - struct machine_slot *ms; - spl_t s; - - processor = cpu_to_processor(cpu); - - s = splsched(); - processor_lock(processor); - ms = &machine_slot[cpu]; - ms->running = FALSE; - machine_info.avail_cpus--; - /* - * processor has already been removed from pset. - */ - processor->processor_set_next = PROCESSOR_SET_NULL; - processor->state = PROCESSOR_OFF_LINE; + simple_unlock(&pset->sched_lock); + hw_atomic_add(&machine_info.avail_cpus, 1); + ml_cpu_up(); processor_unlock(processor); splx(s); } kern_return_t host_reboot( - host_priv_t host_priv, + host_priv_t host_priv, int options) { if (host_priv == HOST_PRIV_NULL) @@ -185,133 +141,35 @@ host_reboot( if (options & HOST_REBOOT_DEBUGGER) { Debugger("Debugger"); - } - else - halt_all_cpus(!(options & HOST_REBOOT_HALT)); - - return (KERN_SUCCESS); -} - -/* - * processor_request_action: - * - * Common internals of processor_assign and processor_shutdown. - * If new_pset is null, this is a shutdown, else it's an assign - * and caller must donate a reference. - * For assign operations, it returns an old pset that must be deallocated - * if it's not NULL. - * For shutdown operations, it always returns PROCESSOR_SET_NULL. - */ -processor_set_t -processor_request_action( - processor_t processor, - processor_set_t new_pset) -{ - processor_set_t pset, old_next_pset; - - /* - * Processor must be in a processor set. Must lock its idle lock to - * get at processor state. - */ - pset = processor->processor_set; - simple_lock(&pset->idle_lock); - - /* - * If the processor is dispatching, let it finish - it will set its - * state to running very soon. - */ - while (*(volatile int *)&processor->state == PROCESSOR_DISPATCHING) { - simple_unlock(&pset->idle_lock); - simple_lock(&pset->idle_lock); - } - - /* - * Now lock the action queue and do the dirty work. - */ - simple_lock(&processor_action_lock); - - switch (processor->state) { - - case PROCESSOR_IDLE: - /* - * Remove from idle queue. - */ - queue_remove(&pset->idle_queue, processor, - processor_t, processor_queue); - pset->idle_count--; - - /* fall through ... */ - case PROCESSOR_RUNNING: - /* - * Put it on the action queue. - */ - queue_enter(&processor_action_queue, processor, - processor_t,processor_queue); - - /* Fall through ... */ - case PROCESSOR_ASSIGN: - /* - * And ask the action_thread to do the work. - */ - - if (new_pset == PROCESSOR_SET_NULL) { - processor->state = PROCESSOR_SHUTDOWN; - old_next_pset = PROCESSOR_SET_NULL; - } else { - processor->state = PROCESSOR_ASSIGN; - old_next_pset = processor->processor_set_next; - processor->processor_set_next = new_pset; - } - break; - - default: - printf("state: %d\n", processor->state); - panic("processor_request_action: bad state"); + return (KERN_SUCCESS); } - if (processor_action_active == FALSE) { - processor_action_active = TRUE; - simple_unlock(&processor_action_lock); - simple_unlock(&pset->idle_lock); - processor_unlock(processor); - thread_call_enter(processor_action_call); - processor_lock(processor); - } else { - simple_unlock(&processor_action_lock); - simple_unlock(&pset->idle_lock); - } + halt_all_cpus(!(options & HOST_REBOOT_HALT)); - return (old_next_pset); + return (KERN_SUCCESS); } kern_return_t processor_assign( - processor_t processor, - processor_set_t new_pset, - boolean_t wait) + __unused processor_t processor, + __unused processor_set_t new_pset, + __unused boolean_t wait) { -#ifdef lint - processor++; new_pset++; wait++; -#endif /* lint */ return (KERN_FAILURE); } -/* - * processor_shutdown() queues a processor up for shutdown. - * Any assignment in progress is overriden. - */ kern_return_t processor_shutdown( - processor_t processor) + processor_t processor) { - spl_t s; + processor_set_t pset; + spl_t s; s = splsched(); processor_lock(processor); - if ((processor->state == PROCESSOR_OFF_LINE) || - (processor->state == PROCESSOR_SHUTDOWN)) { + if (processor->state == PROCESSOR_OFF_LINE) { /* - * Already shutdown or being shutdown -- nothing to do. + * Success if already shutdown. */ processor_unlock(processor); splx(s); @@ -319,160 +177,177 @@ processor_shutdown( return (KERN_SUCCESS); } - (void) processor_request_action(processor, PROCESSOR_SET_NULL); - - assert_wait((event_t)processor, THREAD_UNINT); - - processor_unlock(processor); - splx(s); + if (processor->state == PROCESSOR_START) { + /* + * Failure if currently being started. + */ + processor_unlock(processor); + splx(s); - thread_block((void (*)(void)) 0); + return (KERN_FAILURE); + } - return (KERN_SUCCESS); -} + /* + * Must lock the scheduling lock + * to get at the processor state. + */ + pset = processor->processor_set; + if (pset != PROCESSOR_SET_NULL) { + simple_lock(&pset->sched_lock); -/* - * processor_action() shuts down processors or changes their assignment. - */ -static void -_processor_action( - thread_call_param_t p0, - thread_call_param_t p1) -{ - register processor_t processor; - spl_t s; + /* + * If the processor is dispatching, let it finish. + */ + while (processor->state == PROCESSOR_DISPATCHING) { + simple_unlock(&pset->sched_lock); + delay(1); + simple_lock(&pset->sched_lock); + } - s = splsched(); - simple_lock(&processor_action_lock); + /* + * Success if already being shutdown. + */ + if (processor->state == PROCESSOR_SHUTDOWN) { + simple_unlock(&pset->sched_lock); + processor_unlock(processor); + splx(s); - while (!queue_empty(&processor_action_queue)) { - processor = (processor_t) queue_first(&processor_action_queue); - queue_remove(&processor_action_queue, processor, - processor_t, processor_queue); - simple_unlock(&processor_action_lock); + return (KERN_SUCCESS); + } + } + else { + /* + * Success, already being shutdown. + */ + processor_unlock(processor); splx(s); - processor_doaction(processor); + return (KERN_SUCCESS); + } - s = splsched(); - simple_lock(&processor_action_lock); + if (processor->state == PROCESSOR_IDLE) { + remqueue(&pset->idle_queue, (queue_entry_t)processor); + pset->idle_count--; } + else + if (processor->state == PROCESSOR_RUNNING) + remqueue(&pset->active_queue, (queue_entry_t)processor); + else + panic("processor_shutdown"); + + processor->state = PROCESSOR_SHUTDOWN; + + simple_unlock(&pset->sched_lock); + + processor_unlock(processor); - processor_action_active = FALSE; - simple_unlock(&processor_action_lock); + processor_doshutdown(processor); splx(s); -} -void -processor_action(void) -{ - queue_init(&processor_action_queue); - simple_lock_init(&processor_action_lock, ETAP_THREAD_ACTION); - processor_action_active = FALSE; + cpu_exit_wait(PROCESSOR_DATA(processor, slot_num)); - thread_call_setup(&processor_action_call_data, _processor_action, NULL); - processor_action_call = &processor_action_call_data; + return (KERN_SUCCESS); } /* - * processor_doaction actually does the shutdown. The trick here - * is to schedule ourselves onto a cpu and then save our - * context back into the runqs before taking out the cpu. + * Called at splsched. */ void -processor_doaction( - processor_t processor) +processor_doshutdown( + processor_t processor) { - thread_t self = current_thread(); + thread_t old_thread, self = current_thread(); processor_set_t pset; - thread_t old_thread; - spl_t s; + processor_t prev; + int pcount; /* * Get onto the processor to shutdown */ - thread_bind(self, processor); - thread_block((void (*)(void)) 0); + prev = thread_bind(self, processor); + thread_block(THREAD_CONTINUE_NULL); + processor_lock(processor); pset = processor->processor_set; - simple_lock(&pset->processors_lock); + simple_lock(&pset->sched_lock); - if (pset->processor_count == 1) { - thread_t thread; - extern void start_cpu_thread(void); + if ((pcount = pset->processor_count) == 1) { + simple_unlock(&pset->sched_lock); + processor_unlock(processor); - simple_unlock(&pset->processors_lock); + hibernate_vm_lock(); - /* - * Create the thread, and point it at the routine. - */ - thread = kernel_thread_with_priority( - kernel_task, MAXPRI_KERNEL, - start_cpu_thread, TRUE, FALSE); - - disable_preemption(); - - s = splsched(); - thread_lock(thread); - thread->state |= TH_RUN; - _mk_sp_thread_unblock(thread); - (void)rem_runq(thread); - machine_wake_thread = thread; - thread_unlock(thread); - splx(s); - - simple_lock(&pset->processors_lock); - enable_preemption(); + processor_lock(processor); + simple_lock(&pset->sched_lock); } - s = splsched(); - processor_lock(processor); - - /* - * Do shutdown, make sure we live when processor dies. - */ - if (processor->state != PROCESSOR_SHUTDOWN) { - panic("action_thread -- bad processor state"); - } + assert(processor->state == PROCESSOR_SHUTDOWN); pset_remove_processor(pset, processor); + simple_unlock(&pset->sched_lock); processor_unlock(processor); - simple_unlock(&pset->processors_lock); + + if (pcount == 1) + hibernate_vm_unlock(); /* - * Clean up. + * Continue processor shutdown in shutdown context. */ - thread_bind(self, PROCESSOR_NULL); - self->continuation = 0; - old_thread = switch_to_shutdown_context(self, - processor_doshutdown, processor); + thread_bind(self, prev); + old_thread = machine_processor_shutdown(self, processor_offline, processor); + + thread_begin(self, self->last_processor); + thread_dispatch(old_thread); - thread_wakeup((event_t)processor); - splx(s); + + /* + * If we just shutdown another processor, move the + * timer call outs to the current processor. + */ + if (processor != current_processor()) { + processor_lock(processor); + if ( processor->state == PROCESSOR_OFF_LINE || + processor->state == PROCESSOR_SHUTDOWN ) + timer_call_shutdown(processor); + processor_unlock(processor); + } } /* - * Actually do the processor shutdown. This is called at splsched, - * running on the processor's shutdown stack. + * Complete the shutdown and place the processor offline. + * + * Called at splsched in the shutdown context. */ - void -processor_doshutdown( +processor_offline( processor_t processor) { - register int cpu = processor->slot_num; + thread_t thread, old_thread = processor->active_thread; - timer_call_cancel(&processor->quantum_timer); - thread_dispatch(current_thread()); - timer_switch(&kernel_timer[cpu]); + thread = processor->idle_thread; + processor->active_thread = thread; + processor->current_pri = IDLEPRI; + + processor->last_dispatch = mach_absolute_time(); + timer_switch((uint32_t)processor->last_dispatch, + &PROCESSOR_DATA(processor, offline_timer)); + + thread_done(old_thread, thread, processor); + + machine_set_current_thread(thread); + + thread_begin(thread, processor); + + thread_dispatch(old_thread); + + PMAP_DEACTIVATE_KERNEL(PROCESSOR_DATA(processor, slot_num)); + + processor_lock(processor); + processor->state = PROCESSOR_OFF_LINE; + hw_atomic_sub(&machine_info.avail_cpus, 1); + ml_cpu_down(); + processor_unlock(processor); - /* - * OK, now exit this cpu. - */ - PMAP_DEACTIVATE_KERNEL(cpu); - cpu_data[cpu].active_thread = THREAD_NULL; - active_kloaded[cpu] = THR_ACT_NULL; - cpu_down(cpu); cpu_sleep(); panic("zombie processor"); /*NOTREACHED*/ @@ -483,11 +358,7 @@ host_get_boot_info( host_priv_t host_priv, kernel_boot_info_t boot_info) { - char *src = ""; - extern char *machine_boot_info( - kernel_boot_info_t boot_info, - vm_size_t buf_len); - + const char *src = ""; if (host_priv == HOST_PRIV_NULL) return (KERN_INVALID_HOST);