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,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);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue