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

Make elfload not use hooks. Opt for flags and iterators instead.

Browse source
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2013-03-02 16:45:57 +01:00
parent 7f8c105f61
commit 73bf57e2c8
9 changed files with 298 additions and 629 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -51,6 +51,7 @@ grub_elf_close (grub_elf_t elf)
grub_file_t file = elf->file;
grub_free (elf->phdrs);
grub_free (elf->filename);
grub_free (elf);
if (file)
@ -85,9 +86,14 @@ grub_elf_file (grub_file_t file, const char *filename)
if (grub_elf_check_header (elf))
goto fail;
elf->filename = grub_strdup (filename);
if (!elf->filename)
goto fail;
return elf;
fail:
grub_free (elf->filename);
grub_free (elf->phdrs);
grub_free (elf);
return 0;
@ -112,420 +118,41 @@ grub_elf_open (const char *name)
/* 32-bit */
#define ehdrXX ehdr32
#define ELFCLASSXX ELFCLASS32
#define ElfXX_Addr Elf32_Addr
#define grub_elfXX_size grub_elf32_size
#define grub_elfXX_load grub_elf32_load
#define FOR_ELFXX_PHDRS FOR_ELF32_PHDRS
#define grub_elf_is_elfXX grub_elf_is_elf32
#define grub_elfXX_load_phdrs grub_elf32_load_phdrs
#define ElfXX_Phdr Elf32_Phdr
#define grub_uintXX_t grub_uint32_t
int
grub_elf_is_elf32 (grub_elf_t elf)
{
return elf->ehdr.ehdr32.e_ident[EI_CLASS] == ELFCLASS32;
}
#include "elfXX.c"
static grub_err_t
grub_elf32_load_phdrs (grub_elf_t elf, const char *filename)
{
grub_ssize_t phdrs_size;
phdrs_size = elf->ehdr.ehdr32.e_phnum * elf->ehdr.ehdr32.e_phentsize;
grub_dprintf ("elf", "Loading program headers at 0x%llx, size 0x%lx.\n",
(unsigned long long) elf->ehdr.ehdr32.e_phoff,
(unsigned long) phdrs_size);
elf->phdrs = grub_malloc (phdrs_size);
if (! elf->phdrs)
return grub_errno;
if ((grub_file_seek (elf->file, elf->ehdr.ehdr32.e_phoff) == (grub_off_t) -1)
|| (grub_file_read (elf->file, elf->phdrs, phdrs_size) != phdrs_size))
{
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
filename);
return grub_errno;
}
return GRUB_ERR_NONE;
}
grub_err_t
grub_elf32_phdr_iterate (grub_elf_t elf,
const char *filename,
grub_elf32_phdr_iterate_hook_t hook, void *hook_arg)
{
Elf32_Phdr *phdrs;
unsigned int i;
if (! elf->phdrs)
if (grub_elf32_load_phdrs (elf, filename))
return grub_errno;
phdrs = elf->phdrs;
for (i = 0; i < elf->ehdr.ehdr32.e_phnum; i++)
{
Elf32_Phdr *phdr = phdrs + i;
grub_dprintf ("elf",
"Segment %u: type 0x%x paddr 0x%lx memsz 0x%lx "
"filesz %lx\n",
i, phdr->p_type,
(unsigned long) phdr->p_paddr,
(unsigned long) phdr->p_memsz,
(unsigned long) phdr->p_filesz);
if (hook (elf, phdr, hook_arg))
break;
}
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. */
grub_size_t
grub_elf32_size (grub_elf_t elf, const char *filename,
Elf32_Addr *base, grub_uint32_t *max_align)
{
struct grub_elf32_size_ctx ctx = {
.segments_start = (Elf32_Addr) -1,
.segments_end = 0,
.nr_phdrs = 0,
.curr_align = 1
};
grub_elf32_phdr_iterate (elf, filename, grub_elf32_calcsize, &ctx);
if (base)
*base = 0;
if (ctx.nr_phdrs == 0)
{
grub_error (GRUB_ERR_BAD_OS, "no program headers present");
return 0;
}
if (ctx.segments_end < ctx.segments_start)
{
/* Very bad addresses. */
grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");
return 0;
}
if (base)
*base = ctx.segments_start;
if (max_align)
*max_align = ctx.curr_align;
return ctx.segments_end - ctx.segments_start;
}
struct grub_elf32_load_ctx
{
const char *filename;
grub_elf32_load_hook_t load_hook;
grub_addr_t load_base;
grub_size_t load_size;
};
static int
grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *data)
{
struct grub_elf32_load_ctx *ctx = data;
grub_addr_t load_addr;
int do_load = 1;
load_addr = phdr->p_paddr;
if (ctx->load_hook && ctx->load_hook (phdr, &load_addr, &do_load))
return 1;
if (! do_load)
return 0;
if (load_addr < ctx->load_base)
ctx->load_base = load_addr;
grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",
(unsigned long long) load_addr,
(unsigned long long) phdr->p_memsz);
if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)
return grub_errno;
if (phdr->p_filesz)
{
grub_ssize_t read;
read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);
if (read != (grub_ssize_t) phdr->p_filesz)
{
/* XXX How can we free memory from `ctx->load_hook'? */
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
ctx->filename);
return grub_errno;
}
}
if (phdr->p_filesz < phdr->p_memsz)
grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
0, phdr->p_memsz - phdr->p_filesz);
ctx->load_size += phdr->p_memsz;
return 0;
}
/* Load every loadable segment into memory specified by `_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)
*base = ctx.load_base;
if (size)
*size = ctx.load_size;
return err;
}
#undef ehdrXX
#undef ELFCLASSXX
#undef ElfXX_Addr
#undef grub_elfXX_size
#undef grub_elfXX_load
#undef FOR_ELFXX_PHDRS
#undef grub_elf_is_elfXX
#undef grub_elfXX_load_phdrs
#undef ElfXX_Phdr
#undef grub_uintXX_t
/* 64-bit */
#define ehdrXX ehdr64
#define ELFCLASSXX ELFCLASS64
#define ElfXX_Addr Elf64_Addr
#define grub_elfXX_size grub_elf64_size
#define grub_elfXX_load grub_elf64_load
#define FOR_ELFXX_PHDRS FOR_ELF64_PHDRS
#define grub_elf_is_elfXX grub_elf_is_elf64
#define grub_elfXX_load_phdrs grub_elf64_load_phdrs
#define ElfXX_Phdr Elf64_Phdr
#define grub_uintXX_t grub_uint64_t
int
grub_elf_is_elf64 (grub_elf_t elf)
{
return elf->ehdr.ehdr64.e_ident[EI_CLASS] == ELFCLASS64;
}
static grub_err_t
grub_elf64_load_phdrs (grub_elf_t elf, const char *filename)
{
grub_ssize_t phdrs_size;
phdrs_size = elf->ehdr.ehdr64.e_phnum * elf->ehdr.ehdr64.e_phentsize;
grub_dprintf ("elf", "Loading program headers at 0x%llx, size 0x%lx.\n",
(unsigned long long) elf->ehdr.ehdr64.e_phoff,
(unsigned long) phdrs_size);
elf->phdrs = grub_malloc (phdrs_size);
if (! elf->phdrs)
return grub_errno;
if ((grub_file_seek (elf->file, elf->ehdr.ehdr64.e_phoff) == (grub_off_t) -1)
|| (grub_file_read (elf->file, elf->phdrs, phdrs_size) != phdrs_size))
{
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
filename);
return grub_errno;
}
return GRUB_ERR_NONE;
}
grub_err_t
grub_elf64_phdr_iterate (grub_elf_t elf,
const char *filename,
grub_elf64_phdr_iterate_hook_t hook, void *hook_arg)
{
Elf64_Phdr *phdrs;
unsigned int i;
if (! elf->phdrs)
if (grub_elf64_load_phdrs (elf, filename))
return grub_errno;
phdrs = elf->phdrs;
for (i = 0; i < elf->ehdr.ehdr64.e_phnum; i++)
{
Elf64_Phdr *phdr = phdrs + i;
grub_dprintf ("elf",
"Segment %u: type 0x%x paddr 0x%lx memsz 0x%lx "
"filesz %lx\n",
i, phdr->p_type,
(unsigned long) phdr->p_paddr,
(unsigned long) phdr->p_memsz,
(unsigned long) phdr->p_filesz);
if (hook (elf, phdr, hook_arg))
break;
}
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. */
grub_size_t
grub_elf64_size (grub_elf_t elf, const char *filename,
Elf64_Addr *base, grub_uint64_t *max_align)
{
struct grub_elf64_size_ctx ctx = {
.segments_start = (Elf64_Addr) -1,
.segments_end = 0,
.nr_phdrs = 0,
.curr_align = 1
};
grub_elf64_phdr_iterate (elf, filename, grub_elf64_calcsize, &ctx);
if (base)
*base = 0;
if (ctx.nr_phdrs == 0)
{
grub_error (GRUB_ERR_BAD_OS, "no program headers present");
return 0;
}
if (ctx.segments_end < ctx.segments_start)
{
/* Very bad addresses. */
grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");
return 0;
}
if (base)
*base = ctx.segments_start;
if (max_align)
*max_align = ctx.curr_align;
return ctx.segments_end - ctx.segments_start;
}
struct grub_elf64_load_ctx
{
const char *filename;
grub_elf64_load_hook_t load_hook;
grub_addr_t load_base;
grub_size_t load_size;
};
static int
grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr, void *data)
{
struct grub_elf64_load_ctx *ctx = data;
grub_addr_t load_addr;
int do_load = 1;
load_addr = phdr->p_paddr;
if (ctx->load_hook && ctx->load_hook (phdr, &load_addr, &do_load))
return 1;
if (! do_load)
return 0;
if (load_addr < ctx->load_base)
ctx->load_base = load_addr;
grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",
(unsigned long long) load_addr,
(unsigned long long) phdr->p_memsz);
if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)
return grub_errno;
if (phdr->p_filesz)
{
grub_ssize_t read;
read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);
if (read != (grub_ssize_t) phdr->p_filesz)
{
/* XXX How can we free memory from `ctx->load_hook'? */
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
ctx->filename);
return grub_errno;
}
}
if (phdr->p_filesz < phdr->p_memsz)
grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
0, phdr->p_memsz - phdr->p_filesz);
ctx->load_size += phdr->p_memsz;
return 0;
}
/* Load every loadable segment into memory specified by `_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)
*base = ctx.load_base;
if (size)
*size = ctx.load_size;
return err;
}
#include "elfXX.c"

144
grub-core/kern/elfXX.c Normal file
View file

@ -0,0 +1,144 @@
int
grub_elf_is_elfXX (grub_elf_t elf)
{
return elf->ehdr.ehdrXX.e_ident[EI_CLASS] == ELFCLASSXX;
}
grub_err_t
grub_elfXX_load_phdrs (grub_elf_t elf)
{
grub_ssize_t phdrs_size;
if (elf->phdrs)
return GRUB_ERR_NONE;
phdrs_size = elf->ehdr.ehdrXX.e_phnum * elf->ehdr.ehdrXX.e_phentsize;
grub_dprintf ("elf", "Loading program headers at 0x%llx, size 0x%lx.\n",
(unsigned long long) elf->ehdr.ehdrXX.e_phoff,
(unsigned long) phdrs_size);
elf->phdrs = grub_malloc (phdrs_size);
if (! elf->phdrs)
return grub_errno;
if ((grub_file_seek (elf->file, elf->ehdr.ehdrXX.e_phoff) == (grub_off_t) -1)
|| (grub_file_read (elf->file, elf->phdrs, phdrs_size) != phdrs_size))
{
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
elf->filename);
return grub_errno;
}
return GRUB_ERR_NONE;
}
/* Calculate the amount of memory spanned by the segments. */
grub_size_t
grub_elfXX_size (grub_elf_t elf,
ElfXX_Addr *base, grub_uintXX_t *max_align)
{
ElfXX_Addr segments_start = (ElfXX_Addr) -1;
ElfXX_Addr segments_end = 0;
int nr_phdrs = 0;
grub_uint32_t curr_align = 1;
ElfXX_Phdr *phdr;
/* Run through the program headers to calculate the total memory size we
* should claim. */
FOR_ELFXX_PHDRS (elf, phdr)
{
/* Only consider loadable segments. */
if (phdr->p_type != PT_LOAD)
continue;
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;
}
if (base)
*base = 0;
if (nr_phdrs == 0)
{
grub_error (GRUB_ERR_BAD_OS, "no program headers present");
return 0;
}
if (segments_end < segments_start)
{
/* Very bad addresses. */
grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");
return 0;
}
if (base)
*base = segments_start;
if (max_align)
*max_align = curr_align;
return segments_end - segments_start;
}
grub_err_t
grub_elfXX_load (grub_elf_t elf, const char *filename,
void *load_offset, enum grub_elf_load_flags load_flags,
grub_addr_t *base, grub_size_t *size)
{
grub_addr_t load_base = (grub_addr_t) -1ULL;
grub_size_t load_size = 0;
ElfXX_Phdr *phdr;
FOR_ELFXX_PHDRS(elf, phdr)
{
grub_addr_t load_addr;
if (phdr->p_type != PT_LOAD && !((load_flags & GRUB_ELF_LOAD_FLAGS_LOAD_PT_DYNAMIC) && phdr->p_type == PT_DYNAMIC))
continue;
load_addr = (grub_addr_t) phdr->p_paddr;
if (load_flags & GRUB_ELF_LOAD_FLAGS_28BITS)
load_addr &= 0xFFFFFFF;
load_addr += (grub_addr_t) load_offset;
if (load_addr < load_base)
load_base = load_addr;
grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",
(unsigned long long) load_addr,
(unsigned long long) phdr->p_memsz);
if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)
return grub_errno;
if (phdr->p_filesz)
{
grub_ssize_t read;
read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);
if (read != (grub_ssize_t) phdr->p_filesz)
{
if (!grub_errno)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
filename);
return grub_errno;
}
}
if (phdr->p_filesz < phdr->p_memsz)
grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
0, phdr->p_memsz - phdr->p_filesz);
load_size += phdr->p_memsz;
}
if (base)
*base = load_base;
if (size)
*size = load_size;
return grub_errno;
}