--- /dev/null
+ /*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2007,2008,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 <http://www.gnu.org/licenses/>.
+ */
+
+ #include <grub/machine/memory.h>
+ #include <grub/memory.h>
+ #ifdef GRUB_MACHINE_PCBIOS
+ #include <grub/machine/biosnum.h>
+ #endif
+ #include <grub/multiboot.h>
+ #include <grub/cpu/relocator.h>
+ #include <grub/disk.h>
+ #include <grub/device.h>
+ #include <grub/partition.h>
+ #include <grub/mm.h>
+ #include <grub/misc.h>
+ #include <grub/env.h>
+ #include <grub/relocator.h>
+ #include <grub/video.h>
+ #include <grub/file.h>
+
+ /* The bits in the required part of flags field we don't support. */
+ #define UNSUPPORTED_FLAGS 0x0000fff8
+
+ struct module
+ {
+ struct module *next;
+ grub_addr_t start;
+ grub_size_t size;
+ char *cmdline;
+ int cmdline_size;
+ };
+
+ struct module *modules, *modules_last;
+ static grub_size_t cmdline_size;
+ static grub_size_t total_modcmd;
+ static unsigned modcnt;
+ static char *cmdline = NULL;
+ static grub_uint32_t bootdev;
+ static int bootdev_set;
+ static grub_size_t elf_sec_num, elf_sec_entsize;
+ static unsigned elf_sec_shstrndx;
+ static void *elf_sections;
+
+
+ grub_err_t
+ grub_multiboot_load (grub_file_t file)
+ {
+ char *buffer;
+ grub_ssize_t len;
+ struct multiboot_header *header;
+ grub_err_t err;
+
+ buffer = grub_malloc (MULTIBOOT_SEARCH);
+ if (!buffer)
+ return grub_errno;
+
+ len = grub_file_read (file, buffer, MULTIBOOT_SEARCH);
+ if (len < 32)
+ {
+ grub_free (buffer);
+ return grub_error (GRUB_ERR_BAD_OS, "file too small");
+ }
+
+ /* Look for the multiboot header in the buffer. The header should
+ be at least 12 bytes and aligned on a 4-byte boundary. */
+ for (header = (struct multiboot_header *) buffer;
+ ((char *) header <= buffer + len - 12) || (header = 0);
+ header = (struct multiboot_header *) ((char *) header + MULTIBOOT_HEADER_ALIGN))
+ {
+ if (header->magic == MULTIBOOT_HEADER_MAGIC
+ && !(header->magic + header->flags + header->checksum))
+ break;
+ }
+
+ if (header == 0)
+ {
+ grub_free (buffer);
+ return grub_error (GRUB_ERR_BAD_ARGUMENT, "no multiboot header found");
+ }
+
+ if (header->flags & UNSUPPORTED_FLAGS)
+ {
+ grub_free (buffer);
+ return grub_error (GRUB_ERR_UNKNOWN_OS,
+ "unsupported flag: 0x%x", header->flags);
+ }
+
+ if (header->flags & MULTIBOOT_AOUT_KLUDGE)
+ {
+ int offset = ((char *) header - buffer -
+ (header->header_addr - header->load_addr));
+ int load_size = ((header->load_end_addr == 0) ? file->size - offset :
+ header->load_end_addr - header->load_addr);
+ grub_size_t code_size;
+ void *source;
+ grub_relocator_chunk_t ch;
+
+ if (header->bss_end_addr)
+ code_size = (header->bss_end_addr - header->load_addr);
+ else
+ code_size = load_size;
+
+ err = grub_relocator_alloc_chunk_addr (grub_multiboot_relocator,
+ &ch, header->load_addr,
+ code_size);
+ if (err)
+ {
+ grub_dprintf ("multiboot_loader", "Error loading aout kludge\n");
+ grub_free (buffer);
+ return err;
+ }
+ source = get_virtual_current_address (ch);
+
+ if ((grub_file_seek (file, offset)) == (grub_off_t) -1)
+ {
+ grub_free (buffer);
+ return grub_errno;
+ }
+
+ grub_file_read (file, source, load_size);
+ if (grub_errno)
+ {
+ grub_free (buffer);
+ return grub_errno;
+ }
+
+ if (header->bss_end_addr)
+ grub_memset ((grub_uint32_t *) source + load_size, 0,
+ header->bss_end_addr - header->load_addr - load_size);
+
+ grub_multiboot_payload_eip = header->entry_addr;
+ }
+ else
+ {
+ err = grub_multiboot_load_elf (file, buffer);
+ if (err)
+ {
+ grub_free (buffer);
+ return err;
+ }
+ }
+
+ if (header->flags & MULTIBOOT_VIDEO_MODE)
+ {
+ switch (header->mode_type)
+ {
+ case 1:
+ err = grub_multiboot_set_console (GRUB_MULTIBOOT_CONSOLE_EGA_TEXT,
+ GRUB_MULTIBOOT_CONSOLE_EGA_TEXT
+ | GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER,
+ 0, 0, 0, 0);
+ break;
+ case 0:
+ err = grub_multiboot_set_console (GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER,
+ GRUB_MULTIBOOT_CONSOLE_EGA_TEXT
+ | GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER,
+ header->width, header->height,
+ header->depth, 0);
+ break;
+ default:
+ err = grub_error (GRUB_ERR_BAD_OS,
+ "unsupported graphical mode type %d",
+ header->mode_type);
+ break;
+ }
+ }
+ else
+ err = grub_multiboot_set_console (GRUB_MULTIBOOT_CONSOLE_EGA_TEXT,
+ GRUB_MULTIBOOT_CONSOLE_EGA_TEXT,
+ 0, 0, 0, 0);
+ return err;
+ }
+
+ static grub_size_t
+ grub_multiboot_get_mbi_size (void)
+ {
+ return sizeof (struct multiboot_info) + ALIGN_UP (cmdline_size, 4)
+ + modcnt * sizeof (struct multiboot_mod_list) + total_modcmd
+ + ALIGN_UP (sizeof(PACKAGE_STRING), 4)
+ + grub_get_multiboot_mmap_count () * sizeof (struct multiboot_mmap_entry)
+ + elf_sec_entsize * elf_sec_num
++#if HAS_VBE
++ + sizeof (struct grub_vbe_info_block)
++ + sizeof (struct grub_vbe_mode_info_block)
++#endif
+ + 256 * sizeof (struct multiboot_color);
+ }
+
+ /* Fill previously allocated Multiboot mmap. */
+ static void
+ grub_fill_multiboot_mmap (struct multiboot_mmap_entry *first_entry)
+ {
+ struct multiboot_mmap_entry *mmap_entry = (struct multiboot_mmap_entry *) first_entry;
+
+ auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
+ int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size, grub_uint32_t type)
+ {
+ mmap_entry->addr = addr;
+ mmap_entry->len = size;
+ switch (type)
+ {
+ case GRUB_MACHINE_MEMORY_AVAILABLE:
+ mmap_entry->type = MULTIBOOT_MEMORY_AVAILABLE;
+ break;
+
+ #ifdef GRUB_MACHINE_MEMORY_ACPI_RECLAIMABLE
+ case GRUB_MACHINE_MEMORY_ACPI_RECLAIMABLE:
+ mmap_entry->type = MULTIBOOT_MEMORY_ACPI_RECLAIMABLE;
+ break;
+ #endif
+
+ #ifdef GRUB_MACHINE_MEMORY_NVS
+ case GRUB_MACHINE_MEMORY_NVS:
+ mmap_entry->type = MULTIBOOT_MEMORY_NVS;
+ break;
+ #endif
+
+ default:
+ mmap_entry->type = MULTIBOOT_MEMORY_RESERVED;
+ break;
+ }
+ mmap_entry->size = sizeof (struct multiboot_mmap_entry) - sizeof (mmap_entry->size);
+ mmap_entry++;
+
+ return 0;
+ }
+
+ grub_mmap_iterate (hook);
+ }
+
++#if HAS_VBE
++static grub_err_t
++fill_vbe_info (struct multiboot_info *mbi, grub_uint8_t *ptrorig,
++ grub_uint32_t ptrdest, int fill_generic)
++{
++ grub_vbe_status_t status;
++ grub_uint32_t vbe_mode;
++ void *scratch = (void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
++ struct grub_vbe_mode_info_block *mode_info;
++
++ status = grub_vbe_bios_get_controller_info (scratch);
++ if (status != GRUB_VBE_STATUS_OK)
++ return grub_error (GRUB_ERR_IO, "Can't get controller info.");
++
++ mbi->vbe_control_info = ptrdest;
++ grub_memcpy (ptrorig, scratch, sizeof (struct grub_vbe_info_block));
++ ptrorig += sizeof (struct grub_vbe_info_block);
++ ptrdest += sizeof (struct grub_vbe_info_block);
++
++ status = grub_vbe_bios_get_mode (scratch);
++ vbe_mode = *(grub_uint32_t *) scratch;
++ if (status != GRUB_VBE_STATUS_OK)
++ return grub_error (GRUB_ERR_IO, "can't get VBE mode");
++ mbi->vbe_mode = vbe_mode;
++
++ mode_info = (struct grub_vbe_mode_info_block *) ptrorig;
++ mbi->vbe_mode_info = ptrdest;
++ /* get_mode_info isn't available for mode 3. */
++ if (vbe_mode == 3)
++ {
++ grub_memset (mode_info, 0, sizeof (struct grub_vbe_mode_info_block));
++ mode_info->memory_model = GRUB_VBE_MEMORY_MODEL_TEXT;
++ mode_info->x_resolution = 80;
++ mode_info->y_resolution = 25;
++ }
++ else
++ {
++ status = grub_vbe_bios_get_mode_info (vbe_mode, scratch);
++ if (status != GRUB_VBE_STATUS_OK)
++ return grub_error (GRUB_ERR_IO, "can't get mode info");
++ grub_memcpy (mode_info, scratch,
++ sizeof (struct grub_vbe_mode_info_block));
++ }
++ ptrorig += sizeof (struct grub_vbe_mode_info_block);
++ ptrdest += sizeof (struct grub_vbe_mode_info_block);
++
++ /* FIXME: retrieve those. */
++ mbi->vbe_interface_seg = 0;
++ mbi->vbe_interface_off = 0;
++ mbi->vbe_interface_len = 0;
++
++ mbi->flags |= MULTIBOOT_INFO_VBE_INFO;
++
++ if (fill_generic && mode_info->memory_model == GRUB_VBE_MEMORY_MODEL_TEXT)
++ {
++ mbi->framebuffer_addr = 0xb8000;
++
++ mbi->framebuffer_pitch = 2 * mode_info->x_resolution;
++ mbi->framebuffer_width = mode_info->x_resolution;
++ mbi->framebuffer_height = mode_info->y_resolution;
++
++ mbi->framebuffer_bpp = 16;
++
++ mbi->framebuffer_type = MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT;
++
++ mbi->flags |= MULTIBOOT_INFO_FRAMEBUFFER_INFO;
++ }
++
++ return GRUB_ERR_NONE;
++}
++#endif
++
+ static grub_err_t
+ retrieve_video_parameters (struct multiboot_info *mbi,
+ grub_uint8_t *ptrorig, grub_uint32_t ptrdest)
+ {
+ grub_err_t err;
+ struct grub_video_mode_info mode_info;
+ void *framebuffer;
+ grub_video_driver_id_t driv_id;
+ struct grub_video_palette_data palette[256];
+
+ err = grub_multiboot_set_video_mode ();
+ if (err)
+ {
+ grub_print_error ();
+ grub_errno = GRUB_ERR_NONE;
+ }
+
+ grub_video_get_palette (0, ARRAY_SIZE (palette), palette);
+
+ driv_id = grub_video_get_driver_id ();
++#if GRUB_MACHINE_HAS_VGA_TEXT
++ if (driv_id == GRUB_VIDEO_DRIVER_NONE)
++ return fill_vbe_info (mbi, ptrorig, ptrdest, 1);
++#else
+ if (driv_id == GRUB_VIDEO_DRIVER_NONE)
+ return GRUB_ERR_NONE;
++#endif
+
+ err = grub_video_get_info_and_fini (&mode_info, &framebuffer);
+ if (err)
+ return err;
+
+ mbi->framebuffer_addr = (grub_addr_t) framebuffer;
+ mbi->framebuffer_pitch = mode_info.pitch;
+
+ mbi->framebuffer_width = mode_info.width;
+ mbi->framebuffer_height = mode_info.height;
+
+ mbi->framebuffer_bpp = mode_info.bpp;
+
+ if (mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)
+ {
+ struct multiboot_color *mb_palette;
+ unsigned i;
+ mbi->framebuffer_type = MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED;
+ mbi->framebuffer_palette_addr = ptrdest;
+ mbi->framebuffer_palette_num_colors = mode_info.number_of_colors;
+ if (mbi->framebuffer_palette_num_colors > ARRAY_SIZE (palette))
+ mbi->framebuffer_palette_num_colors = ARRAY_SIZE (palette);
+ mb_palette = (struct multiboot_color *) ptrorig;
+ for (i = 0; i < mbi->framebuffer_palette_num_colors; i++)
+ {
+ mb_palette[i].red = palette[i].r;
+ mb_palette[i].green = palette[i].g;
+ mb_palette[i].blue = palette[i].b;
+ }
+ ptrorig += mbi->framebuffer_palette_num_colors
+ * sizeof (struct multiboot_color);
+ ptrdest += mbi->framebuffer_palette_num_colors
+ * sizeof (struct multiboot_color);
+ }
+ else
+ {
+ mbi->framebuffer_type = MULTIBOOT_FRAMEBUFFER_TYPE_RGB;
+ mbi->framebuffer_red_field_position = mode_info.red_field_pos;
+ mbi->framebuffer_red_mask_size = mode_info.red_mask_size;
+ mbi->framebuffer_green_field_position = mode_info.green_field_pos;
+ mbi->framebuffer_green_mask_size = mode_info.green_mask_size;
+ mbi->framebuffer_blue_field_position = mode_info.blue_field_pos;
+ mbi->framebuffer_blue_mask_size = mode_info.blue_mask_size;
+ }
+
+ mbi->flags |= MULTIBOOT_INFO_FRAMEBUFFER_INFO;
+
++#if GRUB_MACHINE_HAS_VBE
++ if (driv_id == GRUB_VIDEO_DRIVER_VBE)
++ return fill_vbe_info (mbi, ptrorig, ptrdest, 0);
++#endif
++
+ return GRUB_ERR_NONE;
+ }
+
+ grub_err_t
+ grub_multiboot_make_mbi (grub_uint32_t *target)
+ {
+ struct multiboot_info *mbi;
+ struct multiboot_mod_list *modlist;
+ unsigned i;
+ struct module *cur;
+ grub_size_t mmap_size;
+ grub_uint8_t *ptrorig;
+ grub_addr_t ptrdest;
+
+ grub_err_t err;
+ grub_size_t bufsize;
+ grub_relocator_chunk_t ch;
+
+ bufsize = grub_multiboot_get_mbi_size ();
+
+ err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator, &ch,
+ 0, 0xffffffff - bufsize,
+ bufsize, 4,
+ GRUB_RELOCATOR_PREFERENCE_NONE);
+ if (err)
+ return err;
+ ptrorig = get_virtual_current_address (ch);
+ ptrdest = (grub_addr_t) get_virtual_current_address (ch);
+
+ *target = ptrdest;
+
+ mbi = (struct multiboot_info *) ptrorig;
+ ptrorig += sizeof (*mbi);
+ ptrdest += sizeof (*mbi);
+ grub_memset (mbi, 0, sizeof (*mbi));
+
+ grub_memcpy (ptrorig, cmdline, cmdline_size);
+ mbi->flags |= MULTIBOOT_INFO_CMDLINE;
+ mbi->cmdline = ptrdest;
+ ptrorig += ALIGN_UP (cmdline_size, 4);
+ ptrdest += ALIGN_UP (cmdline_size, 4);
+
+ grub_memcpy (ptrorig, PACKAGE_STRING, sizeof(PACKAGE_STRING));
+ mbi->flags |= MULTIBOOT_INFO_BOOT_LOADER_NAME;
+ mbi->boot_loader_name = ptrdest;
+ ptrorig += ALIGN_UP (sizeof(PACKAGE_STRING), 4);
+ ptrdest += ALIGN_UP (sizeof(PACKAGE_STRING), 4);
+
+ if (modcnt)
+ {
+ mbi->flags |= MULTIBOOT_INFO_MODS;
+ mbi->mods_addr = ptrdest;
+ mbi->mods_count = modcnt;
+ modlist = (struct multiboot_mod_list *) ptrorig;
+ ptrorig += modcnt * sizeof (struct multiboot_mod_list);
+ ptrdest += modcnt * sizeof (struct multiboot_mod_list);
+
+ for (i = 0, cur = modules; i < modcnt; i++, cur = cur->next)
+ {
+ modlist[i].mod_start = cur->start;
+ modlist[i].mod_end = modlist[i].mod_start + cur->size;
+ modlist[i].cmdline = ptrdest;
+ grub_memcpy (ptrorig, cur->cmdline, cur->cmdline_size);
+ ptrorig += ALIGN_UP (cur->cmdline_size, 4);
+ ptrdest += ALIGN_UP (cur->cmdline_size, 4);
+ }
+ }
+ else
+ {
+ mbi->mods_addr = 0;
+ mbi->mods_count = 0;
+ }
+
+ mmap_size = grub_get_multiboot_mmap_count ()
+ * sizeof (struct multiboot_mmap_entry);
+ grub_fill_multiboot_mmap ((struct multiboot_mmap_entry *) ptrorig);
+ mbi->mmap_length = mmap_size;
+ mbi->mmap_addr = ptrdest;
+ mbi->flags |= MULTIBOOT_INFO_MEM_MAP;
+ ptrorig += mmap_size;
+ ptrdest += mmap_size;
+
+ /* Convert from bytes to kilobytes. */
+ mbi->mem_lower = grub_mmap_get_lower () / 1024;
+ mbi->mem_upper = grub_mmap_get_upper () / 1024;
+ mbi->flags |= MULTIBOOT_INFO_MEMORY;
+
+ if (bootdev_set)
+ {
+ mbi->boot_device = bootdev;
+ mbi->flags |= MULTIBOOT_INFO_BOOTDEV;
+ }
+
+ if (elf_sec_num)
+ {
+ mbi->u.elf_sec.addr = ptrdest;
+ grub_memcpy (ptrorig, elf_sections, elf_sec_entsize * elf_sec_num);
+ mbi->u.elf_sec.num = elf_sec_num;
+ mbi->u.elf_sec.size = elf_sec_entsize;
+ mbi->u.elf_sec.shndx = elf_sec_shstrndx;
+
+ mbi->flags |= MULTIBOOT_INFO_ELF_SHDR;
+ }
+
+ err = retrieve_video_parameters (mbi, ptrorig, ptrdest);
+ if (err)
+ {
+ grub_print_error ();
+ grub_errno = GRUB_ERR_NONE;
+ }
++#if GRUB_MACHINE_HAS_VBE
++ ptrorig += sizeof (struct grub_vbe_info_block);
++ ptrdest += sizeof (struct grub_vbe_info_block);
++ ptrorig += sizeof (struct grub_vbe_mode_info_block);
++ ptrdest += sizeof (struct grub_vbe_mode_info_block);
++#endif
+
+ return GRUB_ERR_NONE;
+ }
+
+ void
+ grub_multiboot_add_elfsyms (grub_size_t num, grub_size_t entsize,
+ unsigned shndx, void *data)
+ {
+ elf_sec_num = num;
+ elf_sec_shstrndx = shndx;
+ elf_sec_entsize = entsize;
+ elf_sections = data;
+ }
+
+ void
+ grub_multiboot_free_mbi (void)
+ {
+ struct module *cur, *next;
+
+ cmdline_size = 0;
+ total_modcmd = 0;
+ modcnt = 0;
+ grub_free (cmdline);
+ cmdline = NULL;
+ bootdev_set = 0;
+
+ for (cur = modules; cur; cur = next)
+ {
+ next = cur->next;
+ grub_free (cur->cmdline);
+ grub_free (cur);
+ }
+ modules = NULL;
+ modules_last = NULL;
+
+ grub_free (elf_sections);
+ elf_sections = NULL;
+ elf_sec_entsize = 0;
+ elf_sec_num = 0;
+ }
+
+ grub_err_t
+ grub_multiboot_init_mbi (int argc, char *argv[])
+ {
+ grub_ssize_t len = 0;
+ char *p;
+ int i;
+
+ grub_multiboot_free_mbi ();
+
+ for (i = 0; i < argc; i++)
+ len += grub_strlen (argv[i]) + 1;
+ if (len == 0)
+ len = 1;
+
+ cmdline = p = grub_malloc (len);
+ if (! cmdline)
+ return grub_errno;
+ cmdline_size = len;
+
+ for (i = 0; i < argc; i++)
+ {
+ p = grub_stpcpy (p, argv[i]);
+ *(p++) = ' ';
+ }
+
+ /* Remove the space after the last word. */
+ if (p != cmdline)
+ p--;
+ *p = '\0';
+
+ return GRUB_ERR_NONE;
+ }
+
+ grub_err_t
+ grub_multiboot_add_module (grub_addr_t start, grub_size_t size,
+ int argc, char *argv[])
+ {
+ struct module *newmod;
+ char *p;
+ grub_ssize_t len = 0;
+ int i;
+
+ newmod = grub_malloc (sizeof (*newmod));
+ if (!newmod)
+ return grub_errno;
+ newmod->start = start;
+ newmod->size = size;
+
+ for (i = 0; i < argc; i++)
+ len += grub_strlen (argv[i]) + 1;
+
+ if (len == 0)
+ len = 1;
+
+ newmod->cmdline = p = grub_malloc (len);
+ if (! newmod->cmdline)
+ {
+ grub_free (newmod);
+ return grub_errno;
+ }
+ newmod->cmdline_size = len;
+ total_modcmd += ALIGN_UP (len, 4);
+
+ for (i = 0; i < argc; i++)
+ {
+ p = grub_stpcpy (p, argv[i]);
+ *(p++) = ' ';
+ }
+
+ /* Remove the space after the last word. */
+ if (p != newmod->cmdline)
+ p--;
+ *p = '\0';
+
+ if (modules_last)
+ modules_last->next = newmod;
+ else
+ {
+ modules = newmod;
+ modules_last->next = NULL;
+ }
+ modules_last = newmod;
+
+ modcnt++;
+
+ return GRUB_ERR_NONE;
+ }
+
+ void
+ grub_multiboot_set_bootdev (void)
+ {
+ grub_uint32_t biosdev, slice = ~0, part = ~0;
+ grub_device_t dev;
+
+ #ifdef GRUB_MACHINE_PCBIOS
+ biosdev = grub_get_root_biosnumber ();
+ #else
+ biosdev = 0xffffffff;
+ #endif
+
+ if (biosdev == 0xffffffff)
+ return;
+
+ dev = grub_device_open (0);
+ if (dev && dev->disk && dev->disk->partition)
+ {
+ if (dev->disk->partition->parent)
+ {
+ part = dev->disk->partition->number;
+ slice = dev->disk->partition->parent->number;
+ }
+ else
+ slice = dev->disk->partition->number;
+ }
+ if (dev)
+ grub_device_close (dev);
+
+ bootdev = ((biosdev & 0xff) << 24) | ((slice & 0xff) << 16)
+ | ((part & 0xff) << 8) | 0xff;
+ bootdev_set = 1;
+ }
--- /dev/null
- * - VBE support
- * - symbol table
+ /* multiboot.c - boot a multiboot OS image. */
+ /*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2007,2008,2009,2010 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 <http://www.gnu.org/licenses/>.
+ */
+
+ /*
+ * FIXME: The following features from the Multiboot specification still
+ * need to be implemented:
+ * - drives table
+ * - ROM configuration table
+ * - APM table
+ */
+
+ #include <grub/loader.h>
+ #include <grub/command.h>
+ #include <grub/multiboot.h>
+ #include <grub/cpu/multiboot.h>
+ #include <grub/machine/memory.h>
+ #include <grub/elf.h>
+ #include <grub/aout.h>
+ #include <grub/file.h>
+ #include <grub/err.h>
+ #include <grub/dl.h>
+ #include <grub/mm.h>
+ #include <grub/misc.h>
+ #include <grub/env.h>
+ #include <grub/cpu/relocator.h>
+ #include <grub/video.h>
+ #include <grub/memory.h>
+ #include <grub/i18n.h>
+
+ #ifdef GRUB_MACHINE_EFI
+ #include <grub/efi/efi.h>
+ #endif
+
+ struct grub_relocator *grub_multiboot_relocator = NULL;
+ grub_uint32_t grub_multiboot_payload_eip;
+ #if defined (GRUB_MACHINE_PCBIOS) || defined (GRUB_MACHINE_MULTIBOOT) || defined (GRUB_MACHINE_COREBOOT) || defined (GRUB_MACHINE_QEMU)
+ #define DEFAULT_VIDEO_MODE "text"
+ #else
+ #define DEFAULT_VIDEO_MODE "auto"
+ #endif
+
+ static int accepts_video;
+ static int accepts_ega_text;
+ static int console_required;
+ static grub_dl_t my_mod;
+
+
+ /* Return the length of the Multiboot mmap that will be needed to allocate
+ our platform's map. */
+ grub_uint32_t
+ grub_get_multiboot_mmap_count (void)
+ {
+ grub_size_t count = 0;
+
+ auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
+ int NESTED_FUNC_ATTR hook (grub_uint64_t addr __attribute__ ((unused)),
+ grub_uint64_t size __attribute__ ((unused)),
+ grub_uint32_t type __attribute__ ((unused)))
+ {
+ count++;
+ return 0;
+ }
+
+ grub_mmap_iterate (hook);
+
+ return count;
+ }
+
+ grub_err_t
+ grub_multiboot_set_video_mode (void)
+ {
+ grub_err_t err;
+ const char *modevar;
+
+ if (accepts_video || !GRUB_MACHINE_HAS_VGA_TEXT)
+ {
+ modevar = grub_env_get ("gfxpayload");
+ if (! modevar || *modevar == 0)
+ err = grub_video_set_mode (DEFAULT_VIDEO_MODE, 0, 0);
+ else
+ {
+ char *tmp;
+ tmp = grub_xasprintf ("%s;" DEFAULT_VIDEO_MODE, modevar);
+ if (! tmp)
+ return grub_errno;
+ err = grub_video_set_mode (tmp, 0, 0);
+ grub_free (tmp);
+ }
+ }
+ else
+ err = grub_video_set_mode ("text", 0, 0);
+
+ return err;
+ }
+
+ static grub_err_t
+ grub_multiboot_boot (void)
+ {
+ grub_err_t err;
+ struct grub_relocator32_state state = MULTIBOOT_INITIAL_STATE;
+
+ state.MULTIBOOT_ENTRY_REGISTER = grub_multiboot_payload_eip;
+
+ err = grub_multiboot_make_mbi (&state.MULTIBOOT_MBI_REGISTER);
+
+ if (err)
+ return err;
+
+ #ifdef GRUB_MACHINE_EFI
+ err = grub_efi_finish_boot_services (NULL, NULL, NULL, NULL, NULL);
+ if (err)
+ return err;
+ #endif
+
+ grub_relocator32_boot (grub_multiboot_relocator, state);
+
+ /* Not reached. */
+ return GRUB_ERR_NONE;
+ }
+
+ static grub_err_t
+ grub_multiboot_unload (void)
+ {
+ grub_multiboot_free_mbi ();
+
+ grub_relocator_unload (grub_multiboot_relocator);
+ grub_multiboot_relocator = NULL;
+
+ grub_dl_unref (my_mod);
+
+ return GRUB_ERR_NONE;
+ }
+
+ #define MULTIBOOT_LOAD_ELF64
+ #include "multiboot_elfxx.c"
+ #undef MULTIBOOT_LOAD_ELF64
+
+ #define MULTIBOOT_LOAD_ELF32
+ #include "multiboot_elfxx.c"
+ #undef MULTIBOOT_LOAD_ELF32
+
+ /* Load ELF32 or ELF64. */
+ grub_err_t
+ grub_multiboot_load_elf (grub_file_t file, void *buffer)
+ {
+ if (grub_multiboot_is_elf32 (buffer))
+ return grub_multiboot_load_elf32 (file, buffer);
+ else if (grub_multiboot_is_elf64 (buffer))
+ return grub_multiboot_load_elf64 (file, buffer);
+
+ return grub_error (GRUB_ERR_UNKNOWN_OS, "unknown ELF class");
+ }
+
+ grub_err_t
+ grub_multiboot_set_console (int console_type, int accepted_consoles,
+ int width, int height, int depth,
+ int console_req)
+ {
+ console_required = console_req;
+ if (!(accepted_consoles
+ & (GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER
+ | (GRUB_MACHINE_HAS_VGA_TEXT ? GRUB_MULTIBOOT_CONSOLE_EGA_TEXT : 0))))
+ {
+ if (console_required)
+ return grub_error (GRUB_ERR_BAD_OS,
+ "OS requires a console but none is available");
+ grub_printf ("WARNING: no console will be available to OS");
+ accepts_video = 0;
+ accepts_ega_text = 0;
+ return GRUB_ERR_NONE;
+ }
+
+ if (console_type == GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER)
+ {
+ char *buf;
+ if (depth && width && height)
+ buf = grub_xasprintf ("%dx%dx%d,%dx%d,auto", width,
+ height, depth, width, height);
+ else if (width && height)
+ buf = grub_xasprintf ("%dx%d,auto", width, height);
+ else
+ buf = grub_strdup ("auto");
+
+ if (!buf)
+ return grub_errno;
+ grub_env_set ("gfxpayload", buf);
+ grub_free (buf);
+ }
+ else
+ grub_env_set ("gfxpayload", "text");
+
+ accepts_video = !!(accepted_consoles & GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER);
+ accepts_ega_text = !!(accepted_consoles & GRUB_MULTIBOOT_CONSOLE_EGA_TEXT);
+ return GRUB_ERR_NONE;
+ }
+
+ 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 ();
+
+ if (argc == 0)
+ return grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
+
+ file = grub_file_open (argv[0]);
+ if (! file)
+ return grub_error (GRUB_ERR_BAD_ARGUMENT, "couldn't open file");
+
+ 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);
+ 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);
+ }
+
+ return grub_errno;
+ }
+
+ static grub_err_t
+ grub_cmd_module (grub_command_t cmd __attribute__ ((unused)),
+ int argc, char *argv[])
+ {
+ grub_file_t file = 0;
+ grub_ssize_t size;
+ void *module = NULL;
+ grub_addr_t target;
+ grub_err_t err;
+ int nounzip = 0;
+
+ if (argc == 0)
+ return grub_error (GRUB_ERR_BAD_ARGUMENT, "no module specified");
+
+ if (grub_strcmp (argv[0], "--nounzip") == 0)
+ {
+ argv++;
+ argc--;
+ nounzip = 1;
+ }
+
+ if (argc == 0)
+ return grub_error (GRUB_ERR_BAD_ARGUMENT, "no module specified");
+
+ if (!grub_multiboot_relocator)
+ return grub_error (GRUB_ERR_BAD_ARGUMENT,
+ "you need to load the multiboot kernel first");
+
+ if (nounzip)
+ grub_file_filter_disable_compression ();
+
+ file = grub_file_open (argv[0]);
+ if (! file)
+ return grub_errno;
+
+ size = grub_file_size (file);
+ {
+ grub_relocator_chunk_t ch;
+ err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator, &ch,
+ 0, (0xffffffff - size) + 1,
+ size, MULTIBOOT_MOD_ALIGN,
+ GRUB_RELOCATOR_PREFERENCE_NONE);
+ if (err)
+ {
+ grub_file_close (file);
+ return err;
+ }
+ module = get_virtual_current_address (ch);
+ target = (grub_addr_t) get_virtual_current_address (ch);
+ }
+
+ err = grub_multiboot_add_module (target, size, argc - 1, argv + 1);
+ if (err)
+ {
+ grub_file_close (file);
+ return err;
+ }
+
+ if (grub_file_read (file, module, size) != size)
+ {
+ grub_file_close (file);
+ return grub_error (GRUB_ERR_FILE_READ_ERROR, "couldn't read file");
+ }
+
+ grub_file_close (file);
+ return GRUB_ERR_NONE;;
+ }
+
+ static grub_command_t cmd_multiboot, cmd_module;
+
+ GRUB_MOD_INIT(multiboot)
+ {
+ cmd_multiboot =
+ #ifdef GRUB_USE_MULTIBOOT2
+ grub_register_command ("multiboot2", grub_cmd_multiboot,
+ 0, N_("Load a multiboot 2 kernel."));
+ cmd_module =
+ grub_register_command ("module2", grub_cmd_module,
+ 0, N_("Load a multiboot 2 module."));
+ #else
+ grub_register_command ("multiboot", grub_cmd_multiboot,
+ 0, N_("Load a multiboot kernel."));
+ cmd_module =
+ grub_register_command ("module", grub_cmd_module,
+ 0, N_("Load a multiboot module."));
+ #endif
+
+ my_mod = mod;
+ }
+
+ GRUB_MOD_FINI(multiboot)
+ {
+ grub_unregister_command (cmd_multiboot);
+ grub_unregister_command (cmd_module);
+ }
projects / grub.git / commitdiff