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

Remove nested functions from memory map iterators.

Browse source 
* 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 2013-01-15 12:02:35 +00:00
parent 22099030ad
commit d0d4b8a063
32 changed files with 1315 additions and 1045 deletions
Download patch file Download diff file Expand all files Collapse all files

23
grub-core/mmap/efi/mmap.c
View file

@ -29,7 +29,8 @@
((grub_efi_memory_descriptor_t *) ((char *) (desc) + (size)))
grub_err_t
grub_efi_mmap_iterate (grub_memory_hook_t hook, int avoid_efi_boot_services)
grub_efi_mmap_iterate (grub_memory_hook_t hook, void *hook_data,
int avoid_efi_boot_services)
{
grub_efi_uintn_t mmap_size = 0;
grub_efi_memory_descriptor_t *map_buf = 0;
@ -69,17 +70,17 @@ grub_efi_mmap_iterate (grub_memory_hook_t hook, int avoid_efi_boot_services)
if (!avoid_efi_boot_services)
{
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MEMORY_AVAILABLE);
GRUB_MEMORY_AVAILABLE, hook_data);
break;
}
case GRUB_EFI_RUNTIME_SERVICES_CODE:
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MEMORY_CODE);
GRUB_MEMORY_CODE, hook_data);
break;
case GRUB_EFI_UNUSABLE_MEMORY:
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MEMORY_BADRAM);
GRUB_MEMORY_BADRAM, hook_data);
break;
default:
@ -90,7 +91,7 @@ grub_efi_mmap_iterate (grub_memory_hook_t hook, int avoid_efi_boot_services)
if (!avoid_efi_boot_services)
{
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MEMORY_AVAILABLE);
GRUB_MEMORY_AVAILABLE, hook_data);
break;
}
case GRUB_EFI_RESERVED_MEMORY_TYPE:
@ -99,24 +100,24 @@ grub_efi_mmap_iterate (grub_memory_hook_t hook, int avoid_efi_boot_services)
case GRUB_EFI_MEMORY_MAPPED_IO_PORT_SPACE:
case GRUB_EFI_PAL_CODE:
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MEMORY_RESERVED);
GRUB_MEMORY_RESERVED, hook_data);
break;
case GRUB_EFI_LOADER_CODE:
case GRUB_EFI_LOADER_DATA:
case GRUB_EFI_CONVENTIONAL_MEMORY:
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MEMORY_AVAILABLE);
GRUB_MEMORY_AVAILABLE, hook_data);
break;
case GRUB_EFI_ACPI_RECLAIM_MEMORY:
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MEMORY_ACPI);
GRUB_MEMORY_ACPI, hook_data);
break;
case GRUB_EFI_ACPI_MEMORY_NVS:
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MEMORY_NVS);
GRUB_MEMORY_NVS, hook_data);
break;
}
}
@ -125,9 +126,9 @@ grub_efi_mmap_iterate (grub_memory_hook_t hook, int avoid_efi_boot_services)
}
grub_err_t
grub_machine_mmap_iterate (grub_memory_hook_t hook)
grub_machine_mmap_iterate (grub_memory_hook_t hook, void *hook_data)
{
return grub_efi_mmap_iterate (hook, 0);
return grub_efi_mmap_iterate (hook, hook_data, 0);
}
static inline grub_efi_memory_type_t

52
grub-core/mmap/i386/mmap.c
View file

