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

Remove nested functions from ELF iterators.

Browse source
This commit is contained in:
Colin Watson 2013-01-20 15:54:09 +00:00
parent 25239370fd
commit 6c724b85b4
4 changed files with 227 additions and 181 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
ChangeLog
View file

@ -1,3 +1,7 @@
2013-01-20 Colin Watson <cjwatson@ubuntu.com>
Remove nested functions from ELF iterators.
2013-01-20 Colin Watson <cjwatson@ubuntu.com> 2013-01-20 Colin Watson <cjwatson@ubuntu.com>
Remove nested functions from device iterators. Remove nested functions from device iterators.

261
grub-core/kern/elf.c
View file

@ -149,8 +149,7 @@ grub_elf32_load_phdrs (grub_elf_t elf, const char *filename)
grub_err_t grub_err_t
grub_elf32_phdr_iterate (grub_elf_t elf, grub_elf32_phdr_iterate (grub_elf_t elf,
const char *filename, const char *filename,
int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf32_Phdr *, void *), grub_elf32_phdr_iterate_hook_t hook, void *hook_arg)
void *hook_arg)
{ {
Elf32_Phdr *phdrs; Elf32_Phdr *phdrs;
unsigned int i; unsigned int i;
@ -177,48 +176,58 @@ grub_elf32_phdr_iterate (grub_elf_t elf,
return grub_errno; return grub_errno;
} }
struct grub_elf32_size_ctx
{
Elf32_Addr segments_start, segments_end;
int nr_phdrs;
grub_uint32_t curr_align;
};
/* Run through the program headers to calculate the total memory size we
* should claim. */
static int
grub_elf32_calcsize (grub_elf_t _elf __attribute__ ((unused)),
Elf32_Phdr *phdr, void *data)
{
struct grub_elf32_size_ctx *ctx = data;
/* Only consider loadable segments. */
if (phdr->p_type != PT_LOAD)
return 0;
ctx->nr_phdrs++;
if (phdr->p_paddr < ctx->segments_start)
ctx->segments_start = phdr->p_paddr;
if (phdr->p_paddr + phdr->p_memsz > ctx->segments_end)
ctx->segments_end = phdr->p_paddr + phdr->p_memsz;
if (ctx->curr_align < phdr->p_align)
ctx->curr_align = phdr->p_align;
return 0;
}
/* Calculate the amount of memory spanned by the segments. */ /* Calculate the amount of memory spanned by the segments. */
grub_size_t grub_size_t
grub_elf32_size (grub_elf_t elf, const char *filename, grub_elf32_size (grub_elf_t elf, const char *filename,
Elf32_Addr *base, grub_uint32_t *max_align) Elf32_Addr *base, grub_uint32_t *max_align)
{ {
Elf32_Addr segments_start = (Elf32_Addr) -1; struct grub_elf32_size_ctx ctx = {
Elf32_Addr segments_end = 0; .segments_start = (Elf32_Addr) -1,
int nr_phdrs = 0; .segments_end = 0,
grub_uint32_t curr_align = 1; .nr_phdrs = 0,
.curr_align = 1
};
/* Run through the program headers to calculate the total memory size we grub_elf32_phdr_iterate (elf, filename, grub_elf32_calcsize, &ctx);
* should claim. */
auto int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf, Elf32_Phdr *phdr, void *_arg);
int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf __attribute__ ((unused)),
Elf32_Phdr *phdr,
void *_arg __attribute__ ((unused)))
{
/* Only consider loadable segments. */
if (phdr->p_type != PT_LOAD)
return 0;
nr_phdrs++;
if (phdr->p_paddr < segments_start)
segments_start = phdr->p_paddr;
if (phdr->p_paddr + phdr->p_memsz > segments_end)
segments_end = phdr->p_paddr + phdr->p_memsz;
if (curr_align < phdr->p_align)
curr_align = phdr->p_align;
return 0;
}
grub_elf32_phdr_iterate (elf, filename, calcsize, 0);
if (base) if (base)
*base = 0; *base = 0;
if (nr_phdrs == 0) if (ctx.nr_phdrs == 0)
{ {
grub_error (GRUB_ERR_BAD_OS, "no program headers present"); grub_error (GRUB_ERR_BAD_OS, "no program headers present");
return 0; return 0;
} }
if (segments_end < segments_start) if (ctx.segments_end < ctx.segments_start)
{ {
/* Very bad addresses. */ /* Very bad addresses. */
grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses"); grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");
@ -226,38 +235,36 @@ grub_elf32_size (grub_elf_t elf, const char *filename,
} }
if (base) if (base)
*base = segments_start; *base = ctx.segments_start;
if (max_align) if (max_align)
*max_align = curr_align; *max_align = ctx.curr_align;
return segments_end - segments_start; return ctx.segments_end - ctx.segments_start;
} }
/* Load every loadable segment into memory specified by `_load_hook'. */ struct grub_elf32_load_ctx
grub_err_t
grub_elf32_load (grub_elf_t _elf, const char *filename,
grub_elf32_load_hook_t _load_hook,
grub_addr_t *base, grub_size_t *size)
{ {
grub_addr_t load_base = (grub_addr_t) -1ULL; const char *filename;
grub_size_t load_size = 0; grub_elf32_load_hook_t load_hook;
grub_err_t err; grub_addr_t load_base;
grub_size_t load_size;
};
auto int NESTED_FUNC_ATTR grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *hook); static int
int NESTED_FUNC_ATTR grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *hook) grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *data)
{ {
grub_elf32_load_hook_t load_hook = (grub_elf32_load_hook_t) hook; struct grub_elf32_load_ctx *ctx = data;
grub_addr_t load_addr; grub_addr_t load_addr;
int do_load = 1; int do_load = 1;
load_addr = phdr->p_paddr; load_addr = phdr->p_paddr;
if (load_hook && load_hook (phdr, &load_addr, &do_load)) if (ctx->load_hook && ctx->load_hook (phdr, &load_addr, &do_load))
return 1; return 1;
if (! do_load) if (! do_load)
return 0; return 0;
if (load_addr < load_base) if (load_addr < ctx->load_base)
load_base = load_addr; ctx->load_base = load_addr;
grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n", grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",
(unsigned long long) load_addr, (unsigned long long) load_addr,
@ -272,10 +279,10 @@ grub_elf32_load (grub_elf_t _elf, const char *filename,
read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz); read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);
if (read != (grub_ssize_t) phdr->p_filesz) if (read != (grub_ssize_t) phdr->p_filesz)
{ {
/* XXX How can we free memory from `load_hook'? */ /* XXX How can we free memory from `ctx->load_hook'? */
if (!grub_errno) if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"), grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
filename); ctx->filename);
return grub_errno; return grub_errno;
} }
} }
@ -284,18 +291,31 @@ grub_elf32_load (grub_elf_t _elf, const char *filename,
grub_memset ((void *) (long) (load_addr + phdr->p_filesz), grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
0, phdr->p_memsz - phdr->p_filesz); 0, phdr->p_memsz - phdr->p_filesz);
load_size += phdr->p_memsz; ctx->load_size += phdr->p_memsz;
return 0; return 0;
} }
err = grub_elf32_phdr_iterate (_elf, filename, /* Load every loadable segment into memory specified by `_load_hook'. */
grub_elf32_load_segment, _load_hook); grub_err_t
grub_elf32_load (grub_elf_t elf, const char *filename,
grub_elf32_load_hook_t load_hook,
grub_addr_t *base, grub_size_t *size)
{
struct grub_elf32_load_ctx ctx = {
.filename = filename,
.load_hook = load_hook,
.load_base = (grub_addr_t) -1ULL,
.load_size = 0
};
grub_err_t err;
err = grub_elf32_phdr_iterate (elf, filename, grub_elf32_load_segment, &ctx);
if (base) if (base)
*base = load_base; *base = ctx.load_base;
if (size) if (size)
*size = load_size; *size = ctx.load_size;
return err; return err;
} }
@ -339,8 +359,7 @@ grub_elf64_load_phdrs (grub_elf_t elf, const char *filename)
grub_err_t grub_err_t
grub_elf64_phdr_iterate (grub_elf_t elf, grub_elf64_phdr_iterate (grub_elf_t elf,
const char *filename, const char *filename,
int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf64_Phdr *, void *), grub_elf64_phdr_iterate_hook_t hook, void *hook_arg)
void *hook_arg)
{ {
Elf64_Phdr *phdrs; Elf64_Phdr *phdrs;
unsigned int i; unsigned int i;
@ -367,48 +386,58 @@ grub_elf64_phdr_iterate (grub_elf_t elf,
return grub_errno; return grub_errno;
} }
struct grub_elf64_size_ctx
{
Elf64_Addr segments_start, segments_end;
int nr_phdrs;
grub_uint64_t curr_align;
};
/* Run through the program headers to calculate the total memory size we
* should claim. */
static int
grub_elf64_calcsize (grub_elf_t _elf __attribute__ ((unused)),
Elf64_Phdr *phdr, void *data)
{
struct grub_elf64_size_ctx *ctx = data;
/* Only consider loadable segments. */
if (phdr->p_type != PT_LOAD)
return 0;
ctx->nr_phdrs++;
if (phdr->p_paddr < ctx->segments_start)
ctx->segments_start = phdr->p_paddr;
if (phdr->p_paddr + phdr->p_memsz > ctx->segments_end)
ctx->segments_end = phdr->p_paddr + phdr->p_memsz;
if (ctx->curr_align < phdr->p_align)
ctx->curr_align = phdr->p_align;
return 0;
}
/* Calculate the amount of memory spanned by the segments. */ /* Calculate the amount of memory spanned by the segments. */
grub_size_t grub_size_t
grub_elf64_size (grub_elf_t elf, const char *filename, grub_elf64_size (grub_elf_t elf, const char *filename,
Elf64_Addr *base, grub_uint64_t *max_align) Elf64_Addr *base, grub_uint64_t *max_align)
{ {
Elf64_Addr segments_start = (Elf64_Addr) -1; struct grub_elf64_size_ctx ctx = {
Elf64_Addr segments_end = 0; .segments_start = (Elf64_Addr) -1,
int nr_phdrs = 0; .segments_end = 0,
grub_uint64_t curr_align = 1; .nr_phdrs = 0,
.curr_align = 1
};
/* Run through the program headers to calculate the total memory size we grub_elf64_phdr_iterate (elf, filename, grub_elf64_calcsize, &ctx);
* should claim. */
auto int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf, Elf64_Phdr *phdr, void *_arg);
int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf __attribute__ ((unused)),
Elf64_Phdr *phdr,
void *_arg __attribute__ ((unused)))
{
/* Only consider loadable segments. */
if (phdr->p_type != PT_LOAD)
return 0;
nr_phdrs++;
if (phdr->p_paddr < segments_start)
segments_start = phdr->p_paddr;
if (phdr->p_paddr + phdr->p_memsz > segments_end)
segments_end = phdr->p_paddr + phdr->p_memsz;
if (curr_align < phdr->p_align)
curr_align = phdr->p_align;
return 0;
}
grub_elf64_phdr_iterate (elf, filename, calcsize, 0);
if (base) if (base)
*base = 0; *base = 0;
if (nr_phdrs == 0) if (ctx.nr_phdrs == 0)
{ {
grub_error (GRUB_ERR_BAD_OS, "no program headers present"); grub_error (GRUB_ERR_BAD_OS, "no program headers present");
return 0; return 0;
} }
if (segments_end < segments_start) if (ctx.segments_end < ctx.segments_start)
{ {
/* Very bad addresses. */ /* Very bad addresses. */
grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses"); grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");
@ -416,39 +445,36 @@ grub_elf64_size (grub_elf_t elf, const char *filename,
} }
if (base) if (base)
*base = segments_start; *base = ctx.segments_start;
if (max_align) if (max_align)
*max_align = curr_align; *max_align = ctx.curr_align;
return segments_end - segments_start; return ctx.segments_end - ctx.segments_start;
} }
/* Load every loadable segment into memory specified by `_load_hook'. */ struct grub_elf64_load_ctx
grub_err_t
grub_elf64_load (grub_elf_t _elf, const char *filename,
grub_elf64_load_hook_t _load_hook,
grub_addr_t *base, grub_size_t *size)
{ {
grub_addr_t load_base = (grub_addr_t) -1ULL; const char *filename;
grub_size_t load_size = 0; grub_elf64_load_hook_t load_hook;
grub_err_t err; grub_addr_t load_base;
grub_size_t load_size;
};
auto int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr, static int
void *hook); grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr, void *data)
int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr, void *hook) {
{ struct grub_elf64_load_ctx *ctx = data;
grub_elf64_load_hook_t load_hook = (grub_elf64_load_hook_t) hook;
grub_addr_t load_addr; grub_addr_t load_addr;
int do_load = 1; int do_load = 1;
load_addr = phdr->p_paddr; load_addr = phdr->p_paddr;
if (load_hook && load_hook (phdr, &load_addr, &do_load)) if (ctx->load_hook && ctx->load_hook (phdr, &load_addr, &do_load))
return 1; return 1;
if (! do_load) if (! do_load)
return 0; return 0;
if (load_addr < load_base) if (load_addr < ctx->load_base)
load_base = load_addr; ctx->load_base = load_addr;
grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n", grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",
(unsigned long long) load_addr, (unsigned long long) load_addr,
@ -463,10 +489,10 @@ grub_elf64_load (grub_elf_t _elf, const char *filename,
read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz); read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);
if (read != (grub_ssize_t) phdr->p_filesz) if (read != (grub_ssize_t) phdr->p_filesz)
{ {
/* XXX How can we free memory from `load_hook'? */ /* XXX How can we free memory from `ctx->load_hook'? */
if (!grub_errno) if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"), grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
filename); ctx->filename);
return grub_errno; return grub_errno;
} }
} }
@ -475,18 +501,31 @@ grub_elf64_load (grub_elf_t _elf, const char *filename,
grub_memset ((void *) (long) (load_addr + phdr->p_filesz), grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
0, phdr->p_memsz - phdr->p_filesz); 0, phdr->p_memsz - phdr->p_filesz);
load_size += phdr->p_memsz; ctx->load_size += phdr->p_memsz;
return 0; return 0;
} }
err = grub_elf64_phdr_iterate (_elf, filename, /* Load every loadable segment into memory specified by `_load_hook'. */
grub_elf64_load_segment, _load_hook); grub_err_t
grub_elf64_load (grub_elf_t elf, const char *filename,
grub_elf64_load_hook_t load_hook,
grub_addr_t *base, grub_size_t *size)
{
struct grub_elf64_load_ctx ctx = {
.filename = filename,
.load_hook = load_hook,
.load_base = (grub_addr_t) -1ULL,
.load_size = 0
};
grub_err_t err;
err = grub_elf64_phdr_iterate (elf, filename, grub_elf64_load_segment, &ctx);
if (base) if (base)
*base = load_base; *base = ctx.load_base;
if (size) if (size)
*size = load_size; *size = ctx.load_size;
return err; return err;
} }

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

