vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

merge mainline into backtrace

Browse source
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2011-11-14 10:50:24 +01:00
commit 245f4582f9
871 changed files with 102908 additions and 16407 deletions
Download patch file Download diff file Expand all files Collapse all files

2
grub-core/loader/aout.c
View file

@ -21,6 +21,8 @@
#include <grub/misc.h>
#include <grub/aout.h>
GRUB_MOD_LICENSE ("GPLv3+");
int
grub_aout_get_type (union grub_aout_header *header)
{

198
grub-core/loader/efi/appleloader.c
View file

@ -27,6 +27,8 @@
#include <grub/command.h>
#include <grub/i18n.h>
GRUB_MOD_LICENSE ("GPLv3+");
static grub_dl_t my_mod;
static grub_efi_handle_t image_handle;
@ -67,165 +69,60 @@ struct piwg_full_device_path
struct grub_efi_device_path end;
};
/* early 2006 Core Duo / Core Solo models */
static struct piwg_full_device_path devpath_1 =
{
.comp1 =
{
.header = {
.type = GRUB_EFI_HARDWARE_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_MEMORY_MAPPED_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_memory_mapped_device_path), 0}
},
.memory_type = GRUB_EFI_MEMORY_MAPPED_IO,
.start_address = 0xffe00000,
.end_address = 0xfff9ffff
},
.comp2 =
{
.header = {
.type = GRUB_EFI_MEDIA_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_PIWG_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_piwg_device_path), 0}
},
.guid = {0x2B0585EB, 0xD8B8, 0x49A9, {0x8B, 0x8C, 0xE2, 0x1B,
0x01, 0xAE, 0xF2, 0xB7}}
},
.end =
{
.type = GRUB_EFI_END_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_device_path), 0}
#define MAKE_PIWG_PATH(st, en) \
{ \
.comp1 = \
{ \
.header = { \
.type = GRUB_EFI_HARDWARE_DEVICE_PATH_TYPE, \
.subtype = GRUB_EFI_MEMORY_MAPPED_DEVICE_PATH_SUBTYPE, \
.length = {sizeof (struct grub_efi_memory_mapped_device_path), 0} \
}, \
.memory_type = GRUB_EFI_MEMORY_MAPPED_IO, \
.start_address = st, \
.end_address = en \
}, \
.comp2 = \
{ \
.header = { \
.type = GRUB_EFI_MEDIA_DEVICE_PATH_TYPE, \
.subtype = GRUB_EFI_PIWG_DEVICE_PATH_SUBTYPE, \
.length = {sizeof (struct grub_efi_piwg_device_path), 0} \
}, \
.guid = {0x2B0585EB, 0xD8B8, 0x49A9, {0x8B, 0x8C, 0xE2, 0x1B, \
0x01, 0xAE, 0xF2, 0xB7}} \
}, \
.end = \
{ \
.type = GRUB_EFI_END_DEVICE_PATH_TYPE, \
.subtype = GRUB_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE, \
.length = {sizeof (struct grub_efi_device_path), 0} \
} \
}
};
/* early 2006 Core Duo / Core Solo models */
static struct piwg_full_device_path devpath_1 = MAKE_PIWG_PATH (0xffe00000,
0xfff9ffff);
/* mid-2006 Mac Pro (and probably other Core 2 models) */
static struct piwg_full_device_path devpath_2 =
{
.comp1 =
{
.header = {
.type = GRUB_EFI_HARDWARE_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_MEMORY_MAPPED_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_memory_mapped_device_path), 0}
},
.memory_type = GRUB_EFI_MEMORY_MAPPED_IO,
.start_address = 0xffe00000,
.end_address = 0xfff7ffff
},
.comp2 =
{
.header = {
.type = GRUB_EFI_MEDIA_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_PIWG_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_piwg_device_path), 0}
},
.guid = {0x2B0585EB, 0xD8B8, 0x49A9, {0x8B, 0x8C, 0xE2, 0x1B,
0x01, 0xAE, 0xF2, 0xB7}}
},
.end =
{
.type = GRUB_EFI_END_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_device_path), 0}
}
};
static struct piwg_full_device_path devpath_2 = MAKE_PIWG_PATH (0xffe00000,
0xfff7ffff);
/* mid-2007 MBP ("Santa Rosa" based models) */
static struct piwg_full_device_path devpath_3 =
{
.comp1 =
{
.header = {
.type = GRUB_EFI_HARDWARE_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_MEMORY_MAPPED_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_memory_mapped_device_path), 0}
},
.memory_type = GRUB_EFI_MEMORY_MAPPED_IO,
.start_address = 0xffe00000,
.end_address = 0xfff8ffff
},
.comp2 =
{
.header = {
.type = GRUB_EFI_MEDIA_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_PIWG_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_piwg_device_path), 0}
},
.guid = {0x2B0585EB, 0xD8B8, 0x49A9, {0x8B, 0x8C, 0xE2, 0x1B,
0x01, 0xAE, 0xF2, 0xB7}}
},
.end =
{
.type = GRUB_EFI_END_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_device_path), 0}
}
};
static struct piwg_full_device_path devpath_3 = MAKE_PIWG_PATH (0xffe00000,
0xfff8ffff);
/* early-2008 MBA */
static struct piwg_full_device_path devpath_4 =
{
.comp1 =
{
.header = {
.type = GRUB_EFI_HARDWARE_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_MEMORY_MAPPED_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_memory_mapped_device_path), 0}
},
.memory_type = GRUB_EFI_MEMORY_MAPPED_IO,
.start_address = 0xffc00000,
.end_address = 0xfff8ffff
},
.comp2 =
{
.header = {
.type = GRUB_EFI_MEDIA_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_PIWG_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_piwg_device_path), 0}
},
.guid = {0x2B0585EB, 0xD8B8, 0x49A9, {0x8B, 0x8C, 0xE2, 0x1B,
0x01, 0xAE, 0xF2, 0xB7}}
},
.end =
{
.type = GRUB_EFI_END_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_device_path), 0}
}
};
static struct piwg_full_device_path devpath_4 = MAKE_PIWG_PATH (0xffc00000,
0xfff8ffff);
/* late-2008 MB/MBP (NVidia chipset) */
static struct piwg_full_device_path devpath_5 =
{
.comp1 =
{
.header = {
.type = GRUB_EFI_HARDWARE_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_MEMORY_MAPPED_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_memory_mapped_device_path), 0}
},
.memory_type = GRUB_EFI_MEMORY_MAPPED_IO,
.start_address = 0xffcb4000,
.end_address = 0xffffbfff
},
.comp2 =
{
.header = {
.type = GRUB_EFI_MEDIA_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_PIWG_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_piwg_device_path), 0}
},
.guid = {0x2B0585EB, 0xD8B8, 0x49A9, {0x8B, 0x8C, 0xE2, 0x1B,
0x01, 0xAE, 0xF2, 0xB7}}
},
.end =
{
.type = GRUB_EFI_END_DEVICE_PATH_TYPE,
.subtype = GRUB_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE,
.length = {sizeof (struct grub_efi_device_path), 0}
}
};
static struct piwg_full_device_path devpath_5 = MAKE_PIWG_PATH (0xffcb4000,
0xffffbfff);
/* mid-2010 MB/MBP (NVidia chipset) */
static struct piwg_full_device_path devpath_6 = MAKE_PIWG_PATH (0xffcc4000,
0xffffbfff);
struct devdata
{
@ -240,6 +137,7 @@ struct devdata devs[] =
{"MBP", (grub_efi_device_path_t *) &devpath_3},
{"MBA", (grub_efi_device_path_t *) &devpath_4},
{"MB NV", (grub_efi_device_path_t *) &devpath_5},
{"MB NV2", (grub_efi_device_path_t *) &devpath_6},
{NULL, NULL},
};

15
grub-core/loader/efi/chainloader.c
View file

@ -35,6 +35,8 @@
#include <grub/command.h>
#include <grub/i18n.h>
GRUB_MOD_LICENSE ("GPLv3+");
static grub_dl_t my_mod;
static grub_efi_physical_address_t address;
@ -55,6 +57,7 @@ grub_chainloader_unload (void)
grub_free (file_path);
grub_free (cmdline);
cmdline = 0;
file_path = 0;
grub_dl_unref (my_mod);
return GRUB_ERR_NONE;
@ -66,7 +69,7 @@ grub_chainloader_boot (void)
grub_efi_boot_services_t *b;
grub_efi_status_t status;
grub_efi_uintn_t exit_data_size;
grub_efi_char16_t *exit_data;
grub_efi_char16_t *exit_data = NULL;
b = grub_efi_system_table->boot_services;
status = efi_call_3 (b->start_image, image_handle, &exit_data_size, &exit_data);
@ -93,7 +96,7 @@ grub_chainloader_boot (void)
if (exit_data)
efi_call_1 (b->free_pool, exit_data);
grub_chainloader_unload ();
grub_loader_unset ();
return grub_errno;
}
@ -236,6 +239,11 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
grub_efi_print_device_path (file_path);
size = grub_file_size (file);
if (!size)
{
grub_error (GRUB_ERR_BAD_OS, "file is empty");
goto fail;
}
pages = (((grub_efi_uintn_t) size + ((1 << 12) - 1)) >> 12);
status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_ANY_PAGES,
@ -321,8 +329,7 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
if (file)
grub_file_close (file);
if (file_path)
grub_free (file_path);
grub_free (file_path);
if (address)
efi_call_2 (b->free_pages, address, pages);

160
grub-core/loader/i386/bsd.c
View file

@ -19,8 +19,8 @@
#include <grub/loader.h>
#include <grub/i386/bsd.h>
#include <grub/i386/cpuid.h>
#include <grub/machine/memory.h>
#include <grub/memory.h>
#include <grub/i386/memory.h>
#include <grub/file.h>
#include <grub/err.h>
#include <grub/dl.h>
@ -33,6 +33,10 @@
#include <grub/extcmd.h>
#include <grub/i18n.h>
#include <grub/ns8250.h>
#include <grub/bsdlabel.h>
#include <grub/crypto.h>
GRUB_MOD_LICENSE ("GPLv3+");
#include <grub/video.h>
#ifdef GRUB_MACHINE_PCBIOS
@ -65,7 +69,7 @@ static void *kern_chunk_src;
static grub_uint32_t bootflags;
static int is_elf_kernel, is_64bit;
static grub_uint32_t openbsd_root;
struct grub_relocator *relocator = NULL;
static struct grub_relocator *relocator = NULL;
static struct grub_openbsd_ramdisk_descriptor openbsd_ramdisk;
struct bsd_tag
@ -252,7 +256,7 @@ struct grub_e820_mmap
#define GRUB_E820_RESERVED 2
#define GRUB_E820_ACPI 3
#define GRUB_E820_NVS 4
#define GRUB_E820_EXEC_CODE 5
#define GRUB_E820_BADRAM 5
static void
generate_e820_mmap (grub_size_t *len, grub_size_t *cnt, void *buf)
@ -261,37 +265,30 @@ generate_e820_mmap (grub_size_t *len, grub_size_t *cnt, void *buf)
struct grub_e820_mmap *mmap = buf;
struct grub_e820_mmap prev, cur;
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t,
grub_memory_type_t);
int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size,
grub_uint32_t type)
grub_memory_type_t type)
{
cur.addr = addr;
cur.size = size;
switch (type)
{
case GRUB_MACHINE_MEMORY_AVAILABLE:
case GRUB_MEMORY_AVAILABLE:
cur.type = GRUB_E820_RAM;
break;
#ifdef GRUB_MACHINE_MEMORY_ACPI
case GRUB_MACHINE_MEMORY_ACPI:
case GRUB_MEMORY_ACPI:
cur.type = GRUB_E820_ACPI;
break;
#endif
#ifdef GRUB_MACHINE_MEMORY_NVS
case GRUB_MACHINE_MEMORY_NVS:
case GRUB_MEMORY_NVS:
cur.type = GRUB_E820_NVS;
break;
#endif
default:
#ifdef GRUB_MACHINE_MEMORY_CODE
case GRUB_MACHINE_MEMORY_CODE:
#endif
#ifdef GRUB_MACHINE_MEMORY_RESERVED
case GRUB_MACHINE_MEMORY_RESERVED:
#endif
case GRUB_MEMORY_CODE:
case GRUB_MEMORY_RESERVED:
cur.type = GRUB_E820_RESERVED;
break;
}
@ -453,7 +450,8 @@ grub_freebsd_list_modules (void)
{
struct bsd_tag *tag;
grub_printf (" %-18s %-18s%14s%14s\n", "name", "type", "addr", "size");
grub_printf (" %-18s %-18s%14s%14s\n", _("name"), _("type"), _("addr"),
_("size"));
for (tag = tags; tag; tag = tag->next)
{
@ -518,7 +516,8 @@ grub_netbsd_list_modules (void)
{
struct netbsd_module *mod;
grub_printf (" %-18s%14s%14s%14s\n", "name", "type", "addr", "size");
grub_printf (" %-18s%14s%14s%14s\n", _("name"), _("type"), _("addr"),
_("size"));
for (mod = netbsd_mods; mod; mod = mod->next)
grub_printf (" %-18s 0x%08x 0x%08x 0x%08x", mod->mod.name,
@ -528,6 +527,8 @@ grub_netbsd_list_modules (void)
/* This function would be here but it's under different license. */
#include "bsd_pagetable.c"
static grub_uint32_t freebsd_bootdev, freebsd_biosdev;
static grub_err_t
grub_freebsd_boot (void)
{
@ -535,7 +536,6 @@ grub_freebsd_boot (void)
grub_uint8_t *p, *p0;
grub_addr_t p_target;
grub_size_t p_size = 0;
grub_uint32_t bootdev, biosdev, unit, slice, part;
grub_err_t err;
grub_size_t tag_buf_len = 0;
@ -571,11 +571,7 @@ grub_freebsd_boot (void)
bi.version = FREEBSD_BOOTINFO_VERSION;
bi.length = sizeof (bi);
grub_bsd_get_device (&biosdev, &unit, &slice, &part);
bootdev = (FREEBSD_B_DEVMAGIC + ((slice + 1) << FREEBSD_B_SLICESHIFT) +
(unit << FREEBSD_B_UNITSHIFT) + (part << FREEBSD_B_PARTSHIFT));
bi.boot_device = biosdev;
bi.boot_device = freebsd_biosdev;
p_size = 0;
grub_env_iterate (iterate_env_count);
@ -748,7 +744,7 @@ grub_freebsd_boot (void)
state.ebp = stack_target;
stack[0] = entry; /* "Return" address. */
stack[1] = bootflags | FREEBSD_RB_BOOTINFO;
stack[2] = bootdev;
stack[2] = freebsd_bootdev;
stack[3] = 0;
stack[4] = 0;
stack[5] = 0;
@ -954,6 +950,88 @@ grub_netbsd_add_modules (void)
return err;
}
/*
* Adds NetBSD bootinfo bootdisk and bootwedge. The partition identified
* in these bootinfo fields is the root device.
*/
static void
grub_netbsd_add_boot_disk_and_wedge (void)
{
grub_device_t dev;
grub_disk_t disk;
grub_partition_t part;
grub_uint32_t biosdev;
grub_uint32_t partmapsector;
union {
grub_uint64_t raw[GRUB_DISK_SECTOR_SIZE / 8];
struct grub_partition_bsd_disk_label label;
} buf;
grub_uint8_t *hash;
grub_uint64_t ctx[(GRUB_MD_MD5->contextsize + 7) / 8];
dev = grub_device_open (0);
if (! (dev && dev->disk && dev->disk->partition))
goto fail;
disk = dev->disk;
part = disk->partition;
if (disk->dev && disk->dev->id == GRUB_DISK_DEVICE_BIOSDISK_ID)
biosdev = (grub_uint32_t) disk->id & 0xff;
else
biosdev = 0xff;
/* Absolute sector of the partition map describing this partition. */
partmapsector = grub_partition_get_start (part->parent) + part->offset;
disk->partition = part->parent;
if (grub_disk_read (disk, part->offset, 0, GRUB_DISK_SECTOR_SIZE, buf.raw)
!= GRUB_ERR_NONE)
goto fail;
disk->partition = part;
/* Fill bootwedge. */
{
struct grub_netbsd_btinfo_bootwedge biw;
grub_memset (&biw, 0, sizeof (biw));
biw.biosdev = biosdev;
biw.startblk = grub_partition_get_start (part);
biw.nblks = part->len;
biw.matchblk = partmapsector;
biw.matchnblks = 1;
GRUB_MD_MD5->init (&ctx);
GRUB_MD_MD5->write (&ctx, buf.raw, GRUB_DISK_SECTOR_SIZE);
GRUB_MD_MD5->final (&ctx);
hash = GRUB_MD_MD5->read (&ctx);
memcpy (biw.matchhash, hash, 16);
grub_bsd_add_meta (NETBSD_BTINFO_BOOTWEDGE, &biw, sizeof (biw));
}
/* Fill bootdisk if this a NetBSD disk label. */
if (part->partmap != NULL &&
(grub_strcmp (part->partmap->name, "netbsd") == 0) &&
buf.label.magic == grub_cpu_to_le32 (GRUB_PC_PARTITION_BSD_LABEL_MAGIC))
{
struct grub_netbsd_btinfo_bootdisk bid;
grub_memset (&bid, 0, sizeof (bid));
bid.labelsector = partmapsector;
bid.label.type = buf.label.type;
bid.label.checksum = buf.label.checksum;
memcpy (bid.label.packname, buf.label.packname, 16);
bid.biosdev = biosdev;
bid.partition = part->number;
grub_bsd_add_meta (NETBSD_BTINFO_BOOTDISK, &bid, sizeof (bid));
}
fail:
if (dev)
grub_device_close (dev);
}
static grub_err_t
grub_netbsd_boot (void)
{
@ -974,7 +1052,7 @@ grub_netbsd_boot (void)
if (err)
{
grub_print_error ();
grub_printf ("Booting however\n");
grub_puts_ (N_("Booting in blind mode"));
grub_errno = GRUB_ERR_NONE;
}
@ -1330,6 +1408,11 @@ grub_bsd_load (int argc, char *argv[])
goto fail;
relocator = grub_relocator_new ();
if (!relocator)
{
grub_file_close (file);
goto fail;
}
elf = grub_elf_file (file);
if (elf)
@ -1351,7 +1434,7 @@ grub_bsd_load (int argc, char *argv[])
fail:
if (grub_errno != GRUB_ERR_NONE)
grub_dl_unref (my_mod);
grub_dl_unref (my_mod);
return grub_errno;
}
@ -1378,6 +1461,8 @@ grub_cmd_freebsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
{
grub_uint32_t unit, slice, part;
kern_end = ALIGN_PAGE (kern_end);
if (is_elf_kernel)
{
@ -1421,6 +1506,10 @@ grub_cmd_freebsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
if (err)
return err;
}
grub_bsd_get_device (&freebsd_biosdev, &unit, &slice, &part);
freebsd_bootdev = (FREEBSD_B_DEVMAGIC + ((slice + 1) << FREEBSD_B_SLICESHIFT) +
(unit << FREEBSD_B_UNITSHIFT) + (part << FREEBSD_B_PARTSHIFT));
grub_loader_set (grub_freebsd_boot, grub_bsd_unload, 0);
}
@ -1566,6 +1655,9 @@ grub_cmd_netbsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
grub_memset (&serial, 0, sizeof (serial));
grub_strcpy (serial.devname, "com");
serial.addr = grub_ns8250_hw_get_port (0);
serial.speed = 9600;
if (ctxt->state[NETBSD_SERIAL_ARG].arg)
{
ptr = ctxt->state[NETBSD_SERIAL_ARG].arg;
@ -1588,7 +1680,7 @@ grub_cmd_netbsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
return grub_errno;
}
}
grub_bsd_add_meta (NETBSD_BTINFO_CONSOLE, &serial, sizeof (serial));
}
else
@ -1601,6 +1693,8 @@ grub_cmd_netbsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
grub_bsd_add_meta (NETBSD_BTINFO_CONSOLE, &cons, sizeof (cons));
}
grub_netbsd_add_boot_disk_and_wedge ();
grub_loader_set (grub_netbsd_boot, grub_bsd_unload, 0);
}
@ -1615,7 +1709,7 @@ grub_cmd_freebsd_loadenv (grub_command_t cmd __attribute__ ((unused)),
char *buf = 0, *curr, *next;
int len;
if (kernel_type == KERNEL_TYPE_NONE)
if (! grub_loader_is_loaded ())
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"you need to load the kernel first");
@ -1848,7 +1942,7 @@ grub_cmd_freebsd_module_elf (grub_command_t cmd __attribute__ ((unused)),
grub_file_t file = 0;
grub_err_t err;
if (kernel_type == KERNEL_TYPE_NONE)
if (! grub_loader_is_loaded ())
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"you need to load the kernel first");
@ -1969,7 +2063,7 @@ GRUB_MOD_INIT (bsd)
cmd_openbsd_ramdisk = grub_register_command ("kopenbsd_ramdisk",
grub_cmd_openbsd_ramdisk, 0,
"Load kOpenBSD ramdisk. ");
N_("Load kOpenBSD ramdisk."));
my_mod = mod;
}