@ -27,34 +27,48 @@
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
/* Context for grub_mmap_malign_and_register. */
struct grub_mmap_malign_and_register_ctx
{
grub_uint64_t align, size, highestlow;
};
/* Helper for grub_mmap_malign_and_register. */
static int
find_hook (grub_uint64_t start, grub_uint64_t rangesize,
grub_memory_type_t memtype, void *data)
{
struct grub_mmap_malign_and_register_ctx *ctx = data;
grub_uint64_t end = start + rangesize;
if (memtype != GRUB_MEMORY_AVAILABLE)
return 0;
if (end > 0x100000)
end = 0x100000;
if (end > start + ctx->size
&& ctx->highestlow < ((end - ctx->size)
- ((end - ctx->size) & (ctx->align - 1))))
ctx->highestlow = (end - ctx->size)
- ((end - ctx->size) & (ctx->align - 1));
return 0;
}
void *
grub_mmap_malign_and_register (grub_uint64_t align, grub_uint64_t size,
int *handle, int type, int flags)
{
grub_uint64_t highestlow = 0;
auto int NESTED_FUNC_ATTR find_hook (grub_uint64_t, grub_uint64_t,
grub_memory_type_t);
int NESTED_FUNC_ATTR find_hook (grub_uint64_t start, grub_uint64_t rangesize,
grub_memory_type_t memtype)
{
grub_uint64_t end = start + rangesize;
if (memtype != GRUB_MEMORY_AVAILABLE)
return 0;
if (end > 0x100000)
end = 0x100000;
if (end > start + size
&& highestlow < ((end - size) - ((end - size) & (align - 1))))
highestlow = (end - size) - ((end - size) & (align - 1));
return 0;
}
struct grub_mmap_malign_and_register_ctx ctx = {
.align = align,
.size = size,
.highestlow = 0
};
void *ret;
if (flags & GRUB_MMAP_MALLOC_LOW)
{
/* FIXME: use low-memory mm allocation once it's available. */
grub_mmap_iterate (find_hook);
ret = (void *) (grub_addr_t) highestlow;
grub_mmap_iterate (find_hook, &ctx);
ret = (void *) (grub_addr_t) ctx.highestlow;
}
else
ret = grub_memalign (align, size);

49
grub-core/mmap/i386/pc/mmap.c
View file

@ -50,22 +50,23 @@ struct grub_e820_mmap_entry
} __attribute__((packed));
/* Helper for preboot. */
static int fill_hook (grub_uint64_t addr, grub_uint64_t size,
grub_memory_type_t type, void *data)
{
struct grub_e820_mmap_entry **hookmmapcur = data;
grub_dprintf ("mmap", "mmap chunk %llx-%llx:%x\n", addr, addr + size, type);
(*hookmmapcur)->addr = addr;
(*hookmmapcur)->len = size;
(*hookmmapcur)->type = type;
(*hookmmapcur)++;
return 0;
}
static grub_err_t
preboot (int noreturn __attribute__ ((unused)))
{
struct grub_e820_mmap_entry *hookmmap, *hookmmapcur;
auto int NESTED_FUNC_ATTR fill_hook (grub_uint64_t, grub_uint64_t,
grub_uint32_t);
int NESTED_FUNC_ATTR fill_hook (grub_uint64_t addr, grub_uint64_t size,
grub_memory_type_t type)
{
grub_dprintf ("mmap", "mmap chunk %llx-%llx:%x\n", addr, addr + size, type);
hookmmapcur->addr = addr;
hookmmapcur->len = size;
hookmmapcur->type = type;
hookmmapcur++;
return 0;
}
if (! hooktarget)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
@ -77,7 +78,7 @@ preboot (int noreturn __attribute__ ((unused)))
((grub_uint8_t *) hooktarget + (&grub_machine_mmaphook_end
- &grub_machine_mmaphook_start));
grub_mmap_iterate (fill_hook);
grub_mmap_iterate (fill_hook, &hookmmapcur);
grub_machine_mmaphook_mmap_num = hookmmapcur - hookmmap;
grub_machine_mmaphook_kblow = grub_mmap_get_lower () >> 10;
@ -123,6 +124,17 @@ preboot_rest (void)
return GRUB_ERR_NONE;
}
/* Helper for malloc_hook. */
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)
{
int *regcount = data;
(*regcount)++;
return 0;
}
static grub_err_t
malloc_hook (void)
{
@ -131,22 +143,13 @@ malloc_hook (void)
static int slots_available = 0;
int hooksize;
int regcount = 0;
auto int NESTED_FUNC_ATTR count_hook (grub_uint64_t, grub_uint64_t,
grub_uint32_t);
int NESTED_FUNC_ATTR count_hook (grub_uint64_t addr __attribute__ ((unused)),
grub_uint64_t size __attribute__ ((unused)),
grub_memory_type_t type __attribute__ ((unused)))
{
regcount++;
return 0;
}
if (reentry)
return GRUB_ERR_NONE;
grub_dprintf ("mmap", "registering\n");
grub_mmap_iterate (count_hook);
grub_mmap_iterate (count_hook, &regcount);
/* Mapping hook itself may introduce up to 2 additional regions. */
regcount += 2;

83
grub-core/mmap/i386/uppermem.c
View file

@ -22,68 +22,73 @@
#include <grub/mm.h>
#include <grub/misc.h>
/* Helper for grub_mmap_get_lower. */
static int
lower_hook (grub_uint64_t addr, grub_uint64_t size, grub_memory_type_t type,
void *data)
{
grub_uint64_t *lower = data;
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr == 0)
*lower = size;
return 0;
}
grub_uint64_t
grub_mmap_get_lower (void)
{
grub_uint64_t lower = 0;
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)
{
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr == 0)
lower = size;
return 0;
}
grub_mmap_iterate (hook);
grub_mmap_iterate (lower_hook, &lower);
if (lower > 0x100000)
lower = 0x100000;
return lower;
}
/* Helper for grub_mmap_get_upper. */
static int
upper_hook (grub_uint64_t addr, grub_uint64_t size, grub_memory_type_t type,
void *data)
{
grub_uint64_t *upper = data;
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr <= 0x100000 && addr + size > 0x100000)
*upper = addr + size - 0x100000;
return 0;
}
grub_uint64_t
grub_mmap_get_upper (void)
{
grub_uint64_t upper = 0;
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)
{
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr <= 0x100000 && addr + size > 0x100000)
upper = addr + size - 0x100000;
return 0;
}
grub_mmap_iterate (hook);
grub_mmap_iterate (upper_hook, &upper);
return upper;
}
/* Helper for grub_mmap_get_post64. */
static int
post64_hook (grub_uint64_t addr, grub_uint64_t size, grub_memory_type_t type,
void *data)
{
grub_uint64_t *post64 = data;
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr <= 0x4000000 && addr + size > 0x4000000)
*post64 = addr + size - 0x4000000;
return 0;
}
/* Count the continuous bytes after 64 MiB. */
grub_uint64_t
grub_mmap_get_post64 (void)
{
grub_uint64_t post64 = 0;
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)
{
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr <= 0x4000000 && addr + size > 0x4000000)
post64 = addr + size - 0x4000000;
return 0;
}
grub_mmap_iterate (hook);
grub_mmap_iterate (post64_hook, &post64);
return post64;
}

