Manually reimported XNU branch
This commit is contained in:
Vladimir 'phcoder' Serbinenko
parent
32764030b5
commit
1d3c6f1de7
29 changed files with 1128 additions and 633 deletions
|
|
@ -25,6 +25,7 @@
|
|||
#include <grub/device.h>
|
||||
#include <grub/disk.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/charset.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/dl.h>
|
||||
|
|
|
|||
|
|
@ -25,9 +25,13 @@
|
|||
#include <grub/loader.h>
|
||||
#include <grub/autoefi.h>
|
||||
#include <grub/i386/tsc.h>
|
||||
#include <grub/efi/api.h>
|
||||
#include <grub/i386/pit.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/charset.h>
|
||||
#include <grub/term.h>
|
||||
#include <grub/command.h>
|
||||
#include <grub/gzio.h>
|
||||
|
||||
char grub_xnu_cmdline[1024];
|
||||
|
||||
|
|
@ -44,6 +48,14 @@ struct tbl_alias table_aliases[] =
|
|||
{GRUB_EFI_ACPI_TABLE_GUID, "ACPI"},
|
||||
};
|
||||
|
||||
struct grub_xnu_devprop_device_descriptor
|
||||
{
|
||||
struct grub_xnu_devprop_device_descriptor *next;
|
||||
struct property_descriptor *properties;
|
||||
struct grub_efi_device_path *path;
|
||||
int pathlen;
|
||||
};
|
||||
|
||||
/* The following function is used to be able to debug xnu loader
|
||||
with grub-emu. */
|
||||
#ifdef GRUB_UTIL
|
||||
|
|
@ -205,6 +217,417 @@ guessfsb (void)
|
|||
((msrlow >> 7) & 0x3e) + ((msrlow >> 14) & 1), 0);
|
||||
}
|
||||
|
||||
struct property_descriptor
|
||||
{
|
||||
struct property_descriptor *next;
|
||||
grub_uint8_t *name;
|
||||
grub_uint16_t *name16;
|
||||
int name16len;
|
||||
int length;
|
||||
void *data;
|
||||
};
|
||||
|
||||
struct grub_xnu_devprop_device_descriptor *devices = 0;
|
||||
|
||||
grub_err_t
|
||||
grub_xnu_devprop_remove_property (struct grub_xnu_devprop_device_descriptor *dev,
|
||||
char *name)
|
||||
{
|
||||
struct property_descriptor *prop;
|
||||
prop = grub_named_list_find (GRUB_AS_NAMED_LIST_P (&dev->properties), name);
|
||||
if (!prop)
|
||||
return GRUB_ERR_NONE;
|
||||
|
||||
grub_free (prop->name);
|
||||
grub_free (prop->name16);
|
||||
grub_free (prop->data);
|
||||
|
||||
grub_list_remove (GRUB_AS_LIST_P (&dev->properties), GRUB_AS_LIST (prop));
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_xnu_devprop_remove_device (struct grub_xnu_devprop_device_descriptor *dev)
|
||||
{
|
||||
void *t;
|
||||
struct property_descriptor *prop;
|
||||
|
||||
grub_list_remove (GRUB_AS_LIST_P (&devices), GRUB_AS_LIST (dev));
|
||||
|
||||
for (prop = dev->properties; prop; )
|
||||
{
|
||||
grub_free (prop->name);
|
||||
grub_free (prop->name16);
|
||||
grub_free (prop->data);
|
||||
t = prop;
|
||||
prop = prop->next;
|
||||
grub_free (t);
|
||||
}
|
||||
|
||||
grub_free (dev->path);
|
||||
grub_free (dev);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
struct grub_xnu_devprop_device_descriptor *
|
||||
grub_xnu_devprop_add_device (struct grub_efi_device_path *path, int length)
|
||||
{
|
||||
struct grub_xnu_devprop_device_descriptor *ret;
|
||||
|
||||
ret = grub_zalloc (sizeof (*ret));
|
||||
if (!ret)
|
||||
return 0;
|
||||
|
||||
ret->path = grub_malloc (length);
|
||||
if (!ret->path)
|
||||
{
|
||||
grub_free (ret);
|
||||
return 0;
|
||||
}
|
||||
ret->pathlen = length;
|
||||
grub_memcpy (ret->path, path, length);
|
||||
|
||||
grub_list_push (GRUB_AS_LIST_P (&devices), GRUB_AS_LIST (ret));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_xnu_devprop_add_property (struct grub_xnu_devprop_device_descriptor *dev,
|
||||
grub_uint8_t *utf8, grub_uint16_t *utf16,
|
||||
int utf16len, void *data, int datalen)
|
||||
{
|
||||
struct property_descriptor *prop;
|
||||
|
||||
prop = grub_malloc (sizeof (*prop));
|
||||
if (!prop)
|
||||
return grub_errno;
|
||||
|
||||
prop->name = utf8;
|
||||
prop->name16 = utf16;
|
||||
prop->name16len = utf16len;
|
||||
|
||||
prop->length = datalen;
|
||||
prop->data = grub_malloc (prop->length);
|
||||
if (!prop->data)
|
||||
{
|
||||
grub_free (prop);
|
||||
grub_free (prop->name);
|
||||
grub_free (prop->name16);
|
||||
return grub_errno;
|
||||
}
|
||||
grub_memcpy (prop->data, data, prop->length);
|
||||
grub_list_push (GRUB_AS_LIST_P (&dev->properties),
|
||||
GRUB_AS_LIST (prop));
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_xnu_devprop_add_property_utf8 (struct grub_xnu_devprop_device_descriptor *dev,
|
||||
char *name, void *data, int datalen)
|
||||
{
|
||||
grub_uint8_t *utf8;
|
||||
grub_uint16_t *utf16;
|
||||
int len, utf16len;
|
||||
grub_err_t err;
|
||||
|
||||
utf8 = (grub_uint8_t *) grub_strdup (name);
|
||||
if (!utf8)
|
||||
return grub_errno;
|
||||
|
||||
len = grub_strlen (name);
|
||||
utf16 = grub_malloc (sizeof (grub_uint16_t) * len);
|
||||
if (!utf16)
|
||||
{
|
||||
grub_free (utf8);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
utf16len = grub_utf8_to_utf16 (utf16, len, utf8, len, NULL);
|
||||
if (utf16len < 0)
|
||||
{
|
||||
grub_free (utf8);
|
||||
grub_free (utf16);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
err = grub_xnu_devprop_add_property (dev, utf8, utf16,
|
||||
utf16len, data, datalen);
|
||||
if (err)
|
||||
{
|
||||
grub_free (utf8);
|
||||
grub_free (utf16);
|
||||
return err;
|
||||
}
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_xnu_devprop_add_property_utf16 (struct grub_xnu_devprop_device_descriptor *dev,
|
||||
grub_uint16_t *name, int namelen,
|
||||
void *data, int datalen)
|
||||
{
|
||||
grub_uint8_t *utf8;
|
||||
grub_uint16_t *utf16;
|
||||
grub_err_t err;
|
||||
|
||||
utf16 = grub_malloc (sizeof (grub_uint16_t) * namelen);
|
||||
if (!utf16)
|
||||
return grub_errno;
|
||||
grub_memcpy (utf16, name, sizeof (grub_uint16_t) * namelen);
|
||||
|
||||
utf8 = grub_malloc (namelen * 4 + 1);
|
||||
if (!utf8)
|
||||
{
|
||||
grub_free (utf8);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
*grub_utf16_to_utf8 ((grub_uint8_t *) utf8, name, namelen) = '\0';
|
||||
|
||||
err = grub_xnu_devprop_add_property (dev, utf8, utf16,
|
||||
namelen, data, datalen);
|
||||
if (err)
|
||||
{
|
||||
grub_free (utf8);
|
||||
grub_free (utf16);
|
||||
return err;
|
||||
}
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static inline int
|
||||
hextoval (char c)
|
||||
{
|
||||
if (c >= '0' && c <= '9')
|
||||
return c - '0';
|
||||
if (c >= 'a' && c <= 'z')
|
||||
return c - 'a' + 10;
|
||||
if (c >= 'A' && c <= 'Z')
|
||||
return c - 'A' + 10;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
grub_cpu_xnu_unload (void)
|
||||
{
|
||||
struct grub_xnu_devprop_device_descriptor *dev1, *dev2;
|
||||
|
||||
for (dev1 = devices; dev1; )
|
||||
{
|
||||
dev2 = dev1->next;
|
||||
grub_xnu_devprop_remove_device (dev1);
|
||||
dev1 = dev2;
|
||||
}
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_cpu_xnu_fill_devprop (void)
|
||||
{
|
||||
struct grub_xnu_devtree_key *efikey;
|
||||
int total_length = sizeof (struct grub_xnu_devprop_header);
|
||||
struct grub_xnu_devtree_key *devprop;
|
||||
struct grub_xnu_devprop_device_descriptor *device;
|
||||
void *ptr;
|
||||
struct grub_xnu_devprop_header *head;
|
||||
void *t;
|
||||
int numdevs = 0;
|
||||
|
||||
/* The key "efi". */
|
||||
efikey = grub_xnu_create_key (&grub_xnu_devtree_root, "efi");
|
||||
if (! efikey)
|
||||
return grub_errno;
|
||||
|
||||
for (device = devices; device; device = device->next)
|
||||
{
|
||||
struct property_descriptor *propdesc;
|
||||
total_length += sizeof (struct grub_xnu_devprop_device_header);
|
||||
total_length += device->pathlen;
|
||||
|
||||
for (propdesc = device->properties; propdesc; propdesc = propdesc->next)
|
||||
{
|
||||
total_length += sizeof (grub_uint32_t);
|
||||
total_length += sizeof (grub_uint16_t)
|
||||
* (propdesc->name16len + 1);
|
||||
total_length += sizeof (grub_uint32_t);
|
||||
total_length += propdesc->length;
|
||||
}
|
||||
numdevs++;
|
||||
}
|
||||
|
||||
devprop = grub_xnu_create_value (&(efikey->first_child), "device-properties");
|
||||
if (devprop)
|
||||
{
|
||||
devprop->data = grub_malloc (total_length);
|
||||
devprop->datasize = total_length;
|
||||
}
|
||||
|
||||
ptr = devprop->data;
|
||||
head = ptr;
|
||||
ptr = head + 1;
|
||||
head->length = total_length;
|
||||
head->alwaysone = 1;
|
||||
head->num_devices = numdevs;
|
||||
for (device = devices; device; )
|
||||
{
|
||||
struct grub_xnu_devprop_device_header *devhead;
|
||||
struct property_descriptor *propdesc;
|
||||
devhead = ptr;
|
||||
devhead->num_values = 0;
|
||||
ptr = devhead + 1;
|
||||
|
||||
grub_memcpy (ptr, device->path, device->pathlen);
|
||||
ptr = (char *) ptr + device->pathlen;
|
||||
|
||||
for (propdesc = device->properties; propdesc; )
|
||||
{
|
||||
grub_uint32_t *len;
|
||||
grub_uint16_t *name;
|
||||
void *data;
|
||||
|
||||
len = ptr;
|
||||
*len = 2 * propdesc->name16len + sizeof (grub_uint16_t)
|
||||
+ sizeof (grub_uint32_t);
|
||||
ptr = len + 1;
|
||||
|
||||
name = ptr;
|
||||
grub_memcpy (name, propdesc->name16, 2 * propdesc->name16len);
|
||||
name += propdesc->name16len;
|
||||
|
||||
/* NUL terminator. */
|
||||
*name = 0;
|
||||
ptr = name + 1;
|
||||
|
||||
len = ptr;
|
||||
*len = propdesc->length + sizeof (grub_uint32_t);
|
||||
data = len + 1;
|
||||
ptr = data;
|
||||
grub_memcpy (ptr, propdesc->data, propdesc->length);
|
||||
ptr = (char *) ptr + propdesc->length;
|
||||
|
||||
grub_free (propdesc->name);
|
||||
grub_free (propdesc->name16);
|
||||
grub_free (propdesc->data);
|
||||
t = propdesc;
|
||||
propdesc = propdesc->next;
|
||||
grub_free (t);
|
||||
devhead->num_values++;
|
||||
}
|
||||
|
||||
devhead->length = (char *) ptr - (char *) devhead;
|
||||
t = device;
|
||||
device = device->next;
|
||||
grub_free (t);
|
||||
}
|
||||
|
||||
devices = 0;
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_cmd_devprop_load (grub_command_t cmd __attribute__ ((unused)),
|
||||
int argc, char *args[])
|
||||
{
|
||||
grub_file_t file;
|
||||
void *buf, *bufstart, *bufend;
|
||||
struct grub_xnu_devprop_header *head;
|
||||
grub_size_t size;
|
||||
unsigned i, j;
|
||||
|
||||
if (argc != 1)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "File name required. ");
|
||||
|
||||
file = grub_gzfile_open (args[0], 1);
|
||||
if (! file)
|
||||
return grub_error (GRUB_ERR_FILE_NOT_FOUND,
|
||||
"Couldn't load device-propertie dump. ");
|
||||
size = grub_file_size (file);
|
||||
buf = grub_malloc (size);
|
||||
if (!buf)
|
||||
{
|
||||
grub_file_close (file);
|
||||
return grub_errno;
|
||||
}
|
||||
if (grub_file_read (file, buf, size) != (grub_ssize_t) size)
|
||||
{
|
||||
grub_file_close (file);
|
||||
return grub_errno;
|
||||
}
|
||||
grub_file_close (file);
|
||||
|
||||
bufstart = buf;
|
||||
bufend = (char *) buf + size;
|
||||
head = buf;
|
||||
buf = head + 1;
|
||||
for (i = 0; i < grub_le_to_cpu32 (head->num_devices) && buf < bufend; i++)
|
||||
{
|
||||
struct grub_efi_device_path *dp, *dpstart;
|
||||
struct grub_xnu_devprop_device_descriptor *dev;
|
||||
struct grub_xnu_devprop_device_header *devhead;
|
||||
|
||||
devhead = buf;
|
||||
buf = devhead + 1;
|
||||
dpstart = buf;
|
||||
|
||||
do
|
||||
{
|
||||
dp = buf;
|
||||
buf = (char *) buf + GRUB_EFI_DEVICE_PATH_LENGTH (dp);
|
||||
}
|
||||
while (!GRUB_EFI_END_ENTIRE_DEVICE_PATH (dp) && buf < bufend);
|
||||
|
||||
dev = grub_xnu_devprop_add_device (dpstart, (char *) buf
|
||||
- (char *) dpstart);
|
||||
|
||||
for (j = 0; j < grub_le_to_cpu32 (devhead->num_values) && buf < bufend;
|
||||
j++)
|
||||
{
|
||||
grub_uint32_t *namelen;
|
||||
grub_uint32_t *datalen;
|
||||
grub_uint16_t *utf16;
|
||||
void *data;
|
||||
grub_err_t err;
|
||||
|
||||
namelen = buf;
|
||||
buf = namelen + 1;
|
||||
if (buf >= bufend)
|
||||
break;
|
||||
|
||||
utf16 = buf;
|
||||
buf = (char *) buf + *namelen - sizeof (grub_uint32_t);
|
||||
if (buf >= bufend)
|
||||
break;
|
||||
|
||||
datalen = buf;
|
||||
buf = datalen + 1;
|
||||
if (buf >= bufend)
|
||||
break;
|
||||
|
||||
data = buf;
|
||||
buf = (char *) buf + *datalen - sizeof (grub_uint32_t);
|
||||
if (buf >= bufend)
|
||||
break;
|
||||
err = grub_xnu_devprop_add_property_utf16
|
||||
(dev, utf16, (*namelen - sizeof (grub_uint32_t)
|
||||
- sizeof (grub_uint16_t)) / sizeof (grub_uint16_t),
|
||||
data, *datalen - sizeof (grub_uint32_t));
|
||||
if (err)
|
||||
{
|
||||
grub_free (bufstart);
|
||||
return err;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
grub_free (bufstart);
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Fill device tree. */
|
||||
/* FIXME: some entries may be platform-agnostic. Move them to loader/xnu.c. */
|
||||
grub_err_t
|
||||
|
|
@ -216,11 +639,6 @@ grub_cpu_xnu_fill_devicetree (void)
|
|||
struct grub_xnu_devtree_key *runtimesrvkey;
|
||||
struct grub_xnu_devtree_key *platformkey;
|
||||
unsigned i, j;
|
||||
grub_err_t err;
|
||||
|
||||
err = grub_autoefi_prepare ();
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* The value "model". */
|
||||
/* FIXME: may this value be sometimes different? */
|
||||
|
|
@ -436,6 +854,22 @@ grub_xnu_boot (void)
|
|||
grub_size_t devtreelen;
|
||||
int i;
|
||||
|
||||
err = grub_autoefi_prepare ();
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = grub_cpu_xnu_fill_devprop ();
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = grub_cpu_xnu_fill_devicetree ();
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = grub_xnu_fill_devicetree ();
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Page-align to avoid following parts to be inadvertently freed. */
|
||||
err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE);
|
||||
if (err)
|
||||
|
|
@ -590,3 +1024,19 @@ grub_xnu_boot (void)
|
|||
/* Never reaches here. */
|
||||
return 0;
|
||||
}
|
||||
|
||||
static grub_command_t cmd_devprop_load;
|
||||
|
||||
void
|
||||
grub_cpu_xnu_init (void)
|
||||
{
|
||||
cmd_devprop_load = grub_register_command ("xnu_devprop_load",
|
||||
grub_cmd_devprop_load,
|
||||
0, "Load device-properties dump.");
|
||||
}
|
||||
|
||||
void
|
||||
grub_cpu_xnu_fini (void)
|
||||
{
|
||||
grub_unregister_command (cmd_devprop_load);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ SUFFIX (grub_macho_parse) (grub_macho_t macho)
|
|||
}
|
||||
if (head.magic != GRUB_MACHO_MAGIC)
|
||||
{
|
||||
grub_error (GRUB_ERR_BAD_OS, "Invalid Mach-O " XX "-bit header.");
|
||||
grub_error (GRUB_ERR_BAD_OS, "Invalid Mach-O 32-bit header.");
|
||||
macho->offsetXX = -1;
|
||||
return;
|
||||
}
|
||||
|
|
@ -94,7 +94,7 @@ SUFFIX (grub_macho_readfile) (grub_macho_t macho, void *dest)
|
|||
return grub_error (GRUB_ERR_BAD_OS,
|
||||
"Couldn't read architecture-specific part");
|
||||
|
||||
if (grub_file_seek (macho->file, macho->offsetXX) == (grub_off_t) -1)
|
||||
if (grub_file_seek (macho->file, macho->offset32) == (grub_off_t) -1)
|
||||
{
|
||||
grub_error_push ();
|
||||
return grub_error (GRUB_ERR_BAD_OS,
|
||||
|
|
@ -102,8 +102,8 @@ SUFFIX (grub_macho_readfile) (grub_macho_t macho, void *dest)
|
|||
}
|
||||
|
||||
read = grub_file_read (macho->file, dest,
|
||||
macho->endXX - macho->offsetXX);
|
||||
if (read != (grub_ssize_t) (macho->endXX - macho->offsetXX))
|
||||
macho->end32 - macho->offset32);
|
||||
if (read != (grub_ssize_t) (macho->end32 - macho->offset32))
|
||||
{
|
||||
grub_error_push ();
|
||||
return grub_error (GRUB_ERR_BAD_OS,
|
||||
|
|
|
|||
301
loader/xnu.c
301
loader/xnu.c
|
|
@ -31,6 +31,7 @@
|
|||
#include <grub/gzio.h>
|
||||
#include <grub/command.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/env.h>
|
||||
|
||||
struct grub_xnu_devtree_key *grub_xnu_devtree_root = 0;
|
||||
static int driverspackagenum = 0;
|
||||
|
|
@ -334,6 +335,8 @@ grub_xnu_create_value (struct grub_xnu_devtree_key **parent, char *name)
|
|||
static grub_err_t
|
||||
grub_xnu_unload (void)
|
||||
{
|
||||
grub_cpu_xnu_unload ();
|
||||
|
||||
grub_xnu_free_devtree (grub_xnu_devtree_root);
|
||||
grub_xnu_devtree_root = 0;
|
||||
|
||||
|
|
@ -437,10 +440,6 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
|
|||
if (ptr != grub_xnu_cmdline)
|
||||
*(ptr - 1) = 0;
|
||||
|
||||
err = grub_cpu_xnu_fill_devicetree ();
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
grub_loader_set (grub_xnu_boot, grub_xnu_unload, 0);
|
||||
|
||||
grub_xnu_lock ();
|
||||
|
|
@ -542,10 +541,6 @@ grub_cmd_xnu_kernel64 (grub_command_t cmd __attribute__ ((unused)),
|
|||
if (ptr != grub_xnu_cmdline)
|
||||
*(ptr - 1) = 0;
|
||||
|
||||
err = grub_cpu_xnu_fill_devicetree ();
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
grub_loader_set (grub_xnu_boot, grub_xnu_unload, 0);
|
||||
|
||||
grub_xnu_lock ();
|
||||
|
|
@ -907,135 +902,6 @@ grub_cmd_xnu_ramdisk (grub_command_t cmd __attribute__ ((unused)),
|
|||
return grub_xnu_register_memory ("RAMDisk", 0, loadto, size);
|
||||
}
|
||||
|
||||
/* Parse a devtree file. It uses the following format:
|
||||
valuename:valuedata;
|
||||
keyname{
|
||||
contents
|
||||
}
|
||||
keyname, valuename and valuedata are in hex.
|
||||
*/
|
||||
static char *
|
||||
grub_xnu_parse_devtree (struct grub_xnu_devtree_key **parent,
|
||||
char *start, char *end)
|
||||
{
|
||||
char *ptr, *ptr2;
|
||||
char *name, *data;
|
||||
int namelen, datalen, i;
|
||||
for (ptr = start; ptr && ptr < end; )
|
||||
{
|
||||
if (grub_isspace (*ptr))
|
||||
{
|
||||
ptr++;
|
||||
continue;
|
||||
}
|
||||
if (*ptr == '}')
|
||||
return ptr + 1;
|
||||
namelen = 0;
|
||||
|
||||
/* Parse the name. */
|
||||
for (ptr2 = ptr; ptr2 < end && (grub_isspace (*ptr2)
|
||||
|| (*ptr2 >= '0' && *ptr2 <= '9')
|
||||
|| (*ptr2 >= 'a' && *ptr2 <= 'f')
|
||||
|| (*ptr2 >= 'A' && *ptr2 <= 'F'));
|
||||
ptr2++)
|
||||
if (! grub_isspace (*ptr2))
|
||||
namelen++;
|
||||
if (ptr2 == end)
|
||||
return 0;
|
||||
namelen /= 2;
|
||||
name = grub_malloc (namelen + 1);
|
||||
if (!name)
|
||||
return 0;
|
||||
for (i = 0; i < 2 * namelen; i++)
|
||||
{
|
||||
int hex = 0;
|
||||
while (grub_isspace (*ptr))
|
||||
ptr++;
|
||||
if (*ptr >= '0' && *ptr <= '9')
|
||||
hex = *ptr - '0';
|
||||
if (*ptr >= 'a' && *ptr <= 'f')
|
||||
hex = *ptr - 'a' + 10;
|
||||
if (*ptr >= 'A' && *ptr <= 'F')
|
||||
hex = *ptr - 'A' + 10;
|
||||
|
||||
if (i % 2 == 0)
|
||||
name[i / 2] = hex << 4;
|
||||
else
|
||||
name[i / 2] |= hex;
|
||||
ptr++;
|
||||
}
|
||||
name [namelen] = 0;
|
||||
while (grub_isspace (*ptr))
|
||||
ptr++;
|
||||
|
||||
/* If it describes a key recursively invoke the function. */
|
||||
if (*ptr == '{')
|
||||
{
|
||||
struct grub_xnu_devtree_key *newkey
|
||||
= grub_xnu_create_key (parent, name);
|
||||
grub_free (name);
|
||||
if (! newkey)
|
||||
return 0;
|
||||
ptr = grub_xnu_parse_devtree (&(newkey->first_child), ptr + 1, end);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Parse the data. */
|
||||
if (*ptr != ':')
|
||||
return 0;
|
||||
ptr++;
|
||||
datalen = 0;
|
||||
for (ptr2 = ptr; ptr2 < end && (grub_isspace (*ptr2)
|
||||
|| (*ptr2 >= '0' && *ptr2 <= '9')
|
||||
|| (*ptr2 >= 'a' && *ptr2 <= 'f')
|
||||
|| (*ptr2 >= 'A' && *ptr2 <= 'F'));
|
||||
ptr2++)
|
||||
if (! grub_isspace (*ptr2))
|
||||
datalen++;
|
||||
if (ptr2 == end)
|
||||
return 0;
|
||||
datalen /= 2;
|
||||
data = grub_malloc (datalen);
|
||||
if (! data)
|
||||
return 0;
|
||||
for (i = 0; i < 2 * datalen; i++)
|
||||
{
|
||||
int hex = 0;
|
||||
while (grub_isspace (*ptr))
|
||||
ptr++;
|
||||
if (*ptr >= '0' && *ptr <= '9')
|
||||
hex = *ptr - '0';
|
||||
if (*ptr >= 'a' && *ptr <= 'f')
|
||||
hex = *ptr - 'a' + 10;
|
||||
if (*ptr >= 'A' && *ptr <= 'F')
|
||||
hex = *ptr - 'A' + 10;
|
||||
|
||||
if (i % 2 == 0)
|
||||
data[i / 2] = hex << 4;
|
||||
else
|
||||
data[i / 2] |= hex;
|
||||
ptr++;
|
||||
}
|
||||
while (ptr < end && grub_isspace (*ptr))
|
||||
ptr++;
|
||||
{
|
||||
struct grub_xnu_devtree_key *newkey
|
||||
= grub_xnu_create_value (parent, name);
|
||||
grub_free (name);
|
||||
if (! newkey)
|
||||
return 0;
|
||||
newkey->datasize = datalen;
|
||||
newkey->data = data;
|
||||
}
|
||||
if (*ptr != ';')
|
||||
return 0;
|
||||
ptr++;
|
||||
}
|
||||
if (ptr >= end && *parent != grub_xnu_devtree_root)
|
||||
return 0;
|
||||
return ptr;
|
||||
}
|
||||
|
||||
/* Returns true if the kext should be loaded according to plist
|
||||
and osbundlereq. Also fill BINNAME. */
|
||||
static int
|
||||
|
|
@ -1332,53 +1198,6 @@ grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
|
|||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Load devtree file. */
|
||||
static grub_err_t
|
||||
grub_cmd_xnu_devtree (grub_command_t cmd __attribute__ ((unused)),
|
||||
int argc, char *args[])
|
||||
{
|
||||
grub_file_t file;
|
||||
char *data, *endret;
|
||||
grub_size_t datalen;
|
||||
|
||||
if (argc != 1)
|
||||
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Filename required");
|
||||
|
||||
if (! grub_xnu_heap_size)
|
||||
return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
|
||||
|
||||
/* Load the file. */
|
||||
file = grub_gzfile_open (args[0], 1);
|
||||
if (! file)
|
||||
return grub_error (GRUB_ERR_FILE_NOT_FOUND, "Couldn't load device tree");
|
||||
datalen = grub_file_size (file);
|
||||
data = grub_malloc (datalen + 1);
|
||||
if (! data)
|
||||
{
|
||||
grub_file_close (file);
|
||||
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
|
||||
"Could load device tree into memory");
|
||||
}
|
||||
if (grub_file_read (file, data, datalen) != (grub_ssize_t) datalen)
|
||||
{
|
||||
grub_file_close (file);
|
||||
grub_free (data);
|
||||
grub_error_push ();
|
||||
return grub_error (GRUB_ERR_BAD_OS, "Couldn't read file %s", args[0]);
|
||||
}
|
||||
grub_file_close (file);
|
||||
data[datalen] = 0;
|
||||
|
||||
/* Parse the file. */
|
||||
endret = grub_xnu_parse_devtree (&grub_xnu_devtree_root,
|
||||
data, data + datalen);
|
||||
grub_free (data);
|
||||
|
||||
if (! endret)
|
||||
return grub_error (GRUB_ERR_BAD_OS, "Couldn't parse devtree");
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
static int locked=0;
|
||||
static grub_dl_t my_mod;
|
||||
|
|
@ -1439,6 +1258,107 @@ grub_cmd_xnu_kextdir (grub_command_t cmd __attribute__ ((unused)),
|
|||
}
|
||||
}
|
||||
|
||||
static inline int
|
||||
hextoval (char c)
|
||||
{
|
||||
if (c >= '0' && c <= '9')
|
||||
return c - '0';
|
||||
if (c >= 'a' && c <= 'z')
|
||||
return c - 'a' + 10;
|
||||
if (c >= 'A' && c <= 'Z')
|
||||
return c - 'A' + 10;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void
|
||||
unescape (char *name, char *curdot, char *nextdot, int *len)
|
||||
{
|
||||
char *ptr, *dptr;
|
||||
dptr = name;
|
||||
for (ptr = curdot; ptr < nextdot;)
|
||||
if (ptr + 2 < nextdot && *ptr == '%')
|
||||
{
|
||||
*dptr = (hextoval (ptr[1]) << 4) | (hextoval (ptr[2]));
|
||||
ptr += 3;
|
||||
dptr++;
|
||||
}
|
||||
else
|
||||
{
|
||||
*dptr = *ptr;
|
||||
ptr++;
|
||||
dptr++;
|
||||
}
|
||||
*len = dptr - name;
|
||||
}
|
||||
|
||||
grub_err_t
|
||||
grub_xnu_fill_devicetree (void)
|
||||
{
|
||||
auto int iterate_env (struct grub_env_var *var);
|
||||
int iterate_env (struct grub_env_var *var)
|
||||
{
|
||||
char *nextdot = 0, *curdot;
|
||||
struct grub_xnu_devtree_key **curkey = &grub_xnu_devtree_root;
|
||||
struct grub_xnu_devtree_key *curvalue;
|
||||
char *name = 0, *data;
|
||||
int len;
|
||||
|
||||
if (grub_memcmp (var->name, "XNU.DeviceTree.",
|
||||
sizeof ("XNU.DeviceTree.") - 1) != 0)
|
||||
return 0;
|
||||
|
||||
curdot = var->name + sizeof ("XNU.DeviceTree.") - 1;
|
||||
nextdot = grub_strchr (curdot, '.');
|
||||
if (nextdot)
|
||||
nextdot++;
|
||||
while (nextdot)
|
||||
{
|
||||
name = grub_realloc (name, nextdot - curdot + 1);
|
||||
|
||||
if (!name)
|
||||
return 1;
|
||||
|
||||
unescape (name, curdot, nextdot, &len);
|
||||
name[len - 1] = 0;
|
||||
|
||||
curkey = &(grub_xnu_create_key (curkey, name)->first_child);
|
||||
|
||||
curdot = nextdot;
|
||||
nextdot = grub_strchr (nextdot, '.');
|
||||
if (nextdot)
|
||||
nextdot++;
|
||||
}
|
||||
|
||||
nextdot = curdot + grub_strlen (curdot) + 1;
|
||||
|
||||
name = grub_realloc (name, nextdot - curdot + 1);
|
||||
|
||||
if (!name)
|
||||
return 1;
|
||||
|
||||
unescape (name, curdot, nextdot, &len);
|
||||
name[len] = 0;
|
||||
|
||||
curvalue = grub_xnu_create_value (curkey, name);
|
||||
grub_free (name);
|
||||
|
||||
data = grub_malloc (grub_strlen (var->value) + 1);
|
||||
if (!data)
|
||||
return 1;
|
||||
|
||||
unescape (data, var->value, var->value + grub_strlen (var->value),
|
||||
&len);
|
||||
curvalue->datasize = len;
|
||||
curvalue->data = data;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
grub_env_iterate (iterate_env);
|
||||
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
struct grub_video_bitmap *grub_xnu_bitmap = 0;
|
||||
|
||||
static grub_err_t
|
||||
|
|
@ -1485,8 +1405,7 @@ grub_xnu_unlock ()
|
|||
}
|
||||
|
||||
static grub_command_t cmd_kernel64, cmd_kernel, cmd_mkext, cmd_kext;
|
||||
static grub_command_t cmd_kextdir, cmd_ramdisk, cmd_devtree, cmd_resume;
|
||||
static grub_command_t cmd_splash;
|
||||
static grub_command_t cmd_kextdir, cmd_ramdisk, cmd_resume, cmd_splash;
|
||||
|
||||
GRUB_MOD_INIT(xnu)
|
||||
{
|
||||
|
|
@ -1504,8 +1423,6 @@ GRUB_MOD_INIT(xnu)
|
|||
cmd_ramdisk = grub_register_command ("xnu_ramdisk", grub_cmd_xnu_ramdisk, 0,
|
||||
"Load XNU ramdisk. "
|
||||
"It will be seen as md0");
|
||||
cmd_devtree = grub_register_command ("xnu_devtree", grub_cmd_xnu_devtree, 0,
|
||||
"Load XNU devtree");
|
||||
cmd_splash = grub_register_command ("xnu_splash", grub_cmd_xnu_splash, 0,
|
||||
"Load a splash image for XNU");
|
||||
|
||||
|
|
@ -1513,7 +1430,10 @@ GRUB_MOD_INIT(xnu)
|
|||
cmd_resume = grub_register_command ("xnu_resume", grub_cmd_xnu_resume,
|
||||
0, "Load XNU hibernate image.");
|
||||
#endif
|
||||
my_mod=mod;
|
||||
|
||||
grub_cpu_xnu_init ();
|
||||
|
||||
my_mod = mod;
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI(xnu)
|
||||
|
|
@ -1524,9 +1444,10 @@ GRUB_MOD_FINI(xnu)
|
|||
grub_unregister_command (cmd_mkext);
|
||||
grub_unregister_command (cmd_kext);
|
||||
grub_unregister_command (cmd_kextdir);
|
||||
grub_unregister_command (cmd_devtree);
|
||||
grub_unregister_command (cmd_ramdisk);
|
||||
grub_unregister_command (cmd_kernel);
|
||||
grub_unregister_command (cmd_kernel64);
|
||||
grub_unregister_command (cmd_splash);
|
||||
|
||||
grub_cpu_xnu_fini ();
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue