static grub_err_t
grub_cmd_chain (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_err_t err;
grub_file_t file;
grub_elf_t elf;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_loader_unset ();
file = grub_file_open (argv[0]);
if (!file)
return grub_errno;
relocator = grub_relocator_new ();
if (!relocator)
{
grub_file_close (file);
return grub_errno;
}
elf = grub_elf_file (file, argv[0]);
if (!elf)
{
grub_relocator_unload (relocator);
relocator = 0;
grub_file_close (file);
}
if (!grub_elf_is_elf32 (elf))
{
grub_relocator_unload (relocator);
relocator = 0;
grub_elf_close (elf);
}
entry = elf->ehdr.ehdr32.e_entry & 0xFFFFFF;
err = grub_elf32_load (elf, argv[0], grub_chain_elf32_hook, 0, 0);
grub_elf_close (elf);
if (err)
return err;
grub_loader_set (grub_chain_boot, grub_chain_unload, 0);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_cmd_appleloader (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_efi_boot_services_t *b;
grub_efi_loaded_image_t *loaded_image;
struct devdata *pdev;
grub_dl_ref (my_mod);
/* Initialize some global variables. */
image_handle = 0;
b = grub_efi_system_table->boot_services;
for (pdev = devs ; pdev->devpath ; pdev++)
if (efi_call_6 (b->load_image, 0, grub_efi_image_handle, pdev->devpath,
NULL, 0, &image_handle) == GRUB_EFI_SUCCESS)
break;
if (! pdev->devpath)
{
grub_error (GRUB_ERR_BAD_OS, "can't find model");
goto fail;
}
grub_dprintf ("appleload", "Model: %s\n", pdev->model);
loaded_image = grub_efi_get_loaded_image (image_handle);
if (! loaded_image)
{
grub_error (GRUB_ERR_BAD_OS, "no loaded image available");
goto fail;
}
if (argc > 0)
{
int i, len;
grub_efi_char16_t *p16;
for (i = 0, len = 0; i < argc; i++)
len += grub_strlen (argv[i]) + 1;
len *= sizeof (grub_efi_char16_t);
cmdline = p16 = grub_malloc (len);
if (! cmdline)
goto fail;
for (i = 0; i < argc; i++)
{
char *p8;
p8 = argv[i];
while (*p8)
*(p16++) = *(p8++);
*(p16++) = ' ';
}
*(--p16) = 0;
loaded_image->load_options = cmdline;
loaded_image->load_options_size = len;
}
grub_loader_set (grub_appleloader_boot, grub_appleloader_unload, 0);
return 0;
fail:
grub_dl_unref (my_mod);
return grub_errno;
}
static grub_err_t
grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_file_t file = 0;
struct linux_kernel_header lh;
grub_ssize_t len, start, filelen;
void *kernel = NULL;
grub_dl_ref (my_mod);
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
file = grub_file_open (argv[0]);
if (! file)
goto fail;
filelen = grub_file_size (file);
kernel = grub_malloc(filelen);
if (!kernel)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("cannot allocate kernel buffer"));
goto fail;
}
if (grub_file_read (file, kernel, filelen) != filelen)
{
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("Can't read kernel %s"), argv[0]);
goto fail;
}
grub_tpm_measure (kernel, filelen, GRUB_KERNEL_PCR);
if (! grub_linuxefi_secure_validate (kernel, filelen))
{
grub_error (GRUB_ERR_INVALID_COMMAND, N_("%s has invalid signature"), argv[0]);
grub_free (kernel);
goto fail;
}
params = grub_efi_allocate_pages_max (0x3fffffff, BYTES_TO_PAGES(16384));
if (! params)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot allocate kernel parameters");
goto fail;
}
grub_memset (params, 0, 16384);
grub_memcpy (&lh, kernel, sizeof (lh));
if (lh.boot_flag != grub_cpu_to_le16 (0xaa55))
{
grub_error (GRUB_ERR_BAD_OS, N_("invalid magic number"));
goto fail;
}
if (lh.setup_sects > GRUB_LINUX_MAX_SETUP_SECTS)
{
grub_error (GRUB_ERR_BAD_OS, N_("too many setup sectors"));
goto fail;
}
if (lh.version < grub_cpu_to_le16 (0x020b))
{
grub_error (GRUB_ERR_BAD_OS, N_("kernel too old"));
goto fail;
}
if (!lh.handover_offset)
{
grub_error (GRUB_ERR_BAD_OS, N_("kernel doesn't support EFI handover"));
goto fail;
}
linux_cmdline = grub_efi_allocate_pages_max(0x3fffffff,
BYTES_TO_PAGES(lh.cmdline_size + 1));
if (!linux_cmdline)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("can't allocate cmdline"));
goto fail;
}
grub_memcpy (linux_cmdline, LINUX_IMAGE, sizeof (LINUX_IMAGE));
grub_create_loader_cmdline (argc, argv,
linux_cmdline + sizeof (LINUX_IMAGE) - 1,
lh.cmdline_size - (sizeof (LINUX_IMAGE) - 1));
grub_pass_verity_hash(&lh, linux_cmdline);
lh.cmd_line_ptr = (grub_uint32_t)(grub_uint64_t)linux_cmdline;
handover_offset = lh.handover_offset;
start = (lh.setup_sects + 1) * 512;
len = grub_file_size(file) - start;
kernel_mem = grub_efi_allocate_pages(lh.pref_address,
BYTES_TO_PAGES(lh.init_size));
if (!kernel_mem)
kernel_mem = grub_efi_allocate_pages_max(0x3fffffff,
BYTES_TO_PAGES(lh.init_size));
if (!kernel_mem)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("can't allocate kernel"));
goto fail;
}
grub_memcpy (kernel_mem, (char *)kernel + start, len);
grub_loader_set (grub_linuxefi_boot, grub_linuxefi_unload, 0);
loaded=1;
lh.code32_start = (grub_uint32_t)(grub_uint64_t) kernel_mem;
grub_memcpy (params, &lh, 2 * 512);
params->type_of_loader = 0x21;
fail:
if (file)
grub_file_close (file);
if (kernel)
grub_free (kernel);
if (grub_errno != GRUB_ERR_NONE)
{
grub_dl_unref (my_mod);
loaded = 0;
}
if (linux_cmdline && !loaded)
grub_efi_free_pages((grub_efi_physical_address_t)linux_cmdline, BYTES_TO_PAGES(lh.cmdline_size + 1));
if (kernel_mem && !loaded)
grub_efi_free_pages((grub_efi_physical_address_t)kernel_mem, BYTES_TO_PAGES(kernel_size));
if (params && !loaded)
grub_efi_free_pages((grub_efi_physical_address_t)params, BYTES_TO_PAGES(16384));
return grub_errno;
}
static grub_err_t
grub_cmd_multiboot (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_file_t file = 0;
grub_err_t err;
grub_loader_unset ();
highest_load = 0;
#ifndef GRUB_USE_MULTIBOOT2
grub_multiboot_quirks = GRUB_MULTIBOOT_QUIRKS_NONE;
int option_found = 0;
do
{
option_found = 0;
if (argc != 0 && grub_strcmp (argv[0], "--quirk-bad-kludge") == 0)
{
argc--;
argv++;
option_found = 1;
grub_multiboot_quirks |= GRUB_MULTIBOOT_QUIRK_BAD_KLUDGE;
}
if (argc != 0 && grub_strcmp (argv[0], "--quirk-modules-after-kernel") == 0)
{
argc--;
argv++;
option_found = 1;
grub_multiboot_quirks |= GRUB_MULTIBOOT_QUIRK_MODULES_AFTER_KERNEL;
}
} while (option_found);
#endif
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
file = grub_file_open (argv[0]);
if (! file)
return grub_errno;
grub_dl_ref (my_mod);
/* Skip filename. */
grub_multiboot_init_mbi (argc - 1, argv + 1);
grub_relocator_unload (grub_multiboot_relocator);
grub_multiboot_relocator = grub_relocator_new ();
if (!grub_multiboot_relocator)
goto fail;
err = grub_multiboot_load (file, argv[0]);
if (err)
goto fail;
grub_multiboot_set_bootdev ();
grub_loader_set (grub_multiboot_boot, grub_multiboot_unload, 0);
fail:
if (file)
grub_file_close (file);
if (grub_errno != GRUB_ERR_NONE)
{
grub_relocator_unload (grub_multiboot_relocator);
grub_multiboot_relocator = NULL;
grub_dl_unref (my_mod);
} else {
/* Begin TCG Extension */
grub_TPM_measure_file( argv[0], TPM_LOADER_MEASUREMENT_PCR );
/* End TCG Extension */
}
return grub_errno;
}
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, *loadaddr;
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);
loadaddr = grub_xnu_heap_malloc (endcode - startcode);
grub_xnu_heap_will_be_at = startcode;
if (! loadaddr)
{
grub_macho_close (macho);
grub_xnu_unload ();
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"not enough memory to load kernel");
}
/* Load kernel. */
err = grub_macho_load64 (macho, 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;
grub_loader_set (grub_xnu_boot, grub_xnu_unload, 0);
grub_xnu_lock ();
grub_xnu_is_64bit = 1;
return 0;
}
static void
grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
{
grub_file_t file = 0;
grub_uint16_t signature;
grub_device_t dev;
int drive = -1;
void *part_addr = 0;
grub_dl_ref (my_mod);
file = grub_file_open (filename);
if (! file)
goto fail;
/* Read the first block. */
if (grub_file_read (file, (void *) 0x7C00, GRUB_DISK_SECTOR_SIZE)
!= GRUB_DISK_SECTOR_SIZE)
{
if (grub_errno == GRUB_ERR_NONE)
grub_error (GRUB_ERR_BAD_OS, "too small");
goto fail;
}
/* Check the signature. */
signature = *((grub_uint16_t *) (0x7C00 + GRUB_DISK_SECTOR_SIZE - 2));
if (signature != grub_le_to_cpu16 (0xaa55)
&& ! (flags & GRUB_CHAINLOADER_FORCE))
{
grub_error (GRUB_ERR_BAD_OS, "invalid signature");
goto fail;
}
grub_file_close (file);
/* Obtain the partition table from the root device. */
drive = grub_get_root_biosnumber ();
dev = grub_device_open (0);
if (dev && dev->disk && dev->disk->partition)
{
grub_disk_t disk = dev->disk;
if (disk)
{
grub_partition_t p = disk->partition;
if (p && grub_strcmp (p->partmap->name, "msdos") == 0)
{
disk->partition = p->parent;
grub_disk_read (disk, p->offset, 446, 64,
(void *) GRUB_MEMORY_MACHINE_PART_TABLE_ADDR);
part_addr = (void *) (GRUB_MEMORY_MACHINE_PART_TABLE_ADDR
+ (p->index << 4));
disk->partition = p;
}
}
}
if (dev)
grub_device_close (dev);
/* Ignore errors. Perhaps it's not fatal. */
grub_errno = GRUB_ERR_NONE;
boot_drive = drive;
boot_part_addr = part_addr;
grub_loader_set (grub_chainloader_boot, grub_chainloader_unload, 1);
return;
fail:
if (file)
grub_file_close (file);
grub_dl_unref (my_mod);
}
static grub_err_t
grub_cmd_ntldr (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_file_t file = 0;
grub_err_t err;
void *bs, *ntldr;
grub_size_t ntldrsize;
grub_device_t dev;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
grub_dl_ref (my_mod);
rel = grub_relocator_new ();
if (!rel)
goto fail;
file = grub_file_open (argv[0]);
if (! file)
goto fail;
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (rel, &ch, 0x7C00,
GRUB_DISK_SECTOR_SIZE);
if (err)
goto fail;
bs = get_virtual_current_address (ch);
}
edx = grub_get_root_biosnumber ();
dev = grub_device_open (0);
if (dev && dev->disk)
{
err = grub_disk_read (dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, bs);
if (err)
{
grub_device_close (dev);
goto fail;
}
}
if (dev)
grub_device_close (dev);
ntldrsize = grub_file_size (file);
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (rel, &ch, GRUB_NTLDR_SEGMENT << 4,
ntldrsize);
if (err)
goto fail;
ntldr = get_virtual_current_address (ch);
}
if (grub_file_read (file, ntldr, ntldrsize)
!= (grub_ssize_t) ntldrsize)
goto fail;
grub_loader_set (grub_ntldr_boot, grub_ntldr_unload, 1);
return GRUB_ERR_NONE;
fail:
if (file)
grub_file_close (file);
grub_ntldr_unload ();
return grub_errno;
}
static grub_err_t
grub_cmd_pxechain (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_file_t file = 0;
grub_err_t err;
void *image;
grub_size_t imagesize;
char *fname;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_dl_ref (my_mod);
rel = grub_relocator_new ();
if (!rel)
goto fail;
file = grub_file_open (argv[0]);
if (! file)
goto fail;
if (file->device->net && file->device->net->name)
fname = file->device->net->name;
else
{
fname = argv[0];
if (fname[0] == '(')
{
fname = grub_strchr (fname, ')');
if (fname)
fname++;
else
fname = argv[0];
}
}
grub_memset (boot_file, 0, sizeof (boot_file));
grub_strncpy (boot_file, fname, sizeof (boot_file));
grub_memset (server_name, 0, sizeof (server_name));
if (file->device->net && file->device->net->server)
grub_strncpy (server_name, file->device->net->server, sizeof (server_name));
edx = grub_get_root_biosnumber ();
imagesize = grub_file_size (file);
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (rel, &ch, 0x7c00, imagesize);
if (err)
goto fail;
image = get_virtual_current_address (ch);
}
if (grub_file_read (file, image, imagesize) != (grub_ssize_t) imagesize)
goto fail;
grub_loader_set (grub_pxechain_boot, grub_pxechain_unload,
GRUB_LOADER_FLAG_NORETURN | GRUB_LOADER_FLAG_PXE_NOT_UNLOAD);
return GRUB_ERR_NONE;
fail:
if (file)
grub_file_close (file);
grub_pxechain_unload ();
return grub_errno;
}
static grub_err_t
grub_cmd_freedos (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_file_t file = 0;
grub_err_t err;
void *bs, *kernelsys;
grub_size_t kernelsyssize;
grub_device_t dev;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_dl_ref (my_mod);
rel = grub_relocator_new ();
if (!rel)
goto fail;
file = grub_file_open (argv[0]);
if (! file)
goto fail;
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (rel, &ch, GRUB_FREEDOS_BPB_ADDR,
GRUB_DISK_SECTOR_SIZE);
if (err)
goto fail;
bs = get_virtual_current_address (ch);
}
ebx = grub_get_root_biosnumber ();
dev = grub_device_open (0);
if (dev && dev->disk)
{
err = grub_disk_read (dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, bs);
if (err)
{
grub_device_close (dev);
goto fail;
}
grub_chainloader_patch_bpb (bs, dev, ebx);
}
if (dev)
grub_device_close (dev);
kernelsyssize = grub_file_size (file);
if (kernelsyssize > GRUB_FREEDOS_MAX_SIZE)
{
grub_error (GRUB_ERR_BAD_OS,
N_("the size of `%s' is too large"), argv[0]);
goto fail;
}
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (rel, &ch, GRUB_FREEDOS_ADDR,
kernelsyssize);
if (err)
goto fail;
kernelsys = get_virtual_current_address (ch);
}
if (grub_file_read (file, kernelsys, kernelsyssize)
!= (grub_ssize_t) kernelsyssize)
goto fail;
grub_loader_set (grub_freedos_boot, grub_freedos_unload, 1);
return GRUB_ERR_NONE;
fail:
if (file)
grub_file_close (file);
grub_freedos_unload ();
return grub_errno;
}
static grub_err_t
grub_cmd_ntldr (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_file_t file = 0;
grub_err_t err;
void *bs, *ntldr;
grub_size_t ntldrsize;
grub_device_t dev;
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
grub_dl_ref (my_mod);
rel = grub_relocator_new ();
if (!rel)
goto fail;
file = grub_file_open (argv[0]);
if (! file)
goto fail;
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (rel, &ch, 0x7C00,
GRUB_DISK_SECTOR_SIZE);
if (err)
goto fail;
bs = get_virtual_current_address (ch);
}
edx = grub_get_root_biosnumber ();
dev = grub_device_open (0);
if (dev && dev->disk)
{
err = grub_disk_read (dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, bs);
if (err)
{
grub_device_close (dev);
goto fail;
}
grub_chainloader_patch_bpb (bs, dev, edx);
}
if (dev)
grub_device_close (dev);
ntldrsize = grub_file_size (file);
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (rel, &ch, GRUB_NTLDR_SEGMENT << 4,
ntldrsize);
if (err)
goto fail;
ntldr = get_virtual_current_address (ch);
}
if (grub_file_read (file, ntldr, ntldrsize)
!= (grub_ssize_t) ntldrsize)
goto fail;
grub_loader_set (grub_ntldr_boot, grub_ntldr_unload, 1);
/* Begin TCG Extension */
if (grub_TPM_isAvailable())
grub_TPM_measureFile( argv[0], TPM_LOADED_FILES_PCR );
/* End TCG Extension */
return GRUB_ERR_NONE;
fail:
if (file)
grub_file_close (file);
grub_ntldr_unload ();
return grub_errno;
}
void
grub_multiboot2 (int argc, char *argv[])
{
char *buffer;
grub_file_t file = 0;
grub_elf_t elf = 0;
struct multiboot_header *header = 0;
char *p;
grub_ssize_t len;
grub_err_t err;
int header_found = 0;
grub_loader_unset ();
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "No kernel specified");
goto fail;
}
file = grub_gzfile_open (argv[0], 1);
if (! file)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "Couldn't open file");
goto fail;
}
buffer = grub_malloc (MULTIBOOT2_HEADER_SEARCH);
if (! buffer)
return;
len = grub_file_read (file, buffer, MULTIBOOT2_HEADER_SEARCH);
if (len < 32)
{
grub_error (GRUB_ERR_BAD_OS, "File too small");
goto fail;
}
/* Look for the multiboot header in the buffer. The header should
be at least 8 bytes and aligned on a 8-byte boundary. */
for (p = buffer; p <= buffer + len - 8; p += 8)
{
header = (struct multiboot_header *) p;
if (header->magic == MULTIBOOT2_HEADER_MAGIC)
{
header_found = 1;
break;
}
}
if (! header_found)
grub_dprintf ("loader", "No multiboot 2 header found.\n");
/* Create the basic tags. */
grub_dprintf ("loader", "Creating multiboot 2 tags\n");
grub_mb2_tags_create ();
/* Load the kernel and create its tag. */
elf = grub_elf_file (file);
if (elf)
{
grub_dprintf ("loader", "Loading ELF multiboot 2 file.\n");
err = grub_mb2_load_elf (elf, argc-1, &argv[1]);
grub_elf_close (elf);
}
else
{
grub_errno = 0;
grub_dprintf ("loader", "Loading non-ELF multiboot 2 file.\n");
if (header)
err = grub_mb2_load_other (file, header);
else
err = grub_error (GRUB_ERR_BAD_OS,
"Need multiboot 2 header to load non-ELF files.");
grub_file_close (file);
}
grub_free (buffer);
if (err)
goto fail;
/* Good to go. */
grub_loader_set (grub_mb2_boot, grub_mb2_unload, 1);
return;
fail:
grub_mb2_tags_free ();
grub_dl_unref (my_mod);
}