58
grub-core/mmap/mips/uppermem.c
View file

@ -22,47 +22,51 @@
#include <grub/misc.h>
#include <grub/cpu/memory.h>
/* Helper for grub_mmap_get_lower. */
static int
lower_hook (grub_uint64_t addr, grub_uint64_t size, grub_memory_type_t type,
void *data)
{
grub_uint64_t *lower = data;
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr == 0)
*lower = size;
return 0;
}
grub_uint64_t
grub_mmap_get_lower (void)
{
grub_uint64_t lower = 0;
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)
{
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr == 0)
lower = size;
return 0;
}
grub_mmap_iterate (hook);
grub_mmap_iterate (lower_hook, &lower);
if (lower > GRUB_ARCH_LOWMEMMAXSIZE)
lower = GRUB_ARCH_LOWMEMMAXSIZE;
return lower;
}
/* Helper for grub_mmap_get_upper. */
static int
upper_hook (grub_uint64_t addr, grub_uint64_t size, grub_memory_type_t type,
void *data)
{
grub_uint64_t *upper = data;
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr <= GRUB_ARCH_HIGHMEMPSTART && addr + size
> GRUB_ARCH_HIGHMEMPSTART)
*upper = addr + size - GRUB_ARCH_HIGHMEMPSTART;
return 0;
}
grub_uint64_t
grub_mmap_get_upper (void)
{
grub_uint64_t upper = 0;
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)
{
if (type != GRUB_MEMORY_AVAILABLE)
return 0;
if (addr <= GRUB_ARCH_HIGHMEMPSTART && addr + size
> GRUB_ARCH_HIGHMEMPSTART)
upper = addr + size - GRUB_ARCH_HIGHMEMPSTART;
return 0;
}
grub_mmap_iterate (hook);
grub_mmap_iterate (upper_hook, &upper);
return upper;
}

