osfmk/i386/cpu.c

   1 /*
   2  * Copyright (c) 2000-2009 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   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.
  14  *
  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
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  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.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  *      File:   i386/cpu.c
  30  *
  31  *      cpu specific routines
  32  */
  33
  34 #include <kern/kalloc.h>
  35 #include <kern/misc_protos.h>
  36 #include <kern/machine.h>
  37 #include <mach/processor_info.h>
  38 #include <i386/pmap.h>
  39 #include <i386/machine_cpu.h>
  40 #include <i386/machine_routines.h>
  41 #include <i386/misc_protos.h>
  42 #include <i386/cpu_threads.h>
  43 #include <i386/rtclock_protos.h>
  44 #include <i386/cpuid.h>
  45 #if CONFIG_VMX
  46 #include <i386/vmx/vmx_cpu.h>
  47 #endif
  48 #include <vm/vm_kern.h>
  49 #include <kern/timer_call.h>
  50
  51 struct processor        processor_master;
  52
  53 /*ARGSUSED*/
  54 kern_return_t
  55 cpu_control(
  56         int                     slot_num,
  57         processor_info_t        info,
  58         unsigned int            count)
  59 {
  60         printf("cpu_control(%d,%p,%d) not implemented\n",
  61                 slot_num, info, count);
  62         return (KERN_FAILURE);
  63 }
  64
  65 /*ARGSUSED*/
  66 kern_return_t
  67 cpu_info_count(
  68         __unused processor_flavor_t      flavor,
  69         unsigned int                    *count)
  70 {
  71         *count = 0;
  72         return (KERN_FAILURE);
  73 }
  74
  75 /*ARGSUSED*/
  76 kern_return_t
  77 cpu_info(
  78         processor_flavor_t      flavor,
  79         int                     slot_num,
  80         processor_info_t        info,
  81         unsigned int            *count)
  82 {
  83         printf("cpu_info(%d,%d,%p,%p) not implemented\n",
  84                 flavor, slot_num, info, count);
  85         return (KERN_FAILURE);
  86 }
  87
  88 void
  89 cpu_sleep(void)
  90 {
  91         cpu_data_t      *cdp = current_cpu_datap();
  92
  93         PE_cpu_machine_quiesce(cdp->cpu_id);
  94
  95         cpu_thread_halt();
  96 }
  97
  98 void
  99 cpu_init(void)
 100 {
 101         cpu_data_t      *cdp = current_cpu_datap();
 102
 103         timer_call_queue_init(&cdp->rtclock_timer.queue);
 104         cdp->rtclock_timer.deadline = EndOfAllTime;
 105
 106         cdp->cpu_type = cpuid_cputype();
 107         cdp->cpu_subtype = cpuid_cpusubtype();
 108
 109         i386_activate_cpu();
 110 }
 111
 112 kern_return_t
 113 cpu_start(
 114         int cpu)
 115 {
 116         kern_return_t           ret;
 117
 118         if (cpu == cpu_number()) {
 119                 cpu_machine_init();
 120                 return KERN_SUCCESS;
 121         }
 122
 123         /*
 124          * Try to bring the CPU back online without a reset.
 125          * If the fast restart doesn't succeed, fall back to
 126          * the slow way.
 127          */
 128         ret = intel_startCPU_fast(cpu);
 129         if (ret != KERN_SUCCESS) {
 130                 /*
 131                  * Should call out through PE.
 132                  * But take the shortcut here.
 133                  */
 134                 ret = intel_startCPU(cpu);
 135         }
 136
 137         if (ret != KERN_SUCCESS)
 138                 kprintf("cpu: cpu_start(%d) returning failure!\n", cpu);
 139
 140         return(ret);
 141 }
 142
 143 void
 144 cpu_exit_wait(
 145         int cpu)
 146 {
 147         cpu_data_t      *cdp = cpu_datap(cpu);
 148         boolean_t       intrs_enabled;
 149         uint64_t        tsc_timeout;
 150
 151         /*
 152          * Wait until the CPU indicates that it has stopped.
 153          * Disable interrupts while the topo lock is held -- arguably
 154          * this should always be done but in this instance it can lead to
 155          * a timeout if long-running interrupt were to occur here.
 156          */
 157         intrs_enabled = ml_set_interrupts_enabled(FALSE);
 158         mp_safe_spin_lock(&x86_topo_lock);
 159         /* Set a generous timeout of several seconds (in TSC ticks) */
 160         tsc_timeout = rdtsc64() + (10ULL * 1000 * 1000 * 1000);
 161         while ((cdp->lcpu.state != LCPU_HALT)
 162                && (cdp->lcpu.state != LCPU_OFF)
 163                && !cdp->lcpu.stopped) {
 164             simple_unlock(&x86_topo_lock);
 165             ml_set_interrupts_enabled(intrs_enabled);
 166             cpu_pause();
 167             if (rdtsc64() > tsc_timeout)
 168                 panic("cpu_exit_wait(%d) timeout", cpu);
 169             ml_set_interrupts_enabled(FALSE);
 170             mp_safe_spin_lock(&x86_topo_lock);
 171         }
 172         simple_unlock(&x86_topo_lock);
 173         ml_set_interrupts_enabled(intrs_enabled);
 174 }
 175
 176 void
 177 cpu_machine_init(
 178         void)
 179 {
 180         cpu_data_t      *cdp = current_cpu_datap();
 181
 182         PE_cpu_machine_init(cdp->cpu_id, !cdp->cpu_boot_complete);
 183         cdp->cpu_boot_complete = TRUE;
 184         cdp->cpu_running = TRUE;
 185         ml_init_interrupt();
 186
 187 #if CONFIG_VMX
 188         /* initialize VMX for every CPU */
 189         vmx_cpu_init();
 190 #endif
 191 }
 192
 193 processor_t
 194 cpu_processor_alloc(boolean_t is_boot_cpu)
 195 {
 196         int             ret;
 197         processor_t     proc;
 198
 199         if (is_boot_cpu)
 200                 return &processor_master;
 201
 202         ret = kmem_alloc(kernel_map, (vm_offset_t *) &proc, sizeof(*proc), VM_KERN_MEMORY_OSFMK);
 203         if (ret != KERN_SUCCESS)
 204                 return NULL;
 205
 206         bzero((void *) proc, sizeof(*proc));
 207         return proc;
 208 }
 209
 210 void
 211 cpu_processor_free(processor_t proc)
 212 {
 213         if (proc != NULL && proc != &processor_master)
 214                 kfree((void *) proc, sizeof(*proc));
 215 }
 216
 217 processor_t
 218 current_processor(void)
 219 {
 220         return current_cpu_datap()->cpu_processor;
 221 }
 222
 223 processor_t
 224 cpu_to_processor(
 225         int                     cpu)
 226 {
 227         return cpu_datap(cpu)->cpu_processor;
 228 }
 229
 230 ast_t *
 231 ast_pending(void)
 232 {
 233         return (&current_cpu_datap()->cpu_pending_ast);
 234 }
 235
 236 cpu_type_t
 237 slot_type(
 238         int             slot_num)
 239 {
 240         return (cpu_datap(slot_num)->cpu_type);
 241 }
 242
 243 cpu_subtype_t
 244 slot_subtype(
 245         int             slot_num)
 246 {
 247         return (cpu_datap(slot_num)->cpu_subtype);
 248 }
 249
 250 cpu_threadtype_t
 251 slot_threadtype(
 252         int             slot_num)
 253 {
 254         return (cpu_datap(slot_num)->cpu_threadtype);
 255 }
 256
 257 cpu_type_t
 258 cpu_type(void)
 259 {
 260         return (current_cpu_datap()->cpu_type);
 261 }
 262
 263 cpu_subtype_t
 264 cpu_subtype(void)
 265 {
 266         return (current_cpu_datap()->cpu_subtype);
 267 }
 268
 269 cpu_threadtype_t
 270 cpu_threadtype(void)
 271 {
 272         return (current_cpu_datap()->cpu_threadtype);
 273 }