@ -1311,7 +1311,7 @@ grub_bsd_load_aout (grub_file_t file, const char *filename)
bss_size); bss_size);
} }
static int NESTED_FUNC_ATTR static int
grub_bsd_elf32_size_hook (grub_elf_t elf __attribute__ ((unused)), grub_bsd_elf32_size_hook (grub_elf_t elf __attribute__ ((unused)),
Elf32_Phdr *phdr, void *arg __attribute__ ((unused))) Elf32_Phdr *phdr, void *arg __attribute__ ((unused)))
{ {
@ -1353,7 +1353,7 @@ grub_bsd_elf32_hook (Elf32_Phdr * phdr, grub_addr_t * addr, int *do_load)
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
static int NESTED_FUNC_ATTR static int
grub_bsd_elf64_size_hook (grub_elf_t elf __attribute__ ((unused)), grub_bsd_elf64_size_hook (grub_elf_t elf __attribute__ ((unused)),
Elf64_Phdr *phdr, void *arg __attribute__ ((unused))) Elf64_Phdr *phdr, void *arg __attribute__ ((unused)))
{ {

11
include/grub/elfload.h
View file

@ -41,6 +41,11 @@ typedef grub_err_t (*grub_elf32_load_hook_t)
typedef grub_err_t (*grub_elf64_load_hook_t) typedef grub_err_t (*grub_elf64_load_hook_t)
(Elf64_Phdr *phdr, grub_addr_t *addr, int *load); (Elf64_Phdr *phdr, grub_addr_t *addr, int *load);
typedef int (*grub_elf32_phdr_iterate_hook_t)
(grub_elf_t elf, Elf32_Phdr *phdr, void *arg);
typedef int (*grub_elf64_phdr_iterate_hook_t)
(grub_elf_t elf, Elf64_Phdr *phdr, void *arg);
grub_elf_t grub_elf_open (const char *); grub_elf_t grub_elf_open (const char *);
grub_elf_t grub_elf_file (grub_file_t file, const char *filename); grub_elf_t grub_elf_file (grub_file_t file, const char *filename);
grub_err_t grub_elf_close (grub_elf_t); grub_err_t grub_elf_close (grub_elf_t);
@ -63,12 +68,10 @@ grub_err_t grub_elf64_load (grub_elf_t, const char *filename,
grub_err_t grub_err_t
grub_elf32_phdr_iterate (grub_elf_t elf, grub_elf32_phdr_iterate (grub_elf_t elf,
const char *filename, const char *filename,
int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf32_Phdr *, void *), grub_elf32_phdr_iterate_hook_t hook, void *hook_arg);
void *hook_arg);
grub_err_t grub_err_t
grub_elf64_phdr_iterate (grub_elf_t elf, grub_elf64_phdr_iterate (grub_elf_t elf,
const char *filename, const char *filename,
int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf64_Phdr *, void *), grub_elf64_phdr_iterate_hook_t hook, void *hook_arg);
void *hook_arg);
#endif /* ! GRUB_ELFLOAD_HEADER */ #endif /* ! GRUB_ELFLOAD_HEADER */