13
grub-core/loader/i386/bsdXX.c
View file

@ -195,6 +195,11 @@ SUFFIX (grub_freebsd_load_elfmodule) (struct grub_relocator *relocator,
chunk_size = s->sh_addr + s->sh_size;
}
if (chunk_size < sizeof (e))
chunk_size = sizeof (e);
chunk_size += e.e_phnum * e.e_phentsize;
chunk_size += e.e_shnum * e.e_shentsize;
{
grub_relocator_chunk_t ch;
@ -394,12 +399,10 @@ SUFFIX (grub_netbsd_load_elf_meta) (struct grub_relocator *relocator,
grub_err_t err;
Elf_Ehdr e;
Elf_Shdr *s, *symsh, *strsh;
char *shdr;
char *shdr = NULL;
unsigned symsize, strsize;
Elf_Sym *sym;
void *sym_chunk;
grub_uint8_t *curload;
const char *str;
grub_size_t chunk_size;
Elf_Ehdr *e2;
struct grub_netbsd_btinfo_symtab symtab;
@ -473,7 +476,6 @@ SUFFIX (grub_netbsd_load_elf_meta) (struct grub_relocator *relocator,
if (grub_file_seek (file, symsh->sh_offset) == (grub_off_t) -1)
return grub_errno;
sym = (Elf_Sym *) curload;
if (grub_file_read (file, curload, symsize) != (grub_ssize_t) symsize)
{
if (! grub_errno)
@ -484,7 +486,6 @@ SUFFIX (grub_netbsd_load_elf_meta) (struct grub_relocator *relocator,
if (grub_file_seek (file, strsh->sh_offset) == (grub_off_t) -1)
return grub_errno;
str = (char *) curload;
if (grub_file_read (file, curload, strsize) != (grub_ssize_t) strsize)
{
if (! grub_errno)
@ -515,7 +516,7 @@ SUFFIX(grub_openbsd_find_ramdisk) (grub_file_t file,
grub_err_t err;
Elf_Ehdr e;
Elf_Shdr *s;
char *shdr;
char *shdr = NULL;
err = read_headers (file, &e, &shdr);
if (err)

3
grub-core/loader/i386/bsd_pagetable.c
View file

@ -53,7 +53,7 @@ static void
fill_bsd64_pagetable (grub_uint8_t *src, grub_addr_t target)
{
grub_uint64_t *pt2, *pt3, *pt4;
grub_addr_t pt2t, pt3t, pt4t;
grub_addr_t pt2t, pt3t;
int i;
#define PG_V 0x001
@ -65,7 +65,6 @@ fill_bsd64_pagetable (grub_uint8_t *src, grub_addr_t target)
pt3 = (grub_uint64_t *) (src + 4096);
pt2 = (grub_uint64_t *) (src + 8192);
pt4t = target;
pt3t = target + 4096;
pt2t = target + 8192;

145
grub-core/loader/i386/coreboot/chainloader.c Normal file
View file

@ -0,0 +1,145 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2011 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/loader.h>
#include <grub/memory.h>
#include <grub/i386/memory.h>
#include <grub/file.h>
#include <grub/err.h>
#include <grub/dl.h>
#include <grub/mm.h>
#include <grub/elfload.h>
#include <grub/video.h>
#include <grub/relocator.h>
#include <grub/i386/relocator.h>
#include <grub/command.h>
#include <grub/i18n.h>
GRUB_MOD_LICENSE ("GPLv3+");
static grub_addr_t entry;
static struct grub_relocator *relocator = NULL;
static grub_err_t
grub_chain_boot (void)
{
struct grub_relocator32_state state;
grub_video_set_mode ("text", 0, 0);
state.eip = entry;
return grub_relocator32_boot (relocator, state);
}
static grub_err_t
grub_chain_unload (void)
{
grub_relocator_unload (relocator);
relocator = NULL;
return GRUB_ERR_NONE;
}
static grub_err_t
grub_chain_elf32_hook (Elf32_Phdr * phdr, grub_addr_t * addr, int *do_load)
{
grub_err_t err;
grub_relocator_chunk_t ch;
if (phdr->p_type != PT_LOAD)
{
*do_load = 0;
return 0;
}
*do_load = 1;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
phdr->p_paddr, phdr->p_memsz);
if (err)
return err;
*addr = (grub_addr_t) get_virtual_current_address (ch);
return GRUB_ERR_NONE;
}
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, "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);
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, 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_command_t cmd_chain;
GRUB_MOD_INIT (chain)
{
cmd_chain = grub_register_command ("chainloader", grub_cmd_chain,
N_("FILE"), N_("Load another payload"));
}
GRUB_MOD_FINI (chain)
{
grub_unregister_command (cmd_chain);
grub_chain_unload ();
}

426
grub-core/loader/i386/linux.c
View file

@ -17,7 +17,6 @@
*/
#include <grub/loader.h>
#include <grub/machine/memory.h>
#include <grub/memory.h>
#include <grub/normal.h>
#include <grub/file.h>
@ -34,24 +33,33 @@
#include <grub/command.h>
#include <grub/i386/relocator.h>
#include <grub/i18n.h>
#include <grub/lib/cmdline.h>
GRUB_MOD_LICENSE ("GPLv3+");
#ifdef GRUB_MACHINE_PCBIOS
#include <grub/i386/pc/vesa_modes_table.h>
#endif
#ifdef GRUB_MACHINE_EFI
#include <grub/efi/efi.h>
#define HAS_VGA_TEXT 0
#define DEFAULT_VIDEO_MODE "800x600"
#define DEFAULT_VIDEO_MODE "auto"
#define ACCEPTS_PURE_TEXT 0
#elif defined (GRUB_MACHINE_IEEE1275)
#include <grub/ieee1275/ieee1275.h>
#define HAS_VGA_TEXT 0
#define DEFAULT_VIDEO_MODE "text"
#define ACCEPTS_PURE_TEXT 1
#else
#include <grub/i386/pc/vbe.h>
#include <grub/i386/pc/console.h>
#define HAS_VGA_TEXT 1
#define DEFAULT_VIDEO_MODE "text"
#define ACCEPTS_PURE_TEXT 1
#endif
#define GRUB_LINUX_CL_OFFSET 0x1000
#define GRUB_LINUX_CL_END_OFFSET 0x2000
static grub_dl_t my_mod;
@ -68,6 +76,7 @@ static grub_uint32_t prot_mode_pages;
static grub_uint32_t initrd_pages;
static struct grub_relocator *relocator = NULL;
static void *efi_mmap_buf;
static grub_size_t maximal_cmdline_size;
#ifdef GRUB_MACHINE_EFI
static grub_efi_uintn_t efi_mmap_size;
#else
@ -89,175 +98,6 @@ static struct idt_descriptor idt_desc =
};
#endif
#ifdef GRUB_MACHINE_PCBIOS
struct linux_vesafb_res
{
grub_uint16_t width;
grub_uint16_t height;
};
struct linux_vesafb_mode
{
grub_uint8_t res_index;
grub_uint8_t depth;
};
enum vga_modes
{
VGA_320_200,
VGA_640_400,
VGA_640_480,
VGA_800_500,
VGA_800_600,
VGA_896_672,
VGA_1024_640,
VGA_1024_768,
VGA_1152_720,
VGA_1280_1024,
VGA_1440_900,
VGA_1600_1200,
};
static struct linux_vesafb_res linux_vesafb_res[] =
{
{ 320, 200 },
{ 640, 400 },
{ 640, 480 },
{ 800, 500 },
{ 800, 600 },
{ 896, 672 },
{ 1024, 640 },
{ 1024, 768 },
{ 1152, 720 },
{ 1280, 1024 },
{ 1440, 900 },
{ 1600, 1200 },
};
/* This is the reverse of the table in [linux]/Documentation/fb/vesafb.txt
plus a few more modes based on the table in
http://en.wikipedia.org/wiki/VESA_BIOS_Extensions */
struct linux_vesafb_mode linux_vesafb_modes[] =
{
{ VGA_640_400, 8 }, /* 0x300 */
{ VGA_640_480, 8 }, /* 0x301 */
{ VGA_800_600, 4 }, /* 0x302 */
{ VGA_800_600, 8 }, /* 0x303 */
{ VGA_1024_768, 4 }, /* 0x304 */
{ VGA_1024_768, 8 }, /* 0x305 */
{ VGA_1280_1024, 4 }, /* 0x306 */
{ VGA_1280_1024, 8 }, /* 0x307 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_320_200, 15 }, /* 0x30d */
{ VGA_320_200, 16 }, /* 0x30e */
{ VGA_320_200, 24 }, /* 0x30f */
{ VGA_640_480, 15 }, /* 0x310 */
{ VGA_640_480, 16 }, /* 0x311 */
{ VGA_640_480, 24 }, /* 0x312 */
{ VGA_800_600, 15 }, /* 0x313 */
{ VGA_800_600, 16 }, /* 0x314 */
{ VGA_800_600, 24 }, /* 0x315 */
{ VGA_1024_768, 15 }, /* 0x316 */
{ VGA_1024_768, 16 }, /* 0x317 */
{ VGA_1024_768, 24 }, /* 0x318 */
{ VGA_1280_1024, 15 }, /* 0x319 */
{ VGA_1280_1024, 16 }, /* 0x31a */
{ VGA_1280_1024, 24 }, /* 0x31b */
{ VGA_1600_1200, 8 }, /* 0x31c */
{ VGA_1600_1200, 15 }, /* 0x31d */
{ VGA_1600_1200, 16 }, /* 0x31e */
{ VGA_1600_1200, 24 }, /* 0x31f */
{ 0, 0 },
{ VGA_640_400, 15 }, /* 0x321 */
{ VGA_640_400, 16 }, /* 0x322 */
{ VGA_640_400, 24 }, /* 0x323 */
{ VGA_640_400, 32 }, /* 0x324 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_640_480, 32 }, /* 0x329 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_896_672, 8 }, /* 0x32f */
{ VGA_896_672, 15 }, /* 0x330 */
{ VGA_896_672, 16 }, /* 0x331 */
{ VGA_896_672, 24 }, /* 0x332 */
{ VGA_896_672, 32 }, /* 0x333 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_1600_1200, 32 }, /* 0x342 */
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ VGA_1440_900, 8 }, /* 0x360 */
{ VGA_1440_900, 15 }, /* 0x361 */
{ VGA_1440_900, 16 }, /* 0x362 */
{ VGA_1440_900, 24 }, /* 0x363 */
{ VGA_1440_900, 32 }, /* 0x364 */
{ VGA_1152_720, 8 }, /* 0x365 */
{ VGA_1152_720, 15 }, /* 0x366 */
{ VGA_1152_720, 16 }, /* 0x367 */
{ VGA_1152_720, 24 }, /* 0x368 */
{ VGA_1152_720, 32 }, /* 0x369 */
{ VGA_1024_640, 8 }, /* 0x36a */
{ VGA_1024_640, 15 }, /* 0x36b */
{ VGA_1024_640, 16 }, /* 0x36c */
{ VGA_1024_640, 24 }, /* 0x36d */
{ VGA_1024_640, 32 }, /* 0x36e */
{ VGA_800_500, 8 }, /* 0x36f */
{ VGA_800_500, 15 }, /* 0x370 */
{ VGA_800_500, 16 }, /* 0x371 */
{ VGA_800_500, 24 }, /* 0x372 */
{ VGA_800_500, 32 }, /* 0x373 */
};
#endif
static inline grub_size_t
page_align (grub_size_t size)
{
@ -290,7 +130,10 @@ find_efi_mmap_size (void)
grub_free (mmap);
if (ret < 0)
grub_fatal ("cannot get memory map");
{
grub_error (GRUB_ERR_IO, "cannot get memory map");
return 0;
}
else if (ret > 0)
break;
@ -301,7 +144,8 @@ find_efi_mmap_size (void)
later, and EFI itself may allocate more. */
mmap_size += (1 << 12);
return page_align (mmap_size);
mmap_size = page_align (mmap_size);
return mmap_size;
}
#endif
@ -312,10 +156,11 @@ find_mmap_size (void)
{
grub_size_t count = 0, mmap_size;
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t,
grub_memory_type_t);
int NESTED_FUNC_ATTR hook (grub_uint64_t addr __attribute__ ((unused)),
grub_uint64_t size __attribute__ ((unused)),
grub_uint32_t type __attribute__ ((unused)))
grub_memory_type_t type __attribute__ ((unused)))
{
count++;
return 0;
@ -350,12 +195,14 @@ allocate_pages (grub_size_t prot_size)
grub_err_t err;
/* Make sure that each size is aligned to a page boundary. */
real_size = GRUB_LINUX_CL_END_OFFSET;
real_size = GRUB_LINUX_CL_OFFSET + maximal_cmdline_size;
prot_size = page_align (prot_size);
mmap_size = find_mmap_size ();
#ifdef GRUB_MACHINE_EFI
efi_mmap_size = find_efi_mmap_size ();
if (efi_mmap_size == 0)
return grub_errno;
#endif
grub_dprintf ("linux", "real_size = %x, prot_size = %x, mmap_size = %x\n",
@ -379,12 +226,14 @@ allocate_pages (grub_size_t prot_size)
/* FIXME: Should request low memory from the heap when this feature is
implemented. */
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)
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t,
grub_memory_type_t);
int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size,
grub_memory_type_t type)
{
/* We must put real mode code in the traditional space. */
if (type == GRUB_MACHINE_MEMORY_AVAILABLE
if (type == GRUB_MEMORY_AVAILABLE
&& addr <= 0x90000)
{
if (addr < 0x10000)
@ -447,7 +296,7 @@ allocate_pages (grub_size_t prot_size)
return err;
}
static void
static grub_err_t
grub_e820_add_region (struct grub_e820_mmap *e820_map, int *e820_num,
grub_uint64_t start, grub_uint64_t size,
grub_uint32_t type)
@ -455,7 +304,10 @@ grub_e820_add_region (struct grub_e820_mmap *e820_map, int *e820_num,
int n = *e820_num;
if (n >= GRUB_E820_MAX_ENTRY)
grub_fatal ("Too many e820 memory map entries");
{
return grub_error (GRUB_ERR_OUT_OF_RANGE,
"Too many e820 memory map entries");
}
if ((n > 0) && (e820_map[n - 1].addr + e820_map[n - 1].size == start) &&
(e820_map[n - 1].type == type))
@ -467,6 +319,7 @@ grub_e820_add_region (struct grub_e820_mmap *e820_map, int *e820_num,
e820_map[n].type = type;
(*e820_num)++;
}
return GRUB_ERR_NONE;
}
static grub_err_t
@ -475,6 +328,13 @@ grub_linux_setup_video (struct linux_kernel_params *params)
struct grub_video_mode_info mode_info;
void *framebuffer;
grub_err_t err;
grub_video_driver_id_t driver_id;
const char *gfxlfbvar = grub_env_get ("gfxpayloadforcelfb");
driver_id = grub_video_get_driver_id ();
if (driver_id == GRUB_VIDEO_DRIVER_NONE)
return 1;
err = grub_video_get_info_and_fini (&mode_info, &framebuffer);
@ -501,12 +361,42 @@ grub_linux_setup_video (struct linux_kernel_params *params)
params->reserved_mask_size = mode_info.reserved_mask_size;
params->reserved_field_pos = mode_info.reserved_field_pos;
if (gfxlfbvar && (gfxlfbvar[0] == '1' || gfxlfbvar[0] == 'y'))
params->have_vga = GRUB_VIDEO_LINUX_TYPE_SIMPLE;
else
{
switch (driver_id)
{
case GRUB_VIDEO_DRIVER_VBE:
params->lfb_size >>= 16;
params->have_vga = GRUB_VIDEO_LINUX_TYPE_VESA;
break;
case GRUB_VIDEO_DRIVER_EFI_UGA:
case GRUB_VIDEO_DRIVER_EFI_GOP:
params->have_vga = GRUB_VIDEO_LINUX_TYPE_EFIFB;
break;
/* FIXME: check if better id is available. */
case GRUB_VIDEO_DRIVER_SM712:
case GRUB_VIDEO_DRIVER_SIS315PRO:
case GRUB_VIDEO_DRIVER_VGA:
case GRUB_VIDEO_DRIVER_CIRRUS:
case GRUB_VIDEO_DRIVER_BOCHS:
case GRUB_VIDEO_DRIVER_RADEON_FULOONG2E:
/* Make gcc happy. */
case GRUB_VIDEO_DRIVER_SDL:
case GRUB_VIDEO_DRIVER_NONE:
params->have_vga = GRUB_VIDEO_LINUX_TYPE_SIMPLE;
break;
}
}
#ifdef GRUB_MACHINE_PCBIOS
/* VESA packed modes may come with zeroed mask sizes, which need
to be set here according to DAC Palette width. If we don't,
this results in Linux displaying a black screen. */
if (mode_info.bpp <= 8)
if (driver_id == GRUB_VIDEO_DRIVER_VBE && mode_info.bpp <= 8)
{
struct grub_vbe_info_block controller_info;
int status;
@ -537,14 +427,15 @@ grub_linux_boot (void)
struct linux_kernel_params *params;
int e820_num;
grub_err_t err = 0;
char *modevar, *tmp;
const char *modevar;
char *tmp;
struct grub_relocator32_state state;
params = real_mode_mem;
#ifdef GRUB_MACHINE_IEEE1275
{
char *bootpath;
const char *bootpath;
grub_ssize_t len;
bootpath = grub_env_get ("root");
@ -559,46 +450,43 @@ grub_linux_boot (void)
grub_dprintf ("linux", "code32_start = %x\n",
(unsigned) params->code32_start);
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)
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t,
grub_memory_type_t);
int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size,
grub_memory_type_t type)
{
grub_uint32_t e820_type;
switch (type)
{
case GRUB_MACHINE_MEMORY_AVAILABLE:
grub_e820_add_region (params->e820_map, &e820_num,
addr, size, GRUB_E820_RAM);
case GRUB_MEMORY_AVAILABLE:
e820_type = GRUB_E820_RAM;
break;
#ifdef GRUB_MACHINE_MEMORY_ACPI
case GRUB_MACHINE_MEMORY_ACPI:
grub_e820_add_region (params->e820_map, &e820_num,
addr, size, GRUB_E820_ACPI);
case GRUB_MEMORY_ACPI:
e820_type = GRUB_E820_ACPI;
break;
#endif
#ifdef GRUB_MACHINE_MEMORY_NVS
case GRUB_MACHINE_MEMORY_NVS:
grub_e820_add_region (params->e820_map, &e820_num,
addr, size, GRUB_E820_NVS);
case GRUB_MEMORY_NVS:
e820_type = GRUB_E820_NVS;
break;
#endif
#ifdef GRUB_MACHINE_MEMORY_CODE
case GRUB_MACHINE_MEMORY_CODE:
grub_e820_add_region (params->e820_map, &e820_num,
addr, size, GRUB_E820_EXEC_CODE);
case GRUB_MEMORY_BADRAM:
e820_type = GRUB_E820_BADRAM;
break;
#endif
default:
grub_e820_add_region (params->e820_map, &e820_num,
addr, size, GRUB_E820_RESERVED);
e820_type = GRUB_E820_RESERVED;
}
if (grub_e820_add_region (params->e820_map, &e820_num,
addr, size, e820_type))
return 1;
return 0;
}
e820_num = 0;
grub_mmap_iterate (hook);
if (grub_mmap_iterate (hook))
return grub_errno;
params->mmap_size = e820_num;
modevar = grub_env_get ("gfxpayload");
@ -610,28 +498,30 @@ grub_linux_boot (void)
tmp = grub_xasprintf ("%s;" DEFAULT_VIDEO_MODE, modevar);
if (! tmp)
return grub_errno;
#if ACCEPTS_PURE_TEXT
err = grub_video_set_mode (tmp, 0, 0);
#else
err = grub_video_set_mode (tmp, GRUB_VIDEO_MODE_TYPE_PURE_TEXT, 0);
#endif
grub_free (tmp);
}
else
err = grub_video_set_mode (DEFAULT_VIDEO_MODE, 0, 0);
{
#if ACCEPTS_PURE_TEXT
err = grub_video_set_mode (DEFAULT_VIDEO_MODE, 0, 0);
#else
err = grub_video_set_mode (DEFAULT_VIDEO_MODE,
GRUB_VIDEO_MODE_TYPE_PURE_TEXT, 0);
#endif
}
if (err)
{
grub_print_error ();
grub_printf ("Booting however\n");
grub_puts_ (N_("Booting in blind mode"));
grub_errno = GRUB_ERR_NONE;
}
if (! grub_linux_setup_video (params))
{
/* Use generic framebuffer unless VESA is known to be supported. */
if (params->have_vga != GRUB_VIDEO_LINUX_TYPE_VESA)
params->have_vga = GRUB_VIDEO_LINUX_TYPE_SIMPLE;
else
params->lfb_size >>= 16;
}
else
if (grub_linux_setup_video (params))
{
#if defined (GRUB_MACHINE_PCBIOS) || defined (GRUB_MACHINE_COREBOOT) || defined (GRUB_MACHINE_QEMU)
params->have_vga = GRUB_VIDEO_LINUX_TYPE_TEXT;
@ -685,6 +575,7 @@ grub_linux_boot (void)
#ifdef GRUB_MACHINE_EFI
{
grub_efi_uintn_t efi_desc_size;
grub_size_t efi_mmap_target;
grub_efi_uint32_t efi_desc_version;
err = grub_efi_finish_boot_services (&efi_mmap_size, efi_mmap_buf, NULL,
&efi_desc_size, &efi_desc_version);
@ -692,23 +583,24 @@ grub_linux_boot (void)
return err;
/* Note that no boot services are available from here. */
efi_mmap_target = real_mode_target
+ ((grub_uint8_t *) efi_mmap_buf - (grub_uint8_t *) real_mode_mem);
/* Pass EFI parameters. */
if (grub_le_to_cpu16 (params->version) >= 0x0206)
{
params->v0206.efi_mem_desc_size = efi_desc_size;
params->v0206.efi_mem_desc_version = efi_desc_version;
params->v0206.efi_mmap = (grub_uint32_t) (unsigned long) efi_mmap_buf;
params->v0206.efi_mmap = efi_mmap_target;
params->v0206.efi_mmap_size = efi_mmap_size;
#ifdef __x86_64__
params->v0206.efi_mmap_hi = (grub_uint32_t) ((grub_uint64_t) efi_mmap_buf >> 32);
params->v0206.efi_mmap_hi = (efi_mmap_target >> 32);
#endif
}
else if (grub_le_to_cpu16 (params->version) >= 0x0204)
{
params->v0204.efi_mem_desc_size = efi_desc_size;
params->v0204.efi_mem_desc_version = efi_desc_version;
params->v0204.efi_mmap = (grub_uint32_t) (unsigned long) efi_mmap_buf;
params->v0204.efi_mmap = efi_mmap_target;
params->v0204.efi_mmap_size = efi_mmap_size;
}
}
@ -742,7 +634,6 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_size_t real_size, prot_size;
grub_ssize_t len;
int i;
char *dest;
grub_dl_ref (my_mod);
@ -797,6 +688,14 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
goto fail;
}
if (grub_le_to_cpu16 (lh.version) >= 0x0206)
maximal_cmdline_size = grub_le_to_cpu32 (lh.cmdline_size) + 1;
else
maximal_cmdline_size = 256;
if (maximal_cmdline_size < 128)
maximal_cmdline_size = 128;
setup_sects = lh.setup_sects;
/* If SETUP_SECTS is not set, set it to the default (4). */
@ -810,7 +709,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
goto fail;
params = (struct linux_kernel_params *) real_mode_mem;
grub_memset (params, 0, GRUB_LINUX_CL_END_OFFSET);
grub_memset (params, 0, GRUB_LINUX_CL_OFFSET + maximal_cmdline_size);
grub_memcpy (&params->setup_sects, &lh.setup_sects, sizeof (lh) - 0x1F1);
params->ps_mouse = params->padding10 = 0;
@ -822,7 +721,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
goto fail;
}
params->type_of_loader = (LINUX_LOADER_ID_GRUB << 4);
params->type_of_loader = GRUB_LINUX_BOOT_LOADER_TYPE;
/* These two are used (instead of cmd_line_ptr) by older versions of Linux,
and otherwise ignored. */
@ -882,17 +781,19 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
/* Video mode selection support. */
char *val = argv[i] + 4;
unsigned vid_mode = GRUB_LINUX_VID_MODE_NORMAL;
struct linux_vesafb_mode *linux_mode;
struct grub_vesa_mode_table_entry *linux_mode;
grub_err_t err;
char *buf;
grub_dl_load ("vbe");
if (grub_strcmp (val, "normal") == 0)
vid_mode = GRUB_LINUX_VID_MODE_NORMAL;
else if (grub_strcmp (val, "ext") == 0)
vid_mode = GRUB_LINUX_VID_MODE_EXTENDED;
else if (grub_strcmp (val, "ask") == 0)
{
grub_printf ("Legacy `ask' parameter no longer supported.\n");
grub_puts_ (N_("Legacy `ask' parameter no longer supported."));
/* We usually would never do this in a loader, but "vga=ask" means user
requested interaction, so it can't hurt to request keyboard input. */
@ -908,9 +809,9 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
case 0:
case GRUB_LINUX_VID_MODE_NORMAL:
grub_env_set ("gfxpayload", "text");
grub_printf ("%s is deprecated. "
"Use set gfxpayload=text before "
"linux command instead.\n",
grub_printf_ (N_("%s is deprecated. "
"Use set gfxpayload=text before "
"linux command instead.\n"),
argv[i]);
break;
@ -918,44 +819,37 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
case GRUB_LINUX_VID_MODE_EXTENDED:
/* FIXME: support 80x50 text. */
grub_env_set ("gfxpayload", "text");
grub_printf ("%s is deprecated. "
"Use set gfxpayload=text before "
"linux command instead.\n",
grub_printf_ (N_("%s is deprecated. "
"Use set gfxpayload=text before "
"linux command instead.\n"),
argv[i]);
break;
default:
/* Ignore invalid values. */
if (vid_mode < GRUB_LINUX_VID_MODE_VESA_START ||
vid_mode >= GRUB_LINUX_VID_MODE_VESA_START +
ARRAY_SIZE (linux_vesafb_modes))
if (vid_mode < GRUB_VESA_MODE_TABLE_START ||
vid_mode > GRUB_VESA_MODE_TABLE_END)
{
grub_env_set ("gfxpayload", "text");
grub_printf ("%s is deprecated. Mode %d isn't recognized. "
"Use set gfxpayload=WIDTHxHEIGHT[xDEPTH] before "
"linux command instead.\n",
grub_printf_ (N_("%s is deprecated. Mode %d isn't recognized. "
"Use set gfxpayload=WIDTHxHEIGHT[xDEPTH] "
"before linux command instead.\n"),
argv[i], vid_mode);
break;
}
/* We can't detect VESA, but user is implicitly telling us that it
is built-in because `vga=' parameter was used. */
params->have_vga = GRUB_VIDEO_LINUX_TYPE_VESA;
linux_mode
= &linux_vesafb_modes[vid_mode - GRUB_LINUX_VID_MODE_VESA_START];
linux_mode = &grub_vesa_mode_table[vid_mode
- GRUB_VESA_MODE_TABLE_START];
buf = grub_xasprintf ("%ux%ux%u,%ux%u",
linux_vesafb_res[linux_mode->res_index].width,
linux_vesafb_res[linux_mode->res_index].height,
linux_mode->width, linux_mode->height,
linux_mode->depth,
linux_vesafb_res[linux_mode->res_index].width,
linux_vesafb_res[linux_mode->res_index].height);
linux_mode->width, linux_mode->height);
if (! buf)
goto fail;
grub_printf ("%s is deprecated. "
"Use set gfxpayload=%s before "
"linux command instead.\n",
grub_printf_ (N_("%s is deprecated. "
"Use set gfxpayload=%s before "
"linux command instead.\n"),
argv[i], buf);
err = grub_env_set ("gfxpayload", buf);
grub_free (buf);
@ -1004,22 +898,14 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
params->loadflags |= GRUB_LINUX_FLAG_QUIET;
}
/* Specify the boot file. */
dest = grub_stpcpy ((char *) real_mode_mem + GRUB_LINUX_CL_OFFSET,
"BOOT_IMAGE=");
dest = grub_stpcpy (dest, argv[0]);
/* Copy kernel parameters. */
for (i = 1;
i < argc
&& dest + grub_strlen (argv[i]) + 1 < ((char *) real_mode_mem
+ GRUB_LINUX_CL_END_OFFSET);
i++)
{
*dest++ = ' ';
dest = grub_stpcpy (dest, argv[i]);
}
/* Create kernel command line. */
grub_memcpy ((char *)real_mode_mem + GRUB_LINUX_CL_OFFSET, LINUX_IMAGE,
sizeof (LINUX_IMAGE));
grub_create_loader_cmdline (argc, argv,
(char *)real_mode_mem + GRUB_LINUX_CL_OFFSET
+ sizeof (LINUX_IMAGE) - 1,
maximal_cmdline_size
- (sizeof (LINUX_IMAGE) - 1));
len = prot_size;
if (grub_file_read (file, prot_mode_mem, len) != len)

208
grub-core/loader/i386/multiboot_mbi.c
View file

@ -16,10 +16,11 @@
* 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>
#include <grub/machine/apm.h>
#include <grub/machine/memory.h>
#endif
#include <grub/multiboot.h>
#include <grub/cpu/relocator.h>
@ -32,6 +33,7 @@
#include <grub/relocator.h>
#include <grub/video.h>
#include <grub/file.h>
#include <grub/net.h>
/* The bits in the required part of flags field we don't support. */
#define UNSUPPORTED_FLAGS 0x0000fff8
@ -45,7 +47,7 @@ struct module
int cmdline_size;
};
struct module *modules, *modules_last;
static struct module *modules, *modules_last;
static grub_size_t cmdline_size;
static grub_size_t total_modcmd;
static unsigned modcnt;
@ -140,7 +142,7 @@ grub_multiboot_load (grub_file_t file)
}
if (header->bss_end_addr)
grub_memset ((grub_uint32_t *) source + load_size, 0,
grub_memset ((grub_uint8_t *) source + load_size, 0,
header->bss_end_addr - header->load_addr - load_size);
grub_multiboot_payload_eip = header->entry_addr;
@ -186,15 +188,36 @@ grub_multiboot_load (grub_file_t file)
return err;
}
#if GRUB_MACHINE_HAS_VBE || GRUB_MACHINE_HAS_VGA_TEXT
#include <grub/i386/pc/vbe.h>
#endif
static grub_size_t
grub_multiboot_get_mbi_size (void)
{
return sizeof (struct multiboot_info) + ALIGN_UP (cmdline_size, 4)
grub_size_t ret;
struct grub_net_network_level_interface *net;
ret = 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
+ 256 * sizeof (struct multiboot_color);
+ 256 * sizeof (struct multiboot_color)
#if GRUB_MACHINE_HAS_VBE || GRUB_MACHINE_HAS_VGA_TEXT
+ sizeof (struct grub_vbe_info_block)
+ sizeof (struct grub_vbe_mode_info_block)
#endif
+ ALIGN_UP (sizeof (struct multiboot_apm_info), 4);
FOR_NET_NETWORK_LEVEL_INTERFACES(net)
if (net->dhcp_ack)
{
ret += net->dhcp_acklen;
break;
}
return ret;
}
/* Fill previously allocated Multiboot mmap. */
@ -203,28 +226,30 @@ 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)
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t,
grub_memory_type_t);
int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size,
grub_memory_type_t type)
{
mmap_entry->addr = addr;
mmap_entry->len = size;
switch (type)
{
case GRUB_MACHINE_MEMORY_AVAILABLE:
case GRUB_MEMORY_AVAILABLE:
mmap_entry->type = MULTIBOOT_MEMORY_AVAILABLE;
break;
#ifdef GRUB_MACHINE_MEMORY_ACPI_RECLAIMABLE
case GRUB_MACHINE_MEMORY_ACPI_RECLAIMABLE:
case GRUB_MEMORY_ACPI:
mmap_entry->type = MULTIBOOT_MEMORY_ACPI_RECLAIMABLE;
break;
#endif
#ifdef GRUB_MACHINE_MEMORY_NVS
case GRUB_MACHINE_MEMORY_NVS:
case GRUB_MEMORY_NVS:
mmap_entry->type = MULTIBOOT_MEMORY_NVS;
break;
#endif
case GRUB_MEMORY_BADRAM:
mmap_entry->type = MULTIBOOT_MEMORY_BADRAM;
break;
default:
mmap_entry->type = MULTIBOOT_MEMORY_RESERVED;
@ -239,6 +264,90 @@ grub_fill_multiboot_mmap (struct multiboot_mmap_entry *first_entry)
grub_mmap_iterate (hook);
}
#if GRUB_MACHINE_HAS_VBE || GRUB_MACHINE_HAS_VGA_TEXT
static grub_err_t
fill_vbe_info (struct multiboot_info *mbi, grub_uint8_t *ptrorig,
grub_uint32_t ptrdest, int fill_generic)
{
grub_uint32_t vbe_mode;
struct grub_vbe_mode_info_block *mode_info;
#if GRUB_MACHINE_HAS_VBE
grub_vbe_status_t status;
void *scratch = (void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
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);
#else
mbi->vbe_control_info = 0;
#endif
#if GRUB_MACHINE_HAS_VBE
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");
#else
vbe_mode = 3;
#endif
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
{
#if GRUB_MACHINE_HAS_VBE
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));
#endif
}
ptrorig += sizeof (struct grub_vbe_mode_info_block);
ptrdest += sizeof (struct grub_vbe_mode_info_block);
#if GRUB_MACHINE_HAS_VBE
grub_vbe_bios_get_pm_interface (&mbi->vbe_interface_seg,
&mbi->vbe_interface_off,
&mbi->vbe_interface_len);
#endif
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)
@ -259,8 +368,13 @@ retrieve_video_parameters (struct multiboot_info *mbi,
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)
@ -308,6 +422,11 @@ retrieve_video_parameters (struct multiboot_info *mbi,
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;
}
@ -329,13 +448,13 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
bufsize = grub_multiboot_get_mbi_size ();
err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator, &ch,
0, 0xffffffff - bufsize,
0x10000, 0x100000 - 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);
ptrdest = get_physical_target_address (ch);
*target = ptrdest;
@ -356,6 +475,29 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
ptrorig += ALIGN_UP (sizeof(PACKAGE_STRING), 4);
ptrdest += ALIGN_UP (sizeof(PACKAGE_STRING), 4);
#ifdef GRUB_MACHINE_PCBIOS
{
struct grub_apm_info info;
if (grub_apm_get_info (&info))
{
struct multiboot_apm_info *mbinfo = (void *) ptrorig;
mbinfo->cseg = info.cseg;
mbinfo->offset = info.offset;
mbinfo->cseg_16 = info.cseg_16;
mbinfo->dseg = info.dseg;
mbinfo->flags = info.flags;
mbinfo->cseg_len = info.cseg_len;
mbinfo->dseg_len = info.dseg_len;
mbinfo->cseg_16_len = info.cseg_16_len;
mbinfo->version = info.version;
ptrorig += ALIGN_UP (sizeof (struct multiboot_apm_info), 4);
ptrdest += ALIGN_UP (sizeof (struct multiboot_apm_info), 4);
}
}
#endif
if (modcnt)
{
mbi->flags |= MULTIBOOT_INFO_MODS;
@ -401,6 +543,20 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
mbi->flags |= MULTIBOOT_INFO_BOOTDEV;
}
{
struct grub_net_network_level_interface *net;
FOR_NET_NETWORK_LEVEL_INTERFACES(net)
if (net->dhcp_ack)
{
grub_memcpy (ptrorig, net->dhcp_ack, net->dhcp_acklen);
mbi->drives_addr = ptrdest;
mbi->drives_length = net->dhcp_acklen;
ptrorig += net->dhcp_acklen;
ptrdest += net->dhcp_acklen;
break;
}
}
if (elf_sec_num)
{
mbi->u.elf_sec.addr = ptrdest;
@ -410,6 +566,9 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
mbi->u.elf_sec.shndx = elf_sec_shstrndx;
mbi->flags |= MULTIBOOT_INFO_ELF_SHDR;
ptrorig += elf_sec_entsize * elf_sec_num;
ptrdest += elf_sec_entsize * elf_sec_num;
}
err = retrieve_video_parameters (mbi, ptrorig, ptrdest);
@ -419,6 +578,22 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
grub_errno = GRUB_ERR_NONE;
}
if ((mbi->flags & MULTIBOOT_INFO_FRAMEBUFFER_INFO)
&& mbi->framebuffer_type == MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED)
{
ptrorig += mbi->framebuffer_palette_num_colors
* sizeof (struct multiboot_color);
ptrdest += mbi->framebuffer_palette_num_colors
* sizeof (struct multiboot_color);
}
#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;
}
@ -506,6 +681,7 @@ grub_multiboot_add_module (grub_addr_t start, grub_size_t size,
return grub_errno;
newmod->start = start;
newmod->size = size;
newmod->next = 0;
for (i = 0; i < argc; i++)
len += grub_strlen (argv[i]) + 1;

155
grub-core/loader/i386/pc/chainloader.c
View file

@ -18,8 +18,8 @@
*/
#include <grub/loader.h>
#include <grub/machine/loader.h>
#include <grub/machine/chainloader.h>
#include <grub/machine/memory.h>
#include <grub/file.h>
#include <grub/err.h>
#include <grub/device.h>
@ -27,7 +27,7 @@
#include <grub/misc.h>
#include <grub/types.h>
#include <grub/partition.h>
#include <grub/machine/memory.h>
#include <grub/memory.h>
#include <grub/dl.h>
#include <grub/command.h>
#include <grub/msdos_partition.h>
@ -36,28 +36,110 @@
#include <grub/i18n.h>
#include <grub/video.h>
#include <grub/mm.h>
#include <grub/fat.h>
#include <grub/ntfs.h>
#include <grub/i386/relocator.h>
GRUB_MOD_LICENSE ("GPLv3+");
static grub_dl_t my_mod;
static int boot_drive;
static void *boot_part_addr;
static grub_addr_t boot_part_addr;
static struct grub_relocator *rel;
typedef enum
{
GRUB_CHAINLOADER_FORCE = 0x1,
GRUB_CHAINLOADER_BPB = 0x2,
} grub_chainloader_flags_t;
static grub_err_t
grub_chainloader_boot (void)
{
struct grub_relocator16_state state = {
.edx = boot_drive,
.esi = boot_part_addr,
.ds = 0,
.es = 0,
.fs = 0,
.gs = 0,
.ss = 0,
.cs = 0,
.sp = GRUB_MEMORY_MACHINE_BOOT_LOADER_ADDR,
.ip = GRUB_MEMORY_MACHINE_BOOT_LOADER_ADDR,
.a20 = 0
};
grub_video_set_mode ("text", 0, 0);
grub_chainloader_real_boot (boot_drive, boot_part_addr);
/* Never reach here. */
return GRUB_ERR_NONE;
return grub_relocator16_boot (rel, state);
}
static grub_err_t
grub_chainloader_unload (void)
{
grub_relocator_unload (rel);
rel = NULL;
grub_dl_unref (my_mod);
return GRUB_ERR_NONE;
}
void
grub_chainloader_patch_bpb (void *bs, grub_device_t dev, grub_uint8_t dl)
{
grub_uint32_t part_start = 0;
if (dev && dev->disk)
part_start = grub_partition_get_start (dev->disk->partition);
if (grub_memcmp ((char *) &((struct grub_ntfs_bpb *) bs)->oem_name,
"NTFS", 4) == 0)
{
struct grub_ntfs_bpb *bpb = (struct grub_ntfs_bpb *) bs;
bpb->num_hidden_sectors = grub_cpu_to_le32 (part_start);
bpb->bios_drive = dl;
return;
}
do
{
struct grub_fat_bpb *bpb = (struct grub_fat_bpb *) bs;
if (grub_strncmp((const char *) bpb->version_specific.fat12_or_fat16.fstype, "FAT12", 5)
&& grub_strncmp((const char *) bpb->version_specific.fat12_or_fat16.fstype, "FAT16", 5)
&& grub_strncmp((const char *) bpb->version_specific.fat32.fstype, "FAT32", 5))
break;
if (grub_le_to_cpu16 (bpb->bytes_per_sector) < 512
|| (grub_le_to_cpu16 (bpb->bytes_per_sector)
& (grub_le_to_cpu16 (bpb->bytes_per_sector) - 1)))
break;
if (bpb->sectors_per_cluster == 0
|| (bpb->sectors_per_cluster & (bpb->sectors_per_cluster - 1)))
break;
if (bpb->num_reserved_sectors == 0)
break;
if (bpb->num_total_sectors_16 == 0 || bpb->num_total_sectors_32 == 0)
break;
if (bpb->num_fats == 0)
break;
if (bpb->sectors_per_fat_16)
{
bpb->num_hidden_sectors = grub_cpu_to_le32 (part_start);
bpb->version_specific.fat12_or_fat16.num_ph_drive = dl;
return;
}
if (bpb->version_specific.fat32.sectors_per_fat_32)
{
bpb->num_hidden_sectors = grub_cpu_to_le32 (part_start);
bpb->version_specific.fat32.num_ph_drive = dl;
return;
}
break;
}
while (0);
}
static void
grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
{
@ -65,7 +147,12 @@ grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
grub_uint16_t signature;
grub_device_t dev;
int drive = -1;
void *part_addr = 0;
grub_addr_t part_addr = 0;
grub_uint8_t *bs, *ptable;
rel = grub_relocator_new ();
if (!rel)
goto fail;
grub_dl_ref (my_mod);
@ -74,8 +161,25 @@ grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
if (! file)
goto fail;
{
grub_relocator_chunk_t ch;
grub_err_t err;
err = grub_relocator_alloc_chunk_addr (rel, &ch, 0x7C00,
GRUB_DISK_SECTOR_SIZE);
if (err)
goto fail;
bs = get_virtual_current_address (ch);
err = grub_relocator_alloc_chunk_addr (rel, &ch,
GRUB_MEMORY_MACHINE_PART_TABLE_ADDR,
64);
if (err)
goto fail;
ptable = get_virtual_current_address (ch);
}
/* Read the first block. */
if (grub_file_read (file, (void *) 0x7C00, GRUB_DISK_SECTOR_SIZE)
if (grub_file_read (file, bs, GRUB_DISK_SECTOR_SIZE)
!= GRUB_DISK_SECTOR_SIZE)
{
if (grub_errno == GRUB_ERR_NONE)
@ -85,7 +189,7 @@ grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
}
/* Check the signature. */
signature = *((grub_uint16_t *) (0x7C00 + GRUB_DISK_SECTOR_SIZE - 2));
signature = *((grub_uint16_t *) (bs + GRUB_DISK_SECTOR_SIZE - 2));
if (signature != grub_le_to_cpu16 (0xaa55)
&& ! (flags & GRUB_CHAINLOADER_FORCE))
{
@ -109,15 +213,17 @@ grub_chainloader_cmd (const char *filename, grub_chainloader_flags_t flags)
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));
grub_disk_read (disk, p->offset, 446, 64, ptable);
part_addr = (GRUB_MEMORY_MACHINE_PART_TABLE_ADDR
+ (p->index << 4));
disk->partition = p;
}
}
}
if (flags & GRUB_CHAINLOADER_BPB)
grub_chainloader_patch_bpb ((void *) 0x7C00, dev, drive);
if (dev)
grub_device_close (dev);
@ -144,11 +250,23 @@ grub_cmd_chainloader (grub_command_t cmd __attribute__ ((unused)),
{
grub_chainloader_flags_t flags = 0;
if (argc > 0 && grub_strcmp (argv[0], "--force") == 0)
while (argc > 0)
{
flags |= GRUB_CHAINLOADER_FORCE;
argc--;
argv++;
if (grub_strcmp (argv[0], "--force") == 0)
{
flags |= GRUB_CHAINLOADER_FORCE;
argc--;
argv++;
continue;
}
if (grub_strcmp (argv[0], "--bpb") == 0)
{
flags |= GRUB_CHAINLOADER_BPB;
argc--;
argv++;
continue;
}
break;
}
if (argc == 0)
@ -164,7 +282,8 @@ static grub_command_t cmd;
GRUB_MOD_INIT(chainloader)
{
cmd = grub_register_command ("chainloader", grub_cmd_chainloader,
0, N_("Load another boot loader."));
N_("[--force|--bpb] FILE"),
N_("Load another boot loader."));
my_mod = mod;
}

139
grub-core/loader/i386/pc/freedos.c Normal file
View file

@ -0,0 +1,139 @@
/* chainloader.c - boot another boot loader */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2002,2004,2007,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/>.
*/
#include <grub/loader.h>
#include <grub/file.h>
#include <grub/err.h>
#include <grub/device.h>
#include <grub/disk.h>
#include <grub/misc.h>
#include <grub/types.h>
#include <grub/partition.h>
#include <grub/dl.h>
#include <grub/command.h>
#include <grub/machine/biosnum.h>
#include <grub/i18n.h>
#include <grub/video.h>
#include <grub/mm.h>
#include <grub/cpu/relocator.h>
GRUB_MOD_LICENSE ("GPLv3+");
static grub_dl_t my_mod;
static struct grub_relocator *rel;
static grub_uint32_t ebx = 0xffffffff;
#define GRUB_FREEDOS_SEGMENT 0x60
#define GRUB_FREEDOS_STACK_SEGMENT 0x1fe0
#define GRUB_FREEDOS_STACK_POINTER 0x8000
static grub_err_t
grub_freedos_boot (void)
{
struct grub_relocator16_state state = {
.cs = GRUB_FREEDOS_SEGMENT,
.ip = 0,
.ds = 0,
.es = 0,
.fs = 0,
.gs = 0,
.ss = GRUB_FREEDOS_STACK_SEGMENT,
.sp = GRUB_FREEDOS_STACK_POINTER,
.ebx = ebx,
.edx = 0,
.a20 = 1
};
grub_video_set_mode ("text", 0, 0);
return grub_relocator16_boot (rel, state);
}
static grub_err_t
grub_freedos_unload (void)
{
grub_relocator_unload (rel);
rel = NULL;
grub_dl_unref (my_mod);
return GRUB_ERR_NONE;
}
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 *kernelsys;
grub_size_t kernelsyssize;
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;
ebx = grub_get_root_biosnumber ();
kernelsyssize = grub_file_size (file);
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (rel, &ch, GRUB_FREEDOS_SEGMENT << 4,
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_command_t cmd;
GRUB_MOD_INIT(freedos)
{
cmd = grub_register_command ("freedos", grub_cmd_freedos,
0, N_("Load FreeDOS kernel.sys."));
my_mod = mod;
}
GRUB_MOD_FINI(freedos)
{
grub_unregister_command (cmd);
}

51
grub-core/loader/i386/pc/linux.c
View file

@ -18,14 +18,13 @@
*/
#include <grub/loader.h>
#include <grub/machine/loader.h>
#include <grub/file.h>
#include <grub/err.h>
#include <grub/device.h>
#include <grub/disk.h>
#include <grub/misc.h>
#include <grub/types.h>
#include <grub/machine/memory.h>
#include <grub/memory.h>
#include <grub/dl.h>
#include <grub/cpu/linux.h>
#include <grub/command.h>
@ -34,9 +33,11 @@
#include <grub/cpu/relocator.h>
#include <grub/video.h>
#include <grub/i386/floppy.h>
#include <grub/lib/cmdline.h>
GRUB_MOD_LICENSE ("GPLv3+");
#define GRUB_LINUX_CL_OFFSET 0x9000
#define GRUB_LINUX_CL_END_OFFSET 0x90FF
static grub_dl_t my_mod;
@ -46,6 +47,7 @@ static struct grub_relocator *relocator = NULL;
static grub_addr_t grub_linux_real_target;
static char *grub_linux_real_chunk;
static grub_size_t grub_linux16_prot_size;
static grub_size_t maximal_cmdline_size;
static grub_err_t
grub_linux16_boot (void)
@ -58,6 +60,7 @@ grub_linux16_boot (void)
state.sp = GRUB_LINUX_SETUP_STACK;
state.cs = segment + 0x20;
state.ip = 0;
state.a20 = 1;
grub_video_set_mode ("text", 0, 0);
@ -86,7 +89,6 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_size_t real_size;
grub_ssize_t len;
int i;
char *dest;
char *grub_linux_prot_chunk;
int grub_linux_is_bzimage;
grub_addr_t grub_linux_prot_target;
@ -126,15 +128,20 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
setup_sects = lh.setup_sects;
linux_mem_size = 0;
maximal_cmdline_size = 256;
if (lh.header == grub_cpu_to_le32 (GRUB_LINUX_MAGIC_SIGNATURE)
&& grub_le_to_cpu16 (lh.version) >= 0x0200)
{
grub_linux_is_bzimage = (lh.loadflags & GRUB_LINUX_FLAG_BIG_KERNEL);
lh.type_of_loader = GRUB_LINUX_BOOT_LOADER_TYPE;
if (grub_le_to_cpu16 (lh.version) >= 0x0206)
maximal_cmdline_size = grub_le_to_cpu32 (lh.cmdline_size) + 1;
/* Put the real mode part at as a high location as possible. */
grub_linux_real_target = grub_mmap_get_lower ()
- GRUB_LINUX_SETUP_MOVE_SIZE;
- (GRUB_LINUX_CL_OFFSET + maximal_cmdline_size);
/* But it must not exceed the traditional area. */
if (grub_linux_real_target > GRUB_LINUX_OLD_REAL_MODE_ADDR)
grub_linux_real_target = GRUB_LINUX_OLD_REAL_MODE_ADDR;
@ -151,7 +158,8 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
{
lh.cl_magic = grub_cpu_to_le16 (GRUB_LINUX_CL_MAGIC);
lh.cl_offset = grub_cpu_to_le16 (GRUB_LINUX_CL_OFFSET);
lh.setup_move_size = grub_cpu_to_le16 (GRUB_LINUX_SETUP_MOVE_SIZE);
lh.setup_move_size = grub_cpu_to_le16 (GRUB_LINUX_CL_OFFSET
+ maximal_cmdline_size);
}
}
else
@ -183,12 +191,13 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
goto fail;
}
if (grub_linux_real_target + GRUB_LINUX_SETUP_MOVE_SIZE
if (grub_linux_real_target + GRUB_LINUX_CL_OFFSET + maximal_cmdline_size
> grub_mmap_get_lower ())
{
grub_error (GRUB_ERR_OUT_OF_RANGE,
"too small lower memory (0x%x > 0x%x)",
grub_linux_real_target + GRUB_LINUX_SETUP_MOVE_SIZE,
grub_linux_real_target + GRUB_LINUX_CL_OFFSET
+ maximal_cmdline_size,
(int) grub_mmap_get_lower ());
goto fail;
}
@ -261,7 +270,8 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
grub_linux_real_target,
GRUB_LINUX_SETUP_MOVE_SIZE);
GRUB_LINUX_CL_OFFSET
+ maximal_cmdline_size);
if (err)
return err;
grub_linux_real_chunk = get_virtual_current_address (ch);
@ -286,21 +296,14 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
((GRUB_LINUX_MAX_SETUP_SECTS - setup_sects - 1)
<< GRUB_DISK_SECTOR_BITS));
/* Specify the boot file. */
dest = grub_stpcpy (grub_linux_real_chunk + GRUB_LINUX_CL_OFFSET,
"BOOT_IMAGE=");
dest = grub_stpcpy (dest, argv[0]);
/* Copy kernel parameters. */
for (i = 1;
i < argc
&& dest + grub_strlen (argv[i]) + 1 < (grub_linux_real_chunk
+ GRUB_LINUX_CL_END_OFFSET);
i++)
{
*dest++ = ' ';
dest = grub_stpcpy (dest, argv[i]);
}
/* Create kernel command line. */
grub_memcpy ((char *)grub_linux_real_chunk + GRUB_LINUX_CL_OFFSET,
LINUX_IMAGE, sizeof (LINUX_IMAGE));
grub_create_loader_cmdline (argc, argv,
(char *)grub_linux_real_chunk
+ GRUB_LINUX_CL_OFFSET + sizeof (LINUX_IMAGE) - 1,
maximal_cmdline_size
- (sizeof (LINUX_IMAGE) - 1));
if (grub_linux_is_bzimage)
grub_linux_prot_target = GRUB_LINUX_BZIMAGE_ADDR;