388
grub-core/mmap/mmap.c
View file

@ -35,43 +35,90 @@ static int curhandle = 1;
#endif
grub_err_t
grub_mmap_iterate (grub_memory_hook_t hook)
/* If same page is used by multiple types it's resolved
according to priority:
1 - free memory
2 - memory usable by firmware-aware code
3 - unusable memory
4 - a range deliberately empty
*/
static const int priority[] =
{
[GRUB_MEMORY_AVAILABLE] = 1,
[GRUB_MEMORY_RESERVED] = 3,
[GRUB_MEMORY_ACPI] = 2,
[GRUB_MEMORY_CODE] = 3,
[GRUB_MEMORY_NVS] = 3,
[GRUB_MEMORY_HOLE] = 4,
};
/* Scanline events. */
struct grub_mmap_scan
{
/* At which memory address. */
grub_uint64_t pos;
/* 0 = region starts, 1 = region ends. */
int type;
/* Which type of memory region? */
int memtype;
};
/* Context for grub_mmap_iterate. */
struct grub_mmap_iterate_ctx
{
struct grub_mmap_scan *scanline_events;
int i;
};
/* Helper for grub_mmap_iterate. */
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)
{
int *mmap_num = data;
(*mmap_num)++;
return 0;
}
/* Helper for grub_mmap_iterate. */
static int
fill_hook (grub_uint64_t addr, grub_uint64_t size, grub_memory_type_t type,
void *data)
{
struct grub_mmap_iterate_ctx *ctx = data;
ctx->scanline_events[ctx->i].pos = addr;
ctx->scanline_events[ctx->i].type = 0;
if (type < ARRAY_SIZE (priority) && priority[type])
ctx->scanline_events[ctx->i].memtype = type;
else
{
grub_dprintf ("mmap", "Unknown memory type %d. Assuming unusable\n",
type);
ctx->scanline_events[ctx->i].memtype = GRUB_MEMORY_RESERVED;
}
ctx->i++;
ctx->scanline_events[ctx->i].pos = addr + size;
ctx->scanline_events[ctx->i].type = 1;
ctx->scanline_events[ctx->i].memtype =
ctx->scanline_events[ctx->i - 1].memtype;
ctx->i++;
return 0;
}
grub_err_t
grub_mmap_iterate (grub_memory_hook_t hook, void *hook_data)
{
/* This function resolves overlapping regions and sorts the memory map.
It uses scanline (sweeping) algorithm.
*/
/* If same page is used by multiple types it's resolved
according to priority:
1 - free memory
2 - memory usable by firmware-aware code
3 - unusable memory
4 - a range deliberately empty
*/
int priority[] =
{
[GRUB_MEMORY_AVAILABLE] = 1,
[GRUB_MEMORY_RESERVED] = 3,
[GRUB_MEMORY_ACPI] = 2,
[GRUB_MEMORY_CODE] = 3,
[GRUB_MEMORY_NVS] = 3,
[GRUB_MEMORY_HOLE] = 4,
};
struct grub_mmap_iterate_ctx ctx;
int i, done;
/* Scanline events. */
struct grub_mmap_scan
{
/* At which memory address. */
grub_uint64_t pos;
/* 0 = region starts, 1 = region ends. */
int type;
/* Which type of memory region? */
int memtype;
};
struct grub_mmap_scan *scanline_events;
struct grub_mmap_scan t;
/* Previous scanline event. */
@ -88,42 +135,6 @@ grub_mmap_iterate (grub_memory_hook_t hook)
struct grub_mmap_region *cur;
#endif
auto int NESTED_FUNC_ATTR count_hook (grub_uint64_t, grub_uint64_t,
grub_uint32_t);
int NESTED_FUNC_ATTR count_hook (grub_uint64_t addr __attribute__ ((unused)),
grub_uint64_t size __attribute__ ((unused)),
grub_memory_type_t type __attribute__ ((unused)))
{
mmap_num++;
return 0;
}
auto int NESTED_FUNC_ATTR fill_hook (grub_uint64_t, grub_uint64_t,
grub_uint32_t);
int NESTED_FUNC_ATTR fill_hook (grub_uint64_t addr,
grub_uint64_t size,
grub_memory_type_t type)
{
scanline_events[i].pos = addr;
scanline_events[i].type = 0;
if (type < ARRAY_SIZE (priority) && priority[type])
scanline_events[i].memtype = type;
else
{
grub_dprintf ("mmap", "Unknown memory type %d. Assuming unusable\n",
type);
scanline_events[i].memtype = GRUB_MEMORY_RESERVED;
}
i++;
scanline_events[i].pos = addr + size;
scanline_events[i].type = 1;
scanline_events[i].memtype = scanline_events[i - 1].memtype;
i++;
return 0;
}
mmap_num = 0;
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
@ -131,37 +142,38 @@ grub_mmap_iterate (grub_memory_hook_t hook)
mmap_num++;
#endif
grub_machine_mmap_iterate (count_hook);
grub_machine_mmap_iterate (count_hook, &mmap_num);
/* Initialize variables. */
grub_memset (present, 0, sizeof (present));
scanline_events = (struct grub_mmap_scan *)
ctx.scanline_events = (struct grub_mmap_scan *)
grub_malloc (sizeof (struct grub_mmap_scan) * 2 * mmap_num);
if (! scanline_events)
if (! ctx.scanline_events)
return grub_errno;
i = 0;
ctx.i = 0;
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
/* Register scanline events. */
for (cur = grub_mmap_overlays; cur; cur = cur->next)
{
scanline_events[i].pos = cur->start;
scanline_events[i].type = 0;
ctx.scanline_events[ctx.i].pos = cur->start;
ctx.scanline_events[ctx.i].type = 0;
if (cur->type < ARRAY_SIZE (priority) && priority[cur->type])
scanline_events[i].memtype = cur->type;
ctx.scanline_events[ctx.i].memtype = cur->type;
else
scanline_events[i].memtype = GRUB_MEMORY_RESERVED;
i++;
ctx.scanline_events[ctx.i].memtype = GRUB_MEMORY_RESERVED;
ctx.i++;
scanline_events[i].pos = cur->end;
scanline_events[i].type = 1;
scanline_events[i].memtype = scanline_events[i - 1].memtype;
i++;
ctx.scanline_events[ctx.i].pos = cur->end;
ctx.scanline_events[ctx.i].type = 1;
ctx.scanline_events[ctx.i].memtype =
ctx.scanline_events[ctx.i - 1].memtype;
ctx.i++;
}
#endif /* ! GRUB_MMAP_REGISTER_BY_FIRMWARE */
grub_machine_mmap_iterate (fill_hook);
grub_machine_mmap_iterate (fill_hook, &ctx);
/* Primitive bubble sort. It has complexity O(n^2) but since we're
unlikely to have more than 100 chunks it's probably one of the
@ -171,28 +183,28 @@ grub_mmap_iterate (grub_memory_hook_t hook)
{
done = 0;
for (i = 0; i < 2 * mmap_num - 1; i++)
if (scanline_events[i + 1].pos < scanline_events[i].pos
|| (scanline_events[i + 1].pos == scanline_events[i].pos
&& scanline_events[i + 1].type == 0
&& scanline_events[i].type == 1))
if (ctx.scanline_events[i + 1].pos < ctx.scanline_events[i].pos
|| (ctx.scanline_events[i + 1].pos == ctx.scanline_events[i].pos
&& ctx.scanline_events[i + 1].type == 0
&& ctx.scanline_events[i].type == 1))
{
t = scanline_events[i + 1];
scanline_events[i + 1] = scanline_events[i];
scanline_events[i] = t;
t = ctx.scanline_events[i + 1];
ctx.scanline_events[i + 1] = ctx.scanline_events[i];
ctx.scanline_events[i] = t;
done = 1;
}
}
lastaddr = scanline_events[0].pos;
lasttype = scanline_events[0].memtype;
lastaddr = ctx.scanline_events[0].pos;
lasttype = ctx.scanline_events[0].memtype;
for (i = 0; i < 2 * mmap_num; i++)
{
unsigned k;
/* Process event. */
if (scanline_events[i].type)
present[scanline_events[i].memtype]--;
if (ctx.scanline_events[i].type)
present[ctx.scanline_events[i].memtype]--;
else
present[scanline_events[i].memtype]++;
present[ctx.scanline_events[i].memtype]++;
/* Determine current region type. */
curtype = -1;
@ -202,12 +214,13 @@ grub_mmap_iterate (grub_memory_hook_t hook)
/* Announce region to the hook if necessary. */
if ((curtype == -1 || curtype != lasttype)
&& lastaddr != scanline_events[i].pos
&& lastaddr != ctx.scanline_events[i].pos
&& lasttype != -1
&& lasttype != GRUB_MEMORY_HOLE
&& hook (lastaddr, scanline_events[i].pos - lastaddr, lasttype))
&& hook (lastaddr, ctx.scanline_events[i].pos - lastaddr, lasttype,
hook_data))
{
grub_free (scanline_events);
grub_free (ctx.scanline_events);
return GRUB_ERR_NONE;
}
@ -215,11 +228,11 @@ grub_mmap_iterate (grub_memory_hook_t hook)
if (curtype == -1 || curtype != lasttype)
{
lasttype = curtype;
lastaddr = scanline_events[i].pos;
lastaddr = ctx.scanline_events[i].pos;
}
}
grub_free (scanline_events);
grub_free (ctx.scanline_events);
return GRUB_ERR_NONE;
}
@ -280,19 +293,23 @@ grub_mmap_unregister (int handle)
#define CHUNK_SIZE 0x400
struct badram_entry {
grub_uint64_t addr, mask;
};
static inline grub_uint64_t
fill_mask (grub_uint64_t addr, grub_uint64_t mask, grub_uint64_t iterator)
fill_mask (struct badram_entry *entry, grub_uint64_t iterator)
{
int i, j;
grub_uint64_t ret = (addr & mask);
grub_uint64_t ret = (entry->addr & entry->mask);
/* Find first fixed bit. */
for (i = 0; i < 64; i++)
if ((mask & (1ULL << i)) != 0)
if ((entry->mask & (1ULL << i)) != 0)
break;
j = 0;
for (; i < 64; i++)
if ((mask & (1ULL << i)) == 0)
if ((entry->mask & (1ULL << i)) == 0)
{
if ((iterator & (1ULL << j)) != 0)
ret |= 1ULL << i;
@ -301,64 +318,64 @@ fill_mask (grub_uint64_t addr, grub_uint64_t mask, grub_uint64_t iterator)
return ret;
}
/* Helper for grub_cmd_badram. */
static int
badram_iter (grub_uint64_t addr, grub_uint64_t size,
grub_memory_type_t type __attribute__ ((unused)), void *data)
{
struct badram_entry *entry = data;
grub_uint64_t iterator, low, high, cur;
int tail, var;
int i;
grub_dprintf ("badram", "hook %llx+%llx\n", (unsigned long long) addr,
(unsigned long long) size);
/* How many trailing zeros? */
for (tail = 0; ! (entry->mask & (1ULL << tail)); tail++);
/* How many zeros in mask? */
var = 0;
for (i = 0; i < 64; i++)
if (! (entry->mask & (1ULL << i)))
var++;
if (fill_mask (entry, 0) >= addr)
iterator = 0;
else
{
low = 0;
high = ~0ULL;
/* Find starting value. Keep low and high such that
fill_mask (low) < addr and fill_mask (high) >= addr;
*/
while (high - low > 1)
{
cur = (low + high) / 2;
if (fill_mask (entry, cur) >= addr)
high = cur;
else
low = cur;
}
iterator = high;
}
for (; iterator < (1ULL << (var - tail))
&& (cur = fill_mask (entry, iterator)) < addr + size;
iterator++)
{
grub_dprintf ("badram", "%llx (size %llx) is a badram range\n",
(unsigned long long) cur, (1ULL << tail));
grub_mmap_register (cur, (1ULL << tail), GRUB_MEMORY_HOLE);
}
return 0;
}
static grub_err_t
grub_cmd_badram (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
char * str;
grub_uint64_t badaddr, badmask;
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 __attribute__ ((unused)))
{
grub_uint64_t iterator, low, high, cur;
int tail, var;
int i;
grub_dprintf ("badram", "hook %llx+%llx\n", (unsigned long long) addr,
(unsigned long long) size);
/* How many trailing zeros? */
for (tail = 0; ! (badmask & (1ULL << tail)); tail++);
/* How many zeros in mask? */
var = 0;
for (i = 0; i < 64; i++)
if (! (badmask & (1ULL << i)))
var++;
if (fill_mask (badaddr, badmask, 0) >= addr)
iterator = 0;
else
{
low = 0;
high = ~0ULL;
/* Find starting value. Keep low and high such that
fill_mask (low) < addr and fill_mask (high) >= addr;
*/
while (high - low > 1)
{
cur = (low + high) / 2;
if (fill_mask (badaddr, badmask, cur) >= addr)
high = cur;
else
low = cur;
}
iterator = high;
}
for (; iterator < (1ULL << (var - tail))
&& (cur = fill_mask (badaddr, badmask, iterator)) < addr + size;
iterator++)
{
grub_dprintf ("badram", "%llx (size %llx) is a badram range\n",
(unsigned long long) cur, (1ULL << tail));
grub_mmap_register (cur, (1ULL << tail), GRUB_MEMORY_HOLE);
}
return 0;
}
struct badram_entry entry;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
@ -370,10 +387,10 @@ grub_cmd_badram (grub_command_t cmd __attribute__ ((unused)),
while (1)
{
/* Parse address and mask. */
badaddr = grub_strtoull (str, &str, 16);
entry.addr = grub_strtoull (str, &str, 16);
if (*str == ',')
str++;
badmask = grub_strtoull (str, &str, 16);
entry.mask = grub_strtoull (str, &str, 16);
if (*str == ',')
str++;
@ -385,12 +402,13 @@ grub_cmd_badram (grub_command_t cmd __attribute__ ((unused)),
/* When part of a page is tainted, we discard the whole of it. There's
no point in providing sub-page chunks. */
badmask &= ~(CHUNK_SIZE - 1);
entry.mask &= ~(CHUNK_SIZE - 1);
grub_dprintf ("badram", "badram %llx:%llx\n",
(unsigned long long) badaddr, (unsigned long long) badmask);
(unsigned long long) entry.addr,
(unsigned long long) entry.mask);
grub_mmap_iterate (hook);
grub_mmap_iterate (badram_iter, &entry);
}
}
@ -416,44 +434,48 @@ parsemem (const char *str)
return ret;
}
struct cutmem_range {
grub_uint64_t from, to;
};
/* Helper for grub_cmd_cutmem. */
static int
cutmem_iter (grub_uint64_t addr, grub_uint64_t size,
grub_memory_type_t type __attribute__ ((unused)), void *data)
{
struct cutmem_range *range = data;
grub_uint64_t end = addr + size;
if (addr <= range->from)
addr = range->from;
if (end >= range->to)
end = range->to;
if (end <= addr)
return 0;
grub_mmap_register (addr, end - addr, GRUB_MEMORY_HOLE);
return 0;
}
static grub_err_t
grub_cmd_cutmem (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
grub_uint64_t from, to;
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 __attribute__ ((unused)))
{
grub_uint64_t end = addr + size;
if (addr <= from)
addr = from;
if (end >= to)
end = to;
if (end <= addr)
return 0;
grub_mmap_register (addr, end - addr, GRUB_MEMORY_HOLE);
return 0;
}
struct cutmem_range range;
if (argc != 2)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("two arguments expected"));
from = parsemem (args[0]);
range.from = parsemem (args[0]);
if (grub_errno)
return grub_errno;
to = parsemem (args[1]);
range.to = parsemem (args[1]);
if (grub_errno)
return grub_errno;
grub_mmap_iterate (hook);
grub_mmap_iterate (cutmem_iter, &range);
return GRUB_ERR_NONE;
}