2 * Copyright (c) 2009-2010 Apple Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
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.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
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.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
30 * file: pal_routines.c
31 * Platform Abstraction Layer routines for bare-metal i386 and x86_64
35 #include <kern/kern_types.h>
36 #include <mach/mach_types.h>
37 #include <kern/thread.h>
38 #include <kern/simple_lock.h>
40 #include <sys/kdebug.h>
41 #include <machine/pal_routines.h>
42 #include <i386/serial_io.h>
43 #include <i386/lapic.h>
44 #include <i386/proc_reg.h>
45 #include <i386/misc_protos.h>
46 #include <i386/machine_routines.h>
47 #include <i386/pmap.h>
51 #define DBG(x...) kprintf("PAL_DBG: " x)
54 #endif /* PAL_DEBUG */
56 extern void *gPEEFIRuntimeServices
;
57 extern void *gPEEFISystemTable
;
59 /* nanotime conversion information */
60 pal_rtc_nanotime_t pal_rtc_nanotime_info
= {0,0,0,0,1,0};
62 /* APIC kext may use this to access xnu internal state */
63 struct pal_apic_table
*apic_table
= NULL
;
65 decl_simple_lock_data(static , pal_efi_lock
);
67 static pml4_entry_t IDPML4
[PTE_PER_PAGE
] __attribute__ ((aligned (4096)));
68 uint64_t pal_efi_saved_cr0
;
69 uint64_t pal_efi_saved_cr3
;
81 pal_serial_putc_nocr(char c
)
87 pal_serial_putc(char c
)
101 /* Generic routines */
105 simple_lock_init(&pal_efi_lock
, 0);
109 pal_get_control_registers( pal_cr_t
*cr0
, pal_cr_t
*cr2
,
110 pal_cr_t
*cr3
, pal_cr_t
*cr4
)
114 *cr3
= get_cr3_raw();
120 * define functions below here to ensure we have symbols for these,
121 * even though they're not used on this platform.
123 #undef pal_dbg_page_fault
125 pal_dbg_page_fault( thread_t thread __unused
,
126 user_addr_t vaddr __unused
,
127 kern_return_t kr __unused
)
131 #undef pal_dbg_set_task_name
133 pal_dbg_set_task_name( task_t task __unused
)
137 #undef pal_set_signal_delivery
139 pal_set_signal_delivery(thread_t thread __unused
)
145 _pal_efi_call_in_64bit_mode_asm(uint64_t func
,
146 struct pal_efi_registers
*efi_reg
,
147 void *stack_contents
,
148 size_t stack_contents_size
);
151 pal_efi_call_in_64bit_mode(uint64_t func
,
152 struct pal_efi_registers
*efi_reg
,
153 void *stack_contents
,
154 size_t stack_contents_size
, /* 16-byte multiple */
155 uint64_t *efi_status
)
157 DBG("pal_efi_call_in_64bit_mode(0x%016llx, %p, %p, %lu, %p)\n",
158 func
, efi_reg
, stack_contents
, stack_contents_size
, efi_status
);
161 return KERN_INVALID_ADDRESS
;
164 if ((efi_reg
== NULL
)
165 || (stack_contents
== NULL
)
166 || (stack_contents_size
% 16 != 0)) {
167 return KERN_INVALID_ARGUMENT
;
170 if (!gPEEFISystemTable
|| !gPEEFIRuntimeServices
) {
171 return KERN_NOT_SUPPORTED
;
174 if (func
< VM_MIN_KERNEL_ADDRESS
) {
176 * EFI Runtime Services must be mapped in our address
177 * space at an appropriate location.
179 return KERN_INVALID_ADDRESS
;
182 _pal_efi_call_in_64bit_mode_asm(func
,
185 stack_contents_size
);
187 *efi_status
= efi_reg
->rax
;
193 _pal_efi_call_in_32bit_mode_asm(uint32_t func
,
194 struct pal_efi_registers
*efi_reg
,
195 void *stack_contents
,
196 size_t stack_contents_size
);
199 pal_efi_call_in_32bit_mode(uint32_t func
,
200 struct pal_efi_registers
*efi_reg
,
201 void *stack_contents
,
202 size_t stack_contents_size
, /* 16-byte multiple */
203 uint32_t *efi_status
)
205 DBG("pal_efi_call_in_32bit_mode(0x%08x, %p, %p, %lu, %p)\n",
206 func
, efi_reg
, stack_contents
, stack_contents_size
, efi_status
);
209 return KERN_INVALID_ADDRESS
;
212 if ((efi_reg
== NULL
)
213 || (stack_contents
== NULL
)
214 || (stack_contents_size
% 16 != 0)) {
215 return KERN_INVALID_ARGUMENT
;
218 if (!gPEEFISystemTable
|| !gPEEFIRuntimeServices
) {
219 return KERN_NOT_SUPPORTED
;
222 DBG("pal_efi_call_in_32bit_mode() efi_reg:\n");
223 DBG(" rcx: 0x%016llx\n", efi_reg
->rcx
);
224 DBG(" rdx: 0x%016llx\n", efi_reg
->rdx
);
225 DBG(" r8: 0x%016llx\n", efi_reg
->r8
);
226 DBG(" r9: 0x%016llx\n", efi_reg
->r9
);
227 DBG(" rax: 0x%016llx\n", efi_reg
->rax
);
229 DBG("pal_efi_call_in_32bit_mode() stack:\n");
232 for (i
= 0; i
< stack_contents_size
; i
+= sizeof(uint32_t)) {
233 uint32_t *p
= (uint32_t *) ((uintptr_t)stack_contents
+ i
);
234 DBG(" %p: 0x%08x\n", p
, *p
);
240 * Ensure no interruptions.
241 * Taking a spinlock for serialization is technically unnecessary
242 * because the EFIRuntime kext should serialize.
244 boolean_t istate
= ml_set_interrupts_enabled(FALSE
);
245 simple_lock(&pal_efi_lock
);
248 * Switch to special page tables with the entire high kernel space
249 * double-mapped into the bottom 4GB.
251 * NB: We assume that all data passed exchanged with RuntimeServices is
252 * located in the 4GB of KVA based at VM_MIN_ADDRESS. In particular, kexts
253 * loaded the basement (below VM_MIN_ADDRESS) cannot pass static data.
254 * Kernel stack and heap space is OK.
256 MARK_CPU_IDLE(cpu_number());
257 pal_efi_saved_cr3
= get_cr3_raw();
258 pal_efi_saved_cr0
= get_cr0();
259 IDPML4
[KERNEL_PML4_INDEX
] = IdlePML4
[KERNEL_PML4_INDEX
];
260 IDPML4
[0] = IdlePML4
[KERNEL_PML4_INDEX
];
262 set_cr3_raw((uint64_t) ID_MAP_VTOP(IDPML4
));
264 swapgs(); /* Save kernel's GS base */
266 /* Set segment state ready for compatibility mode */
273 _pal_efi_call_in_32bit_mode_asm(func
,
276 stack_contents_size
);
278 /* Restore NULL segment state */
283 swapgs(); /* Restore kernel's GS base */
285 /* Restore the 64-bit user GS base we just destroyed */
286 wrmsr64(MSR_IA32_KERNEL_GS_BASE
,
287 current_cpu_datap()->cpu_uber
.cu_user_gs_base
);
289 /* End of mapping games */
290 set_cr3_raw(pal_efi_saved_cr3
);
291 set_cr0(pal_efi_saved_cr0
);
292 MARK_CPU_ACTIVE(cpu_number());
294 simple_unlock(&pal_efi_lock
);
295 ml_set_interrupts_enabled(istate
);
297 _pal_efi_call_in_32bit_mode_asm(func
,
300 stack_contents_size
);
303 *efi_status
= (uint32_t)efi_reg
->rax
;
304 DBG("pal_efi_call_in_32bit_mode() efi_status: 0x%x\n", *efi_status
);
309 /* wind-back a syscall instruction */
311 pal_syscall_restart(thread_t thread __unused
, x86_saved_state_t
*state
)
313 /* work out which flavour thread it is */
314 if( is_saved_state32(state
) )
316 x86_saved_state32_t
*regs32
;
317 regs32
= saved_state32(state
);
319 if (regs32
->cs
== SYSENTER_CS
|| regs32
->cs
== SYSENTER_TF_CS
)
326 x86_saved_state64_t
*regs64
;
328 assert( is_saved_state64(state
) );
329 regs64
= saved_state64(state
);
331 /* Only one instruction for 64-bit threads */
332 regs64
->isf
.rip
-= 2;
337 /* Helper function to put the machine to sleep (or shutdown) */
340 pal_machine_sleep(uint8_t type_a __unused
, uint8_t type_b __unused
, uint32_t bit_position __unused
,
341 uint32_t disable_mask __unused
, uint32_t enable_mask __unused
)
347 /* shouldn't be used on native */
349 pal_get_kern_regs( x86_saved_state_t
*state
)
351 panic( "pal_get_kern_regs called. state %p\n", state
);
355 pal_preemption_assert(void)