7
grub-core/loader/i386/pc/ntldr.c
View file

@ -32,6 +32,9 @@
#include <grub/video.h>
#include <grub/mm.h>
#include <grub/cpu/relocator.h>
#include <grub/machine/chainloader.h>
GRUB_MOD_LICENSE ("GPLv3+");
static grub_dl_t my_mod;
static struct grub_relocator *rel;
@ -51,7 +54,8 @@ grub_ntldr_boot (void)
.gs = 0,
.ss = 0,
.sp = 0x7c00,
.edx = edx
.edx = edx,
.a20 = 1
};
grub_video_set_mode ("text", 0, 0);
@ -110,6 +114,7 @@ grub_cmd_ntldr (grub_command_t cmd __attribute__ ((unused)),
grub_device_close (dev);
goto fail;
}
grub_chainloader_patch_bpb (bs, dev, edx);
}
if (dev)

513
grub-core/loader/i386/pc/plan9.c Normal file
View file

@ -0,0 +1,513 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 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/>.
*/
#include <grub/loader.h>
#include <grub/file.h>
#include <grub/err.h>
#include <grub/device.h>
#include <grub/disk.h>
#include <grub/misc.h>
#include <grub/types.h>
#include <grub/partition.h>
#include <grub/msdos_partition.h>
#include <grub/scsi.h>
#include <grub/dl.h>
#include <grub/command.h>
#include <grub/i18n.h>
#include <grub/video.h>
#include <grub/mm.h>
#include <grub/cpu/relocator.h>
#include <grub/extcmd.h>
static grub_dl_t my_mod;
static struct grub_relocator *rel;
static grub_uint32_t eip = 0xffffffff;
#define GRUB_PLAN9_TARGET 0x100000
#define GRUB_PLAN9_ALIGN 4096
#define GRUB_PLAN9_CONFIG_ADDR 0x001200
#define GRUB_PLAN9_CONFIG_PATH_SIZE 0x000040
#define GRUB_PLAN9_CONFIG_MAGIC "ZORT 0\r\n"
static const struct grub_arg_option options[] =
{
{"map", 'm', GRUB_ARG_OPTION_REPEATABLE,
N_("Override guessed mapping of Plan9 devices."),
N_("GRUBDEVICE=PLAN9DEVICE"),
ARG_TYPE_STRING},
{0, 0, 0, 0, 0, 0}
};
struct grub_plan9_header
{
grub_uint32_t magic;
#define GRUB_PLAN9_MAGIC 0x1eb
grub_uint32_t text_size;
grub_uint32_t data_size;
grub_uint32_t bss_size;
grub_uint32_t sectiona;
grub_uint32_t entry_addr;
grub_uint32_t zero;
grub_uint32_t sectionb;
};
static grub_err_t
grub_plan9_boot (void)
{
struct grub_relocator32_state state = {
.eax = 0,
.eip = eip,
.ebx = 0,
.ecx = 0,
.edx = 0,
.edi = 0,
.esp = 0,
.ebp = 0,
.esi = 0
};
grub_video_set_mode ("text", 0, 0);
return grub_relocator32_boot (rel, state);
}
static grub_err_t
grub_plan9_unload (void)
{
grub_relocator_unload (rel);
rel = NULL;
grub_dl_unref (my_mod);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_cmd_plan9 (grub_extcmd_context_t ctxt, int argc, char *argv[])
{
grub_file_t file = 0;
void *mem;
grub_size_t memsize, padsize;
struct grub_plan9_header hdr;
char *config, *configptr;
grub_size_t configsize;
char *pmap = NULL;
grub_size_t pmapalloc = 256;
grub_size_t pmapptr = 0;
int noslash = 1;
char prefixes[5][10] = {"dos", "plan9", "ntfs", "linux", "linuxswap"};
int prefixescnt[5];
char *bootdisk = NULL, *bootpart = NULL, *bootpath = NULL;
auto int fill_partition (grub_disk_t disk,
const grub_partition_t partition);
int fill_partition (grub_disk_t disk,
const grub_partition_t partition)
{
int file_disk = 0;
int pstart, pend;
if (!noslash)
{
if (grub_extend_alloc (pmapptr + 1, &pmapalloc, (void **) &pmap))
return 1;
pmap[pmapptr++] = '/';
}
noslash = 0;
file_disk = file->device->disk && disk->id == file->device->disk->id
&& disk->dev->id == file->device->disk->dev->id;
pstart = pmapptr;
if (grub_strcmp (partition->partmap->name, "plan") == 0)
{
unsigned ptr = partition->index + sizeof ("part ") - 1;
grub_err_t err;
disk->partition = partition->parent;
do
{
if (grub_extend_alloc (pmapptr + 1, &pmapalloc, (void **) &pmap))
return 1;
err = grub_disk_read (disk, 1, ptr, 1, pmap + pmapptr);
if (err)
{
disk->partition = 0;
return err;
}
ptr++;
pmapptr++;
}
while (grub_isalpha (pmap[pmapptr - 1])
|| grub_isdigit (pmap[pmapptr - 1]));
pmapptr--;
}
else
{
char name[50];
int c = 0;
if (grub_strcmp (partition->partmap->name, "msdos") == 0)
{
switch (partition->msdostype)
{
case GRUB_PC_PARTITION_TYPE_PLAN9:
c = 1;
break;
case GRUB_PC_PARTITION_TYPE_NTFS:
c = 2;
break;
case GRUB_PC_PARTITION_TYPE_MINIX:
case GRUB_PC_PARTITION_TYPE_LINUX_MINIX:
case GRUB_PC_PARTITION_TYPE_EXT2FS:
c = 3;
break;
case GRUB_PC_PARTITION_TYPE_LINUX_SWAP:
c = 4;
break;
}
}
if (prefixescnt[c] == 0)
grub_strcpy (name, prefixes[c]);
else
grub_snprintf (name, sizeof (name), "%s.%d", prefixes[c],
prefixescnt[c]);
prefixescnt[c]++;
if (grub_extend_alloc (pmapptr + grub_strlen (name) + 1,
&pmapalloc, (void **) &pmap))
return 1;
grub_strcpy (pmap + pmapptr, name);
pmapptr += grub_strlen (name);
}
pend = pmapptr;
if (grub_extend_alloc (pmapptr + 2 + 25 + 5 + 25, &pmapalloc,
(void **) &pmap))
return 1;
pmap[pmapptr++] = ' ';
grub_snprintf (pmap + pmapptr, 25 + 5 + 25,
"%" PRIuGRUB_UINT64_T " %" PRIuGRUB_UINT64_T,
grub_partition_get_start (partition),
grub_partition_get_start (partition)
+ grub_partition_get_len (partition));
if (file_disk && grub_partition_get_start (partition)
== grub_partition_get_start (file->device->disk->partition)
&& grub_partition_get_len (partition)
== grub_partition_get_len (file->device->disk->partition))
{
grub_free (bootpart);
bootpart = grub_strndup (pmap + pstart, pend - pstart);
}
pmapptr += grub_strlen (pmap + pmapptr);
return 0;
}
auto int fill_disk (const char *name);
int fill_disk (const char *name)
{
grub_device_t dev;
char *plan9name = NULL;
unsigned i;
int file_disk = 0;
dev = grub_device_open (name);
if (!dev)
{
grub_print_error ();
return 0;
}
if (!dev->disk)
{
grub_device_close (dev);
return 0;
}
file_disk = file->device->disk && dev->disk->id == file->device->disk->id
&& dev->disk->dev->id == file->device->disk->dev->id;
for (i = 0; ctxt->state[0].args && ctxt->state[0].args[i]; i++)
if (grub_strncmp (name, ctxt->state[0].args[i], grub_strlen (name)) == 0
&& ctxt->state[0].args[i][grub_strlen (name)] == '=')
break;
if (ctxt->state[0].args && ctxt->state[0].args[i])
plan9name = grub_strdup (ctxt->state[0].args[i] + grub_strlen (name) + 1);
else
switch (dev->disk->dev->id)
{
case GRUB_DISK_DEVICE_BIOSDISK_ID:
if (dev->disk->id & 0x80)
plan9name = grub_xasprintf ("sdB%u",
(unsigned) (dev->disk->id & 0x7f));
else
plan9name = grub_xasprintf ("fd%u",
(unsigned) (dev->disk->id & 0x7f));
break;
/* Shouldn't happen as Plan9 doesn't work on these platforms. */
case GRUB_DISK_DEVICE_OFDISK_ID:
case GRUB_DISK_DEVICE_EFIDISK_ID:
/* Plan9 doesn't see those. */
default:
/* Not sure how to handle those. */
case GRUB_DISK_DEVICE_PXE_ID:
case GRUB_DISK_DEVICE_NAND_ID:
if (!file_disk)
{
grub_device_close (dev);
return 0;
}
/* if it's the disk the kernel is loaded from we need to name
it nevertheless. */
plan9name = grub_strdup ("sdZ0");
break;
case GRUB_DISK_DEVICE_ATA_ID:
{
int unit;
if (grub_strlen (dev->disk->name) < sizeof ("ata0") - 1)
unit = 0;
else
unit = grub_strtoul (dev->disk->name + sizeof ("ata0") - 1, 0, 0);
plan9name = grub_xasprintf ("sd%c%d", 'C' + unit / 2, unit % 2);
}
break;
case GRUB_DISK_DEVICE_SCSI_ID:
if (((dev->disk->id >> GRUB_SCSI_ID_SUBSYSTEM_SHIFT) & 0xff)
== GRUB_SCSI_SUBSYSTEM_PATA)
{
int unit;
if (grub_strlen (dev->disk->name) < sizeof ("ata0") - 1)
unit = 0;
else
unit = grub_strtoul (dev->disk->name + sizeof ("ata0") - 1,
0, 0);
plan9name = grub_xasprintf ("sd%c%d", 'C' + unit / 2, unit % 2);
break;
}
/* FIXME: how does Plan9 number controllers?
We probably need save the SCSI devices and sort them */
plan9name
= grub_xasprintf ("sd0%u", (unsigned)
((dev->disk->id >> GRUB_SCSI_ID_BUS_SHIFT)
& 0xf));
break;
}
if (!plan9name)
{
grub_print_error ();
return 0;
}
if (grub_extend_alloc (pmapptr + grub_strlen (plan9name)
+ sizeof ("part="), &pmapalloc,
(void **) &pmap))
{
grub_free (plan9name);
return 1;
}
grub_strcpy (pmap + pmapptr, plan9name);
pmapptr += grub_strlen (plan9name);
if (!file_disk)
grub_free (plan9name);
else
{
grub_free (bootdisk);
bootdisk = plan9name;
}
grub_strcpy (pmap + pmapptr, "part=");
pmapptr += sizeof ("part=") - 1;
noslash = 1;
grub_memset (prefixescnt, 0, sizeof (prefixescnt));
if (grub_partition_iterate (dev->disk, fill_partition))
return 1;
if (grub_extend_alloc (pmapptr + 1, &pmapalloc, (void **) &pmap))
return 1;
pmap[pmapptr++] = '\n';
return 0;
}
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;
pmap = grub_malloc (pmapalloc);
if (!pmap)
goto fail;
if (grub_disk_dev_iterate (fill_disk))
goto fail;
if (grub_extend_alloc (pmapptr + 1, &pmapalloc,
(void **) &pmap))
goto fail;
pmap[pmapptr] = 0;
{
char *file_name = grub_strchr (argv[0], ')');
if (file_name)
file_name++;
else
file_name = argv[0];
if (*file_name)
file_name++;
if (bootpart)
bootpath = grub_xasprintf ("%s!%s!%s", bootdisk, bootpart, file_name);
else
bootpath = grub_xasprintf ("%s!%s", bootdisk, file_name);
grub_free (bootdisk);
grub_free (bootpart);
}
if (!bootpath)
goto fail;
if (grub_file_read (file, &hdr, sizeof (hdr)) != (grub_ssize_t) sizeof (hdr))
goto fail;
if (grub_be_to_cpu32 (hdr.magic) != GRUB_PLAN9_MAGIC
|| hdr.zero)
{
grub_error (GRUB_ERR_BAD_OS, "unsupported Plan9");
goto fail;
}
memsize = ALIGN_UP (grub_be_to_cpu32 (hdr.text_size) + sizeof (hdr),
GRUB_PLAN9_ALIGN);
memsize += ALIGN_UP (grub_be_to_cpu32 (hdr.data_size), GRUB_PLAN9_ALIGN);
memsize += ALIGN_UP(grub_be_to_cpu32 (hdr.bss_size), GRUB_PLAN9_ALIGN);
eip = grub_be_to_cpu32 (hdr.entry_addr) & 0xfffffff;
/* path */
configsize = GRUB_PLAN9_CONFIG_PATH_SIZE;
/* magic */
configsize += sizeof (GRUB_PLAN9_CONFIG_MAGIC) - 1;
{
int i;
for (i = 1; i < argc; i++)
configsize += grub_strlen (argv[i]) + 1;
}
configsize += (sizeof ("bootfile=") - 1) + grub_strlen (bootpath) + 1;
configsize += pmapptr;
/* Terminating \0. */
configsize++;
{
grub_relocator_chunk_t ch;
grub_err_t err;
err = grub_relocator_alloc_chunk_addr (rel, &ch, GRUB_PLAN9_CONFIG_ADDR,
configsize);
if (err)
goto fail;
config = get_virtual_current_address (ch);
}
grub_memset (config, 0, GRUB_PLAN9_CONFIG_PATH_SIZE);
grub_strncpy (config, bootpath, GRUB_PLAN9_CONFIG_PATH_SIZE - 1);
configptr = config + GRUB_PLAN9_CONFIG_PATH_SIZE;
grub_memcpy (configptr, GRUB_PLAN9_CONFIG_MAGIC,
sizeof (GRUB_PLAN9_CONFIG_MAGIC) - 1);
configptr += sizeof (GRUB_PLAN9_CONFIG_MAGIC) - 1;
configptr = grub_stpcpy (configptr, "bootfile=");
configptr = grub_stpcpy (configptr, bootpath);
*configptr++ = '\n';
{
int i;
for (i = 1; i < argc; i++)
{
configptr = grub_stpcpy (configptr, argv[i]);
*configptr++ = '\n';
}
}
configptr = grub_stpcpy (configptr, pmap);
{
grub_relocator_chunk_t ch;
grub_err_t err;
err = grub_relocator_alloc_chunk_addr (rel, &ch, GRUB_PLAN9_TARGET,
memsize);
if (err)
goto fail;
mem = get_virtual_current_address (ch);
}
{
grub_uint8_t *ptr;
ptr = mem;
grub_memcpy (ptr, &hdr, sizeof (hdr));
ptr += sizeof (hdr);
if (grub_file_read (file, ptr, grub_be_to_cpu32 (hdr.text_size))
!= (grub_ssize_t) grub_be_to_cpu32 (hdr.text_size))
goto fail;
ptr += grub_be_to_cpu32 (hdr.text_size);
padsize = ALIGN_UP (grub_be_to_cpu32 (hdr.text_size) + sizeof (hdr),
GRUB_PLAN9_ALIGN) - grub_be_to_cpu32 (hdr.text_size)
- sizeof (hdr);
grub_memset (ptr, 0, padsize);
ptr += padsize;
if (grub_file_read (file, ptr, grub_be_to_cpu32 (hdr.data_size))
!= (grub_ssize_t) grub_be_to_cpu32 (hdr.data_size))
goto fail;
ptr += grub_be_to_cpu32 (hdr.data_size);
padsize = ALIGN_UP (grub_be_to_cpu32 (hdr.data_size), GRUB_PLAN9_ALIGN)
- grub_be_to_cpu32 (hdr.data_size);
grub_memset (ptr, 0, padsize);
ptr += padsize;
grub_memset (ptr, 0, ALIGN_UP(grub_be_to_cpu32 (hdr.bss_size),
GRUB_PLAN9_ALIGN));
}
grub_loader_set (grub_plan9_boot, grub_plan9_unload, 1);
return GRUB_ERR_NONE;
fail:
grub_free (pmap);
if (file)
grub_file_close (file);
grub_plan9_unload ();
return grub_errno;
}
static grub_extcmd_t cmd;
GRUB_MOD_INIT(plan9)
{
cmd = grub_register_extcmd ("plan9", grub_cmd_plan9,
GRUB_COMMAND_OPTIONS_AT_START,
N_("KERNEL ARGS"), N_("Load Plan9 kernel."),
options);
my_mod = mod;
}
GRUB_MOD_FINI(plan9)
{
grub_unregister_extcmd (cmd);
}

28
grub-core/loader/i386/xnu.c
View file

@ -49,7 +49,7 @@ struct tbl_alias
char *name;
};
struct tbl_alias table_aliases[] =
static struct tbl_alias table_aliases[] =
{
{GRUB_EFI_ACPI_20_TABLE_GUID, "ACPI_20"},
{GRUB_EFI_ACPI_TABLE_GUID, "ACPI"},
@ -219,7 +219,7 @@ struct property_descriptor
void *data;
};
struct grub_xnu_devprop_device_descriptor *devices = 0;
static struct grub_xnu_devprop_device_descriptor *devices = 0;
grub_err_t
grub_xnu_devprop_remove_property (struct grub_xnu_devprop_device_descriptor *dev,
@ -452,11 +452,11 @@ grub_cpu_xnu_fill_devprop (void)
}
devprop = grub_xnu_create_value (&(efikey->first_child), "device-properties");
if (devprop)
{
devprop->data = grub_malloc (total_length);
devprop->datasize = total_length;
}
if (!devprop)
return grub_errno;
devprop->data = grub_malloc (total_length);
devprop->datasize = total_length;
ptr = devprop->data;
head = ptr;
@ -700,7 +700,7 @@ grub_cpu_xnu_fill_devicetree (void)
return grub_errno;
/* First see if user supplies the value. */
char *fsbvar = grub_env_get ("fsb");
const char *fsbvar = grub_env_get ("fsb");
if (! fsbvar)
*((grub_uint64_t *) curval->data) = 0;
else
@ -951,10 +951,11 @@ grub_err_t
grub_xnu_boot (void)
{
struct grub_xnu_boot_params *bootparams;
void *bp_in;
grub_addr_t bootparams_target;
grub_err_t err;
grub_efi_uintn_t memory_map_size = 0;
grub_efi_memory_descriptor_t *memory_map;
void *memory_map;
grub_addr_t memory_map_target;
grub_efi_uintn_t map_key = 0;
grub_efi_uintn_t descriptor_size = 0;
@ -1006,9 +1007,10 @@ grub_xnu_boot (void)
/* Relocate the boot parameters to heap. */
err = grub_xnu_heap_malloc (sizeof (*bootparams),
(void **) &bootparams, &bootparams_target);
&bp_in, &bootparams_target);
if (err)
return err;
bootparams = bp_in;
/* Set video. */
err = grub_xnu_set_video (bootparams);
@ -1016,7 +1018,7 @@ grub_xnu_boot (void)
{
grub_print_error ();
grub_errno = GRUB_ERR_NONE;
grub_printf ("Booting in blind mode\n");
grub_puts_ (N_("Booting in blind mode"));
bootparams->lfb_mode = 0;
bootparams->lfb_width = 0;
@ -1035,7 +1037,7 @@ grub_xnu_boot (void)
memory map growth. */
memory_map_size += 20 * descriptor_size;
err = grub_xnu_heap_malloc (memory_map_size,
(void **) &memory_map, &memory_map_target);
&memory_map, &memory_map_target);
if (err)
return err;
@ -1109,7 +1111,7 @@ grub_xnu_boot (void)
grub_xnu_arg1 = bootparams_target;
grub_autoefi_set_virtual_address_map (memory_map_size, descriptor_size,
descriptor_version,memory_map);
descriptor_version, memory_map);
state.eip = grub_xnu_entry_point;
state.eax = grub_xnu_arg1;

