Remove nested functions from memory map iterators.
* grub-core/efiemu/mm.c (grub_efiemu_mmap_iterate): Add hook_data argument, passed to hook. * grub-core/kern/i386/coreboot/mmap.c (grub_linuxbios_table_iterate): Likewise. (grub_machine_mmap_iterate: iterate_linuxbios_table): Make static instead of nested. (grub_machine_mmap_iterate): Add hook_data argument. * grub-core/kern/i386/multiboot_mmap.c (grub_machine_mmap_iterate): Add hook_data argument, passed to hook. * grub-core/kern/i386/pc/mmap.c (grub_machine_mmap_iterate): Likewise. * grub-core/kern/i386/qemu/mmap.c (grub_machine_mmap_iterate): Likewise. * grub-core/kern/ieee1275/mmap.c (grub_machine_mmap_iterate): Likewise. * grub-core/kern/mips/arc/init.c (grub_machine_mmap_iterate): Likewise. * grub-core/kern/mips/loongson/init.c (grub_machine_mmap_iterate): Likewise. * grub-core/kern/mips/qemu_mips/init.c (grub_machine_mmap_iterate): Likewise. * grub-core/mmap/efi/mmap.c (grub_efi_mmap_iterate): Likewise. (grub_machine_mmap_iterate): Likewise. * grub-core/mmap/mmap.c (grub_mmap_iterate): Likewise. * include/grub/efiemu/efiemu.h (grub_efiemu_mmap_iterate): Update prototype. * include/grub/memory.h (grub_memory_hook_t): Add data argument. Remove NESTED_FUNC_ATTR from here and from all users. (grub_mmap_iterate): Update prototype. (grub_efi_mmap_iterate): Update prototype. Update all callers to pass appropriate hook data. (grub_machine_mmap_iterate): Likewise. * grub-core/commands/acpi.c (grub_acpi_create_ebda: find_hook): Make static instead of nested. * grub-core/commands/lsmmap.c (grub_cmd_lsmmap: hook): Likewise. Rename to ... (lsmmap_hook): ... this. * grub-core/efiemu/mm.c (grub_efiemu_mmap_init: bounds_hook): Likewise. (grub_efiemu_mmap_fill: fill_hook): Likewise. * grub-core/kern/i386/coreboot/init.c (grub_machine_init: heap_init): Likewise. * grub-core/kern/i386/pc/init.c (grub_machine_init: hook): Likewise. Rename to ... (mmap_iterate_hook): ... this. * grub-core/kern/ieee1275/init.c (grub_claim_heap: heap_init): Likewise. * grub-core/lib/ieee1275/relocator.c (grub_relocator_firmware_get_max_events: count): Likewise. (grub_relocator_firmware_fill_events: fill): Likewise. Rename to ... (grub_relocator_firmware_fill_events_iter): ... this. * grub-core/lib/relocator.c (grub_relocator_alloc_chunk_align: hook): Likewise. Rename to ... (grub_relocator_alloc_chunk_align_iter): ... this. * grub-core/loader/i386/bsd.c (generate_e820_mmap: hook): Likewise. Rename to ... (generate_e820_mmap_iter): ... this. * grub-core/loader/i386/linux.c (find_mmap_size: hook): Likewise. Rename to ... (count_hook): ... this. (grub_linux_boot: hook): Likewise. Rename to ... (grub_linux_boot_mmap_find): ... this. (grub_linux_boot: hook_fill): Likewise. Rename to ... (grub_linux_boot_mmap_fill): ... this. * grub-core/loader/i386/multiboot_mbi.c (grub_fill_multiboot_mmap: hook): Likewise. Rename to ... (grub_fill_multiboot_mmap_iter): ... this. * grub-core/loader/multiboot.c (grub_get_multiboot_mmap_count: hook): Likewise. Rename to ... (count_hook): ... this. * grub-core/loader/multiboot_mbi2.c (grub_fill_multiboot_mmap: hook): Likewise. Rename to ... (grub_fill_multiboot_mmap_iter): ... this. * grub-core/loader/powerpc/ieee1275/linux.c (grub_linux_claimmap_iterate: alloc_mem): Likewise. * grub-core/loader/sparc64/ieee1275/linux.c (alloc_phys: choose): Likewise. Rename to ... (alloc_phys_choose): ... this. (determine_phys_base: get_physbase): Likewise. * grub-core/mmap/i386/mmap.c (grub_mmap_malign_and_register: find_hook): Likewise. * grub-core/mmap/i386/pc/mmap.c (preboot: fill_hook): Likewise. (malloc_hook: count_hook): Likewise. * grub-core/mmap/i386/uppermem.c (grub_mmap_get_lower: hook): Likewise. Rename to ... (lower_hook): ... this. (grub_mmap_get_upper: hook): Likewise. Rename to ... (upper_hook): ... this. (grub_mmap_get_post64: hook): Likewise. Rename to ... (post64_hook): ... this. * grub-core/mmap/mips/uppermem.c (grub_mmap_get_lower: hook): Likewise. Rename to ... (lower_hook): ... this. (grub_mmap_get_upper: hook): Likewise. Rename to ... (upper_hook): ... this. * grub-core/mmap/mmap.c (grub_mmap_iterate: count_hook): Likewise. (grub_mmap_iterate: fill_hook): Likewise. (fill_mask): Pass addr and mask within a single struct. (grub_cmd_badram: hook): Make static instead of nested. Rename to ... (badram_iter): ... this. (grub_cmd_cutmem: hook): Likewise. Rename to ... (cutmem_iter): ... this.
This commit is contained in:
Colin Watson
parent
22099030ad
commit
d0d4b8a063
32 changed files with 1315 additions and 1045 deletions
|
|
@ -269,81 +269,93 @@ struct grub_e820_mmap
|
|||
#define GRUB_E820_NVS 4
|
||||
#define GRUB_E820_BADRAM 5
|
||||
|
||||
/* Context for generate_e820_mmap. */
|
||||
struct generate_e820_mmap_ctx
|
||||
{
|
||||
int count;
|
||||
struct grub_e820_mmap *mmap;
|
||||
struct grub_e820_mmap prev, cur;
|
||||
};
|
||||
|
||||
/* Helper for generate_e820_mmap. */
|
||||
static int
|
||||
generate_e820_mmap_iter (grub_uint64_t addr, grub_uint64_t size,
|
||||
grub_memory_type_t type, void *data)
|
||||
{
|
||||
struct generate_e820_mmap_ctx *ctx = data;
|
||||
|
||||
ctx->cur.addr = addr;
|
||||
ctx->cur.size = size;
|
||||
switch (type)
|
||||
{
|
||||
case GRUB_MEMORY_AVAILABLE:
|
||||
ctx->cur.type = GRUB_E820_RAM;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_ACPI:
|
||||
ctx->cur.type = GRUB_E820_ACPI;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_NVS:
|
||||
ctx->cur.type = GRUB_E820_NVS;
|
||||
break;
|
||||
|
||||
default:
|
||||
case GRUB_MEMORY_CODE:
|
||||
case GRUB_MEMORY_RESERVED:
|
||||
ctx->cur.type = GRUB_E820_RESERVED;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Merge regions if possible. */
|
||||
if (ctx->count && ctx->cur.type == ctx->prev.type
|
||||
&& ctx->cur.addr == ctx->prev.addr + ctx->prev.size)
|
||||
{
|
||||
ctx->prev.size += ctx->cur.size;
|
||||
if (ctx->mmap)
|
||||
ctx->mmap[-1] = ctx->prev;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ctx->mmap)
|
||||
*ctx->mmap++ = ctx->cur;
|
||||
ctx->prev = ctx->cur;
|
||||
ctx->count++;
|
||||
}
|
||||
|
||||
if (kernel_type == KERNEL_TYPE_OPENBSD && ctx->prev.addr < 0x100000
|
||||
&& ctx->prev.addr + ctx->prev.size > 0x100000)
|
||||
{
|
||||
ctx->cur.addr = 0x100000;
|
||||
ctx->cur.size = ctx->prev.addr + ctx->prev.size - 0x100000;
|
||||
ctx->cur.type = ctx->prev.type;
|
||||
ctx->prev.size = 0x100000 - ctx->prev.addr;
|
||||
if (ctx->mmap)
|
||||
{
|
||||
ctx->mmap[-1] = ctx->prev;
|
||||
ctx->mmap[0] = ctx->cur;
|
||||
ctx->mmap++;
|
||||
}
|
||||
ctx->prev = ctx->cur;
|
||||
ctx->count++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
generate_e820_mmap (grub_size_t *len, grub_size_t *cnt, void *buf)
|
||||
{
|
||||
int count = 0;
|
||||
struct grub_e820_mmap *mmap = buf;
|
||||
struct grub_e820_mmap prev, cur;
|
||||
struct generate_e820_mmap_ctx ctx = {
|
||||
.count = 0,
|
||||
.mmap = buf
|
||||
};
|
||||
|
||||
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)
|
||||
{
|
||||
cur.addr = addr;
|
||||
cur.size = size;
|
||||
switch (type)
|
||||
{
|
||||
case GRUB_MEMORY_AVAILABLE:
|
||||
cur.type = GRUB_E820_RAM;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_ACPI:
|
||||
cur.type = GRUB_E820_ACPI;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_NVS:
|
||||
cur.type = GRUB_E820_NVS;
|
||||
break;
|
||||
|
||||
default:
|
||||
case GRUB_MEMORY_CODE:
|
||||
case GRUB_MEMORY_RESERVED:
|
||||
cur.type = GRUB_E820_RESERVED;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Merge regions if possible. */
|
||||
if (count && cur.type == prev.type && cur.addr == prev.addr + prev.size)
|
||||
{
|
||||
prev.size += cur.size;
|
||||
if (mmap)
|
||||
mmap[-1] = prev;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mmap)
|
||||
*mmap++ = cur;
|
||||
prev = cur;
|
||||
count++;
|
||||
}
|
||||
|
||||
if (kernel_type == KERNEL_TYPE_OPENBSD && prev.addr < 0x100000
|
||||
&& prev.addr + prev.size > 0x100000)
|
||||
{
|
||||
cur.addr = 0x100000;
|
||||
cur.size = prev.addr + prev.size - 0x100000;
|
||||
cur.type = prev.type;
|
||||
prev.size = 0x100000 - prev.addr;
|
||||
if (mmap)
|
||||
{
|
||||
mmap[-1] = prev;
|
||||
mmap[0] = cur;
|
||||
mmap++;
|
||||
}
|
||||
prev = cur;
|
||||
count++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
grub_mmap_iterate (hook);
|
||||
grub_mmap_iterate (generate_e820_mmap_iter, &ctx);
|
||||
|
||||
if (len)
|
||||
*len = count * sizeof (struct grub_e820_mmap);
|
||||
*cnt = count;
|
||||
*len = ctx.count * sizeof (struct grub_e820_mmap);
|
||||
*cnt = ctx.count;
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -150,23 +150,25 @@ find_efi_mmap_size (void)
|
|||
|
||||
#endif
|
||||
|
||||
/* Helper for find_mmap_size. */
|
||||
static int
|
||||
count_hook (grub_uint64_t addr __attribute__ ((unused)),
|
||||
grub_uint64_t size __attribute__ ((unused)),
|
||||
grub_memory_type_t type __attribute__ ((unused)), void *data)
|
||||
{
|
||||
grub_size_t *count = data;
|
||||
|
||||
(*count)++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Find the optimal number of pages for the memory map. */
|
||||
static grub_size_t
|
||||
find_mmap_size (void)
|
||||
{
|
||||
grub_size_t count = 0, mmap_size;
|
||||
|
||||
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_memory_type_t type __attribute__ ((unused)))
|
||||
{
|
||||
count++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
grub_mmap_iterate (hook);
|
||||
grub_mmap_iterate (count_hook, &count);
|
||||
|
||||
mmap_size = count * sizeof (struct grub_e820_mmap);
|
||||
|
||||
|
|
@ -372,17 +374,96 @@ grub_linux_setup_video (struct linux_kernel_params *params)
|
|||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Context for grub_linux_boot. */
|
||||
struct grub_linux_boot_ctx
|
||||
{
|
||||
grub_addr_t real_mode_target;
|
||||
grub_size_t real_size;
|
||||
struct linux_kernel_params *params;
|
||||
int e820_num;
|
||||
};
|
||||
|
||||
/* Helper for grub_linux_boot. */
|
||||
static int
|
||||
grub_linux_boot_mmap_find (grub_uint64_t addr, grub_uint64_t size,
|
||||
grub_memory_type_t type, void *data)
|
||||
{
|
||||
struct grub_linux_boot_ctx *ctx = data;
|
||||
|
||||
/* We must put real mode code in the traditional space. */
|
||||
if (type != GRUB_MEMORY_AVAILABLE || addr > 0x90000)
|
||||
return 0;
|
||||
|
||||
if (addr + size < 0x10000)
|
||||
return 0;
|
||||
|
||||
if (addr < 0x10000)
|
||||
{
|
||||
size += addr - 0x10000;
|
||||
addr = 0x10000;
|
||||
}
|
||||
|
||||
if (addr + size > 0x90000)
|
||||
size = 0x90000 - addr;
|
||||
|
||||
if (ctx->real_size + efi_mmap_size > size)
|
||||
return 0;
|
||||
|
||||
grub_dprintf ("linux", "addr = %lx, size = %x, need_size = %x\n",
|
||||
(unsigned long) addr,
|
||||
(unsigned) size,
|
||||
(unsigned) (ctx->real_size + efi_mmap_size));
|
||||
ctx->real_mode_target = ((addr + size) - (ctx->real_size + efi_mmap_size));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
grub_linux_boot_mmap_fill (grub_uint64_t addr, grub_uint64_t size,
|
||||
grub_memory_type_t type, void *data)
|
||||
{
|
||||
struct grub_linux_boot_ctx *ctx = data;
|
||||
|
||||
grub_uint32_t e820_type;
|
||||
switch (type)
|
||||
{
|
||||
case GRUB_MEMORY_AVAILABLE:
|
||||
e820_type = GRUB_E820_RAM;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_ACPI:
|
||||
e820_type = GRUB_E820_ACPI;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_NVS:
|
||||
e820_type = GRUB_E820_NVS;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_BADRAM:
|
||||
e820_type = GRUB_E820_BADRAM;
|
||||
break;
|
||||
|
||||
default:
|
||||
e820_type = GRUB_E820_RESERVED;
|
||||
}
|
||||
if (grub_e820_add_region (ctx->params->e820_map, &ctx->e820_num,
|
||||
addr, size, e820_type))
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_linux_boot (void)
|
||||
{
|
||||
int e820_num;
|
||||
grub_err_t err = 0;
|
||||
const char *modevar;
|
||||
char *tmp;
|
||||
struct grub_relocator32_state state;
|
||||
void *real_mode_mem;
|
||||
grub_addr_t real_mode_target = 0;
|
||||
grub_size_t real_size, mmap_size;
|
||||
struct grub_linux_boot_ctx ctx = {
|
||||
.real_mode_target = 0
|
||||
};
|
||||
grub_size_t mmap_size;
|
||||
grub_size_t cl_offset;
|
||||
|
||||
#ifdef GRUB_MACHINE_IEEE1275
|
||||
|
|
@ -484,7 +565,7 @@ grub_linux_boot (void)
|
|||
if (cl_offset < ((grub_size_t) linux_params.setup_sects << GRUB_DISK_SECTOR_BITS))
|
||||
cl_offset = ALIGN_UP ((grub_size_t) (linux_params.setup_sects
|
||||
<< GRUB_DISK_SECTOR_BITS), 4096);
|
||||
real_size = ALIGN_UP (cl_offset + maximal_cmdline_size, 4096);
|
||||
ctx.real_size = ALIGN_UP (cl_offset + maximal_cmdline_size, 4096);
|
||||
|
||||
#ifdef GRUB_MACHINE_EFI
|
||||
efi_mmap_size = find_efi_mmap_size ();
|
||||
|
|
@ -493,118 +574,51 @@ grub_linux_boot (void)
|
|||
#endif
|
||||
|
||||
grub_dprintf ("linux", "real_size = %x, mmap_size = %x\n",
|
||||
(unsigned) real_size, (unsigned) mmap_size);
|
||||
(unsigned) ctx.real_size, (unsigned) mmap_size);
|
||||
|
||||
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_MEMORY_AVAILABLE || addr > 0x90000)
|
||||
return 0;
|
||||
|
||||
if (addr + size < 0x10000)
|
||||
return 0;
|
||||
|
||||
if (addr < 0x10000)
|
||||
{
|
||||
size += addr - 0x10000;
|
||||
addr = 0x10000;
|
||||
}
|
||||
|
||||
if (addr + size > 0x90000)
|
||||
size = 0x90000 - addr;
|
||||
|
||||
if (real_size + efi_mmap_size > size)
|
||||
return 0;
|
||||
|
||||
grub_dprintf ("linux", "addr = %lx, size = %x, need_size = %x\n",
|
||||
(unsigned long) addr,
|
||||
(unsigned) size,
|
||||
(unsigned) (real_size + efi_mmap_size));
|
||||
real_mode_target = ((addr + size) - (real_size + efi_mmap_size));
|
||||
return 1;
|
||||
}
|
||||
#ifdef GRUB_MACHINE_EFI
|
||||
grub_efi_mmap_iterate (hook, 1);
|
||||
if (! real_mode_target)
|
||||
grub_efi_mmap_iterate (hook, 0);
|
||||
grub_efi_mmap_iterate (grub_linux_boot_mmap_find, &ctx, 1);
|
||||
if (! ctx.real_mode_target)
|
||||
grub_efi_mmap_iterate (grub_linux_boot_mmap_find, &ctx, 0);
|
||||
#else
|
||||
grub_mmap_iterate (hook);
|
||||
grub_mmap_iterate (grub_linux_boot_mmap_find, &ctx);
|
||||
#endif
|
||||
grub_dprintf ("linux", "real_mode_target = %lx, real_size = %x, efi_mmap_size = %x\n",
|
||||
(unsigned long) real_mode_target,
|
||||
(unsigned) real_size,
|
||||
(unsigned long) ctx.real_mode_target,
|
||||
(unsigned) ctx.real_size,
|
||||
(unsigned) efi_mmap_size);
|
||||
|
||||
if (! real_mode_target)
|
||||
if (! ctx.real_mode_target)
|
||||
return grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot allocate real mode pages");
|
||||
|
||||
{
|
||||
grub_relocator_chunk_t ch;
|
||||
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
|
||||
real_mode_target,
|
||||
(real_size + efi_mmap_size));
|
||||
ctx.real_mode_target,
|
||||
(ctx.real_size + efi_mmap_size));
|
||||
if (err)
|
||||
return err;
|
||||
real_mode_mem = get_virtual_current_address (ch);
|
||||
}
|
||||
efi_mmap_buf = (grub_uint8_t *) real_mode_mem + real_size;
|
||||
efi_mmap_buf = (grub_uint8_t *) real_mode_mem + ctx.real_size;
|
||||
|
||||
grub_dprintf ("linux", "real_mode_mem = %lx\n",
|
||||
(unsigned long) real_mode_mem);
|
||||
|
||||
struct linux_kernel_params *params;
|
||||
ctx.params = real_mode_mem;
|
||||
|
||||
params = real_mode_mem;
|
||||
|
||||
*params = linux_params;
|
||||
params->cmd_line_ptr = real_mode_target + cl_offset;
|
||||
grub_memcpy ((char *) params + cl_offset, linux_cmdline,
|
||||
*ctx.params = linux_params;
|
||||
ctx.params->cmd_line_ptr = ctx.real_mode_target + cl_offset;
|
||||
grub_memcpy ((char *) ctx.params + cl_offset, linux_cmdline,
|
||||
maximal_cmdline_size);
|
||||
|
||||
grub_dprintf ("linux", "code32_start = %x\n",
|
||||
(unsigned) params->code32_start);
|
||||
(unsigned) ctx.params->code32_start);
|
||||
|
||||
auto int NESTED_FUNC_ATTR hook_fill (grub_uint64_t, grub_uint64_t,
|
||||
grub_memory_type_t);
|
||||
int NESTED_FUNC_ATTR hook_fill (grub_uint64_t addr, grub_uint64_t size,
|
||||
grub_memory_type_t type)
|
||||
{
|
||||
grub_uint32_t e820_type;
|
||||
switch (type)
|
||||
{
|
||||
case GRUB_MEMORY_AVAILABLE:
|
||||
e820_type = GRUB_E820_RAM;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_ACPI:
|
||||
e820_type = GRUB_E820_ACPI;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_NVS:
|
||||
e820_type = GRUB_E820_NVS;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_BADRAM:
|
||||
e820_type = GRUB_E820_BADRAM;
|
||||
break;
|
||||
|
||||
default:
|
||||
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;
|
||||
if (grub_mmap_iterate (hook_fill))
|
||||
ctx.e820_num = 0;
|
||||
if (grub_mmap_iterate (grub_linux_boot_mmap_fill, &ctx))
|
||||
return grub_errno;
|
||||
params->mmap_size = e820_num;
|
||||
ctx.params->mmap_size = ctx.e820_num;
|
||||
|
||||
#ifdef GRUB_MACHINE_EFI
|
||||
{
|
||||
|
|
@ -617,33 +631,33 @@ grub_linux_boot (void)
|
|||
return err;
|
||||
|
||||
/* Note that no boot services are available from here. */
|
||||
efi_mmap_target = real_mode_target
|
||||
efi_mmap_target = ctx.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) >= 0x0208)
|
||||
if (grub_le_to_cpu16 (ctx.params->version) >= 0x0208)
|
||||
{
|
||||
params->v0208.efi_mem_desc_size = efi_desc_size;
|
||||
params->v0208.efi_mem_desc_version = efi_desc_version;
|
||||
params->v0208.efi_mmap = efi_mmap_target;
|
||||
params->v0208.efi_mmap_size = efi_mmap_size;
|
||||
ctx.params->v0208.efi_mem_desc_size = efi_desc_size;
|
||||
ctx.params->v0208.efi_mem_desc_version = efi_desc_version;
|
||||
ctx.params->v0208.efi_mmap = efi_mmap_target;
|
||||
ctx.params->v0208.efi_mmap_size = efi_mmap_size;
|
||||
|
||||
#ifdef __x86_64__
|
||||
params->v0208.efi_mmap_hi = (efi_mmap_target >> 32);
|
||||
ctx.params->v0208.efi_mmap_hi = (efi_mmap_target >> 32);
|
||||
#endif
|
||||
}
|
||||
else if (grub_le_to_cpu16 (params->version) >= 0x0206)
|
||||
else if (grub_le_to_cpu16 (ctx.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 = efi_mmap_target;
|
||||
params->v0206.efi_mmap_size = efi_mmap_size;
|
||||
ctx.params->v0206.efi_mem_desc_size = efi_desc_size;
|
||||
ctx.params->v0206.efi_mem_desc_version = efi_desc_version;
|
||||
ctx.params->v0206.efi_mmap = efi_mmap_target;
|
||||
ctx.params->v0206.efi_mmap_size = efi_mmap_size;
|
||||
}
|
||||
else if (grub_le_to_cpu16 (params->version) >= 0x0204)
|
||||
else if (grub_le_to_cpu16 (ctx.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 = efi_mmap_target;
|
||||
params->v0204.efi_mmap_size = efi_mmap_size;
|
||||
ctx.params->v0204.efi_mem_desc_size = efi_desc_size;
|
||||
ctx.params->v0204.efi_mem_desc_version = efi_desc_version;
|
||||
ctx.params->v0204.efi_mmap = efi_mmap_target;
|
||||
ctx.params->v0204.efi_mmap_size = efi_mmap_size;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
@ -651,9 +665,9 @@ grub_linux_boot (void)
|
|||
/* FIXME. */
|
||||
/* asm volatile ("lidt %0" : : "m" (idt_desc)); */
|
||||
state.ebp = state.edi = state.ebx = 0;
|
||||
state.esi = real_mode_target;
|
||||
state.esp = real_mode_target;
|
||||
state.eip = params->code32_start;
|
||||
state.esi = ctx.real_mode_target;
|
||||
state.esp = ctx.real_mode_target;
|
||||
state.eip = ctx.params->code32_start;
|
||||
return grub_relocator32_boot (relocator, state, 0);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -224,48 +224,50 @@ grub_multiboot_get_mbi_size (void)
|
|||
return ret;
|
||||
}
|
||||
|
||||
/* Helper for grub_fill_multiboot_mmap. */
|
||||
static int
|
||||
grub_fill_multiboot_mmap_iter (grub_uint64_t addr, grub_uint64_t size,
|
||||
grub_memory_type_t type, void *data)
|
||||
{
|
||||
struct multiboot_mmap_entry **mmap_entry = data;
|
||||
|
||||
(*mmap_entry)->addr = addr;
|
||||
(*mmap_entry)->len = size;
|
||||
switch (type)
|
||||
{
|
||||
case GRUB_MEMORY_AVAILABLE:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_AVAILABLE;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_ACPI:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_ACPI_RECLAIMABLE;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_NVS:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_NVS;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_BADRAM:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_BADRAM;
|
||||
break;
|
||||
|
||||
default:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_RESERVED;
|
||||
break;
|
||||
}
|
||||
(*mmap_entry)->size = sizeof (struct multiboot_mmap_entry) - sizeof ((*mmap_entry)->size);
|
||||
(*mmap_entry)++;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Fill previously allocated Multiboot mmap. */
|
||||
static void
|
||||
grub_fill_multiboot_mmap (struct multiboot_mmap_entry *first_entry)
|
||||
{
|
||||
struct multiboot_mmap_entry *mmap_entry = (struct multiboot_mmap_entry *) first_entry;
|
||||
|
||||
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t,
|
||||
grub_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_MEMORY_AVAILABLE:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_AVAILABLE;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_ACPI:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_ACPI_RECLAIMABLE;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_NVS:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_NVS;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_BADRAM:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_BADRAM;
|
||||
break;
|
||||
|
||||
default:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_RESERVED;
|
||||
break;
|
||||
}
|
||||
mmap_entry->size = sizeof (struct multiboot_mmap_entry) - sizeof (mmap_entry->size);
|
||||
mmap_entry++;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
grub_mmap_iterate (hook);
|
||||
grub_mmap_iterate (grub_fill_multiboot_mmap_iter, &mmap_entry);
|
||||
}
|
||||
|
||||
#if GRUB_MACHINE_HAS_VBE || GRUB_MACHINE_HAS_VGA_TEXT
|
||||
|
|
|
|||
|
|
@ -63,6 +63,18 @@ static int console_required;
|
|||
static grub_dl_t my_mod;
|
||||
|
||||
|
||||
/* Helper for grub_get_multiboot_mmap_count. */
|
||||
static int
|
||||
count_hook (grub_uint64_t addr __attribute__ ((unused)),
|
||||
grub_uint64_t size __attribute__ ((unused)),
|
||||
grub_memory_type_t type __attribute__ ((unused)), void *data)
|
||||
{
|
||||
grub_size_t *count = data;
|
||||
|
||||
(*count)++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Return the length of the Multiboot mmap that will be needed to allocate
|
||||
our platform's map. */
|
||||
grub_uint32_t
|
||||
|
|
@ -70,16 +82,7 @@ grub_get_multiboot_mmap_count (void)
|
|||
{
|
||||
grub_size_t count = 0;
|
||||
|
||||
auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
|
||||
int NESTED_FUNC_ATTR hook (grub_uint64_t addr __attribute__ ((unused)),
|
||||
grub_uint64_t size __attribute__ ((unused)),
|
||||
grub_memory_type_t type __attribute__ ((unused)))
|
||||
{
|
||||
count++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
grub_mmap_iterate (hook);
|
||||
grub_mmap_iterate (count_hook, &count);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -322,53 +322,55 @@ grub_multiboot_get_mbi_size (void)
|
|||
+ sizeof (struct multiboot_tag_apm) + MULTIBOOT_TAG_ALIGN - 1;
|
||||
}
|
||||
|
||||
/* Helper for grub_fill_multiboot_mmap. */
|
||||
static int
|
||||
grub_fill_multiboot_mmap_iter (grub_uint64_t addr, grub_uint64_t size,
|
||||
grub_memory_type_t type, void *data)
|
||||
{
|
||||
struct multiboot_mmap_entry **mmap_entry = data;
|
||||
|
||||
(*mmap_entry)->addr = addr;
|
||||
(*mmap_entry)->len = size;
|
||||
switch (type)
|
||||
{
|
||||
case GRUB_MEMORY_AVAILABLE:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_AVAILABLE;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_ACPI:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_ACPI_RECLAIMABLE;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_NVS:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_NVS;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_BADRAM:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_BADRAM;
|
||||
break;
|
||||
|
||||
default:
|
||||
(*mmap_entry)->type = MULTIBOOT_MEMORY_RESERVED;
|
||||
break;
|
||||
}
|
||||
(*mmap_entry)++;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Fill previously allocated Multiboot mmap. */
|
||||
static void
|
||||
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_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_MEMORY_AVAILABLE:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_AVAILABLE;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_ACPI:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_ACPI_RECLAIMABLE;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_NVS:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_NVS;
|
||||
break;
|
||||
|
||||
case GRUB_MEMORY_BADRAM:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_BADRAM;
|
||||
break;
|
||||
|
||||
default:
|
||||
mmap_entry->type = MULTIBOOT_MEMORY_RESERVED;
|
||||
break;
|
||||
}
|
||||
mmap_entry++;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
tag->type = MULTIBOOT_TAG_TYPE_MMAP;
|
||||
tag->size = sizeof (struct multiboot_tag_mmap)
|
||||
+ sizeof (struct multiboot_mmap_entry) * grub_get_multiboot_mmap_count ();
|
||||
tag->entry_size = sizeof (struct multiboot_mmap_entry);
|
||||
tag->entry_version = 0;
|
||||
|
||||
grub_mmap_iterate (hook);
|
||||
grub_mmap_iterate (grub_fill_multiboot_mmap_iter, &mmap_entry);
|
||||
}
|
||||
|
||||
#if defined (GRUB_MACHINE_PCBIOS)
|
||||
|
|
|
|||
|
|
@ -51,49 +51,51 @@ static char *linux_args;
|
|||
typedef void (*kernel_entry_t) (void *, unsigned long, int (void *),
|
||||
unsigned long, unsigned long);
|
||||
|
||||
/* Helper for grub_linux_claimmap_iterate. */
|
||||
static int
|
||||
alloc_mem (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type,
|
||||
void *data)
|
||||
{
|
||||
grub_addr_t *found_addr = data;
|
||||
|
||||
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;
|
||||
}
|
||||
grub_print_error ();
|
||||
}
|
||||
/* Target below the memory chunk. */
|
||||
if (target < addr && addr + size <= end)
|
||||
{
|
||||
if (grub_claimmap (addr, size) == GRUB_ERR_NONE)
|
||||
{
|
||||
*found_addr = addr;
|
||||
return 1;
|
||||
}
|
||||
grub_print_error ();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
grub_print_error ();
|
||||
}
|
||||
/* Target below the memory chunk. */
|
||||
if (target < addr && addr + size <= end)
|
||||
{
|
||||
if (grub_claimmap (addr, size) == GRUB_ERR_NONE)
|
||||
{
|
||||
found_addr = addr;
|
||||
return 1;
|
||||
}
|
||||
grub_print_error ();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
grub_machine_mmap_iterate (alloc_mem);
|
||||
grub_machine_mmap_iterate (alloc_mem, &found_addr);
|
||||
|
||||
return found_addr;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -180,63 +180,64 @@ grub_linux_unload (void)
|
|||
|
||||
#define FOUR_MB (4 * 1024 * 1024)
|
||||
|
||||
/* Helper for alloc_phys. */
|
||||
static int
|
||||
alloc_phys_choose (grub_uint64_t addr, grub_uint64_t len,
|
||||
grub_memory_type_t type, void *data)
|
||||
{
|
||||
grub_addr_t *ret = data;
|
||||
grub_addr_t end = addr + len;
|
||||
|
||||
if (type != 1)
|
||||
return 0;
|
||||
|
||||
addr = ALIGN_UP (addr, FOUR_MB);
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
|
||||
if (addr >= grub_phys_start && addr < grub_phys_end)
|
||||
{
|
||||
addr = ALIGN_UP (grub_phys_end, FOUR_MB);
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
}
|
||||
if ((addr + size) >= grub_phys_start
|
||||
&& (addr + size) < grub_phys_end)
|
||||
{
|
||||
addr = ALIGN_UP (grub_phys_end, FOUR_MB);
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (loaded)
|
||||
{
|
||||
grub_addr_t linux_end = ALIGN_UP (linux_paddr + linux_size, FOUR_MB);
|
||||
|
||||
if (addr >= linux_paddr && addr < linux_end)
|
||||
{
|
||||
addr = linux_end;
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
}
|
||||
if ((addr + size) >= linux_paddr
|
||||
&& (addr + size) < linux_end)
|
||||
{
|
||||
addr = linux_end;
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
*ret = addr;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static grub_addr_t
|
||||
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,
|
||||
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;
|
||||
|
||||
if (type != 1)
|
||||
return 0;
|
||||
|
||||
addr = ALIGN_UP (addr, FOUR_MB);
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
|
||||
if (addr >= grub_phys_start && addr < grub_phys_end)
|
||||
{
|
||||
addr = ALIGN_UP (grub_phys_end, FOUR_MB);
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
}
|
||||
if ((addr + size) >= grub_phys_start
|
||||
&& (addr + size) < grub_phys_end)
|
||||
{
|
||||
addr = ALIGN_UP (grub_phys_end, FOUR_MB);
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (loaded)
|
||||
{
|
||||
grub_addr_t linux_end = ALIGN_UP (linux_paddr + linux_size, FOUR_MB);
|
||||
|
||||
if (addr >= linux_paddr && addr < linux_end)
|
||||
{
|
||||
addr = linux_end;
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
}
|
||||
if ((addr + size) >= linux_paddr
|
||||
&& (addr + size) < linux_end)
|
||||
{
|
||||
addr = linux_end;
|
||||
if (addr + size >= end)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
ret = addr;
|
||||
return 1;
|
||||
}
|
||||
|
||||
grub_machine_mmap_iterate (choose);
|
||||
grub_machine_mmap_iterate (alloc_phys_choose, &ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -454,21 +455,23 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
|
|||
return grub_errno;
|
||||
}
|
||||
|
||||
/* Helper for determine_phys_base. */
|
||||
static int
|
||||
get_physbase (grub_uint64_t addr, grub_uint64_t len __attribute__ ((unused)),
|
||||
grub_uint32_t type, void *data __attribute__ ((unused)))
|
||||
{
|
||||
if (type != 1)
|
||||
return 0;
|
||||
if (addr < phys_base)
|
||||
phys_base = addr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
determine_phys_base (void)
|
||||
{
|
||||
auto int NESTED_FUNC_ATTR get_physbase (grub_uint64_t addr, grub_uint64_t len __attribute__((unused)), grub_uint32_t type);
|
||||
int NESTED_FUNC_ATTR get_physbase (grub_uint64_t addr, grub_uint64_t len __attribute__((unused)), grub_uint32_t type)
|
||||
{
|
||||
if (type != 1)
|
||||
return 0;
|
||||
if (addr < phys_base)
|
||||
phys_base = addr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
phys_base = ~(grub_uint64_t) 0;
|
||||
grub_machine_mmap_iterate (get_physbase);
|
||||
grub_machine_mmap_iterate (get_physbase, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue