Chameleon

Chameleon Svn Source Tree

Root/trunk/i386/libsaio/fake_efi.c

1
2/*
3 * Copyright 2007 David F. Elliott. All rights reserved.
4 */
5#include "saio_types.h"
6#include "libsaio.h"
7#include "boot.h"
8#include "bootstruct.h"
9#include "efi.h"
10#include "acpi.h"
11#include "fake_efi.h"
12#include "efi_tables.h"
13#include "platform.h"
14#include "acpi_patcher.h"
15#include "smbios.h"
16#include "device_inject.h"
17#include "convert.h"
18#include "pci.h"
19#include "sl.h"
20
21#ifndef DEBUG_EFI
22#define DEBUG_EFI 0
23#endif
24
25#ifndef RANDOMSEED
26#define RANDOMSEED 0
27#endif
28
29#if DEBUG_EFI
30#define DBG(x...)printf(x)
31#else
32#define DBG(x...)
33#endif
34
35extern void setup_pci_devs(pci_dt_t *pci_dt);
36
37/*
38 * Modern Darwin kernels require some amount of EFI because Apple machines all
39 * have EFI. Modifying the kernel source to not require EFI is of course
40 * possible but would have to be maintained as a separate patch because it is
41 * unlikely that Apple wishes to add legacy support to their kernel.
42 *
43 * As you can see from the Apple-supplied code in bootstruct.c, it seems that
44 * the intention was clearly to modify this booter to provide EFI-like structures
45 * to the kernel rather than modifying the kernel to handle non-EFI stuff. This
46 * makes a lot of sense from an engineering point of view as it means the kernel
47 * for the as yet unreleased EFI-only Macs could still be booted by the non-EFI
48 * DTK systems so long as the kernel checked to ensure the boot tables were
49 * filled in appropriately.Modern xnu requires a system table and a runtime
50 * services table and performs no checks whatsoever to ensure the pointers to
51 * these tables are non-NULL. Therefore, any modern xnu kernel will page fault
52 * early on in the boot process if the system table pointer is zero.
53 *
54 * Even before that happens, the tsc_init function in modern xnu requires the FSB
55 * Frequency to be a property in the /efi/platform node of the device tree or else
56 * it panics the bootstrap process very early on.
57 *
58 * As of this writing, the current implementation found here is good enough
59 * to make the currently available xnu kernel boot without modification on a
60 * system with an appropriate processor. With a minor source modification to
61 * the tsc_init function to remove the explicit check for Core or Core 2
62 * processors the kernel can be made to boot on other processors so long as
63 * the code can be executed by the processor and the machine contains the
64 * necessary hardware.
65 */
66
67/*==========================================================================
68 * Utility function to make a device tree string from an EFI_GUID
69 */
70static inline char * mallocStringForGuid(EFI_GUID const *pGuid)
71{
72char *string = malloc(37);
73efi_guid_unparse_upper(pGuid, string);
74return string;
75}
76
77/*==========================================================================
78 * Function to map 32 bit physical address to 64 bit virtual address
79 */
80static uint64_t ptov64(uint32_t addr)
81{
82return ((uint64_t)addr | 0xFFFFFF8000000000ULL);
83}
84
85// ==========================================================================
86
87EFI_UINT32 getCPUTick(void)
88{
89uint32_t out;
90__asm__ volatile (
91"rdtsc\n"
92"shl $32,%%edx\n"
93"or %%edx,%%eax\n"
94: "=a" (out)
95:
96: "%edx"
97);
98return out;
99}
100
101/*==========================================================================
102 * Fake EFI implementation
103 */
104
105/* Identify ourselves as the EFI firmware vendor */
106static EFI_CHAR16 const FIRMWARE_VENDOR[] = {'C','h','a','m','e','l','e','o','n','_','2','.','3', 0};
107// Bungo
108//static EFI_UINT32 const FIRMWARE_REVISION = 132; /* FIXME: Find a constant for this. */
109static EFI_UINT32 const FIRMWARE_REVISION = 0x0001000a; // got from real MBP6,1
110// Bungo
111/* Default platform system_id (fix by IntVar)
112 static EFI_CHAR8 const SYSTEM_ID[] = "0123456789ABCDEF"; //random value gen by uuidgen
113 */
114
115/* Just a ret instruction */
116static uint8_t const VOIDRET_INSTRUCTIONS[] = {0xc3};
117
118/* movl $0x80000003,%eax; ret */
119static uint8_t const UNSUPPORTEDRET_INSTRUCTIONS_32[] = {0xb8, 0x03, 0x00, 0x00, 0x80, 0xc3};
120static uint8_t const UNSUPPORTEDRET_INSTRUCTIONS_64[] = {0x48, 0xb8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc3};
121
122EFI_SYSTEM_TABLE_32 *gST32 = NULL;
123EFI_SYSTEM_TABLE_64 *gST64 = NULL;
124Node *gEfiConfigurationTableNode = NULL;
125
126// ==========================================================================
127
128extern EFI_STATUS addConfigurationTable(EFI_GUID const *pGuid, void *table, char const *alias)
129{
130EFI_UINTN i = 0;
131
132//Azi: as is, cpu's with em64t will use EFI64 on pre 10.6 systems,
133// wich seems to cause no problem. In case it does, force i386 arch.
134if (archCpuType == CPU_TYPE_I386)
135{
136i = gST32->NumberOfTableEntries;
137}
138else
139{
140i = gST64->NumberOfTableEntries;
141}
142
143// We only do adds, not modifications and deletes like InstallConfigurationTable
144if (i >= MAX_CONFIGURATION_TABLE_ENTRIES)
145{
146stop("Fake EFI [ERROR]: Ran out of space for configuration tables [%d]. Increase the reserved size in the code.\n", i);
147}
148
149if (pGuid == NULL)
150{
151return EFI_INVALID_PARAMETER;
152}
153
154if (table != NULL)
155{
156// FIXME
157//((EFI_CONFIGURATION_TABLE_64 *)gST->ConfigurationTable)[i].VendorGuid = *pGuid;
158//((EFI_CONFIGURATION_TABLE_64 *)gST->ConfigurationTable)[i].VendorTable = (EFI_PTR64)table;
159
160//++gST->NumberOfTableEntries;
161
162Node *tableNode = DT__AddChild(gEfiConfigurationTableNode, mallocStringForGuid(pGuid));
163
164// Use the pointer to the GUID we just stuffed into the system table
165DT__AddProperty(tableNode, "guid", sizeof(EFI_GUID), (void *)pGuid);
166
167// The "table" property is the 32-bit (in our implementation) physical address of the table
168DT__AddProperty(tableNode, "table", sizeof(void *) * 2, table);
169
170// Assume the alias pointer is a global or static piece of data
171if (alias != NULL)
172{
173DT__AddProperty(tableNode, "alias", strlen(alias)+1, (char *)alias);
174}
175
176return EFI_SUCCESS;
177}
178return EFI_UNSUPPORTED;
179}
180
181// ==========================================================================
182
183//Azi: crc32 done in place, on the cases were it wasn't.
184/*static inline void fixupEfiSystemTableCRC32(EFI_SYSTEM_TABLE_64 *efiSystemTable)
185{
186efiSystemTable->Hdr.CRC32 = 0;
187efiSystemTable->Hdr.CRC32 = crc32(0L, efiSystemTable, efiSystemTable->Hdr.HeaderSize);
188}*/
189
190/*
191 * What we do here is simply allocate a fake EFI system table and a fake EFI
192 * runtime services table.
193 *
194 * Because we build against modern headers with kBootArgsRevision 4 we
195 * also take care to set efiMode = 32.
196 */
197void setupEfiTables32(void)
198{
199// We use the fake_efi_pages struct so that we only need to do one kernel
200// memory allocation for all needed EFI data. Otherwise, small allocations
201// like the FIRMWARE_VENDOR string would take up an entire page.
202// NOTE WELL: Do NOT assume this struct has any particular layout within itself.
203// It is absolutely not intended to be publicly exposed anywhere
204// We say pages (plural) although right now we are well within the 1 page size
205// and probably will stay that way.
206struct fake_efi_pages
207{
208EFI_SYSTEM_TABLE_32 efiSystemTable;
209EFI_RUNTIME_SERVICES_32 efiRuntimeServices;
210EFI_CONFIGURATION_TABLE_32 efiConfigurationTable[MAX_CONFIGURATION_TABLE_ENTRIES];
211EFI_CHAR16 firmwareVendor[sizeof(FIRMWARE_VENDOR)/sizeof(EFI_CHAR16)];
212uint8_t voidret_instructions[sizeof(VOIDRET_INSTRUCTIONS)/sizeof(uint8_t)];
213uint8_t unsupportedret_instructions[sizeof(UNSUPPORTEDRET_INSTRUCTIONS_32)/sizeof(uint8_t)];
214};
215
216struct fake_efi_pages *fakeEfiPages = (struct fake_efi_pages *)AllocateKernelMemory(sizeof(struct fake_efi_pages));
217
218// Zero out all the tables in case fields are added later
219//bzero(fakeEfiPages, sizeof(struct fake_efi_pages));
220
221// --------------------------------------------------------------------
222// Initialize some machine code that will return EFI_UNSUPPORTED for
223// functions returning int and simply return for void functions.
224memcpy(fakeEfiPages->voidret_instructions, VOIDRET_INSTRUCTIONS, sizeof(VOIDRET_INSTRUCTIONS));
225memcpy(fakeEfiPages->unsupportedret_instructions, UNSUPPORTEDRET_INSTRUCTIONS_32, sizeof(UNSUPPORTEDRET_INSTRUCTIONS_32));
226
227// --------------------------------------------------------------------
228// System table
229EFI_SYSTEM_TABLE_32 *efiSystemTable = gST32 = &fakeEfiPages->efiSystemTable;
230efiSystemTable->Hdr.Signature = EFI_SYSTEM_TABLE_SIGNATURE;
231efiSystemTable->Hdr.Revision = EFI_SYSTEM_TABLE_REVISION;
232efiSystemTable->Hdr.HeaderSize = sizeof(EFI_SYSTEM_TABLE_32);
233efiSystemTable->Hdr.CRC32 = 0; // Initialize to zero and then do CRC32
234efiSystemTable->Hdr.Reserved = 0;
235
236efiSystemTable->FirmwareVendor = (EFI_PTR32)&fakeEfiPages->firmwareVendor;
237memcpy(fakeEfiPages->firmwareVendor, FIRMWARE_VENDOR, sizeof(FIRMWARE_VENDOR));
238efiSystemTable->FirmwareRevision = FIRMWARE_REVISION;
239
240// XXX: We may need to have basic implementations of ConIn/ConOut/StdErr
241// The EFI spec states that all handles are invalid after boot services have been
242// exited so we can probably get by with leaving the handles as zero.
243efiSystemTable->ConsoleInHandle = 0;
244efiSystemTable->ConIn = 0;
245
246efiSystemTable->ConsoleOutHandle = 0;
247efiSystemTable->ConOut = 0;
248
249efiSystemTable->StandardErrorHandle = 0;
250efiSystemTable->StdErr = 0;
251
252efiSystemTable->RuntimeServices = (EFI_PTR32)&fakeEfiPages->efiRuntimeServices;
253
254// According to the EFI spec, BootServices aren't valid after the
255// boot process is exited so we can probably do without it.
256// Apple didn't provide a definition for it in pexpert/i386/efi.h
257// so I'm guessing they don't use it.
258efiSystemTable->BootServices = 0;
259
260efiSystemTable->NumberOfTableEntries = 0;
261efiSystemTable->ConfigurationTable = (EFI_PTR32)fakeEfiPages->efiConfigurationTable;
262
263// We're done. Now CRC32 the thing so the kernel will accept it.
264// Must be initialized to zero before CRC32, done above.
265gST32->Hdr.CRC32 = crc32(0L, gST32, gST32->Hdr.HeaderSize);
266
267// --------------------------------------------------------------------
268// Runtime services
269EFI_RUNTIME_SERVICES_32 *efiRuntimeServices = &fakeEfiPages->efiRuntimeServices;
270efiRuntimeServices->Hdr.Signature = EFI_RUNTIME_SERVICES_SIGNATURE;
271efiRuntimeServices->Hdr.Revision = EFI_RUNTIME_SERVICES_REVISION;
272efiRuntimeServices->Hdr.HeaderSize = sizeof(EFI_RUNTIME_SERVICES_32);
273efiRuntimeServices->Hdr.CRC32 = 0;
274efiRuntimeServices->Hdr.Reserved = 0;
275
276// There are a number of function pointers in the efiRuntimeServices table.
277// These are the Foundation (e.g. core) services and are expected to be present on
278// all EFI-compliant machines.Some kernel extensions (notably AppleEFIRuntime)
279// will call these without checking to see if they are null.
280//
281// We don't really feel like doing an EFI implementation in the bootloader
282// but it is nice if we can at least prevent a complete crash by
283// at least providing some sort of implementation until one can be provided
284// nicely in a kext.
285void (*voidret_fp)() = (void *)fakeEfiPages->voidret_instructions;
286void (*unsupportedret_fp)() = (void *)fakeEfiPages->unsupportedret_instructions;
287efiRuntimeServices->GetTime = (EFI_PTR32)unsupportedret_fp;
288efiRuntimeServices->SetTime = (EFI_PTR32)unsupportedret_fp;
289efiRuntimeServices->GetWakeupTime = (EFI_PTR32)unsupportedret_fp;
290efiRuntimeServices->SetWakeupTime = (EFI_PTR32)unsupportedret_fp;
291efiRuntimeServices->SetVirtualAddressMap = (EFI_PTR32)unsupportedret_fp;
292efiRuntimeServices->ConvertPointer = (EFI_PTR32)unsupportedret_fp;
293efiRuntimeServices->GetVariable = (EFI_PTR32)unsupportedret_fp;
294efiRuntimeServices->GetNextVariableName = (EFI_PTR32)unsupportedret_fp;
295efiRuntimeServices->SetVariable = (EFI_PTR32)unsupportedret_fp;
296efiRuntimeServices->GetNextHighMonotonicCount = (EFI_PTR32)unsupportedret_fp;
297efiRuntimeServices->ResetSystem = (EFI_PTR32)voidret_fp;
298
299// We're done.Now CRC32 the thing so the kernel will accept it
300efiRuntimeServices->Hdr.CRC32 = crc32(0L, efiRuntimeServices, efiRuntimeServices->Hdr.HeaderSize);
301
302// --------------------------------------------------------------------
303// Finish filling in the rest of the boot args that we need.
304bootArgs->efiSystemTable = (uint32_t)efiSystemTable;
305bootArgs->efiMode = kBootArgsEfiMode32;
306
307// The bootArgs structure as a whole is bzero'd so we don't need to fill in
308// things like efiRuntimeServices* and what not.
309//
310// In fact, the only code that seems to use that is the hibernate code so it
311// knows not to save the pages. It even checks to make sure its nonzero.
312}
313
314void setupEfiTables64(void)
315{
316struct fake_efi_pages
317{
318EFI_SYSTEM_TABLE_64 efiSystemTable;
319EFI_RUNTIME_SERVICES_64 efiRuntimeServices;
320EFI_CONFIGURATION_TABLE_64 efiConfigurationTable[MAX_CONFIGURATION_TABLE_ENTRIES];
321EFI_CHAR16 firmwareVendor[sizeof(FIRMWARE_VENDOR)/sizeof(EFI_CHAR16)];
322uint8_t voidret_instructions[sizeof(VOIDRET_INSTRUCTIONS)/sizeof(uint8_t)];
323uint8_t unsupportedret_instructions[sizeof(UNSUPPORTEDRET_INSTRUCTIONS_64)/sizeof(uint8_t)];
324};
325
326struct fake_efi_pages *fakeEfiPages = (struct fake_efi_pages *)AllocateKernelMemory(sizeof(struct fake_efi_pages));
327
328// Zero out all the tables in case fields are added later
329//bzero(fakeEfiPages, sizeof(struct fake_efi_pages));
330
331// --------------------------------------------------------------------
332// Initialize some machine code that will return EFI_UNSUPPORTED for
333// functions returning int and simply return for void functions.
334memcpy(fakeEfiPages->voidret_instructions, VOIDRET_INSTRUCTIONS, sizeof(VOIDRET_INSTRUCTIONS));
335memcpy(fakeEfiPages->unsupportedret_instructions, UNSUPPORTEDRET_INSTRUCTIONS_64, sizeof(UNSUPPORTEDRET_INSTRUCTIONS_64));
336
337// --------------------------------------------------------------------
338// System table
339EFI_SYSTEM_TABLE_64 *efiSystemTable = gST64 = &fakeEfiPages->efiSystemTable;
340efiSystemTable->Hdr.Signature = EFI_SYSTEM_TABLE_SIGNATURE;
341efiSystemTable->Hdr.Revision = EFI_SYSTEM_TABLE_REVISION;
342efiSystemTable->Hdr.HeaderSize = sizeof(EFI_SYSTEM_TABLE_64);
343efiSystemTable->Hdr.CRC32 = 0; // Initialize to zero and then do CRC32
344efiSystemTable->Hdr.Reserved = 0;
345
346efiSystemTable->FirmwareVendor = ptov64((EFI_PTR32)&fakeEfiPages->firmwareVendor);
347memcpy(fakeEfiPages->firmwareVendor, FIRMWARE_VENDOR, sizeof(FIRMWARE_VENDOR));
348efiSystemTable->FirmwareRevision = FIRMWARE_REVISION;
349
350// XXX: We may need to have basic implementations of ConIn/ConOut/StdErr
351// The EFI spec states that all handles are invalid after boot services have been
352// exited so we can probably get by with leaving the handles as zero.
353efiSystemTable->ConsoleInHandle = 0;
354efiSystemTable->ConIn = 0;
355
356efiSystemTable->ConsoleOutHandle = 0;
357efiSystemTable->ConOut = 0;
358
359efiSystemTable->StandardErrorHandle = 0;
360efiSystemTable->StdErr = 0;
361
362efiSystemTable->RuntimeServices = ptov64((EFI_PTR32)&fakeEfiPages->efiRuntimeServices);
363// According to the EFI spec, BootServices aren't valid after the
364// boot process is exited so we can probably do without it.
365// Apple didn't provide a definition for it in pexpert/i386/efi.h
366// so I'm guessing they don't use it.
367efiSystemTable->BootServices = 0;
368
369efiSystemTable->NumberOfTableEntries = 0;
370efiSystemTable->ConfigurationTable = ptov64((EFI_PTR32)fakeEfiPages->efiConfigurationTable);
371
372// We're done.Now CRC32 the thing so the kernel will accept it
373gST64->Hdr.CRC32 = crc32(0L, gST64, gST64->Hdr.HeaderSize);
374
375// --------------------------------------------------------------------
376// Runtime services
377EFI_RUNTIME_SERVICES_64 *efiRuntimeServices = &fakeEfiPages->efiRuntimeServices;
378efiRuntimeServices->Hdr.Signature = EFI_RUNTIME_SERVICES_SIGNATURE;
379efiRuntimeServices->Hdr.Revision = EFI_RUNTIME_SERVICES_REVISION;
380efiRuntimeServices->Hdr.HeaderSize = sizeof(EFI_RUNTIME_SERVICES_64);
381efiRuntimeServices->Hdr.CRC32 = 0;
382efiRuntimeServices->Hdr.Reserved = 0;
383
384// There are a number of function pointers in the efiRuntimeServices table.
385// These are the Foundation (e.g. core) services and are expected to be present on
386// all EFI-compliant machines.Some kernel extensions (notably AppleEFIRuntime)
387// will call these without checking to see if they are null.
388//
389// We don't really feel like doing an EFI implementation in the bootloader
390// but it is nice if we can at least prevent a complete crash by
391// at least providing some sort of implementation until one can be provided
392// nicely in a kext.
393
394void (*voidret_fp)() = (void *)fakeEfiPages->voidret_instructions;
395void (*unsupportedret_fp)() = (void *)fakeEfiPages->unsupportedret_instructions;
396efiRuntimeServices->GetTime = ptov64((EFI_PTR32)unsupportedret_fp);
397efiRuntimeServices->SetTime = ptov64((EFI_PTR32)unsupportedret_fp);
398efiRuntimeServices->GetWakeupTime = ptov64((EFI_PTR32)unsupportedret_fp);
399efiRuntimeServices->SetWakeupTime = ptov64((EFI_PTR32)unsupportedret_fp);
400efiRuntimeServices->SetVirtualAddressMap = ptov64((EFI_PTR32)unsupportedret_fp);
401efiRuntimeServices->ConvertPointer = ptov64((EFI_PTR32)unsupportedret_fp);
402efiRuntimeServices->GetVariable = ptov64((EFI_PTR32)unsupportedret_fp);
403efiRuntimeServices->GetNextVariableName = ptov64((EFI_PTR32)unsupportedret_fp);
404efiRuntimeServices->SetVariable = ptov64((EFI_PTR32)unsupportedret_fp);
405efiRuntimeServices->GetNextHighMonotonicCount = ptov64((EFI_PTR32)unsupportedret_fp);
406efiRuntimeServices->ResetSystem = ptov64((EFI_PTR32)voidret_fp);
407
408// We're done.Now CRC32 the thing so the kernel will accept it
409efiRuntimeServices->Hdr.CRC32 = crc32(0L, efiRuntimeServices, efiRuntimeServices->Hdr.HeaderSize);
410
411// --------------------------------------------------------------------
412// Finish filling in the rest of the boot args that we need.
413bootArgs->efiSystemTable = (uint32_t)efiSystemTable;
414bootArgs->efiMode = kBootArgsEfiMode64;
415
416// The bootArgs structure as a whole is bzero'd so we don't need to fill in
417// things like efiRuntimeServices* and what not.
418//
419// In fact, the only code that seems to use that is the hibernate code so it
420// knows not to save the pages. It even checks to make sure its nonzero.
421}
422
423/*
424 * In addition to the EFI tables there is also the EFI device tree node.
425 * In particular, we need /efi/platform to have an FSBFrequency key. Without it,
426 * the tsc_init function will panic very early on in kernel startup, before
427 * the console is available.
428 */
429
430/*==========================================================================
431 * FSB Frequency detection
432 */
433
434/* These should be const but DT__AddProperty takes char* */
435static const char TSC_Frequency_prop[] = "TSCFrequency";
436static const char FSB_Frequency_prop[] = "FSBFrequency";
437static const char CPU_Frequency_prop[] = "CPUFrequency";
438
439/*==========================================================================
440 * SMBIOS
441 */
442
443/* From Foundation/Efi/Guid/Smbios/SmBios.c */
444EFI_GUID const gEfiSmbiosTableGuid = SMBIOS_TABLE_GUID;
445
446#define SMBIOS_RANGE_START0x000F0000
447#define SMBIOS_RANGE_END0x000FFFFF
448
449/* '_SM_' in little endian: */
450#define SMBIOS_ANCHOR_UINT32_LE 0x5f4d535f
451
452EFI_GUID gEfiAcpiTableGuid = ACPI_TABLE_GUID;
453EFI_GUID gEfiAcpi20TableGuid = ACPI_20_TABLE_GUID;
454
455
456/*==========================================================================
457 * Fake EFI implementation
458 */
459
460/* These should be const but DT__AddProperty takes char* */
461static const char FIRMWARE_REVISION_PROP[] = "firmware-revision";
462static const char FIRMWARE_ABI_PROP[] = "firmware-abi";
463static const char FIRMWARE_VENDOR_PROP[] = "firmware-vendor";
464static const char FIRMWARE_ABI_32_PROP_VALUE[] = "EFI32";
465static const char FIRMWARE_ABI_64_PROP_VALUE[] = "EFI64";
466static const char EFI_MODE_PROP[] = "efi-mode"; //Bungo
467static const char SYSTEM_ID_PROP[] = "system-id";
468static const char SYSTEM_SERIAL_PROP[] = "SystemSerialNumber";
469static const char SYSTEM_TYPE_PROP[] = "system-type";
470static const char MODEL_PROP[] = "Model";
471static const char BOARDID_PROP[] = "board-id";
472static const char DEV_PATH_SUP[] = "DevicePathsSupported";
473static const char START_POWER_EV[] = "StartupPowerEvents";
474static const char MACHINE_SIG_PROP[] = "machine-signature";
475static EFI_UINT8 const DEVICE_PATHS_SUPPORTED[] = { 0x01, 0x00, 0x00, 0x00 };
476static EFI_UINT8 const STARTUP_POWER_EVENTS[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
477static EFI_UINT8 const COMPAT_MODE[] = { 0x01, 0x00, 0x00, 0x00 };
478
479/*
480 * Get an smbios option string option to convert to EFI_CHAR16 string
481 */
482static EFI_CHAR16 *getSmbiosChar16(const char *key, size_t *len)
483{
484const char*src = getStringForKey(key, &bootInfo->smbiosConfig);
485EFI_CHAR16*dst = 0;
486size_t i = 0;
487
488if (!key || !(*key) || !len || !src)
489{
490return 0;
491}
492
493*len = strlen(src);
494dst = (EFI_CHAR16 *) malloc( ((*len)+1) * 2 );
495for (; i < (*len); i++)
496{
497dst[i] = src[i];
498}
499dst[(*len)] = '\0';
500*len = ((*len)+1)*2; // return the CHAR16 bufsize including zero terminated CHAR16
501return dst;
502}
503
504// Bungo
505/*
506 * Get the SystemID from the bios dmi info
507
508staticEFI_CHAR8 *getSmbiosUUID()
509{
510static EFI_CHAR8uuid[UUID_LEN];
511inti;
512intisZero;
513intisOnes;
514SMBByte*p;
515
516p = (SMBByte *)Platform.UUID;
517
518for (i=0, isZero=1, isOnes=1; i<UUID_LEN; i++)
519{
520if (p[i] != 0x00)
521{
522isZero = 0;
523}
524
525if (p[i] != 0xff)
526{
527isOnes = 0;
528}
529}
530
531if (isZero || isOnes) // empty or setable means: no uuid present
532{
533verbose("No UUID present in SMBIOS System Information Table\n");
534return 0;
535}
536
537memcpy(uuid, p, UUID_LEN);
538return uuid;
539}
540
541
542// return a binary UUID value from the overriden SystemID and SMUUID if found,
543// or from the bios if not, or from a fixed value if no bios value is found
544
545static EFI_CHAR8 *getSystemID()
546{
547// unable to determine UUID for host. Error: 35 fix
548// Rek: new SMsystemid option conforming to smbios notation standards, this option should
549// belong to smbios config only ...
550const char *sysId = getStringForKey(kSystemID, &bootInfo->chameleonConfig);
551EFI_CHAR8*ret = getUUIDFromString(sysId);
552
553if (!sysId || !ret) // try bios dmi info UUID extraction
554{
555ret = getSmbiosUUID();
556sysId = 0;
557}
558
559if (!ret)
560{
561// no bios dmi UUID available, set a fixed value for system-id
562ret=getUUIDFromString((sysId = (const char *) SYSTEM_ID));
563}
564verbose("Customizing SystemID with : %s\n", getStringFromUUID(ret)); // apply a nice formatting to the displayed output
565return ret;
566}
567 */
568
569/*
570 * Must be called AFTER setupAcpi because we need to take care of correct
571 * FACP content to reflect in ioregs
572 */
573void setupSystemType()
574{
575Node *node = DT__FindNode("/", false);
576if (node == 0)
577{
578stop("Couldn't get root '/' node");
579}
580// we need to write this property after facp parsing
581// Export system-type only if it has been overrriden by the SystemType option
582DT__AddProperty(node, SYSTEM_TYPE_PROP, sizeof(Platform.Type), &Platform.Type);
583}
584
585static void setupEfiDeviceTree(void)
586{
587// EFI_CHAR8*ret = 0; Bungo: not used
588EFI_CHAR16*ret16 = 0;
589size_t len = 0;
590Node*node;
591
592node = DT__FindNode("/", false);
593
594if (node == 0)
595{
596stop("Couldn't get root node");
597}
598
599// We could also just do DT__FindNode("/efi/platform", true)
600// But I think eventually we want to fill stuff in the efi node
601// too so we might as well create it so we have a pointer for it too.
602node = DT__AddChild(node, "efi");
603
604if (archCpuType == CPU_TYPE_I386)
605{
606DT__AddProperty(node, FIRMWARE_ABI_PROP, sizeof(FIRMWARE_ABI_32_PROP_VALUE), (char *)FIRMWARE_ABI_32_PROP_VALUE);
607}
608else
609{
610DT__AddProperty(node, FIRMWARE_ABI_PROP, sizeof(FIRMWARE_ABI_64_PROP_VALUE), (char *)FIRMWARE_ABI_64_PROP_VALUE);
611}
612
613DT__AddProperty(node, EFI_MODE_PROP, sizeof(EFI_UINT8), (EFI_UINT8 *)&bootArgs->efiMode);
614
615DT__AddProperty(node, FIRMWARE_REVISION_PROP, sizeof(FIRMWARE_REVISION), (EFI_UINT32 *)&FIRMWARE_REVISION);
616DT__AddProperty(node, FIRMWARE_VENDOR_PROP, sizeof(FIRMWARE_VENDOR), (EFI_CHAR16 *)FIRMWARE_VENDOR);
617
618// TODO: Fill in other efi properties if necessary
619
620// Set up the /efi/runtime-services table node similar to the way a child node of configuration-table
621// is set up. That is, name and table properties
622Node *runtimeServicesNode = DT__AddChild(node, "runtime-services");
623
624if (archCpuType == CPU_TYPE_I386)
625{
626// The value of the table property is the 32-bit physical address for the RuntimeServices table.
627// Since the EFI system table already has a pointer to it, we simply use the address of that pointer
628// for the pointer to the property data. Warning.. DT finalization calls free on that but we're not
629// the only thing to use a non-malloc'd pointer for something in the DT
630
631DT__AddProperty(runtimeServicesNode, "table", sizeof(uint64_t), &gST32->RuntimeServices);
632}
633else
634{
635DT__AddProperty(runtimeServicesNode, "table", sizeof(uint64_t), &gST64->RuntimeServices);
636}
637
638// Set up the /efi/configuration-table node which will eventually have several child nodes for
639// all of the configuration tables needed by various kernel extensions.
640gEfiConfigurationTableNode = DT__AddChild(node, "configuration-table");
641
642// New node: /efi/kernel-compatibility
643Node *efiKernelComNode = DT__AddChild(node, "kernel-compatibility");
644
645if (MacOSVerCurrent >= MacOSVer2Int("10.9"))
646{
647DT__AddProperty(efiKernelComNode, "x86_64", sizeof(COMPAT_MODE), (EFI_UINT8 *) &COMPAT_MODE);
648}
649else
650{
651DT__AddProperty(efiKernelComNode, "i386", sizeof(COMPAT_MODE), (EFI_UINT8 *) &COMPAT_MODE);
652DT__AddProperty(efiKernelComNode, "x86_64", sizeof(COMPAT_MODE), (EFI_UINT8 *) &COMPAT_MODE);
653}
654
655// Now fill in the /efi/platform Node
656Node *efiPlatformNode = DT__AddChild(node, "platform"); // "/efi/platform"
657
658// NOTE WELL: If you do add FSB Frequency detection, make sure to store
659// the value in the fsbFrequency global and not an malloc'd pointer
660// because the DT_AddProperty function does not copy its args.
661
662if (Platform.CPU.FSBFrequency != 0)
663{
664DT__AddProperty(efiPlatformNode, FSB_Frequency_prop, sizeof(uint64_t), &Platform.CPU.FSBFrequency);
665}
666
667// Export TSC and CPU frequencies for use by the kernel or KEXTs
668if (Platform.CPU.TSCFrequency != 0)
669{
670DT__AddProperty(efiPlatformNode, TSC_Frequency_prop, sizeof(uint64_t), &Platform.CPU.TSCFrequency);
671}
672
673if (Platform.CPU.CPUFrequency != 0)
674{
675DT__AddProperty(efiPlatformNode, CPU_Frequency_prop, sizeof(uint64_t), &Platform.CPU.CPUFrequency);
676}
677
678DT__AddProperty(efiPlatformNode,START_POWER_EV, sizeof(STARTUP_POWER_EVENTS), (EFI_UINT8 *) &STARTUP_POWER_EVENTS);
679
680DT__AddProperty(efiPlatformNode,DEV_PATH_SUP, sizeof(DEVICE_PATHS_SUPPORTED), (EFI_UINT8 *) &DEVICE_PATHS_SUPPORTED);
681
682// Bungo
683/* Export system-id. Can be disabled with SystemId=No in com.apple.Boot.plist
684if ((ret=getSystemID()))
685{
686DT__AddProperty(efiPlatformNode, SYSTEM_ID_PROP, UUID_LEN, (EFI_UINT32 *) ret);
687}
688*/
689
690DT__AddProperty(efiPlatformNode, SYSTEM_ID_PROP, UUID_LEN, (EFI_UINT32 *)Platform.UUID);
691
692// Export SystemSerialNumber if present
693if ((ret16=getSmbiosChar16("SMserial", &len)))
694{
695DT__AddProperty(efiPlatformNode, SYSTEM_SERIAL_PROP, len, ret16);
696}
697
698// Export Model if present
699if ((ret16=getSmbiosChar16("SMproductname", &len)))
700{
701DT__AddProperty(efiPlatformNode, MODEL_PROP, len, ret16);
702}
703
704// Fill /efi/device-properties node.
705setupDeviceProperties(node);
706}
707
708/*
709 * Must be called AFTER getSmbios
710 */
711void setupBoardId()
712{
713Node *node;
714node = DT__FindNode("/", false);
715if (node == 0)
716{
717stop("Couldn't get root '/' node");
718}
719const char *boardid = getStringForKey("SMboardproduct", &bootInfo->smbiosConfig);
720if (boardid)
721{
722DT__AddProperty(node, BOARDID_PROP, strlen(boardid)+1, (EFI_CHAR16*)boardid);
723}
724}
725
726/*
727 * Populate the chosen node
728 */
729
730void setupChosenNode()
731{
732Node *chosenNode;
733chosenNode = DT__FindNode("/chosen", false);
734if (chosenNode == NULL)
735{
736stop("setupChosenNode: Couldn't get '/chosen' node");
737}
738
739// Only accept a UUID with the correct length.
740if (strlen(gBootUUIDString) == 36)
741{
742DT__AddProperty(chosenNode, "boot-uuid", 37, gBootUUIDString);
743}
744
745DT__AddProperty(chosenNode, "boot-args", sizeof(bootArgs->CommandLine), (EFI_UINT8 *)bootArgs->CommandLine);
746
747// Adding the default kernel name (mach_kernel) for kextcache.
748DT__AddProperty(chosenNode, "boot-file", sizeof(bootInfo->bootFile), bootInfo->bootFile);
749
750//DT__AddProperty(chosenNode, "boot-device-path", bootDPsize, gBootDP);
751
752//DT__AddProperty(chosenNode, "boot-file-path", bootFPsize, gBootFP);
753
754//DT__AddProperty(chosenNode, "boot-kernelcache-adler32", sizeof(adler32), adler32);
755
756DT__AddProperty(chosenNode, MACHINE_SIG_PROP, sizeof(Platform.HWSignature), (EFI_UINT32 *)&Platform.HWSignature);
757
758if ( YOSEMITE || ELCAPITAN )
759{
760//
761// Pike R. Alpha - 12 October 2014
762//
763UInt8 index = 0;
764EFI_UINT16 PMTimerValue = 0;
765
766#if RANDOMSEED
767EFI_UINT32 randomValue = 0, cpuTick = 0;
768EFI_UINT32 ecx = 0, edx = 0, esi = 0, edi = 0;
769#else
770EFI_UINT32 randomValue, tempValue, cpuTick;
771EFI_UINT32 ecx, esi, edi = 0;
772EFI_UINT64 rcx, rdx, rsi, rdi;
773
774randomValue = tempValue = ecx = esi = edi = 0;// xor%ecx,%ecx
775cpuTick = rcx = rdx = rsi = rdi = 0;
776#endif
777// LEAF_1 - Feature Information (Function 01h).
778if (Platform.CPU.CPUID[CPUID_1][2] & 0x40000000)// Checking ecx:bit-30
779{
780//
781// i5/i7 Ivy Bridge and Haswell processors with RDRAND support.
782//
783EFI_UINT32 seedBuffer[16] = {0};
784//
785// Main loop to get 16 dwords (four bytes each).
786//
787for (index = 0; index < 16; index++)// 0x17e12:
788{
789randomValue = computeRand();// callq0x18e20
790cpuTick = (EFI_UINT32) getCPUTick();// callq0x121a7
791randomValue = (randomValue ^ cpuTick);// xor%rdi,%rax
792seedBuffer[index] = randomValue;// mov%rax,(%r15,%rsi,8)
793}// jb0x17e12
794
795DT__AddProperty(chosenNode, "random-seed", sizeof(seedBuffer), (EFI_UINT32 *) &seedBuffer);
796}
797else
798{
799//
800// All other processors without RDRAND support.
801//
802EFI_UINT8 seedBuffer[64] = {0};
803//
804// Main loop to get the 64 bytes.
805//
806do// 0x17e55:
807{
808//
809// FIXME: PM Timer is usually @ 0x408, but its position is relocatable
810// via PCI-to-ISA bridge. The location is reported in ACPI FADT,
811// PM Timer Block address - zenith432
812//
813PMTimerValue = inw(0x408);// in(%dx),%ax
814esi = PMTimerValue;// movzwl%ax,%esi
815
816if (esi < ecx)// cmp%ecx,%esi
817{
818continue;// jb0x17e55(retry)
819}
820
821cpuTick = (EFI_UINT32) getCPUTick();// callq0x121a7
822//printf("value: 0x%x\n", getCPUTick());
823
824#if RANDOMSEED
825ecx = (cpuTick >> 8);// mov%rax,%rcx
826// shr$0x8,%rcx
827edx = (cpuTick >> 0x10);// mov%rax,%rdx
828// shr$0x10,%rdx
829edi = esi;// mov%rsi,%rdi
830edi = (edi ^ cpuTick);// xor%rax,%rdi
831edi = (edi ^ ecx);// xor%rcx,%rdi
832edi = (edi ^ edx);// xor%rdx,%rdi
833
834seedBuffer[index] = (edi & 0xff);
835#else
836rcx = (cpuTick >> 8);// mov%rax,%rcx
837// shr$0x8,%rcx
838rdx = (cpuTick >> 0x10);// mov%rax,%rdx
839// shr$0x10,%rdx
840rdi = rsi;// mov%rsi,%rdi
841rdi = (rdi ^ cpuTick);// xor%rax,%rdi
842rdi = (rdi ^ rcx);// xor%rcx,%rdi
843rdi = (rdi ^ rdx);// xor%rdx,%rdi
844
845seedBuffer[index] = (rdi & 0xff);// mov%dil,(%r15,%r12,1)
846#endif
847edi = (edi & 0x2f);// and$0x2f,%edi
848edi = (edi + esi);// add%esi,%edi
849index++;// incr12
850ecx = (edi & 0xffff);// movzwl%di,%ecx
851
852} while (index < 64);// cmp%r14d,%r12d
853// jne0x17e55(next)
854
855DT__AddProperty(chosenNode, "random-seed", sizeof(seedBuffer), (EFI_UINT8 *) &seedBuffer);
856
857}
858}
859}
860
861/*
862 * Load the smbios.plist override config file if any
863 */
864static void setupSmbiosConfigFile(const char *filename)
865{
866chardirSpecSMBIOS[128];
867const char*override_pathname = NULL;
868intlen = 0, err = 0;
869extern void scan_mem();
870
871// Take in account user overriding
872if (getValueForKey(kSMBIOSKey, &override_pathname, &len, &bootInfo->chameleonConfig) && len > 0)
873{
874// Specify a path to a file, e.g. SMBIOS=/Extra/macProXY.plist
875strcpy(dirSpecSMBIOS, override_pathname);
876err = loadConfigFile(dirSpecSMBIOS, &bootInfo->smbiosConfig);
877}
878else
879{
880// Check selected volume's Extra.
881sprintf(dirSpecSMBIOS, "/Extra/%s", filename);
882err = loadConfigFile(dirSpecSMBIOS, &bootInfo->smbiosConfig);
883}
884
885if (err)
886{
887verbose("No SMBIOS replacement found.\n");
888}
889
890// get a chance to scan mem dynamically if user asks for it while having the config options
891// loaded as well, as opposed to when it was in scan_platform(); also load the orig. smbios
892// so that we can access dmi info, without patching the smbios yet.
893scan_mem();
894}
895
896/*
897 * Installs all the needed configuration table entries
898 */
899static void setupEfiConfigurationTable()
900{
901smbios_p = (EFI_PTR32)getSmbios(SMBIOS_PATCHED);
902addConfigurationTable(&gEfiSmbiosTableGuid, &smbios_p, NULL);
903
904setupBoardId(); //need to be called after getSmbios
905
906// Setup ACPI with DSDT overrides (mackerintel's patch)
907setupAcpi();
908
909// We've obviously changed the count.. so fix up the CRC32
910if (archCpuType == CPU_TYPE_I386)
911{
912gST32->Hdr.CRC32 = 0;
913gST32->Hdr.CRC32 = crc32(0L, gST32, gST32->Hdr.HeaderSize);
914}
915else
916{
917gST64->Hdr.CRC32 = 0;
918gST64->Hdr.CRC32 = crc32(0L, gST64, gST64->Hdr.HeaderSize);
919}
920
921// Setup the chosen node
922setupChosenNode();
923}
924
925void saveOriginalSMBIOS(void)
926{
927Node *node;
928SMBEntryPoint *origeps;
929void *tableAddress;
930
931node = DT__FindNode("/efi/platform", false);
932if (!node)
933{
934DBG("saveOriginalSMBIOS: '/efi/platform' node not found\n");
935return;
936}
937
938origeps = getSmbios(SMBIOS_ORIGINAL);
939if (!origeps)
940{
941DBG("saveOriginalSMBIOS: original SMBIOS not found\n");
942return;
943}
944
945tableAddress = (void *)AllocateKernelMemory(origeps->dmi.tableLength);
946if (!tableAddress)
947{
948DBG("saveOriginalSMBIOS: can not allocate memory for original SMBIOS\n");
949return;
950}
951
952memcpy(tableAddress, (void *)origeps->dmi.tableAddress, origeps->dmi.tableLength);
953DT__AddProperty(node, "SMBIOS", origeps->dmi.tableLength, tableAddress);
954}
955
956/*
957 * Entrypoint from boot.c
958 */
959void setupFakeEfi(void)
960{
961// Generate efi device strings
962setup_pci_devs(root_pci_dev);
963
964readSMBIOSInfo(getSmbios(SMBIOS_ORIGINAL));
965
966// load smbios.plist file if any
967setupSmbiosConfigFile("smbios.plist");
968
969setupSMBIOSTable();
970
971// Initialize the base table
972if (archCpuType == CPU_TYPE_I386)
973{
974setupEfiTables32();
975}
976else
977{
978setupEfiTables64();
979}
980
981// Initialize the device tree
982setupEfiDeviceTree();
983
984saveOriginalSMBIOS();
985
986// Add configuration table entries to both the services table and the device tree
987setupEfiConfigurationTable();
988}
989

Archive Download this file

Revision: 2713