797
grub-core/loader/ia64/efi/linux.c Normal file
View file

@ -0,0 +1,797 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2008,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/>.
*/
#include <grub/loader.h>
#include <grub/file.h>
#include <grub/disk.h>
#include <grub/err.h>
#include <grub/misc.h>
#include <grub/types.h>
#include <grub/command.h>
#include <grub/dl.h>
#include <grub/mm.h>
#include <grub/cache.h>
#include <grub/kernel.h>
#include <grub/efi/api.h>
#include <grub/efi/efi.h>
#include <grub/elf.h>
GRUB_MOD_LICENSE ("GPLv3+");
#define ALIGN_MIN (256*1024*1024)
#define GRUB_ELF_SEARCH 1024
#define BOOT_PARAM_SIZE 16384
struct ia64_boot_param
{
grub_uint64_t command_line; /* physical address of command line. */
grub_uint64_t efi_systab; /* physical address of EFI system table */
grub_uint64_t efi_memmap; /* physical address of EFI memory map */
grub_uint64_t efi_memmap_size; /* size of EFI memory map */
grub_uint64_t efi_memdesc_size; /* size of an EFI memory map descriptor */
grub_uint32_t efi_memdesc_version; /* memory descriptor version */
struct
{
grub_uint16_t num_cols; /* number of columns on console output dev */
grub_uint16_t num_rows; /* number of rows on console output device */
grub_uint16_t orig_x; /* cursor's x position */
grub_uint16_t orig_y; /* cursor's y position */
} console_info;
grub_uint64_t fpswa; /* physical address of the fpswa interface */
grub_uint64_t initrd_start;
grub_uint64_t initrd_size;
grub_uint64_t domain_start; /* boot domain address. */
grub_uint64_t domain_size; /* how big is the boot domain */
grub_uint64_t payloads_chain;
grub_uint64_t payloads_nbr;
};
struct ia64_boot_payload
{
grub_uint64_t start;
grub_uint64_t length;
/* Payload command line */
grub_uint64_t cmdline;
grub_uint64_t next;
};
typedef struct
{
grub_uint32_t revision;
grub_uint32_t reserved;
void *fpswa;
} fpswa_interface_t;
static fpswa_interface_t *fpswa;
#define NEXT_MEMORY_DESCRIPTOR(desc, size) \
((grub_efi_memory_descriptor_t *) ((char *) (desc) + (size)))
static grub_dl_t my_mod;
static int loaded;
/* Kernel base and size. */
static void *kernel_mem;
static grub_efi_uintn_t kernel_pages;
static grub_uint64_t entry;
/* Initrd base and size. */
static void *initrd_mem;
static grub_efi_uintn_t initrd_pages;
static grub_efi_uintn_t initrd_size;
static struct ia64_boot_param *boot_param;
static grub_efi_uintn_t boot_param_pages;
static struct ia64_boot_payload *last_payload = NULL;
/* Can linux kernel be relocated ? */
#define RELOCATE_OFF 0 /* No. */
#define RELOCATE_ON 1 /* Yes. */
#define RELOCATE_FORCE 2 /* Always - used to debug. */
static int relocate = RELOCATE_OFF;
static inline grub_size_t
page_align (grub_size_t size)
{
return (size + (1 << 12) - 1) & (~((1 << 12) - 1));
}
static void
query_fpswa (void)
{
grub_efi_handle_t fpswa_image;
grub_efi_boot_services_t *bs;
grub_efi_status_t status;
grub_efi_uintn_t size;
static const grub_efi_guid_t fpswa_protocol =
{ 0xc41b6531, 0x97b9, 0x11d3,
{0x9a, 0x29, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} };
if (fpswa != NULL)
return;
size = sizeof(grub_efi_handle_t);
bs = grub_efi_system_table->boot_services;
status = bs->locate_handle (GRUB_EFI_BY_PROTOCOL,
(void *)&fpswa_protocol,
NULL, &size, &fpswa_image);
if (status != GRUB_EFI_SUCCESS)
{
grub_printf("Could not locate FPSWA driver\n");
return;
}
status = bs->handle_protocol (fpswa_image,
(void *)&fpswa_protocol, (void *)&fpswa);
if (status != GRUB_EFI_SUCCESS)
{
grub_printf ("Fpswa protocol not able find the interface\n");
return;
}
}
/* Find the optimal number of pages for the memory map. Is it better to
move this code to efi/mm.c? */
static grub_efi_uintn_t
find_mmap_size (void)
{
static grub_efi_uintn_t mmap_size = 0;
if (mmap_size != 0)
return mmap_size;
mmap_size = (1 << 12);
while (1)
{
int ret;
grub_efi_memory_descriptor_t *mmap;
grub_efi_uintn_t desc_size;
mmap = grub_malloc (mmap_size);
if (! mmap)
return 0;
ret = grub_efi_get_memory_map (&mmap_size, mmap, 0, &desc_size, 0);
grub_free (mmap);
if (ret < 0)
grub_fatal ("cannot get memory map");
else if (ret > 0)
break;
mmap_size += (1 << 12);
}
/* Increase the size a bit for safety, because GRUB allocates more on
later, and EFI itself may allocate more. */
mmap_size += (1 << 12);
return page_align (mmap_size);
}
static void
free_pages (void)
{
if (kernel_mem)
{
grub_efi_free_pages ((grub_addr_t) kernel_mem, kernel_pages);
kernel_mem = 0;
}
if (initrd_mem)
{
grub_efi_free_pages ((grub_addr_t) initrd_mem, initrd_pages);
initrd_mem = 0;
}
if (boot_param)
{
struct ia64_boot_payload *payload;
struct ia64_boot_payload *next_payload;
/* Free payloads. */
payload = (struct ia64_boot_payload *)boot_param->payloads_chain;
while (payload != 0)
{
next_payload = (struct ia64_boot_payload *)payload->next;
grub_efi_free_pages
(payload->start, page_align (payload->length) >> 12);
grub_efi_free_pages ((grub_efi_physical_address_t)payload, 1);
payload = next_payload;
}
/* Free bootparam. */
grub_efi_free_pages ((grub_efi_physical_address_t)boot_param,
boot_param_pages);
boot_param = 0;
}
}
static void *
allocate_pages (grub_uint64_t align, grub_uint64_t size_pages,
grub_uint64_t nobase)
{
grub_uint64_t size;
grub_efi_uintn_t desc_size;
grub_efi_memory_descriptor_t *mmap, *mmap_end;
grub_efi_uintn_t mmap_size, tmp_mmap_size;
grub_efi_memory_descriptor_t *desc;
void *mem = NULL;
size = size_pages << 12;
mmap_size = find_mmap_size ();
/* Read the memory map temporarily, to find free space. */
mmap = grub_malloc (mmap_size);
if (! mmap)
return 0;
tmp_mmap_size = mmap_size;
if (grub_efi_get_memory_map (&tmp_mmap_size, mmap, 0, &desc_size, 0) <= 0)
grub_fatal ("cannot get memory map");
mmap_end = NEXT_MEMORY_DESCRIPTOR (mmap, tmp_mmap_size);
/* First, find free pages for the real mode code
and the memory map buffer. */
for (desc = mmap;
desc < mmap_end;
desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
{
grub_uint64_t start, end;
grub_uint64_t aligned_start;
if (desc->type != GRUB_EFI_CONVENTIONAL_MEMORY)
continue;
start = desc->physical_start;
end = start + (desc->num_pages << 12);
/* Align is a power of 2. */
aligned_start = (start + align - 1) & ~(align - 1);
if (aligned_start + size > end)
continue;
if (aligned_start == nobase)
aligned_start += align;
if (aligned_start + size > end)
continue;
mem = grub_efi_allocate_pages (aligned_start, size_pages);
if (! mem)
grub_fatal ("cannot allocate pages");
break;
}
if (! mem)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot allocate memory");
goto fail;
}
grub_free (mmap);
return mem;
fail:
grub_free (mmap);
free_pages ();
return 0;
}
static void
set_boot_param_console (void)
{
grub_efi_simple_text_output_interface_t *conout;
grub_efi_uintn_t cols, rows;
conout = grub_efi_system_table->con_out;
if (conout->query_mode (conout, conout->mode->mode, &cols, &rows)
!= GRUB_EFI_SUCCESS)
return;
grub_dprintf("linux",
"Console info: cols=%lu rows=%lu x=%u y=%u\n",
cols, rows,
conout->mode->cursor_column, conout->mode->cursor_row);
boot_param->console_info.num_cols = cols;
boot_param->console_info.num_rows = rows;
boot_param->console_info.orig_x = conout->mode->cursor_column;
boot_param->console_info.orig_y = conout->mode->cursor_row;
}
static grub_err_t
grub_linux_boot (void)
{
grub_efi_uintn_t mmap_size;
grub_efi_uintn_t map_key;
grub_efi_uintn_t desc_size;
grub_efi_uint32_t desc_version;
grub_efi_memory_descriptor_t *mmap_buf;
grub_err_t err;
/* FPSWA. */
query_fpswa ();
boot_param->fpswa = (grub_uint64_t)fpswa;
/* Initrd. */
boot_param->initrd_start = (grub_uint64_t)initrd_mem;
boot_param->initrd_size = (grub_uint64_t)initrd_size;
set_boot_param_console ();
grub_printf ("Jump to %016lx\n", entry);
grub_machine_fini ();
/* MDT.
Must be done after grub_machine_fini because map_key is used by
exit_boot_services. */
mmap_size = find_mmap_size ();
mmap_buf = grub_efi_allocate_pages (0, page_align (mmap_size) >> 12);
if (! mmap_buf)
grub_fatal ("cannot allocate memory map");
err = grub_efi_finish_boot_services (&mmap_size, mmap_buf, &map_key,
&desc_size, &desc_version);
if (err)
return err;
boot_param->efi_memmap = (grub_uint64_t)mmap_buf;
boot_param->efi_memmap_size = mmap_size;
boot_param->efi_memdesc_size = desc_size;
boot_param->efi_memdesc_version = desc_version;
/* See you next boot. */
asm volatile ("mov r28=%1; br.sptk.few %0" :: "b"(entry),"r"(boot_param));
/* Never reach here. */
return GRUB_ERR_NONE;
}
static grub_err_t
grub_linux_unload (void)
{
free_pages ();
grub_dl_unref (my_mod);
loaded = 0;
return GRUB_ERR_NONE;
}
static grub_err_t
grub_load_elf64 (grub_file_t file, void *buffer)
{
Elf64_Ehdr *ehdr = (Elf64_Ehdr *) buffer;
Elf64_Phdr *phdr;
int i;
grub_uint64_t low_addr;
grub_uint64_t high_addr;
grub_uint64_t align;
grub_uint64_t reloc_offset;
if (ehdr->e_ident[EI_CLASS] != ELFCLASS64)
return grub_error (GRUB_ERR_UNKNOWN_OS, "invalid ELF class");
if (ehdr->e_ident[EI_MAG0] != ELFMAG0
|| ehdr->e_ident[EI_MAG1] != ELFMAG1
|| ehdr->e_ident[EI_MAG2] != ELFMAG2
|| ehdr->e_ident[EI_MAG3] != ELFMAG3
|| ehdr->e_version != EV_CURRENT
|| ehdr->e_ident[EI_DATA] != ELFDATA2LSB
|| ehdr->e_machine != EM_IA_64)
return grub_error(GRUB_ERR_UNKNOWN_OS, "no valid ELF header found");
if (ehdr->e_type != ET_EXEC)
return grub_error (GRUB_ERR_UNKNOWN_OS, "invalid ELF file type");
/* FIXME: Should we support program headers at strange locations? */
if (ehdr->e_phoff + ehdr->e_phnum * ehdr->e_phentsize > GRUB_ELF_SEARCH)
return grub_error (GRUB_ERR_BAD_OS, "program header at a too high offset");
entry = ehdr->e_entry;
/* Compute low, high and align addresses. */
low_addr = ~0UL;
high_addr = 0;
align = 0;
for (i = 0; i < ehdr->e_phnum; i++)
{
phdr = (Elf64_Phdr *) ((char *) buffer + ehdr->e_phoff
+ i * ehdr->e_phentsize);
if (phdr->p_type == PT_LOAD)
{
if (phdr->p_paddr < low_addr)
low_addr = phdr->p_paddr;
if (phdr->p_paddr + phdr->p_memsz > high_addr)
high_addr = phdr->p_paddr + phdr->p_memsz;
if (phdr->p_align > align)
align = phdr->p_align;
}
}
if (align < ALIGN_MIN)
align = ALIGN_MIN;
if (high_addr == 0)
return grub_error (GRUB_ERR_BAD_OS, "no program entries");
kernel_pages = page_align (high_addr - low_addr) >> 12;
if (relocate != RELOCATE_FORCE)
{
kernel_mem = grub_efi_allocate_pages (low_addr, kernel_pages);
reloc_offset = 0;
}
/* Try to relocate. */
if (! kernel_mem && relocate != RELOCATE_OFF)
{
kernel_mem = allocate_pages (align, kernel_pages, low_addr);
if (kernel_mem)
{
reloc_offset = (grub_uint64_t)kernel_mem - low_addr;
grub_printf (" Relocated at %p (offset=%016lx)\n",
kernel_mem, reloc_offset);
entry += reloc_offset;
}
}
if (! kernel_mem)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"cannot allocate memory for OS");
/* Load every loadable segment in memory. */
for (i = 0; i < ehdr->e_phnum; i++)
{
phdr = (Elf64_Phdr *) ((char *) buffer + ehdr->e_phoff
+ i * ehdr->e_phentsize);
if (phdr->p_type == PT_LOAD)
{
grub_printf (" [paddr=%lx load=%lx memsz=%08lx "
"off=%lx flags=%x]\n",
phdr->p_paddr, phdr->p_paddr + reloc_offset,
phdr->p_memsz, phdr->p_offset, phdr->p_flags);
if (grub_file_seek (file, phdr->p_offset) == (grub_off_t)-1)
return grub_error (GRUB_ERR_BAD_OS,
"invalid offset in program header");
if (grub_file_read (file, (void *)(phdr->p_paddr + reloc_offset),
phdr->p_filesz)
!= (grub_ssize_t) phdr->p_filesz)
return grub_error (GRUB_ERR_BAD_OS,
"couldn't read segment from file");
if (phdr->p_filesz < phdr->p_memsz)
grub_memset
((char *)(phdr->p_paddr + reloc_offset + phdr->p_filesz),
0, phdr->p_memsz - phdr->p_filesz);
/* Sync caches if necessary. */
if (phdr->p_flags & PF_X)
grub_arch_sync_caches
((void *)(phdr->p_paddr + reloc_offset), phdr->p_memsz);
}
}
loaded = 1;
return 0;
}
static grub_err_t
grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_file_t file = 0;
char buffer[GRUB_ELF_SEARCH];
char *cmdline, *p;
grub_ssize_t len;
int i;
grub_dl_ref (my_mod);
grub_loader_unset ();
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "No kernel specified");
goto fail;
}
file = grub_file_open (argv[0]);
if (! file)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "Couldn't open file");
goto fail;
}
len = grub_file_read (file, buffer, sizeof (buffer));
if (len < (grub_ssize_t)sizeof (Elf64_Ehdr))
{
grub_error (GRUB_ERR_BAD_OS, "File too small");
goto fail;
}
grub_printf ("Loading linux: %s\n", argv[0]);
if (grub_load_elf64 (file, buffer))
goto fail;
len = sizeof("BOOT_IMAGE=") + 8;
for (i = 0; i < argc; i++)
len += grub_strlen (argv[i]) + 1;
len += sizeof (struct ia64_boot_param) + 256; /* Room for extensions. */
boot_param_pages = page_align (len) >> 12;
boot_param = grub_efi_allocate_pages (0, boot_param_pages);
if (boot_param == 0)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY,
"cannot allocate memory for bootparams");
goto fail;
}
grub_memset (boot_param, 0, len);
cmdline = ((char *)(boot_param + 1)) + 256;
/* Build cmdline. */
p = grub_stpcpy (cmdline, "BOOT_IMAGE");
for (i = 0; i < argc; i++)
{
*p++ = ' ';
p = grub_stpcpy (p, argv[i]);
}
cmdline[10] = '=';
boot_param->command_line = (grub_uint64_t) cmdline;
boot_param->efi_systab = (grub_uint64_t) grub_efi_system_table;
grub_errno = GRUB_ERR_NONE;
grub_loader_set (grub_linux_boot, grub_linux_unload, 0);
fail:
if (file)
grub_file_close (file);
if (grub_errno != GRUB_ERR_NONE)
{
grub_efi_free_pages ((grub_efi_physical_address_t) boot_param,
boot_param_pages);
grub_dl_unref (my_mod);
}
return grub_errno;
}
static grub_err_t
grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_file_t file = 0;
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "No filename specified");
goto fail;
}
if (! loaded)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "You need to load the kernel first.");
goto fail;
}
file = grub_file_open (argv[0]);
if (! file)
goto fail;
grub_printf ("Loading initrd: %s\n",argv[0]);
initrd_size = grub_file_size (file);
initrd_pages = (page_align (initrd_size) >> 12);
initrd_mem = grub_efi_allocate_pages (0, initrd_pages);
if (! initrd_mem)
grub_fatal ("cannot allocate pages");
grub_printf (" [addr=0x%lx, size=0x%lx]\n",
(grub_uint64_t)initrd_mem, initrd_size);
if (grub_file_read (file, initrd_mem, initrd_size)
!= (grub_ssize_t)initrd_size)
{
grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
goto fail;
}
fail:
if (file)
grub_file_close (file);
return grub_errno;
}
static grub_err_t
grub_cmd_payload (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_file_t file = 0;
grub_ssize_t size, len = 0;
char *base = 0, *cmdline = 0, *p;
struct ia64_boot_payload *payload = NULL;
int i;
if (argc == 0)
{
grub_error (GRUB_ERR_BAD_ARGUMENT, "No module specified");
goto fail;
}
if (!boot_param)
{
grub_error (GRUB_ERR_BAD_ARGUMENT,
"You need to load the kernel first");
goto fail;
}
file = grub_file_open (argv[0]);
if (! file)
goto fail;
size = grub_file_size (file);
base = grub_efi_allocate_pages (0, page_align (size) >> 12);
if (! base)
goto fail;
grub_printf ("Payload %s [addr=%lx + %lx]\n",
argv[0], (grub_uint64_t)base, size);
if (grub_file_read (file, base, size) != size)
{
grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
goto fail;
}
len = sizeof (struct ia64_boot_payload);
for (i = 0; i < argc; i++)
len += grub_strlen (argv[i]) + 1;
if (len > 4096)
{
grub_error (GRUB_ERR_OUT_OF_RANGE, "payload command line too long");
goto fail;
}
payload = grub_efi_allocate_pages (0, 1);
if (! payload)
goto fail;
p = (char *)(payload + 1);
payload->start = (grub_uint64_t)base;
payload->length = size;
payload->cmdline = (grub_uint64_t)p;
payload->next = 0;
if (last_payload)
last_payload->next = (grub_uint64_t)payload;
else
{
last_payload = payload;
boot_param->payloads_chain = (grub_uint64_t)payload;
}
boot_param->payloads_nbr++;
/* Copy command line. */
for (i = 0; i < argc; i++)
{
p = grub_stpcpy (p, argv[i]);
*(p++) = ' ';
}
/* Remove the space after the last word. */
*(--p) = '\0';
fail:
if (file)
grub_file_close (file);
if (grub_errno != GRUB_ERR_NONE)
{
grub_free (base);
grub_free (cmdline);
}
return grub_errno;
}
static grub_err_t
grub_cmd_relocate (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
static const char * const vals[] = { "off", "on", "force"};
unsigned int i;
if (argc == 0)
{
grub_printf ("relocate is %s\n", vals[relocate]);
return GRUB_ERR_NONE;
}
else if (argc == 1)
{
if (kernel_mem != NULL)
grub_printf ("Warning: kernel already loaded!\n");
for (i = 0; i < sizeof (vals)/sizeof(vals[0]); i++)
if (grub_strcmp (argv[0], vals[i]) == 0)
{
relocate = i;
return GRUB_ERR_NONE;
}
return grub_error (GRUB_ERR_BAD_ARGUMENT, "unknown relocate value");
}
else
{
return grub_error (GRUB_ERR_BAD_ARGUMENT, "accept 0 or 1 argument");
}
}
static grub_err_t
grub_cmd_fpswa (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[] __attribute__((unused)))
{
if (argc != 0)
{
return grub_error (GRUB_ERR_BAD_ARGUMENT, "Arguments not expected");
}
query_fpswa ();
if (fpswa == NULL)
grub_printf ("No FPSWA loaded\n");
else
grub_printf ("FPSWA revision: %x\n", fpswa->revision);
return GRUB_ERR_NONE;
}
static grub_command_t cmd_linux, cmd_initrd, cmd_payload, cmd_relocate, cmd_fpswa;
GRUB_MOD_INIT(linux)
{
cmd_linux = grub_register_command ("linux", grub_cmd_linux,
"FILE [ARGS...]", "Load Linux.");
cmd_initrd = grub_register_command ("initrd", grub_cmd_initrd,
"FILE", "Load initrd.");
cmd_payload = grub_register_command ("payload", grub_cmd_payload,
"FILE [ARGS...]",
"Load an additional file.");
cmd_relocate = grub_register_command ("relocate", grub_cmd_relocate,
"[on|off|force]",
"Set relocate feature.");
cmd_fpswa = grub_register_command ("fpswa", grub_cmd_fpswa,
"", "Display FPSWA version.");
my_mod = mod;
}
GRUB_MOD_FINI(linux)
{
grub_unregister_command (cmd_linux);
grub_unregister_command (cmd_initrd);
grub_unregister_command (cmd_payload);
grub_unregister_command (cmd_relocate);
grub_unregister_command (cmd_fpswa);
}

