/* xnu.c - load xnu kernel. Thanks to Florian Idelberger for all the time he spent testing this */ /* * GRUB -- GRand Unified Bootloader * Copyright (C) 2009 Free Software Foundation, Inc. * * GRUB is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * GRUB is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with GRUB. If not, see . */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include GRUB_MOD_LICENSE ("GPLv3+"); #if defined (__i386) && !defined (GRUB_MACHINE_EFI) #include #endif struct grub_xnu_devtree_key *grub_xnu_devtree_root = 0; static int driverspackagenum = 0; static int driversnum = 0; int grub_xnu_is_64bit = 0; grub_addr_t grub_xnu_heap_target_start = 0; grub_size_t grub_xnu_heap_size = 0; struct grub_relocator *grub_xnu_relocator; static grub_err_t grub_xnu_register_memory (const char *prefix, int *suffix, grub_addr_t addr, grub_size_t size); grub_err_t grub_xnu_heap_malloc (int size, void **src, grub_addr_t *target) { grub_err_t err; grub_relocator_chunk_t ch; err = grub_relocator_alloc_chunk_addr (grub_xnu_relocator, &ch, grub_xnu_heap_target_start + grub_xnu_heap_size, size); if (err) return err; *src = get_virtual_current_address (ch); *target = grub_xnu_heap_target_start + grub_xnu_heap_size; grub_xnu_heap_size += size; grub_dprintf ("xnu", "val=%p\n", *src); return GRUB_ERR_NONE; } /* Make sure next block of the heap will be aligned. Please notice: aligned are pointers AFTER relocation and not the current ones. */ grub_err_t grub_xnu_align_heap (int align) { grub_xnu_heap_size = ALIGN_UP (grub_xnu_heap_target_start+ grub_xnu_heap_size, align) - grub_xnu_heap_target_start; return GRUB_ERR_NONE; } /* Free subtree pointed by CUR. */ void grub_xnu_free_devtree (struct grub_xnu_devtree_key *cur) { struct grub_xnu_devtree_key *d; while (cur) { grub_free (cur->name); if (cur->datasize == -1) grub_xnu_free_devtree (cur->first_child); else if (cur->data) grub_free (cur->data); d = cur->next; grub_free (cur); cur = d; } } /* Compute the size of device tree in xnu format. */ static grub_size_t grub_xnu_writetree_get_size (struct grub_xnu_devtree_key *start, const char *name) { grub_size_t ret; struct grub_xnu_devtree_key *cur; /* Key header. */ ret = 2 * sizeof (grub_uint32_t); /* "name" value. */ ret += 32 + sizeof (grub_uint32_t) + grub_strlen (name) + 4 - (grub_strlen (name) % 4); for (cur = start; cur; cur = cur->next) if (cur->datasize != -1) { int align_overhead; align_overhead = 4 - (cur->datasize % 4); if (align_overhead == 4) align_overhead = 0; ret += 32 + sizeof (grub_uint32_t) + cur->datasize + align_overhead; } else ret += grub_xnu_writetree_get_size (cur->first_child, cur->name); return ret; } /* Write devtree in XNU format at curptr assuming the head is named NAME.*/ static void * grub_xnu_writetree_toheap_real (void *curptr, struct grub_xnu_devtree_key *start, const char *name) { struct grub_xnu_devtree_key *cur; int nkeys = 0, nvals = 0; for (cur = start; cur; cur = cur->next) { if (cur->datasize == -1) nkeys++; else nvals++; } /* For the name. */ nvals++; *((grub_uint32_t *) curptr) = nvals; curptr = ((grub_uint32_t *) curptr) + 1; *((grub_uint32_t *) curptr) = nkeys; curptr = ((grub_uint32_t *) curptr) + 1; /* First comes "name" value. */ grub_memset (curptr, 0, 32); grub_memcpy (curptr, "name", 4); curptr = ((grub_uint8_t *) curptr) + 32; *((grub_uint32_t *)curptr) = grub_strlen (name) + 1; curptr = ((grub_uint32_t *) curptr) + 1; grub_memcpy (curptr, name, grub_strlen (name)); curptr = ((grub_uint8_t *) curptr) + grub_strlen (name); grub_memset (curptr, 0, 4 - (grub_strlen (name) % 4)); curptr = ((grub_uint8_t *) curptr) + (4 - (grub_strlen (name) % 4)); /* Then the other values. */ for (cur = start; cur; cur = cur->next) if (cur->datasize != -1) { int align_overhead; align_overhead = 4 - (cur->datasize % 4); if (align_overhead == 4) align_overhead = 0; grub_memset (curptr, 0, 32); grub_strncpy (curptr, cur->name, 31); curptr = ((grub_uint8_t *) curptr) + 32; *((grub_uint32_t *) curptr) = cur->datasize; curptr = ((grub_uint32_t *) curptr) + 1; grub_memcpy (curptr, cur->data, cur->datasize); curptr = ((grub_uint8_t *) curptr) + cur->datasize; grub_memset (curptr, 0, align_overhead); curptr = ((grub_uint8_t *) curptr) + align_overhead; } /* And then the keys. Recursively use this function. */ for (cur = start; cur; cur = cur->next) if (cur->datasize == -1) if (!(curptr = grub_xnu_writetree_toheap_real (curptr, cur->first_child, cur->name))) return 0; return curptr; } grub_err_t grub_xnu_writetree_toheap (grub_addr_t *target, grub_size_t *size) { struct grub_xnu_devtree_key *chosen; struct grub_xnu_devtree_key *memorymap; struct grub_xnu_devtree_key *driverkey; struct grub_xnu_extdesc *extdesc; grub_err_t err; void *src; err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE); if (err) return err; /* Device tree itself is in the memory map of device tree. */ /* Create a dummy value in memory-map. */ chosen = grub_xnu_create_key (&grub_xnu_devtree_root, "chosen"); if (! chosen) return grub_errno; memorymap = grub_xnu_create_key (&(chosen->first_child), "memory-map"); if (! memorymap) return grub_errno; driverkey = (struct grub_xnu_devtree_key *) grub_malloc (sizeof (*driverkey)); if (! driverkey) return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't write device tree"); driverkey->name = grub_strdup ("DeviceTree"); if (! driverkey->name) return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't write device tree"); driverkey->datasize = sizeof (*extdesc); driverkey->next = memorymap->first_child; memorymap->first_child = driverkey; driverkey->data = extdesc = (struct grub_xnu_extdesc *) grub_malloc (sizeof (*extdesc)); if (! driverkey->data) return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't write device tree"); /* Allocate the space based on the size with dummy value. */ *size = grub_xnu_writetree_get_size (grub_xnu_devtree_root, "/"); err = grub_xnu_heap_malloc (ALIGN_UP (*size + 1, GRUB_XNU_PAGESIZE), &src, target); if (err) return err; /* Put real data in the dummy. */ extdesc->addr = *target; extdesc->size = (grub_uint32_t) *size; /* Write the tree to heap. */ grub_xnu_writetree_toheap_real (src, grub_xnu_devtree_root, "/"); return GRUB_ERR_NONE; } /* Find a key or value in parent key. */ struct grub_xnu_devtree_key * grub_xnu_find_key (struct grub_xnu_devtree_key *parent, const char *name) { struct grub_xnu_devtree_key *cur; for (cur = parent; cur; cur = cur->next) if (grub_strcmp (cur->name, name) == 0) return cur; return 0; } struct grub_xnu_devtree_key * grub_xnu_create_key (struct grub_xnu_devtree_key **parent, const char *name) { struct grub_xnu_devtree_key *ret; ret = grub_xnu_find_key (*parent, name); if (ret) return ret; ret = (struct grub_xnu_devtree_key *) grub_zalloc (sizeof (*ret)); if (! ret) { grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create key %s", name); return 0; } ret->name = grub_strdup (name); if (! ret->name) { grub_free (ret); grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create key %s", name); return 0; } ret->datasize = -1; ret->next = *parent; *parent = ret; return ret; } struct grub_xnu_devtree_key * grub_xnu_create_value (struct grub_xnu_devtree_key **parent, const char *name) { struct grub_xnu_devtree_key *ret; ret = grub_xnu_find_key (*parent, name); if (ret) { if (ret->datasize == -1) grub_xnu_free_devtree (ret->first_child); else if (ret->datasize) grub_free (ret->data); ret->datasize = 0; ret->data = 0; return ret; } ret = (struct grub_xnu_devtree_key *) grub_zalloc (sizeof (*ret)); if (! ret) { grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create value %s", name); return 0; } ret->name = grub_strdup (name); if (! ret->name) { grub_free (ret); grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't create value %s", name); return 0; } ret->next = *parent; *parent = ret; return ret; } 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; /* Free loaded image. */ driversnum = 0; driverspackagenum = 0; grub_relocator_unload (grub_xnu_relocator); grub_xnu_relocator = NULL; grub_xnu_heap_target_start = 0; grub_xnu_heap_size = 0; grub_xnu_unlock (); return GRUB_ERR_NONE; } static grub_err_t grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)), int argc, char *args[]) { grub_err_t err; grub_macho_t macho; grub_uint32_t startcode, endcode; int i; char *ptr; void *loadaddr; grub_addr_t loadaddr_target; if (argc < 1) return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required"); grub_xnu_unload (); macho = grub_macho_open (args[0]); if (! macho) return grub_errno; if (! grub_macho_contains_macho32 (macho)) { grub_macho_close (macho); return grub_error (GRUB_ERR_BAD_OS, "kernel doesn't contain suitable 32-bit architecture"); } err = grub_macho_size32 (macho, &startcode, &endcode, GRUB_MACHO_NOBSS); if (err) { grub_macho_close (macho); grub_xnu_unload (); return err; } grub_dprintf ("xnu", "endcode = %lx, startcode = %lx\n", (unsigned long) endcode, (unsigned long) startcode); grub_xnu_relocator = grub_relocator_new (); if (!grub_xnu_relocator) return grub_errno; grub_xnu_heap_target_start = startcode; err = grub_xnu_heap_malloc (endcode - startcode, &loadaddr, &loadaddr_target); if (err) { grub_macho_close (macho); grub_xnu_unload (); return err; } /* Load kernel. */ err = grub_macho_load32 (macho, (char *) loadaddr - startcode, GRUB_MACHO_NOBSS); if (err) { grub_macho_close (macho); grub_xnu_unload (); return err; } grub_xnu_entry_point = grub_macho_get_entry_point32 (macho); if (! grub_xnu_entry_point) { grub_macho_close (macho); grub_xnu_unload (); return grub_error (GRUB_ERR_BAD_OS, "couldn't find entry point"); } grub_macho_close (macho); err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE); if (err) { grub_xnu_unload (); return err; } /* Copy parameters to kernel command line. */ ptr = grub_xnu_cmdline; for (i = 1; i < argc; i++) { if (ptr + grub_strlen (args[i]) + 1 >= grub_xnu_cmdline + sizeof (grub_xnu_cmdline)) break; grub_memcpy (ptr, args[i], grub_strlen (args[i])); ptr += grub_strlen (args[i]); *ptr = ' '; ptr++; } /* Replace last space by '\0'. */ if (ptr != grub_xnu_cmdline) *(ptr - 1) = 0; #if defined (__i386) && !defined (GRUB_MACHINE_EFI) err = grub_efiemu_autocore (); if (err) return err; #endif grub_loader_set (grub_xnu_boot, grub_xnu_unload, 0); grub_xnu_lock (); grub_xnu_is_64bit = 0; return 0; } static grub_err_t grub_cmd_xnu_kernel64 (grub_command_t cmd __attribute__ ((unused)), int argc, char *args[]) { grub_err_t err; grub_macho_t macho; grub_uint64_t startcode, endcode; int i; char *ptr; void *loadaddr; grub_addr_t loadaddr_target; if (argc < 1) return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required"); grub_xnu_unload (); macho = grub_macho_open (args[0]); if (! macho) return grub_errno; if (! grub_macho_contains_macho64 (macho)) { grub_macho_close (macho); return grub_error (GRUB_ERR_BAD_OS, "kernel doesn't contain suitable 64-bit architecture"); } err = grub_macho_size64 (macho, &startcode, &endcode, GRUB_MACHO_NOBSS); if (err) { grub_macho_close (macho); grub_xnu_unload (); return err; } startcode &= 0x0fffffff; endcode &= 0x0fffffff; grub_dprintf ("xnu", "endcode = %lx, startcode = %lx\n", (unsigned long) endcode, (unsigned long) startcode); grub_xnu_relocator = grub_relocator_new (); if (!grub_xnu_relocator) return grub_errno; grub_xnu_heap_target_start = startcode; err = grub_xnu_heap_malloc (endcode - startcode, &loadaddr, &loadaddr_target); if (err) { grub_macho_close (macho); grub_xnu_unload (); return err; } /* Load kernel. */ err = grub_macho_load64 (macho, (char *) loadaddr - startcode, GRUB_MACHO_NOBSS); if (err) { grub_macho_close (macho); grub_xnu_unload (); return err; } grub_xnu_entry_point = grub_macho_get_entry_point64 (macho) & 0x0fffffff; if (! grub_xnu_entry_point) { grub_macho_close (macho); grub_xnu_unload (); return grub_error (GRUB_ERR_BAD_OS, "couldn't find entry point"); } grub_macho_close (macho); err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE); if (err) { grub_xnu_unload (); return err; } /* Copy parameters to kernel command line. */ ptr = grub_xnu_cmdline; for (i = 1; i < argc; i++) { if (ptr + grub_strlen (args[i]) + 1 >= grub_xnu_cmdline + sizeof (grub_xnu_cmdline)) break; grub_memcpy (ptr, args[i], grub_strlen (args[i])); ptr += grub_strlen (args[i]); *ptr = ' '; ptr++; } /* Replace last space by '\0'. */ if (ptr != grub_xnu_cmdline) *(ptr - 1) = 0; #if defined (__i386) && !defined (GRUB_MACHINE_EFI) err = grub_efiemu_autocore (); if (err) return err; #endif grub_loader_set (grub_xnu_boot, grub_xnu_unload, 0); grub_xnu_lock (); grub_xnu_is_64bit = 1; return 0; } /* Register a memory in a memory map under name PREFIXSUFFIX and increment SUFFIX. */ static grub_err_t grub_xnu_register_memory (const char *prefix, int *suffix, grub_addr_t addr, grub_size_t size) { struct grub_xnu_devtree_key *chosen; struct grub_xnu_devtree_key *memorymap; struct grub_xnu_devtree_key *driverkey; struct grub_xnu_extdesc *extdesc; if (! grub_xnu_heap_size) return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded"); chosen = grub_xnu_create_key (&grub_xnu_devtree_root, "chosen"); if (! chosen) return grub_errno; memorymap = grub_xnu_create_key (&(chosen->first_child), "memory-map"); if (! memorymap) return grub_errno; driverkey = (struct grub_xnu_devtree_key *) grub_malloc (sizeof (*driverkey)); if (! driverkey) return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register memory"); if (suffix) { driverkey->name = grub_xasprintf ("%s%d", prefix, (*suffix)++); if (!driverkey->name) return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register memory"); } else driverkey->name = grub_strdup (prefix); if (! driverkey->name) return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register extension"); driverkey->datasize = sizeof (*extdesc); driverkey->next = memorymap->first_child; memorymap->first_child = driverkey; driverkey->data = extdesc = (struct grub_xnu_extdesc *) grub_malloc (sizeof (*extdesc)); if (! driverkey->data) return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register extension"); extdesc->addr = addr; extdesc->size = (grub_uint32_t) size; return GRUB_ERR_NONE; } static inline char * get_name_ptr (char *name) { char *p = name, *p2; /* Skip Info.plist. */ p2 = grub_strrchr (p, '/'); if (!p2) return name; if (p2 == name) return name + 1; p = p2 - 1; p2 = grub_strrchr (p, '/'); if (!p2) return name; if (p2 == name) return name + 1; if (grub_memcmp (p2, "/Contents/", sizeof ("/Contents/") - 1) != 0) return p2 + 1; p = p2 - 1; p2 = grub_strrchr (p, '/'); if (!p2) return name; return p2 + 1; } /* Load .kext. */ static grub_err_t grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile) { grub_macho_t macho; grub_err_t err; grub_file_t infoplist; struct grub_xnu_extheader *exthead; int neededspace = sizeof (*exthead); grub_uint8_t *buf; void *buf0; grub_addr_t buf_target; grub_size_t infoplistsize = 0, machosize = 0; char *name, *nameend; int namelen; name = get_name_ptr (infoplistname); nameend = grub_strchr (name, '/'); if (nameend) namelen = nameend - name; else namelen = grub_strlen (name); neededspace += namelen + 1; if (! grub_xnu_heap_size) return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded"); /* Compute the needed space. */ if (binaryfile) { macho = grub_macho_file (binaryfile); if (! macho || ! grub_macho_contains_macho32 (macho)) { if (macho) grub_macho_close (macho); return grub_error (GRUB_ERR_BAD_OS, "extension doesn't contain suitable architecture"); } if (grub_xnu_is_64bit) machosize = grub_macho_filesize64 (macho); else machosize = grub_macho_filesize32 (macho); neededspace += machosize; } else macho = 0; if (infoplistname) infoplist = grub_file_open (infoplistname); else infoplist = 0; grub_errno = GRUB_ERR_NONE; if (infoplist) { infoplistsize = grub_file_size (infoplist); neededspace += infoplistsize + 1; } else infoplistsize = 0; /* Allocate the space. */ err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE); if (err) return err; err = grub_xnu_heap_malloc (neededspace, &buf0, &buf_target); if (err) return err; buf = buf0; exthead = (struct grub_xnu_extheader *) buf; grub_memset (exthead, 0, sizeof (*exthead)); buf += sizeof (*exthead); /* Load the binary. */ if (macho) { exthead->binaryaddr = buf_target + (buf - (grub_uint8_t *) buf0); exthead->binarysize = machosize; if (grub_xnu_is_64bit) err = grub_macho_readfile64 (macho, buf); else err = grub_macho_readfile32 (macho, buf); if (err) { grub_macho_close (macho); return err; } grub_macho_close (macho); buf += machosize; } grub_errno = GRUB_ERR_NONE; /* Load the plist. */ if (infoplist) { exthead->infoplistaddr = buf_target + (buf - (grub_uint8_t *) buf0); exthead->infoplistsize = infoplistsize + 1; if (grub_file_read (infoplist, buf, infoplistsize) != (grub_ssize_t) (infoplistsize)) { grub_file_close (infoplist); if (!grub_errno) grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s: "), infoplistname); return grub_errno; } grub_file_close (infoplist); buf[infoplistsize] = 0; buf += infoplistsize + 1; } grub_errno = GRUB_ERR_NONE; exthead->nameaddr = (buf - (grub_uint8_t *) buf0) + buf_target; exthead->namesize = namelen + 1; grub_memcpy (buf, name, namelen); buf[namelen] = 0; buf += namelen + 1; /* Announce to kernel */ return grub_xnu_register_memory ("Driver-", &driversnum, buf_target, neededspace); } /* Load mkext. */ static grub_err_t grub_cmd_xnu_mkext (grub_command_t cmd __attribute__ ((unused)), int argc, char *args[]) { grub_file_t file; void *loadto; grub_addr_t loadto_target; grub_err_t err; grub_off_t readoff = 0; grub_ssize_t readlen = -1; struct grub_macho_fat_header head; struct grub_macho_fat_arch *archs; int narchs, i; if (argc != 1) return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required"); if (! grub_xnu_heap_size) return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded"); file = grub_file_open (args[0]); if (! file) return grub_errno; /* Sometimes caches are fat binary. Errgh. */ if (grub_file_read (file, &head, sizeof (head)) != (grub_ssize_t) (sizeof (head))) { /* I don't know the internal structure of package but can hardly imagine a valid package shorter than 20 bytes. */ grub_file_close (file); if (!grub_errno) grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"), args[0]); return grub_errno; } /* Find the corresponding architecture. */ if (grub_be_to_cpu32 (head.magic) == GRUB_MACHO_FAT_MAGIC) { narchs = grub_be_to_cpu32 (head.nfat_arch); archs = grub_malloc (sizeof (struct grub_macho_fat_arch) * narchs); if (! archs) { grub_file_close (file); return grub_errno; } if (grub_file_read (file, archs, sizeof (struct grub_macho_fat_arch) * narchs) != (grub_ssize_t) sizeof(struct grub_macho_fat_arch) * narchs) { grub_free (archs); if (!grub_errno) grub_error (GRUB_ERR_READ_ERROR, N_("premature end of file %s"), args[0]); return grub_errno; } for (i = 0; i < narchs; i++) { if (!grub_xnu_is_64bit && GRUB_MACHO_CPUTYPE_IS_HOST32 (grub_be_to_cpu32 (archs[i].cputype))) { readoff = grub_be_to_cpu32 (archs[i].offset); readlen = grub_be_to_cpu32 (archs[i].size); } if (grub_xnu_is_64bit && GRUB_MACHO_CPUTYPE_IS_HOST64 (grub_be_to_cpu32 (archs[i].cputype))) { readoff = grub_be_to_cpu32 (archs[i].offset); readlen = grub_be_to_cpu32 (archs[i].size); } } grub_free (archs); } else { /* It's a flat file. Some sane people still exist. */ readoff = 0; readlen = grub_file_size (file); } if (readlen == -1) { grub_file_close (file); return grub_error (GRUB_ERR_BAD_OS, "no suitable architecture is found"); } /* Allocate space. */ err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE); if (err) { grub_file_close (file); return err; } err = grub_xnu_heap_malloc (readlen, &loadto, &loadto_target); if (err) { grub_file_close (file); return err; } /* Read the file. */ grub_file_seek (file, readoff); if (grub_file_read (file, loadto, readlen) != (grub_ssize_t) (readlen)) { grub_file_close (file); if (!grub_errno) grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"), args[0]); return grub_errno; } grub_file_close (file); /* Pass it to kernel. */ return grub_xnu_register_memory ("DriversPackage-", &driverspackagenum, loadto_target, readlen); } static grub_err_t grub_cmd_xnu_ramdisk (grub_command_t cmd __attribute__ ((unused)), int argc, char *args[]) { grub_file_t file; void *loadto; grub_addr_t loadto_target; grub_err_t err; grub_size_t size; if (argc != 1) return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required"); if (! grub_xnu_heap_size) return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded"); file = grub_file_open (args[0]); if (! file) return grub_errno; err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE); if (err) return err; size = grub_file_size (file); err = grub_xnu_heap_malloc (size, &loadto, &loadto_target); if (err) return err; if (grub_file_read (file, loadto, size) != (grub_ssize_t) (size)) { grub_file_close (file); if (!grub_errno) grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"), args[0]); return grub_errno; } return grub_xnu_register_memory ("RAMDisk", 0, loadto_target, size); } /* Returns true if the kext should be loaded according to plist and osbundlereq. Also fill BINNAME. */ static int grub_xnu_check_os_bundle_required (char *plistname, const char *osbundlereq, char **binname) { grub_file_t file; char *buf = 0, *tagstart = 0, *ptr1 = 0, *keyptr = 0; char *stringptr = 0, *ptr2 = 0; grub_size_t size; int depth = 0; int ret; int osbundlekeyfound = 0, binnamekeyfound = 0; if (binname) *binname = 0; file = grub_file_open (plistname); if (! file) return 0; size = grub_file_size (file); buf = grub_malloc (size); if (! buf) { grub_file_close (file); return 0; } if (grub_file_read (file, buf, size) != (grub_ssize_t) (size)) { grub_file_close (file); if (!grub_errno) grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"), plistname); return 0; } grub_file_close (file); /* Set the return value for the case when no OSBundleRequired tag is found. */ if (osbundlereq) ret = grub_strword (osbundlereq, "all") || grub_strword (osbundlereq, "-"); else ret = 1; /* Parse plist. It's quite dirty and inextensible but does its job. */ for (ptr1 = buf; ptr1 < buf + size; ptr1++) switch (*ptr1) { case '<': tagstart = ptr1; *ptr1 = 0; if (keyptr && depth == 4 && grub_strcmp (keyptr, "OSBundleRequired") == 0) osbundlekeyfound = 1; if (keyptr && depth == 4 && grub_strcmp (keyptr, "CFBundleExecutable") == 0) binnamekeyfound = 1; if (stringptr && osbundlekeyfound && osbundlereq && depth == 4) { for (ptr2 = stringptr; *ptr2; ptr2++) *ptr2 = grub_tolower (*ptr2); ret = grub_strword (osbundlereq, stringptr) || grub_strword (osbundlereq, "all"); } if (stringptr && binnamekeyfound && binname && depth == 4) { if (*binname) grub_free (*binname); *binname = grub_strdup (stringptr); } *ptr1 = '<'; keyptr = 0; stringptr = 0; break; case '>': if (! tagstart) { grub_free (buf); grub_error (GRUB_ERR_BAD_OS, "can't parse %s", plistname); return 0; } *ptr1 = 0; if (tagstart[1] == '?' || ptr1[-1] == '/') { osbundlekeyfound = 0; *ptr1 = '>'; break; } if (depth == 3 && grub_strcmp (tagstart + 1, "key") == 0) keyptr = ptr1 + 1; if (depth == 3 && grub_strcmp (tagstart + 1, "string") == 0) stringptr = ptr1 + 1; else if (grub_strcmp (tagstart + 1, "/key") != 0) { osbundlekeyfound = 0; binnamekeyfound = 0; } *ptr1 = '>'; if (tagstart[1] == '/') depth--; else depth++; break; } grub_free (buf); return ret; } /* Load all loadable kexts placed under DIRNAME and matching OSBUNDLEREQUIRED */ grub_err_t grub_xnu_scan_dir_for_kexts (char *dirname, const char *osbundlerequired, int maxrecursion) { grub_device_t dev; char *device_name; grub_fs_t fs; const char *path; auto int load_hook (const char *filename, const struct grub_dirhook_info *info); int load_hook (const char *filename, const struct grub_dirhook_info *info) { char *newdirname; if (! info->dir) return 0; if (filename[0] == '.') return 0; if (grub_strlen (filename) < 5 || grub_memcmp (filename + grub_strlen (filename) - 5, ".kext", 5) != 0) return 0; newdirname = grub_malloc (grub_strlen (dirname) + grub_strlen (filename) + 2); /* It's a .kext. Try to load it. */ if (newdirname) { grub_strcpy (newdirname, dirname); newdirname[grub_strlen (newdirname) + 1] = 0; newdirname[grub_strlen (newdirname)] = '/'; grub_strcpy (newdirname + grub_strlen (newdirname), filename); grub_xnu_load_kext_from_dir (newdirname, osbundlerequired, maxrecursion); if (grub_errno == GRUB_ERR_BAD_OS) grub_errno = GRUB_ERR_NONE; grub_free (newdirname); } return 0; } if (! grub_xnu_heap_size) return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded"); device_name = grub_file_get_device_name (dirname); dev = grub_device_open (device_name); if (dev) { fs = grub_fs_probe (dev); path = grub_strchr (dirname, ')'); if (! path) path = dirname; else path++; if (fs) (fs->dir) (dev, path, load_hook); grub_device_close (dev); } grub_free (device_name); return GRUB_ERR_NONE; } /* Load extension DIRNAME. (extensions are directories in xnu) */ grub_err_t grub_xnu_load_kext_from_dir (char *dirname, const char *osbundlerequired, int maxrecursion) { grub_device_t dev; char *plistname = 0; char *newdirname; char *newpath; char *device_name; grub_fs_t fs; const char *path; char *binsuffix; int usemacos = 0; grub_file_t binfile; auto int load_hook (const char *filename, const struct grub_dirhook_info *info); int load_hook (const char *filename, const struct grub_dirhook_info *info) { if (grub_strlen (filename) > 15) return 0; grub_strcpy (newdirname + grub_strlen (dirname) + 1, filename); /* If the kext contains directory "Contents" all real stuff is in this directory. */ if (info->dir && grub_strcasecmp (filename, "Contents") == 0) grub_xnu_load_kext_from_dir (newdirname, osbundlerequired, maxrecursion - 1); /* Directory "Plugins" contains nested kexts. */ if (info->dir && grub_strcasecmp (filename, "Plugins") == 0) grub_xnu_scan_dir_for_kexts (newdirname, osbundlerequired, maxrecursion - 1); /* Directory "MacOS" contains executable, otherwise executable is on the top. */ if (info->dir && grub_strcasecmp (filename, "MacOS") == 0) usemacos = 1; /* Info.plist is the file which governs our future actions. */ if (! info->dir && grub_strcasecmp (filename, "Info.plist") == 0 && ! plistname) plistname = grub_strdup (newdirname); return 0; } newdirname = grub_malloc (grub_strlen (dirname) + 20); if (! newdirname) return grub_errno; grub_strcpy (newdirname, dirname); newdirname[grub_strlen (dirname)] = '/'; newdirname[grub_strlen (dirname) + 1] = 0; device_name = grub_file_get_device_name (dirname); dev = grub_device_open (device_name); if (dev) { fs = grub_fs_probe (dev); path = grub_strchr (dirname, ')'); if (! path) path = dirname; else path++; newpath = grub_strchr (newdirname, ')'); if (! newpath) newpath = newdirname; else newpath++; /* Look at the directory. */ if (fs) (fs->dir) (dev, path, load_hook); if (plistname && grub_xnu_check_os_bundle_required (plistname, osbundlerequired, &binsuffix)) { if (binsuffix) { /* Open the binary. */ char *binname = grub_malloc (grub_strlen (dirname) + grub_strlen (binsuffix) + sizeof ("/MacOS/")); grub_strcpy (binname, dirname); if (usemacos) grub_strcpy (binname + grub_strlen (binname), "/MacOS/"); else grub_strcpy (binname + grub_strlen (binname), "/"); grub_strcpy (binname + grub_strlen (binname), binsuffix); grub_dprintf ("xnu", "%s:%s\n", plistname, binname); binfile = grub_file_open (binname); if (! binfile) grub_errno = GRUB_ERR_NONE; /* Load the extension. */ grub_xnu_load_driver (plistname, binfile); grub_free (binname); grub_free (binsuffix); } else { grub_dprintf ("xnu", "%s:0\n", plistname); grub_xnu_load_driver (plistname, 0); } } grub_free (plistname); grub_device_close (dev); } grub_free (device_name); return GRUB_ERR_NONE; } static int locked=0; static grub_dl_t my_mod; /* Load the kext. */ static grub_err_t grub_cmd_xnu_kext (grub_command_t cmd __attribute__ ((unused)), int argc, char *args[]) { grub_file_t binfile = 0; if (! grub_xnu_heap_size) return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded"); if (argc == 2) { /* User explicitly specified plist and binary. */ if (grub_strcmp (args[1], "-") != 0) { binfile = grub_file_open (args[1]); if (! binfile) { grub_error (GRUB_ERR_BAD_OS, "can't open file"); return GRUB_ERR_NONE; } } return grub_xnu_load_driver (grub_strcmp (args[0], "-") ? args[0] : 0, binfile); } /* load kext normally. */ if (argc == 1) return grub_xnu_load_kext_from_dir (args[0], 0, 10); return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required"); } /* Load a directory containing kexts. */ static grub_err_t grub_cmd_xnu_kextdir (grub_command_t cmd __attribute__ ((unused)), int argc, char *args[]) { if (argc != 1 && argc != 2) return grub_error (GRUB_ERR_BAD_ARGUMENT, "directory name required"); if (! grub_xnu_heap_size) return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded"); if (argc == 1) return grub_xnu_scan_dir_for_kexts (args[0], "console,root,local-root,network-root", 10); else { char *osbundlerequired = grub_strdup (args[1]), *ptr; grub_err_t err; if (! osbundlerequired) return grub_errno; for (ptr = osbundlerequired; *ptr; ptr++) *ptr = grub_tolower (*ptr); err = grub_xnu_scan_dir_for_kexts (args[0], osbundlerequired, 10); grub_free (osbundlerequired); return err; } } 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; grub_xnu_bitmap_mode_t grub_xnu_bitmap_mode; /* Option array indices. */ #define XNU_SPLASH_CMD_ARGINDEX_MODE 0 static const struct grub_arg_option xnu_splash_cmd_options[] = { {"mode", 'm', 0, N_("Background image mode."), N_("stretch|normal"), ARG_TYPE_STRING}, {0, 0, 0, 0, 0, 0} }; static grub_err_t grub_cmd_xnu_splash (grub_extcmd_context_t ctxt, int argc, char *args[]) { grub_err_t err; if (argc != 1) return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required"); if (! grub_xnu_heap_size) return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded"); if (ctxt->state[XNU_SPLASH_CMD_ARGINDEX_MODE].set && grub_strcmp (ctxt->state[XNU_SPLASH_CMD_ARGINDEX_MODE].arg, "stretch") == 0) grub_xnu_bitmap_mode = GRUB_XNU_BITMAP_STRETCH; else grub_xnu_bitmap_mode = GRUB_XNU_BITMAP_CENTER; err = grub_video_bitmap_load (&grub_xnu_bitmap, args[0]); if (err) grub_xnu_bitmap = 0; return err; } #ifndef GRUB_MACHINE_EMU static grub_err_t grub_cmd_xnu_resume (grub_command_t cmd __attribute__ ((unused)), int argc, char *args[]) { if (argc != 1) return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required"); return grub_xnu_resume (args[0]); } #endif void grub_xnu_lock (void) { if (!locked) grub_dl_ref (my_mod); locked = 1; } void grub_xnu_unlock (void) { if (locked) grub_dl_unref (my_mod); locked = 0; } static grub_command_t cmd_kernel64, cmd_kernel, cmd_mkext, cmd_kext; static grub_command_t cmd_kextdir, cmd_ramdisk, cmd_resume; static grub_extcmd_t cmd_splash; GRUB_MOD_INIT(xnu) { cmd_kernel = grub_register_command ("xnu_kernel", grub_cmd_xnu_kernel, 0, N_("Load XNU image.")); cmd_kernel64 = grub_register_command ("xnu_kernel64", grub_cmd_xnu_kernel64, 0, N_("Load 64-bit XNU image.")); cmd_mkext = grub_register_command ("xnu_mkext", grub_cmd_xnu_mkext, 0, N_("Load XNU extension package.")); cmd_kext = grub_register_command ("xnu_kext", grub_cmd_xnu_kext, 0, N_("Load XNU extension.")); cmd_kextdir = grub_register_command ("xnu_kextdir", grub_cmd_xnu_kextdir, N_("DIRECTORY [OSBundleRequired]"), N_("Load XNU extension directory.")); cmd_ramdisk = grub_register_command ("xnu_ramdisk", grub_cmd_xnu_ramdisk, 0, N_("Load XNU ramdisk. " "It will be seen as md0.")); cmd_splash = grub_register_extcmd ("xnu_splash", grub_cmd_xnu_splash, 0, 0, N_("Load a splash image for XNU."), xnu_splash_cmd_options); #ifndef GRUB_MACHINE_EMU cmd_resume = grub_register_command ("xnu_resume", grub_cmd_xnu_resume, 0, N_("Load XNU hibernate image.")); #endif grub_cpu_xnu_init (); my_mod = mod; } GRUB_MOD_FINI(xnu) { #ifndef GRUB_MACHINE_EMU grub_unregister_command (cmd_resume); #endif grub_unregister_command (cmd_mkext); grub_unregister_command (cmd_kext); grub_unregister_command (cmd_kextdir); grub_unregister_command (cmd_ramdisk); grub_unregister_command (cmd_kernel); grub_unregister_extcmd (cmd_splash); grub_unregister_command (cmd_kernel64); grub_cpu_xnu_fini (); }