X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/593a1d5fd87cdf5b46dd5fcb84467b432cea0f91..2a1bd2d3eef5c7a7bb14f4bb9fdbca9a96ee4752:/osfmk/i386/cpu.c diff --git a/osfmk/i386/cpu.c b/osfmk/i386/cpu.c index 1760eabf5..2b5ef1584 100644 --- a/osfmk/i386/cpu.c +++ b/osfmk/i386/cpu.c @@ -1,8 +1,8 @@ /* - * Copyright (c) 2000-2008 Apple Inc. All rights reserved. + * Copyright (c) 2000-2009 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 @@ -11,10 +11,10 @@ * 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, @@ -22,7 +22,7 @@ * 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@ */ /* @@ -31,63 +31,68 @@ * cpu specific routines */ -#include #include +#include #include #include +#include #include #include -#include #include #include -#include +#include +#include +#if CONFIG_VMX +#include +#endif #include -#include "cpuid.h" +#include + +const char *processor_to_datastring(const char *prefix, processor_t target_processor); -struct processor processor_master; +struct processor processor_master; /*ARGSUSED*/ kern_return_t cpu_control( - int slot_num, - processor_info_t info, - unsigned int count) + int slot_num, + processor_info_t info, + unsigned int count) { printf("cpu_control(%d,%p,%d) not implemented\n", - slot_num, info, count); - return (KERN_FAILURE); + slot_num, info, count); + return KERN_FAILURE; } /*ARGSUSED*/ kern_return_t cpu_info_count( - __unused processor_flavor_t flavor, - unsigned int *count) + __unused processor_flavor_t flavor, + unsigned int *count) { *count = 0; - return (KERN_FAILURE); + return KERN_FAILURE; } /*ARGSUSED*/ kern_return_t cpu_info( - processor_flavor_t flavor, - int slot_num, - processor_info_t info, - unsigned int *count) + processor_flavor_t flavor, + int slot_num, + processor_info_t info, + unsigned int *count) { printf("cpu_info(%d,%d,%p,%p) not implemented\n", - flavor, slot_num, info, count); - return (KERN_FAILURE); + flavor, slot_num, info, count); + return KERN_FAILURE; } void cpu_sleep(void) { - cpu_data_t *cdp = current_cpu_datap(); - - i386_deactivate_cpu(); + cpu_data_t *cdp = current_cpu_datap(); + /* This calls IOCPURunPlatformQuiesceActions when sleeping the boot cpu */ PE_cpu_machine_quiesce(cdp->cpu_id); cpu_thread_halt(); @@ -96,7 +101,10 @@ cpu_sleep(void) void cpu_init(void) { - cpu_data_t *cdp = current_cpu_datap(); + cpu_data_t *cdp = current_cpu_datap(); + + timer_call_queue_init(&cdp->rtclock_timer.queue); + cdp->rtclock_timer.deadline = EndOfAllTime; cdp->cpu_type = cpuid_cputype(); cdp->cpu_subtype = cpuid_cpusubtype(); @@ -108,7 +116,7 @@ kern_return_t cpu_start( int cpu) { - kern_return_t ret; + kern_return_t ret; if (cpu == cpu_number()) { cpu_machine_init(); @@ -129,72 +137,62 @@ cpu_start( ret = intel_startCPU(cpu); } - if (ret != KERN_SUCCESS) + if (ret != KERN_SUCCESS) { kprintf("cpu: cpu_start(%d) returning failure!\n", cpu); + } - return(ret); + return ret; } void cpu_exit_wait( int cpu) { - cpu_data_t *cdp = cpu_datap(cpu); + cpu_data_t *cdp = cpu_datap(cpu); + boolean_t intrs_enabled; + uint64_t tsc_timeout; - simple_lock(&x86_topo_lock); + /* + * Wait until the CPU indicates that it has stopped. + * Disable interrupts while the topo lock is held -- arguably + * this should always be done but in this instance it can lead to + * a timeout if long-running interrupt were to occur here. + */ + intrs_enabled = ml_set_interrupts_enabled(FALSE); + mp_safe_spin_lock(&x86_topo_lock); + /* Set a generous timeout of several seconds (in TSC ticks) */ + tsc_timeout = rdtsc64() + (10ULL * 1000 * 1000 * 1000); while ((cdp->lcpu.state != LCPU_HALT) - && (cdp->lcpu.state != LCPU_OFF)) { - simple_unlock(&x86_topo_lock); - cpu_pause(); - simple_lock(&x86_topo_lock); + && (cdp->lcpu.state != LCPU_OFF) + && !cdp->lcpu.stopped) { + simple_unlock(&x86_topo_lock); + ml_set_interrupts_enabled(intrs_enabled); + cpu_pause(); + if (rdtsc64() > tsc_timeout) { + panic("cpu_exit_wait(%d) timeout", cpu); + } + ml_set_interrupts_enabled(FALSE); + mp_safe_spin_lock(&x86_topo_lock); } simple_unlock(&x86_topo_lock); + ml_set_interrupts_enabled(intrs_enabled); } void cpu_machine_init( void) { - cpu_data_t *cdp = current_cpu_datap(); + cpu_data_t *cdp = current_cpu_datap(); PE_cpu_machine_init(cdp->cpu_id, !cdp->cpu_boot_complete); cdp->cpu_boot_complete = TRUE; cdp->cpu_running = TRUE; -#if 0 - if (cpu_datap(cpu)->hibernate) - { - cpu_datap(cpu)->hibernate = 0; - hibernate_machine_init(); - } -#endif ml_init_interrupt(); - /* for every CPU, get the VT specs */ - vmx_get_specs(); -} - -processor_t -cpu_processor_alloc(boolean_t is_boot_cpu) -{ - int ret; - processor_t proc; - - if (is_boot_cpu) - return &processor_master; - - ret = kmem_alloc(kernel_map, (vm_offset_t *) &proc, sizeof(*proc)); - if (ret != KERN_SUCCESS) - return NULL; - - bzero((void *) proc, sizeof(*proc)); - return proc; -} - -void -cpu_processor_free(processor_t proc) -{ - if (proc != NULL && proc != &processor_master) - kfree((void *) proc, sizeof(*proc)); +#if CONFIG_VMX + /* initialize VMX for every CPU */ + vmx_cpu_init(); +#endif } processor_t @@ -205,7 +203,7 @@ current_processor(void) processor_t cpu_to_processor( - int cpu) + int cpu) { return cpu_datap(cpu)->cpu_processor; } @@ -213,44 +211,75 @@ cpu_to_processor( ast_t * ast_pending(void) { - return (¤t_cpu_datap()->cpu_pending_ast); + return ¤t_cpu_datap()->cpu_pending_ast; } cpu_type_t slot_type( - int slot_num) + int slot_num) { - return (cpu_datap(slot_num)->cpu_type); + return cpu_datap(slot_num)->cpu_type; } cpu_subtype_t slot_subtype( - int slot_num) + int slot_num) { - return (cpu_datap(slot_num)->cpu_subtype); + return cpu_datap(slot_num)->cpu_subtype; } cpu_threadtype_t slot_threadtype( - int slot_num) + int slot_num) { - return (cpu_datap(slot_num)->cpu_threadtype); + return cpu_datap(slot_num)->cpu_threadtype; } cpu_type_t cpu_type(void) { - return (current_cpu_datap()->cpu_type); + return current_cpu_datap()->cpu_type; } cpu_subtype_t cpu_subtype(void) { - return (current_cpu_datap()->cpu_subtype); + return current_cpu_datap()->cpu_subtype; } cpu_threadtype_t cpu_threadtype(void) { - return (current_cpu_datap()->cpu_threadtype); + return current_cpu_datap()->cpu_threadtype; +} + +const char * +processor_to_datastring(const char *prefix, processor_t target_processor) +{ + static char printBuf[256]; + uint32_t cpu_num = target_processor->cpu_id; + + cpu_data_t *cpup = cpu_datap(cpu_num); + thread_t act; + + act = ml_validate_nofault((vm_offset_t)cpup->cpu_active_thread, + sizeof(struct thread)) ? cpup->cpu_active_thread : NULL; + + snprintf(printBuf, sizeof(printBuf), + "%s: tCPU %u (%d) [tid=0x%llx(bp=%d sp=%d) s=0x%x ps=0x%x cpa=0x%x spa=0x%llx pl=%d il=%d r=%d]", + prefix, + cpu_num, + target_processor->state, + act ? act->thread_id : ~0ULL, + act ? act->base_pri : -1, + act ? act->sched_pri : -1, + cpup->cpu_signals, + cpup->cpu_prior_signals, + cpup->cpu_pending_ast, + target_processor->processor_set->pending_AST_URGENT_cpu_mask, + cpup->cpu_preemption_level, + cpup->cpu_interrupt_level, + cpup->cpu_running); + + return (const char *)&printBuf[0]; }