147
grub-core/loader/mips/linux.c
View file

@ -25,13 +25,27 @@
#include <grub/misc.h>
#include <grub/command.h>
#include <grub/mips/relocator.h>
#include <grub/machine/memory.h>
#include <grub/memory.h>
#include <grub/i18n.h>
#include <grub/lib/cmdline.h>
GRUB_MOD_LICENSE ("GPLv3+");
/* For frequencies. */
#include <grub/pci.h>
#include <grub/machine/time.h>
#ifdef GRUB_MACHINE_MIPS_LOONGSON
#include <grub/pci.h>
#include <grub/machine/kernel.h>
const char loongson_machtypes[][60] =
{
[GRUB_ARCH_MACHINE_YEELOONG] = "machtype=lemote-yeeloong-2f-8.9inches",
[GRUB_ARCH_MACHINE_FULOONG2F] = "machtype=lemote-fuloong-2f-box",
[GRUB_ARCH_MACHINE_FULOONG2E] = "machtype=lemote-fuloong-2e-unknown"
};
#endif
static grub_dl_t my_mod;
static int loaded;
@ -41,9 +55,16 @@ static grub_size_t linux_size;
static struct grub_relocator *relocator;
static grub_uint8_t *playground;
static grub_addr_t target_addr, entry_addr;
#ifdef GRUB_MACHINE_MIPS_QEMU_MIPS
static char *params;
#else
static int linux_argc;
static grub_off_t argv_off, envp_off;
static grub_off_t argv_off;
#ifdef GRUB_MACHINE_MIPS_LOONGSON
static grub_off_t envp_off;
#endif
static grub_off_t rd_addr_arg_off, rd_size_arg_off;
#endif
static int initrd_loaded = 0;
static grub_err_t
@ -51,11 +72,43 @@ grub_linux_boot (void)
{
struct grub_relocator32_state state;
grub_memset (&state, 0, sizeof (state));
/* Boot the kernel. */
state.gpr[1] = entry_addr;
#ifdef GRUB_MACHINE_MIPS_QEMU_MIPS
{
grub_err_t err;
grub_relocator_chunk_t ch;
grub_uint32_t *memsize;
grub_uint32_t *magic;
char *str;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
((16 << 20) - 264),
grub_strlen (params) + 1 + 8);
if (err)
return err;
memsize = get_virtual_current_address (ch);
magic = memsize + 1;
*memsize = grub_mmap_get_lower ();
*magic = 0x12345678;
str = (char *) (magic + 1);
grub_strcpy (str, params);
}
#endif
#ifndef GRUB_MACHINE_MIPS_QEMU_MIPS
state.gpr[4] = linux_argc;
state.gpr[5] = target_addr + argv_off;
#ifdef GRUB_MACHINE_MIPS_LOONGSON
state.gpr[6] = target_addr + envp_off;
#else
state.gpr[6] = 0;
#endif
state.gpr[7] = 0;
#endif
state.jumpreg = 1;
grub_relocator32_boot (relocator, state);
@ -68,6 +121,11 @@ grub_linux_unload (void)
grub_relocator_unload (relocator);
grub_dl_unref (my_mod);
#ifdef GRUB_MACHINE_MIPS_QEMU_MIPS
grub_free (params);
params = 0;
#endif
loaded = 0;
return GRUB_ERR_NONE;
@ -83,7 +141,7 @@ grub_linux_load32 (grub_elf_t elf, void **extra_mem, grub_size_t extra_size)
/* Linux's entry point incorrectly contains a virtual address. */
entry_addr = elf->ehdr.ehdr32.e_entry;
linux_size = grub_elf32_size (elf, &base);
linux_size = grub_elf32_size (elf, &base, 0);
if (linux_size == 0)
return grub_errno;
target_addr = base;
@ -138,7 +196,7 @@ grub_linux_load64 (grub_elf_t elf, void **extra_mem, grub_size_t extra_size)
/* Linux's entry point incorrectly contains a virtual address. */
entry_addr = elf->ehdr.ehdr64.e_entry;
linux_size = grub_elf64_size (elf, &base);
linux_size = grub_elf64_size (elf, &base, 0);
if (linux_size == 0)
return grub_errno;
target_addr = base;
@ -187,12 +245,18 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_elf_t elf = 0;
int i;
int size;
void *extra = NULL;
grub_uint32_t *linux_argv, *linux_envp;
char *linux_args, *linux_envs;
#ifndef GRUB_MACHINE_MIPS_QEMU_MIPS
int i;
grub_uint32_t *linux_argv;
char *linux_args;
#endif
grub_err_t err;
#ifdef GRUB_MACHINE_MIPS_LOONGSON
char *linux_envs;
grub_uint32_t *linux_envp;
#endif
if (argc == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
@ -212,8 +276,14 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
grub_loader_unset ();
loaded = 0;
#ifdef GRUB_MACHINE_MIPS_QEMU_MIPS
size = 0;
#else
/* For arguments. */
linux_argc = argc;
#ifdef GRUB_MACHINE_MIPS_LOONGSON
linux_argc++;
#endif
/* Main arguments. */
size = (linux_argc) * sizeof (grub_uint32_t);
/* Initrd address and size. */
@ -226,7 +296,10 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
/* Normal arguments. */
for (i = 1; i < argc; i++)
size += ALIGN_UP (grub_strlen (argv[i]) + 1, 4);
#ifdef GRUB_MACHINE_MIPS_LOONGSON
size += ALIGN_UP (sizeof (loongson_machtypes[0]), 4);
#endif
/* rd arguments. */
size += ALIGN_UP (sizeof ("rd_start=0xXXXXXXXXXXXXXXXX"), 4);
size += ALIGN_UP (sizeof ("rd_size=0xXXXXXXXXXXXXXXXX"), 4);
@ -238,6 +311,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
+ ALIGN_UP (sizeof ("highmemsize=XXXXXXXXXXXXXXXXXXXX"), 4)
+ ALIGN_UP (sizeof ("busclock=XXXXXXXXXX"), 4)
+ ALIGN_UP (sizeof ("cpuclock=XXXXXXXXXX"), 4);
#endif
if (grub_elf_is_elf32 (elf))
err = grub_linux_load32 (elf, &extra, size);
@ -252,6 +326,20 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
if (err)
return err;
#ifdef GRUB_MACHINE_MIPS_QEMU_MIPS
/* Create kernel command line. */
size = grub_loader_cmdline_size(argc, argv);
params = grub_malloc (size + sizeof (LINUX_IMAGE));
if (! params)
{
grub_linux_unload ();
return grub_errno;
}
grub_memcpy (params, LINUX_IMAGE, sizeof (LINUX_IMAGE));
grub_create_loader_cmdline (argc, argv, params + sizeof (LINUX_IMAGE) - 1,
size);
#else
linux_argv = extra;
argv_off = (grub_uint8_t *) linux_argv - (grub_uint8_t *) playground;
extra = linux_argv + (linux_argc + 1 + 2);
@ -263,6 +351,22 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
linux_argv++;
linux_args += ALIGN_UP (sizeof ("a0"), 4);
#ifdef GRUB_MACHINE_MIPS_LOONGSON
{
unsigned mtype = grub_arch_machine;
if (mtype >= ARRAY_SIZE (loongson_machtypes))
mtype = 0;
/* In Loongson platform, it is the responsibility of the bootloader/firmware
to supply the OS kernel with machine type information. */
grub_memcpy (linux_args, loongson_machtypes[mtype],
sizeof (loongson_machtypes[mtype]));
*linux_argv = (grub_uint8_t *) linux_args - (grub_uint8_t *) playground
+ target_addr;
linux_argv++;
linux_args += ALIGN_UP (sizeof (loongson_machtypes[mtype]), 4);
}
#endif
for (i = 1; i < argc; i++)
{
grub_memcpy (linux_args, argv[i], grub_strlen (argv[i]) + 1);
@ -287,6 +391,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
extra = linux_args;
#ifdef GRUB_MACHINE_MIPS_LOONGSON
linux_envp = extra;
envp_off = (grub_uint8_t *) linux_envp - (grub_uint8_t *) playground;
linux_envs = (char *) (linux_envp + 5);
@ -314,8 +419,9 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
+ target_addr;
linux_envs += ALIGN_UP (grub_strlen (linux_envs) + 1, 4);
linux_envp[4] = 0;
#endif
#endif
grub_loader_set (grub_linux_boot, grub_linux_unload, 1);
initrd_loaded = 0;
@ -355,8 +461,9 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_align (relocator, &ch,
target_addr + linux_size + 0x10000,
(0xffffffff - size) + 1,
(target_addr & 0x1fffffff)
+ linux_size + 0x10000,
(0x10000000 - size),
size, 0x10000,
GRUB_RELOCATOR_PREFERENCE_NONE);
@ -377,6 +484,21 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
return grub_errno;
}
#ifdef GRUB_MACHINE_MIPS_QEMU_MIPS
{
char *tmp;
tmp = grub_xasprintf ("%s rd_start=0x%" PRIxGRUB_ADDR
" rd_size=0x%" PRIxGRUB_ADDR, params,
initrd_dest, size);
if (!tmp)
{
grub_file_close (file);
return grub_errno;
}
grub_free (params);
params = tmp;
}
#else
grub_snprintf ((char *) playground + rd_addr_arg_off,
sizeof ("rd_start=0xXXXXXXXXXXXXXXXX"), "rd_start=0x%llx",
(unsigned long long) initrd_dest);
@ -390,6 +512,7 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
((grub_uint32_t *) (playground + argv_off))[linux_argc]
= target_addr + rd_size_arg_off;
linux_argc++;
#endif
initrd_loaded = 1;

12
grub-core/loader/multiboot.c
View file

@ -20,18 +20,16 @@
/*
* FIXME: The following features from the Multiboot specification still
* need to be implemented:
* - VBE support
* - symbol table
* - drives table
* - ROM configuration table
* - APM table
* - SMBIOS tables
* - Networking information
*/
#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>
@ -45,6 +43,8 @@
#include <grub/memory.h>
#include <grub/i18n.h>
GRUB_MOD_LICENSE ("GPLv3+");
#ifdef GRUB_MACHINE_EFI
#include <grub/efi/efi.h>
#endif
@ -73,7 +73,7 @@ grub_get_multiboot_mmap_count (void)
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)))
grub_memory_type_t type __attribute__ ((unused)))
{
count++;
return 0;
@ -182,7 +182,7 @@ grub_multiboot_set_console (int console_type, int accepted_consoles,
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");
grub_puts_ (N_("WARNING: no console will be available to OS"));
accepts_video = 0;
accepts_ega_text = 0;
return GRUB_ERR_NONE;

3
grub-core/loader/multiboot_elfxx.c
View file

@ -22,12 +22,14 @@
# define ELFCLASSXX ELFCLASS32
# define Elf_Ehdr Elf32_Ehdr
# define Elf_Phdr Elf32_Phdr
# define Elf_Shdr Elf32_Shdr
#elif defined(MULTIBOOT_LOAD_ELF64)
# define XX 64
# define E_MACHINE MULTIBOOT_ELF64_MACHINE
# define ELFCLASSXX ELFCLASS64
# define Elf_Ehdr Elf64_Ehdr
# define Elf_Phdr Elf64_Phdr
# define Elf_Shdr Elf64_Shdr
#else
#error "I'm confused"
#endif
@ -223,3 +225,4 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
#undef ELFCLASSXX
#undef Elf_Ehdr
#undef Elf_Phdr
#undef Elf_Shdr

212
grub-core/loader/multiboot_mbi2.c
View file

@ -16,10 +16,11 @@
* 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>
#include <grub/machine/apm.h>
#include <grub/machine/memory.h>
#endif
#include <grub/multiboot.h>
#include <grub/cpu/multiboot.h>
@ -31,6 +32,11 @@
#include <grub/misc.h>
#include <grub/env.h>
#include <grub/video.h>
#include <grub/acpi.h>
#if defined (GRUB_MACHINE_EFI)
#include <grub/efi/efi.h>
#endif
#if defined (GRUB_MACHINE_PCBIOS) || defined (GRUB_MACHINE_COREBOOT) || defined (GRUB_MACHINE_MULTIBOOT) || defined (GRUB_MACHINE_QEMU)
#include <grub/i386/pc/vbe.h>
@ -48,7 +54,7 @@ struct module
int cmdline_size;
};
struct module *modules, *modules_last;
static struct module *modules, *modules_last;
static grub_size_t cmdline_size;
static grub_size_t total_modcmd;
static unsigned modcnt;
@ -138,11 +144,15 @@ grub_multiboot_load (grub_file_t file)
case MULTIBOOT_TAG_TYPE_BOOTDEV:
case MULTIBOOT_TAG_TYPE_MMAP:
case MULTIBOOT_TAG_TYPE_FRAMEBUFFER:
break;
case MULTIBOOT_TAG_TYPE_VBE:
case MULTIBOOT_TAG_TYPE_ELF_SECTIONS:
case MULTIBOOT_TAG_TYPE_APM:
case MULTIBOOT_TAG_TYPE_EFI32:
case MULTIBOOT_TAG_TYPE_EFI64:
case MULTIBOOT_TAG_TYPE_ACPI_OLD:
case MULTIBOOT_TAG_TYPE_ACPI_NEW:
break;
default:
grub_free (buffer);
return grub_error (GRUB_ERR_UNKNOWN_OS,
@ -264,6 +274,22 @@ grub_multiboot_load (grub_file_t file)
return err;
}
static grub_size_t
acpiv2_size (void)
{
#if GRUB_MACHINE_HAS_ACPI
struct grub_acpi_rsdp_v20 *p = grub_acpi_get_rsdpv2 ();
if (!p)
return 0;
return ALIGN_UP (sizeof (struct multiboot_tag_old_acpi)
+ p->length, MULTIBOOT_TAG_ALIGN);
#else
return 0;
#endif
}
static grub_size_t
grub_multiboot_get_mbi_size (void)
{
@ -273,13 +299,22 @@ grub_multiboot_get_mbi_size (void)
+ (sizeof (struct multiboot_tag_string)
+ ALIGN_UP (sizeof (PACKAGE_STRING), MULTIBOOT_TAG_ALIGN))
+ (modcnt * sizeof (struct multiboot_tag_module) + total_modcmd)
+ sizeof (struct multiboot_tag_basic_meminfo)
+ ALIGN_UP (sizeof (struct multiboot_tag_basic_meminfo),
MULTIBOOT_TAG_ALIGN)
+ ALIGN_UP (sizeof (struct multiboot_tag_bootdev), MULTIBOOT_TAG_ALIGN)
+ sizeof (struct multiboot_tag_elf_sections)
+ elf_sec_entsize * elf_sec_num
+ (sizeof (struct multiboot_tag_mmap) + grub_get_multiboot_mmap_count ()
* sizeof (struct multiboot_mmap_entry))
+ sizeof (struct multiboot_tag_vbe) + MULTIBOOT_TAG_ALIGN - 1;
+ ALIGN_UP (sizeof (struct multiboot_tag_elf_sections), MULTIBOOT_TAG_ALIGN)
+ ALIGN_UP (elf_sec_entsize * elf_sec_num, MULTIBOOT_TAG_ALIGN)
+ ALIGN_UP ((sizeof (struct multiboot_tag_mmap)
+ grub_get_multiboot_mmap_count ()
* sizeof (struct multiboot_mmap_entry)), MULTIBOOT_TAG_ALIGN)
+ ALIGN_UP (sizeof (struct multiboot_tag_framebuffer), MULTIBOOT_TAG_ALIGN)
+ ALIGN_UP (sizeof (struct multiboot_tag_efi32), MULTIBOOT_TAG_ALIGN)
+ ALIGN_UP (sizeof (struct multiboot_tag_efi64), MULTIBOOT_TAG_ALIGN)
+ ALIGN_UP (sizeof (struct multiboot_tag_old_acpi)
+ sizeof (struct grub_acpi_rsdp_v10), MULTIBOOT_TAG_ALIGN)
+ acpiv2_size ()
+ sizeof (struct multiboot_tag_vbe) + MULTIBOOT_TAG_ALIGN - 1
+ sizeof (struct multiboot_tag_apm) + MULTIBOOT_TAG_ALIGN - 1;
}
/* Fill previously allocated Multiboot mmap. */
@ -288,29 +323,31 @@ grub_fill_multiboot_mmap (struct multiboot_tag_mmap *tag)
{
struct multiboot_mmap_entry *mmap_entry = tag->entries;
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)
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t,
grub_memory_type_t);
int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size,
grub_memory_type_t type)
{
mmap_entry->addr = addr;
mmap_entry->len = size;
switch (type)
{
case GRUB_MACHINE_MEMORY_AVAILABLE:
case GRUB_MEMORY_AVAILABLE:
mmap_entry->type = MULTIBOOT_MEMORY_AVAILABLE;
break;
#ifdef GRUB_MACHINE_MEMORY_ACPI_RECLAIMABLE
case GRUB_MACHINE_MEMORY_ACPI_RECLAIMABLE:
case GRUB_MEMORY_ACPI:
mmap_entry->type = MULTIBOOT_MEMORY_ACPI_RECLAIMABLE;
break;
#endif
#ifdef GRUB_MACHINE_MEMORY_NVS
case GRUB_MACHINE_MEMORY_NVS:
case GRUB_MEMORY_NVS:
mmap_entry->type = MULTIBOOT_MEMORY_NVS;
break;
#endif
case GRUB_MEMORY_BADRAM:
mmap_entry->type = MULTIBOOT_MEMORY_BADRAM;
break;
default:
mmap_entry->type = MULTIBOOT_MEMORY_RESERVED;
break;
@ -329,6 +366,54 @@ grub_fill_multiboot_mmap (struct multiboot_tag_mmap *tag)
grub_mmap_iterate (hook);
}
#if defined (GRUB_MACHINE_PCBIOS)
static void
fill_vbe_tag (struct multiboot_tag_vbe *tag)
{
grub_vbe_status_t status;
void *scratch = (void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
tag->type = MULTIBOOT_TAG_TYPE_VBE;
tag->size = 0;
status = grub_vbe_bios_get_controller_info (scratch);
if (status != GRUB_VBE_STATUS_OK)
return;
grub_memcpy (&tag->vbe_control_info, scratch,
sizeof (struct grub_vbe_info_block));
status = grub_vbe_bios_get_mode (scratch);
tag->vbe_mode = *(grub_uint32_t *) scratch;
if (status != GRUB_VBE_STATUS_OK)
return;
/* get_mode_info isn't available for mode 3. */
if (tag->vbe_mode == 3)
{
struct grub_vbe_mode_info_block *mode_info = (void *) &tag->vbe_mode_info;
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 (tag->vbe_mode, scratch);
if (status != GRUB_VBE_STATUS_OK)
return;
grub_memcpy (&tag->vbe_mode_info, scratch,
sizeof (struct grub_vbe_mode_info_block));
}
grub_vbe_bios_get_pm_interface (&tag->vbe_interface_seg,
&tag->vbe_interface_off,
&tag->vbe_interface_len);
tag->size = sizeof (*tag);
}
#endif
static grub_err_t
retrieve_video_parameters (grub_uint8_t **ptrorig)
{
@ -417,6 +502,16 @@ retrieve_video_parameters (grub_uint8_t **ptrorig)
return GRUB_ERR_NONE;
#endif
#if GRUB_MACHINE_HAS_VBE
{
struct multiboot_tag_vbe *tag_vbe = (struct multiboot_tag_vbe *) *ptrorig;
fill_vbe_tag (tag_vbe);
*ptrorig += ALIGN_UP (tag_vbe->size, MULTIBOOT_TAG_ALIGN);
}
#endif
err = grub_video_get_info_and_fini (&mode_info, &framebuffer);
if (err)
return err;
@ -482,7 +577,7 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator, &ch,
0, 0xffffffff - bufsize,
bufsize, 4,
bufsize, MULTIBOOT_TAG_ALIGN,
GRUB_RELOCATOR_PREFERENCE_NONE);
if (err)
return err;
@ -515,6 +610,31 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN);
}
#ifdef GRUB_MACHINE_PCBIOS
{
struct grub_apm_info info;
if (grub_apm_get_info (&info))
{
struct multiboot_tag_apm *tag = (struct multiboot_tag_apm *) ptrorig;
tag->type = MULTIBOOT_TAG_TYPE_APM;
tag->size = sizeof (struct multiboot_tag_apm);
tag->cseg = info.cseg;
tag->offset = info.offset;
tag->cseg_16 = info.cseg_16;
tag->dseg = info.dseg;
tag->flags = info.flags;
tag->cseg_len = info.cseg_len;
tag->dseg_len = info.dseg_len;
tag->cseg_16_len = info.cseg_16_len;
tag->version = info.version;
ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN);
}
}
#endif
{
unsigned i;
struct module *cur;
@ -584,7 +704,55 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
grub_errno = GRUB_ERR_NONE;
}
}
#if defined (GRUB_MACHINE_EFI) && defined (__x86_64__)
{
struct multiboot_tag_efi64 *tag = (struct multiboot_tag_efi64 *) ptrorig;
tag->type = MULTIBOOT_TAG_TYPE_EFI64;
tag->size = sizeof (*tag);
tag->pointer = (grub_addr_t) grub_efi_system_table;
ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN);
}
#endif
#if defined (GRUB_MACHINE_EFI) && defined (__i386__)
{
struct multiboot_tag_efi32 *tag = (struct multiboot_tag_efi32 *) ptrorig;
tag->type = MULTIBOOT_TAG_TYPE_EFI32;
tag->size = sizeof (*tag);
tag->pointer = (grub_addr_t) grub_efi_system_table;
ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN);
}
#endif
#if GRUB_MACHINE_HAS_ACPI
{
struct multiboot_tag_old_acpi *tag = (struct multiboot_tag_old_acpi *)
ptrorig;
struct grub_acpi_rsdp_v10 *a = grub_acpi_get_rsdpv1 ();
if (a)
{
tag->type = MULTIBOOT_TAG_TYPE_ACPI_OLD;
tag->size = sizeof (*tag) + sizeof (*a);
grub_memcpy (tag->rsdp, a, sizeof (*a));
ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN);
}
}
{
struct multiboot_tag_new_acpi *tag = (struct multiboot_tag_new_acpi *)
ptrorig;
struct grub_acpi_rsdp_v20 *a = grub_acpi_get_rsdpv2 ();
if (a)
{
tag->type = MULTIBOOT_TAG_TYPE_ACPI_NEW;
tag->size = sizeof (*tag) + a->length;
grub_memcpy (tag->rsdp, a, a->length);
ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN);
}
}
#endif
{
struct multiboot_tag *tag = (struct multiboot_tag *) ptrorig;
tag->type = MULTIBOOT_TAG_TYPE_END;

160
grub-core/loader/powerpc/ieee1275/linux.c
View file

@ -26,6 +26,10 @@
#include <grub/ieee1275/ieee1275.h>
#include <grub/command.h>
#include <grub/i18n.h>
#include <grub/memory.h>
#include <grub/lib/cmdline.h>
GRUB_MOD_LICENSE ("GPLv3+");
#define ELF32_LOADMASK (0xc0000000UL)
#define ELF64_LOADMASK (0xc000000000000000ULL)
@ -45,6 +49,51 @@ static char *linux_args;
typedef void (*kernel_entry_t) (void *, unsigned long, int (void *),
unsigned long, unsigned long);
static grub_addr_t
grub_linux_claimmap_iterate (grub_addr_t target, grub_size_t size,
grub_size_t align)
{
grub_addr_t found_addr = (grub_addr_t) -1;
auto int NESTED_FUNC_ATTR alloc_mem (grub_uint64_t addr, grub_uint64_t len,
grub_memory_type_t type);
int NESTED_FUNC_ATTR alloc_mem (grub_uint64_t addr, grub_uint64_t len,
grub_memory_type_t type)
{
grub_uint64_t end = addr + len;
addr = ALIGN_UP (addr, align);
target = ALIGN_UP (target, align);
/* Target above the memory chunk. */
if (type != GRUB_MEMORY_AVAILABLE || target > end)
return 0;
/* Target inside the memory chunk. */
if (target >= addr && target < end && size <= end - target)
{
if (grub_claimmap (target, size) == GRUB_ERR_NONE)
{
found_addr = target;
return 1;
}
}
/* Target below the memory chunk. */
if (target < addr && addr + size <= end)
{
if (grub_claimmap (addr, size) == GRUB_ERR_NONE)
{
found_addr = addr;
return 1;
}
}
return 0;
}
grub_machine_mmap_iterate (alloc_mem);
return found_addr;
}
static grub_err_t
grub_linux_boot (void)
{
@ -102,34 +151,34 @@ grub_linux_unload (void)
static grub_err_t
grub_linux_load32 (grub_elf_t elf)
{
Elf32_Addr base_addr;
grub_addr_t seg_addr;
grub_uint32_t align;
grub_uint32_t offset;
Elf32_Addr entry;
int found_addr = 0;
/* Linux's entry point incorrectly contains a virtual address. */
entry = elf->ehdr.ehdr32.e_entry & ~ELF32_LOADMASK;
if (entry == 0)
entry = 0x01400000;
linux_size = grub_elf32_size (elf, 0);
linux_size = grub_elf32_size (elf, &base_addr, &align);
if (linux_size == 0)
return grub_errno;
/* Pad it; the kernel scribbles over memory beyond its load address. */
linux_size += 0x100000;
/* Linux's entry point incorrectly contains a virtual address. */
entry = elf->ehdr.ehdr32.e_entry & ~ELF32_LOADMASK;
/* Linux's incorrectly contains a virtual address. */
base_addr &= ~ELF32_LOADMASK;
offset = entry - base_addr;
/* On some systems, firmware occupies the memory we're trying to use.
* Happily, Linux can be loaded anywhere (it relocates itself). Iterate
* until we find an open area. */
for (linux_addr = entry; linux_addr < entry + 200 * 0x100000; linux_addr += 0x100000)
{
grub_dprintf ("loader", "Attempting to claim at 0x%x, size 0x%x.\n",
linux_addr, linux_size);
found_addr = grub_claimmap (linux_addr, linux_size);
if (found_addr != -1)
break;
}
if (found_addr == -1)
seg_addr = grub_linux_claimmap_iterate (base_addr & ~ELF32_LOADMASK, linux_size, align);
if (seg_addr == (grub_addr_t) -1)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't claim memory");
linux_addr = seg_addr + offset;
/* Now load the segments into the area we claimed. */
auto grub_err_t offset_phdr (Elf32_Phdr *phdr, grub_addr_t *addr, int *do_load);
grub_err_t offset_phdr (Elf32_Phdr *phdr, grub_addr_t *addr, int *do_load)
@ -141,9 +190,7 @@ grub_linux_load32 (grub_elf_t elf)
}
*do_load = 1;
/* Linux's program headers incorrectly contain virtual addresses.
* Translate those to physical, and offset to the area we claimed. */
*addr = (phdr->p_paddr & ~ELF32_LOADMASK) + linux_addr;
*addr = (phdr->p_paddr - base_addr) + seg_addr;
return 0;
}
return grub_elf32_load (elf, offset_phdr, 0, 0);
@ -152,34 +199,32 @@ grub_linux_load32 (grub_elf_t elf)
static grub_err_t
grub_linux_load64 (grub_elf_t elf)
{
Elf64_Addr base_addr;
grub_addr_t seg_addr;
grub_uint64_t align;
grub_uint64_t offset;
Elf64_Addr entry;
int found_addr = 0;
/* Linux's entry point incorrectly contains a virtual address. */
entry = elf->ehdr.ehdr64.e_entry & ~ELF64_LOADMASK;
if (entry == 0)
entry = 0x01400000;
linux_size = grub_elf64_size (elf, 0);
linux_size = grub_elf64_size (elf, &base_addr, &align);
if (linux_size == 0)
return grub_errno;
/* Pad it; the kernel scribbles over memory beyond its load address. */
linux_size += 0x100000;
base_addr &= ~ELF64_LOADMASK;
entry = elf->ehdr.ehdr64.e_entry & ~ELF64_LOADMASK;
offset = entry - base_addr;
/* Linux's incorrectly contains a virtual address. */
/* On some systems, firmware occupies the memory we're trying to use.
* Happily, Linux can be loaded anywhere (it relocates itself). Iterate
* until we find an open area. */
for (linux_addr = entry; linux_addr < entry + 200 * 0x100000; linux_addr += 0x100000)
{
grub_dprintf ("loader", "Attempting to claim at 0x%x, size 0x%x.\n",
linux_addr, linux_size);
found_addr = grub_claimmap (linux_addr, linux_size);
if (found_addr != -1)
break;
}
if (found_addr == -1)
seg_addr = grub_linux_claimmap_iterate (base_addr & ~ELF64_LOADMASK, linux_size, align);
if (seg_addr == (grub_addr_t) -1)
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't claim memory");
linux_addr = seg_addr + offset;
/* Now load the segments into the area we claimed. */
auto grub_err_t offset_phdr (Elf64_Phdr *phdr, grub_addr_t *addr, int *do_load);
grub_err_t offset_phdr (Elf64_Phdr *phdr, grub_addr_t *addr, int *do_load)
@ -190,9 +235,8 @@ grub_linux_load64 (grub_elf_t elf)
return 0;
}
*do_load = 1;
/* Linux's program headers incorrectly contain virtual addresses.
* Translate those to physical, and offset to the area we claimed. */
*addr = (phdr->p_paddr & ~ELF64_LOADMASK) + linux_addr;
*addr = (phdr->p_paddr - base_addr) + seg_addr;
return 0;
}
return grub_elf64_load (elf, offset_phdr, 0, 0);
@ -203,9 +247,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_elf_t elf = 0;
int i;
int size;
char *dest;
grub_dl_ref (my_mod);
@ -240,23 +282,15 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
goto out;
}
size = sizeof ("BOOT_IMAGE=") + grub_strlen (argv[0]);
for (i = 0; i < argc; i++)
size += grub_strlen (argv[i]) + 1;
linux_args = grub_malloc (size);
size = grub_loader_cmdline_size(argc, argv);
linux_args = grub_malloc (size + sizeof (LINUX_IMAGE));
if (! linux_args)
goto out;
/* Specify the boot file. */
dest = grub_stpcpy (linux_args, "BOOT_IMAGE=");
dest = grub_stpcpy (dest, argv[0]);
for (i = 1; i < argc; i++)
{
*dest++ = ' ';
dest = grub_stpcpy (dest, argv[i]);
}
/* Create kernel command line. */
grub_memcpy (linux_args, LINUX_IMAGE, sizeof (LINUX_IMAGE));
grub_create_loader_cmdline (argc, argv, linux_args + sizeof (LINUX_IMAGE) - 1,
size);
out:
@ -287,7 +321,6 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
grub_ssize_t size;
grub_addr_t first_addr;
grub_addr_t addr;
int found_addr = 0;
if (argc == 0)
{
@ -311,20 +344,9 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
/* Attempt to claim at a series of addresses until successful in
the same way that grub_rescue_cmd_linux does. */
for (addr = first_addr; addr < first_addr + 200 * 0x100000; addr += 0x100000)
{
grub_dprintf ("loader", "Attempting to claim at 0x%x, size 0x%x.\n",
addr, size);
found_addr = grub_claimmap (addr, size);
if (found_addr != -1)
break;
}
if (found_addr == -1)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot claim memory");
goto fail;
}
addr = grub_linux_claimmap_iterate (first_addr, size, 0x100000);
if (addr == (grub_addr_t) -1)
goto fail;
grub_dprintf ("loader", "Loading initrd at 0x%x, size 0x%x\n", addr, size);

