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

remove all trailing whitespace

Browse source
This commit is contained in:
fzielcke 2009-06-10 21:04:23 +00:00
parent d2d4966571
commit b39f9d20a9
222 changed files with 3286 additions and 3286 deletions
Download patch file Download diff file Expand all files Collapse all files

48
mmap/efi/mmap.c
View file

@ -29,8 +29,8 @@
((grub_efi_memory_descriptor_t *) ((char *) (desc) + (size)))
grub_err_t
grub_machine_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
grub_uint64_t,
grub_machine_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
grub_uint64_t,
grub_uint32_t))
{
grub_efi_uintn_t mmap_size = 0;
@ -62,13 +62,13 @@ grub_machine_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
{
grub_dprintf ("mmap", "EFI memory region 0x%llx-0x%llx: %d\n",
(unsigned long long) desc->physical_start,
(unsigned long long) desc->physical_start,
(unsigned long long) desc->physical_start
+ desc->num_pages * 4096, desc->type);
switch (desc->type)
{
case GRUB_EFI_RUNTIME_SERVICES_CODE:
hook (desc->physical_start, desc->num_pages * 4096,
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MACHINE_MEMORY_CODE);
break;
@ -82,7 +82,7 @@ grub_machine_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
case GRUB_EFI_MEMORY_MAPPED_IO:
case GRUB_EFI_MEMORY_MAPPED_IO_PORT_SPACE:
case GRUB_EFI_PAL_CODE:
hook (desc->physical_start, desc->num_pages * 4096,
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MACHINE_MEMORY_RESERVED);
break;
@ -91,17 +91,17 @@ grub_machine_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
case GRUB_EFI_BOOT_SERVICES_CODE:
case GRUB_EFI_BOOT_SERVICES_DATA:
case GRUB_EFI_CONVENTIONAL_MEMORY:
hook (desc->physical_start, desc->num_pages * 4096,
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MACHINE_MEMORY_AVAILABLE);
break;
case GRUB_EFI_ACPI_RECLAIM_MEMORY:
hook (desc->physical_start, desc->num_pages * 4096,
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MACHINE_MEMORY_ACPI);
break;
case GRUB_EFI_ACPI_MEMORY_NVS:
hook (desc->physical_start, desc->num_pages * 4096,
hook (desc->physical_start, desc->num_pages * 4096,
GRUB_MACHINE_MEMORY_NVS);
break;
}
@ -110,7 +110,7 @@ grub_machine_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
return GRUB_ERR_NONE;
}
static inline grub_efi_memory_type_t
static inline grub_efi_memory_type_t
make_efi_memtype (int type)
{
switch (type)
@ -118,10 +118,10 @@ make_efi_memtype (int type)
case GRUB_MACHINE_MEMORY_CODE:
return GRUB_EFI_RUNTIME_SERVICES_CODE;
/* No way to remove a chunk of memory from EFI mmap.
/* No way to remove a chunk of memory from EFI mmap.
So mark it as unusable. */
case GRUB_MACHINE_MEMORY_HOLE:
default:
case GRUB_MACHINE_MEMORY_RESERVED:
@ -135,7 +135,7 @@ make_efi_memtype (int type)
case GRUB_MACHINE_MEMORY_NVS:
return GRUB_EFI_ACPI_RECLAIM_MEMORY;
}
}
@ -164,7 +164,7 @@ grub_mmap_register (grub_uint64_t start, grub_uint64_t size, int type)
curover = (struct overlay *) grub_malloc (sizeof (struct overlay));
if (! curover)
return 0;
b = grub_efi_system_table->boot_services;
address = start & (~0x3ffULL);
pages = (end - address + 0x3ff) >> 12;
@ -174,7 +174,7 @@ grub_mmap_register (grub_uint64_t start, grub_uint64_t size, int type)
grub_free (curover);
return 0;
}
status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_ADDRESS,
status = efi_call_4 (b->allocate_pages, GRUB_EFI_ALLOCATE_ADDRESS,
make_efi_memtype (type), pages, &address);
if (status != GRUB_EFI_SUCCESS)
{
@ -190,7 +190,7 @@ grub_mmap_register (grub_uint64_t start, grub_uint64_t size, int type)
return curover->handle;
}
grub_err_t
grub_err_t
grub_mmap_unregister (int handle)
{
struct overlay *curover, *prevover;
@ -199,8 +199,8 @@ grub_mmap_unregister (int handle)
b = grub_efi_system_table->boot_services;
for (curover = overlays, prevover = 0; curover;
for (curover = overlays, prevover = 0; curover;
prevover = curover, curover = curover->next)
{
if (curover->handle == handle)
@ -219,9 +219,9 @@ grub_mmap_unregister (int handle)
/* Result is always page-aligned. */
void *
grub_mmap_malign_and_register (grub_uint64_t align __attribute__ ((unused)),
grub_mmap_malign_and_register (grub_uint64_t align __attribute__ ((unused)),
grub_uint64_t size,
int *handle, int type,
int *handle, int type,
int flags __attribute__ ((unused)))
{
grub_efi_physical_address_t address;
@ -234,7 +234,7 @@ grub_mmap_malign_and_register (grub_uint64_t align __attribute__ ((unused)),
curover = (struct overlay *) grub_malloc (sizeof (struct overlay));
if (! curover)
return 0;
b = grub_efi_system_table->boot_services;
address = 0xffffffff;
@ -247,7 +247,7 @@ grub_mmap_malign_and_register (grub_uint64_t align __attribute__ ((unused)),
#endif
pages = (size + 0x3ff) >> 12;
status = efi_call_4 (b->allocate_pages, atype,
status = efi_call_4 (b->allocate_pages, atype,
make_efi_memtype (type), pages, &address);
if (status != GRUB_EFI_SUCCESS)
{
@ -260,13 +260,13 @@ grub_mmap_malign_and_register (grub_uint64_t align __attribute__ ((unused)),
/* Uggh, the address 0 was allocated... This is too annoying,
so reallocate another one. */
address = 0xffffffff;
status = efi_call_4 (b->allocate_pages, atype,
status = efi_call_4 (b->allocate_pages, atype,
make_efi_memtype (type), pages, &address);
grub_efi_free_pages (0, pages);
if (status != GRUB_EFI_SUCCESS)
return 0;
}
curover->next = overlays;
curover->handle = curhandle++;
curover->address = address;
@ -277,7 +277,7 @@ grub_mmap_malign_and_register (grub_uint64_t align __attribute__ ((unused)),
return UINT_TO_PTR (curover->address);
}
void
void
grub_mmap_free_and_unregister (int handle)
{
grub_mmap_unregister (handle);

8
mmap/i386/mmap.c
View file

@ -32,9 +32,9 @@ grub_mmap_malign_and_register (grub_uint64_t align, grub_uint64_t size,
{
grub_uint64_t highestlow = 0;
auto int NESTED_FUNC_ATTR find_hook (grub_uint64_t, grub_uint64_t,
auto int NESTED_FUNC_ATTR find_hook (grub_uint64_t, grub_uint64_t,
grub_uint32_t);
int NESTED_FUNC_ATTR find_hook (grub_uint64_t start, grub_uint64_t rangesize,
int NESTED_FUNC_ATTR find_hook (grub_uint64_t start, grub_uint64_t rangesize,
grub_uint32_t memtype)
{
grub_uint64_t end = start + rangesize;
@ -69,7 +69,7 @@ grub_mmap_malign_and_register (grub_uint64_t align, grub_uint64_t size,
{
grub_free (ret);
return 0;
}
}
return ret;
}
@ -88,7 +88,7 @@ grub_mmap_free_and_unregister (int handle)
return;
addr = cur->start;
grub_mmap_unregister (handle);
if (addr >= 0x100000)

42
mmap/i386/pc/mmap.c
View file

@ -50,13 +50,13 @@ struct grub_e820_mmap_entry
} __attribute__((packed));
static grub_err_t
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,
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,
int NESTED_FUNC_ATTR fill_hook (grub_uint64_t addr, grub_uint64_t size,
grub_uint32_t type)
{
grub_dprintf ("mmap", "mmap chunk %llx-%llx:%x\n", addr, addr + size, type);
@ -68,22 +68,22 @@ preboot (int noreturn __attribute__ ((unused)))
}
if (! hooktarget)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"no space is allocated for memory hook");
grub_dprintf ("mmap", "installing preboot handlers\n");
hookmmapcur = hookmmap = (struct grub_e820_mmap_entry *)
((grub_uint8_t *) hooktarget + (&grub_machine_mmaphook_end
hookmmapcur = hookmmap = (struct grub_e820_mmap_entry *)
((grub_uint8_t *) hooktarget + (&grub_machine_mmaphook_end
- &grub_machine_mmaphook_start));
grub_mmap_iterate (fill_hook);
grub_mmap_iterate (fill_hook);
grub_machine_mmaphook_mmap_num = hookmmapcur - hookmmap;
grub_machine_mmaphook_kblow = grub_mmap_get_lower () >> 10;
grub_machine_mmaphook_kbin16mb
grub_machine_mmaphook_kbin16mb
= min (grub_mmap_get_upper (),0x3f00000ULL) >> 10;
grub_machine_mmaphook_64kbin4gb
grub_machine_mmaphook_64kbin4gb
= min (grub_mmap_get_post64 (), 0xfc000000ULL) >> 16;
/* Correct BDA. */
@ -103,7 +103,7 @@ preboot (int noreturn __attribute__ ((unused)))
*((grub_uint16_t *) 0x4a) = PTR_TO_UINT32 (hooktarget) >> 4;
*((grub_uint16_t *) 0x56) = PTR_TO_UINT32 (hooktarget) >> 4;
*((grub_uint16_t *) 0x48) = &grub_machine_mmaphook_int12
*((grub_uint16_t *) 0x48) = &grub_machine_mmaphook_int12
- &grub_machine_mmaphook_start;
*((grub_uint16_t *) 0x54) = &grub_machine_mmaphook_int15
- &grub_machine_mmaphook_start;
@ -123,7 +123,7 @@ preboot_rest (void)
return GRUB_ERR_NONE;
}
static grub_err_t
static grub_err_t
malloc_hook (void)
{
static int reentry = 0;
@ -131,10 +131,10 @@ 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,
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)),
int NESTED_FUNC_ATTR count_hook (grub_uint64_t addr __attribute__ ((unused)),
grub_uint64_t size __attribute__ ((unused)),
grub_uint32_t type __attribute__ ((unused)))
{
regcount++;
@ -165,13 +165,13 @@ malloc_hook (void)
+ regcount * sizeof (struct grub_e820_mmap_entry);
/* Allocate an integer number of KiB. */
hooksize = ((hooksize - 1) | 0x3ff) + 1;
slots_available = (hooksize - (&grub_machine_mmaphook_end
slots_available = (hooksize - (&grub_machine_mmaphook_end
- &grub_machine_mmaphook_start))
/ sizeof (struct grub_e820_mmap_entry);
reentry = 1;
hooktarget
= grub_mmap_malign_and_register (16, hooksize, &mmapregion,
hooktarget
= grub_mmap_malign_and_register (16, hooksize, &mmapregion,
GRUB_MACHINE_MEMORY_RESERVED,
GRUB_MMAP_MALLOC_LOW);
reentry = 0;
@ -185,8 +185,8 @@ malloc_hook (void)
}
grub_err_t
grub_machine_mmap_register (grub_uint64_t start __attribute__ ((unused)),
grub_uint64_t size __attribute__ ((unused)),
grub_machine_mmap_register (grub_uint64_t start __attribute__ ((unused)),
grub_uint64_t size __attribute__ ((unused)),
int type __attribute__ ((unused)),
int handle __attribute__ ((unused)))
{
@ -200,8 +200,8 @@ grub_machine_mmap_register (grub_uint64_t start __attribute__ ((unused)),
if (! preb_handle)
{
grub_dprintf ("mmap", "adding preboot\n");
preb_handle
= grub_loader_register_preboot_hook (preboot, preboot_rest,
preb_handle
= grub_loader_register_preboot_hook (preboot, preboot_rest,
GRUB_LOADER_PREBOOT_HOOK_PRIO_MEMORY);
if (! preb_handle)
return grub_errno;

12
mmap/i386/pc/mmap_helper.S
View file

@ -21,7 +21,7 @@
#define DS(x) ((x) - segstart)
segstart:
segstart:
VARIABLE(grub_machine_mmaphook_start)
.code16
VARIABLE(grub_machine_mmaphook_int12)
@ -52,7 +52,7 @@ VARIABLE (grub_machine_mmaphook_int15offset)
.word 0
VARIABLE (grub_machine_mmaphook_int15segment)
.word 0
e801:
popf
push %ds
@ -128,8 +128,8 @@ e820:
cmpw DS(EXT_C(grub_machine_mmaphook_mmap_num)), %bx
#endif
jb noclean
xor %bx, %bx
noclean:
xor %bx, %bx
noclean:
mov $0x534d4150, %eax
pop %ds
clc
@ -139,8 +139,8 @@ errexit:
pop %ds
stc
xor %bx, %bx
iret
iret
VARIABLE(grub_machine_mmaphook_mmap_num)
.word 0
VARIABLE(grub_machine_mmaphook_kblow)

6
mmap/i386/uppermem.c
View file

@ -21,7 +21,7 @@
#include <grub/mm.h>
#include <grub/misc.h>
grub_uint64_t
grub_uint64_t
grub_mmap_get_lower (void)
{
grub_uint64_t lower = 0;
@ -43,7 +43,7 @@ grub_mmap_get_lower (void)
return lower;
}
grub_uint64_t
grub_uint64_t
grub_mmap_get_upper (void)
{
grub_uint64_t upper = 0;
@ -64,7 +64,7 @@ grub_mmap_get_upper (void)
}
/* Count the continuous bytes after 64 MiB. */
grub_uint64_t
grub_uint64_t
grub_mmap_get_post64 (void)
{
grub_uint64_t post64 = 0;

66
mmap/mmap.c
View file

@ -33,14 +33,14 @@ static int curhandle = 1;
#endif
grub_err_t
grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
grub_uint64_t, grub_uint32_t))
{
/* 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
/* If same page is used by multiple types it's resolved
according to priority:
1 - free memory
2 - memory usable by firmware-aware code
@ -92,11 +92,11 @@ grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
/* Number of mmap chunks. */
int mmap_num;
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
struct grub_mmap_region *cur;
#endif
auto int NESTED_FUNC_ATTR count_hook (grub_uint64_t, grub_uint64_t,
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)),
@ -106,7 +106,7 @@ grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
return 0;
}
auto int NESTED_FUNC_ATTR fill_hook (grub_uint64_t, grub_uint64_t,
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,
@ -131,35 +131,35 @@ grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
return 0;
}
mmap_num = 0;
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
for (cur = grub_mmap_overlays; cur; cur = cur->next)
mmap_num++;
#endif
grub_machine_mmap_iterate (count_hook);
/* Initialize variables. */
grub_memset (present, 0, sizeof (present));
scanline_events = (struct grub_mmap_scan *)
scanline_events = (struct grub_mmap_scan *)
grub_malloc (sizeof (struct grub_mmap_scan) * 2 * mmap_num);
if (! scanline_events)
{
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't allocate space for new memory map");
}
i = 0;
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
#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;
if (cur->type == GRUB_MACHINE_MEMORY_HOLE
if (cur->type == GRUB_MACHINE_MEMORY_HOLE
|| (cur->type >= 0 && cur->type <= GRUB_MACHINE_MEMORY_MAX_TYPE
&& priority[cur->type]))
scanline_events[i].memtype = cur->type;
@ -176,8 +176,8 @@ grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
grub_machine_mmap_iterate (fill_hook);
/* 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
/* 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
fastest for one purpose. */
done = 1;
while (done)
@ -186,7 +186,7 @@ grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
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 + 1].type == 0
&& scanline_events[i].type == 1))
{
t = scanline_events[i + 1];
@ -213,7 +213,7 @@ grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
curtype = k;
/* Announce region to the hook if necessary. */
if ((curtype == -1 || curtype != lasttype)
if ((curtype == -1 || curtype != lasttype)
&& lastaddr != scanline_events[i].pos
&& lasttype != -1
&& lasttype != GRUB_MACHINE_MEMORY_HOLE
@ -224,7 +224,7 @@ grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
}
/* Update last values if necessary. */
if (curtype == -1 || curtype != lasttype)
if (curtype == -1 || curtype != lasttype)
{
lasttype = curtype;
lastaddr = scanline_events[i].pos;
@ -235,7 +235,7 @@ grub_mmap_iterate (int NESTED_FUNC_ATTR (*hook) (grub_uint64_t,
return GRUB_ERR_NONE;
}
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
#ifndef GRUB_MMAP_REGISTER_BY_FIRMWARE
int
grub_mmap_register (grub_uint64_t start, grub_uint64_t size, int type)
{
@ -243,11 +243,11 @@ grub_mmap_register (grub_uint64_t start, grub_uint64_t size, int type)
grub_dprintf ("mmap", "registering\n");
cur = (struct grub_mmap_region *)
cur = (struct grub_mmap_region *)
grub_malloc (sizeof (struct grub_mmap_region));
if (! cur)
{
grub_error (GRUB_ERR_OUT_OF_MEMORY,
grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't allocate memory map overlay");
return 0;
}
@ -295,7 +295,7 @@ grub_mmap_unregister (int handle)
#define CHUNK_SIZE 0x400
static inline grub_uint64_t
static inline grub_uint64_t
fill_mask (grub_uint64_t addr, grub_uint64_t mask, grub_uint64_t iterator)
{
int i, j;
@ -324,15 +324,15 @@ grub_cmd_badram (grub_command_t cmd __attribute__ ((unused)),
grub_uint64_t badaddr, badmask;
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,
int NESTED_FUNC_ATTR hook (grub_uint64_t addr,
grub_uint64_t size,
grub_uint32_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);
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++);
@ -349,7 +349,7 @@ grub_cmd_badram (grub_command_t cmd __attribute__ ((unused)),
{
low = 0;
high = ~0ULL;
/* Find starting value. Keep low and high such that
/* Find starting value. Keep low and high such that
fill_mask (low) < addr and fill_mask (high) >= addr;
*/
while (high - low > 1)
@ -364,11 +364,11 @@ grub_cmd_badram (grub_command_t cmd __attribute__ ((unused)),
}
for (; iterator < (1ULL << (var - tail))
&& (cur = fill_mask (badaddr, badmask, iterator)) < addr + size;
&& (cur = fill_mask (badaddr, badmask, iterator)) < addr + size;
iterator++)
{
grub_dprintf ("badram", "%llx (size %llx) is a badram range\n",
(long long) cur, (long long) (1ULL << tail) - 1);
grub_dprintf ("badram", "%llx (size %llx) is a badram range\n",
(long long) cur, (long long) (1ULL << tail) - 1);
grub_mmap_register (cur, (1ULL << tail) - 1, GRUB_MACHINE_MEMORY_HOLE);
}
return 0;
@ -401,7 +401,7 @@ grub_cmd_badram (grub_command_t cmd __attribute__ ((unused)),
no point in providing sub-page chunks. */
badmask &= ~(CHUNK_SIZE - 1);
grub_dprintf ("badram", "badram %llx:%llx\n",
grub_dprintf ("badram", "badram %llx:%llx\n",
(unsigned long long) badaddr, (unsigned long long) badmask);
grub_mmap_iterate (hook);
@ -414,7 +414,7 @@ static grub_command_t cmd;
GRUB_MOD_INIT(mmap)
{
cmd = grub_register_command ("badram", grub_cmd_badram,
"badram ADDR1,MASK1[,ADDR2,MASK2[,...]]",
"badram ADDR1,MASK1[,ADDR2,MASK2[,...]]",
"declare memory regions as badram");
}