33
grub-core/loader/sparc64/ieee1275/linux.c
View file

@ -26,6 +26,10 @@
#include <grub/ieee1275/ieee1275.h>
#include <grub/command.h>
#include <grub/i18n.h>
#include <grub/memory.h>
#include <grub/lib/cmdline.h>
GRUB_MOD_LICENSE ("GPLv3+");
static grub_dl_t my_mod;
@ -181,8 +185,10 @@ alloc_phys (grub_addr_t size)
{
grub_addr_t ret = (grub_addr_t) -1;
auto int NESTED_FUNC_ATTR choose (grub_uint64_t addr, grub_uint64_t len __attribute__((unused)), grub_uint32_t type);
int NESTED_FUNC_ATTR choose (grub_uint64_t addr, grub_uint64_t len __attribute__((unused)), grub_uint32_t type)
auto int NESTED_FUNC_ATTR choose (grub_uint64_t addr, grub_uint64_t len,
grub_memory_type_t type);
int NESTED_FUNC_ATTR choose (grub_uint64_t addr, grub_uint64_t len,
grub_memory_type_t type)
{
grub_addr_t end = addr + len;
@ -244,7 +250,7 @@ grub_linux_load64 (grub_elf_t elf)
linux_entry = elf->ehdr.ehdr64.e_entry;
linux_addr = 0x40004000;
off = 0x4000;
linux_size = grub_elf64_size (elf, 0);
linux_size = grub_elf64_size (elf, 0, 0);
if (linux_size == 0)
return grub_errno;
@ -292,9 +298,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
{
grub_file_t file = 0;
grub_elf_t elf = 0;
int i;
int size;
char *dest;
grub_dl_ref (my_mod);
@ -330,23 +334,16 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
goto out;
}
size = sizeof ("BOOT_IMAGE=") + grub_strlen (argv[0]);
for (i = 0; i < argc; i++)
size += grub_strlen (argv[i]) + 1;
size = grub_loader_cmdline_size(argc, argv);
linux_args = grub_malloc (size);
linux_args = grub_malloc (size + sizeof (LINUX_IMAGE));
if (! linux_args)
goto out;
/* Specify the boot file. */
dest = grub_stpcpy (linux_args, "BOOT_IMAGE=");
dest = grub_stpcpy (dest, argv[0]);
for (i = 1; i < argc; i++)
{
*dest++ = ' ';
dest = grub_stpcpy (dest, argv[i]);
}
/* Create kernel command line. */
grub_memcpy (linux_args, LINUX_IMAGE, sizeof (LINUX_IMAGE));
grub_create_loader_cmdline (argc, argv, linux_args + sizeof (LINUX_IMAGE) - 1,
size);
out:
if (elf)

59
grub-core/loader/xnu.c
View file

@ -34,6 +34,12 @@
#include <grub/env.h>
#include <grub/i18n.h>
GRUB_MOD_LICENSE ("GPLv3+");
#if defined (__i386) && !defined (GRUB_MACHINE_EFI)
#include <grub/autoefi.h>
#endif
struct grub_xnu_devtree_key *grub_xnu_devtree_root = 0;
static int driverspackagenum = 0;
static int driversnum = 0;
@ -338,7 +344,8 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
grub_macho_t macho;
grub_uint32_t startcode, endcode;
int i;
char *ptr, *loadaddr;
char *ptr;
void *loadaddr;
grub_addr_t loadaddr_target;
if (argc < 1)
@ -371,7 +378,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
if (!grub_xnu_relocator)
return grub_errno;
grub_xnu_heap_target_start = startcode;
err = grub_xnu_heap_malloc (endcode - startcode, (void **) &loadaddr,
err = grub_xnu_heap_malloc (endcode - startcode, &loadaddr,
&loadaddr_target);
if (err)
@ -382,7 +389,8 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
}
/* Load kernel. */
err = grub_macho_load32 (macho, loadaddr - startcode, GRUB_MACHO_NOBSS);
err = grub_macho_load32 (macho, (char *) loadaddr - startcode,
GRUB_MACHO_NOBSS);
if (err)
{
grub_macho_close (macho);
@ -424,6 +432,12 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
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 ();
@ -440,7 +454,8 @@ grub_cmd_xnu_kernel64 (grub_command_t cmd __attribute__ ((unused)),
grub_macho_t macho;
grub_uint64_t startcode, endcode;
int i;
char *ptr, *loadaddr;
char *ptr;
void *loadaddr;
grub_addr_t loadaddr_target;
if (argc < 1)
@ -476,7 +491,7 @@ grub_cmd_xnu_kernel64 (grub_command_t cmd __attribute__ ((unused)),
if (!grub_xnu_relocator)
return grub_errno;
grub_xnu_heap_target_start = startcode;
err = grub_xnu_heap_malloc (endcode - startcode, (void **) &loadaddr,
err = grub_xnu_heap_malloc (endcode - startcode, &loadaddr,
&loadaddr_target);
if (err)
@ -487,7 +502,8 @@ grub_cmd_xnu_kernel64 (grub_command_t cmd __attribute__ ((unused)),
}
/* Load kernel. */
err = grub_macho_load64 (macho, loadaddr - startcode, GRUB_MACHO_NOBSS);
err = grub_macho_load64 (macho, (char *) loadaddr - startcode,
GRUB_MACHO_NOBSS);
if (err)
{
grub_macho_close (macho);
@ -529,6 +545,12 @@ grub_cmd_xnu_kernel64 (grub_command_t cmd __attribute__ ((unused)),
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 ();
@ -620,7 +642,8 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
grub_file_t infoplist;
struct grub_xnu_extheader *exthead;
int neededspace = sizeof (*exthead);
grub_uint8_t *buf, *buf0;
grub_uint8_t *buf;
void *buf0;
grub_addr_t buf_target;
grub_size_t infoplistsize = 0, machosize = 0;
char *name, *nameend;
@ -676,7 +699,7 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE);
if (err)
return err;
err = grub_xnu_heap_malloc (neededspace, (void **) &buf0, &buf_target);
err = grub_xnu_heap_malloc (neededspace, &buf0, &buf_target);
if (err)
return err;
buf = buf0;
@ -688,7 +711,7 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
/* Load the binary. */
if (macho)
{
exthead->binaryaddr = buf_target + (buf - buf0);
exthead->binaryaddr = buf_target + (buf - (grub_uint8_t *) buf0);
exthead->binarysize = machosize;
if (grub_xnu_is_64bit)
err = grub_macho_readfile64 (macho, buf);
@ -707,7 +730,7 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
/* Load the plist. */
if (infoplist)
{
exthead->infoplistaddr = buf_target + (buf - buf0);
exthead->infoplistaddr = buf_target + (buf - (grub_uint8_t *) buf0);
exthead->infoplistsize = infoplistsize + 1;
if (grub_file_read (infoplist, buf, infoplistsize)
!= (grub_ssize_t) (infoplistsize))
@ -723,7 +746,7 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
}
grub_errno = GRUB_ERR_NONE;
exthead->nameaddr = (buf - buf0) + buf_target;
exthead->nameaddr = (buf - (grub_uint8_t *) buf0) + buf_target;
exthead->namesize = namelen + 1;
grub_memcpy (buf, name, namelen);
buf[namelen] = 0;
@ -1198,6 +1221,10 @@ 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. */
@ -1229,6 +1256,9 @@ grub_cmd_xnu_kextdir (grub_command_t cmd __attribute__ ((unused)),
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",
@ -1370,6 +1400,9 @@ grub_cmd_xnu_splash (grub_extcmd_context_t ctxt,
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)
@ -1398,7 +1431,7 @@ grub_cmd_xnu_resume (grub_command_t cmd __attribute__ ((unused)),
#endif
void
grub_xnu_lock ()
grub_xnu_lock (void)
{
if (!locked)
grub_dl_ref (my_mod);
@ -1406,7 +1439,7 @@ grub_xnu_lock ()
}
void
grub_xnu_unlock ()
grub_xnu_unlock (void)
{
if (locked)
grub_dl_unref (my_mod);