rpms/grub2
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
f19
grub2/0185-Make-elfload-not-use-hooks.-Opt-for-flags-and-iterat.patch
Peter Jones f74b50e380 Rebase to upstream, fix a pile of bugs. The usual. 
Signed-off-by: Peter Jones <pjones@redhat.com>
2013-06-12 15:37:08 -04:00

1185 lines
33 KiB
Diff
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

From 6b0582fa0af9c5b2c3537198b3b142222137978c Mon Sep 17 00:00:00 2001
From: Vladimir 'phcoder' Serbinenko <phcoder@gmail.com>
Date: Sat, 2 Mar 2013 16:45:57 +0100
Subject: [PATCH 185/482] Make elfload not use hooks. Opt for flags and
iterators instead.
---
ChangeLog | 4 +
grub-core/kern/elf.c | 455 +++------------------------
grub-core/kern/elfXX.c | 144 +++++++++
grub-core/loader/i386/bsd.c | 137 +++-----
grub-core/loader/i386/coreboot/chainloader.c | 69 ++--
grub-core/loader/mips/linux.c | 37 +--
grub-core/loader/powerpc/ieee1275/linux.c | 34 +-
grub-core/loader/sparc64/ieee1275/linux.c | 18 +-
include/grub/elfload.h | 35 ++-
9 files changed, 301 insertions(+), 632 deletions(-)
create mode 100644 grub-core/kern/elfXX.c
diff --git a/ChangeLog b/ChangeLog
index d55dd8f..7c80ed6 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,9 @@
2013-03-02 Vladimir Serbinenko <phcoder@gmail.com>
+ Make elfload not use hooks. Opt for flags and iterators instead.
+
+2013-03-02 Vladimir Serbinenko <phcoder@gmail.com>
+
* grub-core/lib/ia64/longjmp.S: Fix the name of longjmp function.
* grub-core/lib/ia64/setjmp.S: Fix the name of setjmp function.
diff --git a/grub-core/kern/elf.c b/grub-core/kern/elf.c
index f52ca21..5f99c43 100644
--- a/grub-core/kern/elf.c
+++ b/grub-core/kern/elf.c
@@ -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 */
-
-int
-grub_elf_is_elf32 (grub_elf_t elf)
-{
- return elf->ehdr.ehdr32.e_ident[EI_CLASS] == ELFCLASS32;
-}
-
-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;
-}
+#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
+
+#include "elfXX.c"
+
+#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 */
-
-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;
-}
+#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
+
+#include "elfXX.c"
diff --git a/grub-core/kern/elfXX.c b/grub-core/kern/elfXX.c
new file mode 100644
index 0000000..b35e235
--- /dev/null
+++ b/grub-core/kern/elfXX.c
@@ -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;
+}
diff --git a/grub-core/loader/i386/bsd.c b/grub-core/loader/i386/bsd.c
index 9b86158..6199609 100644
--- a/grub-core/loader/i386/bsd.c
+++ b/grub-core/loader/i386/bsd.c
@@ -1311,89 +1311,6 @@ grub_bsd_load_aout (grub_file_t file, const char *filename)
bss_size);
}
-static int
-grub_bsd_elf32_size_hook (grub_elf_t elf __attribute__ ((unused)),
- Elf32_Phdr *phdr, void *arg __attribute__ ((unused)))
-{
- Elf32_Addr paddr;
-
- if (phdr->p_type != PT_LOAD
- && phdr->p_type != PT_DYNAMIC)
- return 0;
-
- paddr = phdr->p_paddr & 0xFFFFFFF;
-
- if (paddr < kern_start)
- kern_start = paddr;
-
- if (paddr + phdr->p_memsz > kern_end)
- kern_end = paddr + phdr->p_memsz;
-
- return 0;
-}
-
-static grub_err_t
-grub_bsd_elf32_hook (Elf32_Phdr * phdr, grub_addr_t * addr, int *do_load)
-{
- Elf32_Addr paddr;
-
- if (phdr->p_type != PT_LOAD
- && phdr->p_type != PT_DYNAMIC)
- {
- *do_load = 0;
- return 0;
- }
-
- *do_load = 1;
- phdr->p_paddr &= 0xFFFFFFF;
- paddr = phdr->p_paddr;
-
- *addr = (grub_addr_t) (paddr - kern_start + (grub_uint8_t *) kern_chunk_src);
-
- return GRUB_ERR_NONE;
-}
-
-static int
-grub_bsd_elf64_size_hook (grub_elf_t elf __attribute__ ((unused)),
- Elf64_Phdr *phdr, void *arg __attribute__ ((unused)))
-{
- Elf64_Addr paddr;
-
- if (phdr->p_type != PT_LOAD
- && phdr->p_type != PT_DYNAMIC)
- return 0;
-
- paddr = phdr->p_paddr & 0xfffffff;
-
- if (paddr < kern_start)
- kern_start = paddr;
-
- if (paddr + phdr->p_memsz > kern_end)
- kern_end = paddr + phdr->p_memsz;
-
- return 0;
-}
-
-static grub_err_t
-grub_bsd_elf64_hook (Elf64_Phdr * phdr, grub_addr_t * addr, int *do_load)
-{
- Elf64_Addr paddr;
-
- if (phdr->p_type != PT_LOAD
- && phdr->p_type != PT_DYNAMIC)
- {
- *do_load = 0;
- return 0;
- }
-
- *do_load = 1;
- paddr = phdr->p_paddr & 0xfffffff;
-
- *addr = (grub_addr_t) (paddr - kern_start + (grub_uint8_t *) kern_chunk_src);
-
- return GRUB_ERR_NONE;
-}
-
static grub_err_t
grub_bsd_load_elf (grub_elf_t elf, const char *filename)
{
@@ -1405,12 +1322,29 @@ grub_bsd_load_elf (grub_elf_t elf, const char *filename)
if (grub_elf_is_elf32 (elf))
{
grub_relocator_chunk_t ch;
+ Elf32_Phdr *phdr;
entry = elf->ehdr.ehdr32.e_entry & 0xFFFFFFF;
- err = grub_elf32_phdr_iterate (elf, filename,
- grub_bsd_elf32_size_hook, NULL);
- if (err)
- return err;
+
+ FOR_ELF32_PHDRS (elf, phdr)
+ {
+ Elf32_Addr paddr;
+
+ if (phdr->p_type != PT_LOAD
+ && phdr->p_type != PT_DYNAMIC)
+ continue;
+
+ paddr = phdr->p_paddr & 0xFFFFFFF;
+
+ if (paddr < kern_start)
+ kern_start = paddr;
+
+ if (paddr + phdr->p_memsz > kern_end)
+ kern_end = paddr + phdr->p_memsz;
+ }
+
+ if (grub_errno)
+ return grub_errno;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
kern_start, kern_end - kern_start);
if (err)
@@ -1418,7 +1352,7 @@ grub_bsd_load_elf (grub_elf_t elf, const char *filename)
kern_chunk_src = get_virtual_current_address (ch);
- err = grub_elf32_load (elf, filename, grub_bsd_elf32_hook, 0, 0);
+ err = grub_elf32_load (elf, filename, (grub_uint8_t *) kern_chunk_src - kern_start, GRUB_ELF_LOAD_FLAGS_LOAD_PT_DYNAMIC | GRUB_ELF_LOAD_FLAGS_28BITS, 0, 0);
if (err)
return err;
if (kernel_type != KERNEL_TYPE_OPENBSD)
@@ -1428,6 +1362,8 @@ grub_bsd_load_elf (grub_elf_t elf, const char *filename)
}
else if (grub_elf_is_elf64 (elf))
{
+ Elf64_Phdr *phdr;
+
is_64bit = 1;
if (! grub_cpuid_has_longmode)
@@ -1445,10 +1381,25 @@ grub_bsd_load_elf (grub_elf_t elf, const char *filename)
entry_hi = 0;
}
- err = grub_elf64_phdr_iterate (elf, filename,
- grub_bsd_elf64_size_hook, NULL);
- if (err)
- return err;
+ FOR_ELF64_PHDRS (elf, phdr)
+ {
+ Elf64_Addr paddr;
+
+ if (phdr->p_type != PT_LOAD
+ && phdr->p_type != PT_DYNAMIC)
+ continue;
+
+ paddr = phdr->p_paddr & 0xFFFFFFF;
+
+ if (paddr < kern_start)
+ kern_start = paddr;
+
+ if (paddr + phdr->p_memsz > kern_end)
+ kern_end = paddr + phdr->p_memsz;
+ }
+
+ if (grub_errno)
+ return grub_errno;
grub_dprintf ("bsd", "kern_start = %lx, kern_end = %lx\n",
(unsigned long) kern_start, (unsigned long) kern_end);
@@ -1463,7 +1414,7 @@ grub_bsd_load_elf (grub_elf_t elf, const char *filename)
}
err = grub_elf64_load (elf, filename,
- grub_bsd_elf64_hook, 0, 0);
+ (grub_uint8_t *) kern_chunk_src - kern_start, GRUB_ELF_LOAD_FLAGS_LOAD_PT_DYNAMIC | GRUB_ELF_LOAD_FLAGS_28BITS, 0, 0);
if (err)
return err;
if (kernel_type != KERNEL_TYPE_OPENBSD)
diff --git a/grub-core/loader/i386/coreboot/chainloader.c b/grub-core/loader/i386/coreboot/chainloader.c
index df4e276..505aa0b 100644
--- a/grub-core/loader/i386/coreboot/chainloader.c
+++ b/grub-core/loader/i386/coreboot/chainloader.c
@@ -56,36 +56,13 @@ grub_chain_unload (void)
}
static grub_err_t
-grub_chain_elf32_hook (Elf32_Phdr * phdr, grub_addr_t * addr, int *do_load)
-{
- grub_err_t err;
- grub_relocator_chunk_t ch;
-
- if (phdr->p_type != PT_LOAD)
- {
- *do_load = 0;
- return 0;
- }
-
- *do_load = 1;
- err = grub_relocator_alloc_chunk_addr (relocator, &ch,
- phdr->p_paddr, phdr->p_memsz);
- if (err)
- return err;
-
- *addr = (grub_addr_t) get_virtual_current_address (ch);
-
- return GRUB_ERR_NONE;
-}
-
-
-static grub_err_t
grub_cmd_chain (grub_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
grub_err_t err;
grub_file_t file;
grub_elf_t elf;
+ Elf32_Phdr *phdr;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
@@ -118,13 +95,47 @@ grub_cmd_chain (grub_command_t cmd __attribute__ ((unused)),
grub_elf_close (elf);
}
- entry = elf->ehdr.ehdr32.e_entry & 0xFFFFFF;
-
- err = grub_elf32_load (elf, argv[0], grub_chain_elf32_hook, 0, 0);
+ entry = elf->ehdr.ehdr32.e_entry;
+
+ FOR_ELF32_PHDRS(elf, phdr)
+ {
+ grub_uint8_t *load_addr;
+ grub_relocator_chunk_t ch;
+
+ if (phdr->p_type != PT_LOAD)
+ continue;
+
+ err = grub_relocator_alloc_chunk_addr (relocator, &ch,
+ phdr->p_paddr, phdr->p_memsz);
+ if (err)
+ break;
+
+ load_addr = get_virtual_current_address (ch);
+
+ 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, 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"),
+ argv[0]);
+ break;
+ }
+ }
+
+ if (phdr->p_filesz < phdr->p_memsz)
+ grub_memset ((load_addr + phdr->p_filesz),
+ 0, phdr->p_memsz - phdr->p_filesz);
+ }
grub_elf_close (elf);
- if (err)
- return err;
+ if (grub_errno)
+ return grub_errno;
grub_loader_set (grub_chain_boot, grub_chain_unload, 0);
return GRUB_ERR_NONE;
diff --git a/grub-core/loader/mips/linux.c b/grub-core/loader/mips/linux.c
index f2cf7cc..653f8a2 100644
--- a/grub-core/loader/mips/linux.c
+++ b/grub-core/loader/mips/linux.c
@@ -144,7 +144,7 @@ grub_linux_load32 (grub_elf_t elf, const char *filename,
/* Linux's entry point incorrectly contains a virtual address. */
entry_addr = elf->ehdr.ehdr32.e_entry;
- linux_size = grub_elf32_size (elf, filename, &base, 0);
+ linux_size = grub_elf32_size (elf, &base, 0);
if (linux_size == 0)
return grub_errno;
target_addr = base;
@@ -171,22 +171,7 @@ grub_linux_load32 (grub_elf_t elf, const char *filename,
*extra_mem = playground + extraoff;
/* Now load the segments into the area we claimed. */
- auto grub_err_t offset_phdr (Elf32_Phdr *phdr, grub_addr_t *addr, int *do_load);
- grub_err_t offset_phdr (Elf32_Phdr *phdr, grub_addr_t *addr, int *do_load)
- {
- if (phdr->p_type != PT_LOAD)
- {
- *do_load = 0;
- return 0;
- }
- *do_load = 1;
-
- /* Linux's program headers incorrectly contain virtual addresses.
- * Translate those to physical, and offset to the area we claimed. */
- *addr = (grub_addr_t) (phdr->p_paddr - base + playground);
- return 0;
- }
- return grub_elf32_load (elf, filename, offset_phdr, 0, 0);
+ return grub_elf32_load (elf, filename, playground - base, GRUB_ELF_LOAD_FLAGS_NONE, 0, 0);
}
static grub_err_t
@@ -200,7 +185,7 @@ grub_linux_load64 (grub_elf_t elf, const char *filename,
/* Linux's entry point incorrectly contains a virtual address. */
entry_addr = elf->ehdr.ehdr64.e_entry;
- linux_size = grub_elf64_size (elf, filename, &base, 0);
+ linux_size = grub_elf64_size (elf, &base, 0);
if (linux_size == 0)
return grub_errno;
target_addr = base;
@@ -227,21 +212,7 @@ grub_linux_load64 (grub_elf_t elf, const char *filename,
*extra_mem = playground + extraoff;
/* Now load the segments into the area we claimed. */
- auto grub_err_t offset_phdr (Elf64_Phdr *phdr, grub_addr_t *addr, int *do_load);
- grub_err_t offset_phdr (Elf64_Phdr *phdr, grub_addr_t *addr, int *do_load)
- {
- if (phdr->p_type != PT_LOAD)
- {
- *do_load = 0;
- return 0;
- }
- *do_load = 1;
- /* Linux's program headers incorrectly contain virtual addresses.
- * Translate those to physical, and offset to the area we claimed. */
- *addr = (grub_addr_t) (phdr->p_paddr - base + playground);
- return 0;
- }
- return grub_elf64_load (elf, filename, offset_phdr, 0, 0);
+ return grub_elf64_load (elf, filename, playground - base, GRUB_ELF_LOAD_FLAGS_NONE, 0, 0);
}
static grub_err_t
diff --git a/grub-core/loader/powerpc/ieee1275/linux.c b/grub-core/loader/powerpc/ieee1275/linux.c
index c977941..9055399 100644
--- a/grub-core/loader/powerpc/ieee1275/linux.c
+++ b/grub-core/loader/powerpc/ieee1275/linux.c
@@ -179,7 +179,7 @@ grub_linux_load32 (grub_elf_t elf, const char *filename)
grub_uint32_t offset;
Elf32_Addr entry;
- linux_size = grub_elf32_size (elf, filename, &base_addr, &align);
+ linux_size = grub_elf32_size (elf, &base_addr, &align);
if (linux_size == 0)
return grub_errno;
/* Pad it; the kernel scribbles over memory beyond its load address. */
@@ -203,20 +203,7 @@ grub_linux_load32 (grub_elf_t elf, const char *filename)
linux_addr = seg_addr;
/* Now load the segments into the area we claimed. */
- auto grub_err_t offset_phdr (Elf32_Phdr *phdr, grub_addr_t *addr, int *do_load);
- grub_err_t offset_phdr (Elf32_Phdr *phdr, grub_addr_t *addr, int *do_load)
- {
- if (phdr->p_type != PT_LOAD)
- {
- *do_load = 0;
- return 0;
- }
- *do_load = 1;
-
- *addr = (phdr->p_paddr - base_addr) + seg_addr;
- return 0;
- }
- return grub_elf32_load (elf, filename, offset_phdr, 0, 0);
+ return grub_elf32_load (elf, filename, (void *) (seg_addr - base_addr), GRUB_ELF_LOAD_FLAGS_NONE, 0, 0);
}
static grub_err_t
@@ -228,7 +215,7 @@ grub_linux_load64 (grub_elf_t elf, const char *filename)
grub_uint64_t offset;
Elf64_Addr entry;
- linux_size = grub_elf64_size (elf, filename, &base_addr, &align);
+ linux_size = grub_elf64_size (elf, &base_addr, &align);
if (linux_size == 0)
return grub_errno;
/* Pad it; the kernel scribbles over memory beyond its load address. */
@@ -250,20 +237,7 @@ grub_linux_load64 (grub_elf_t elf, const char *filename)
linux_addr = seg_addr;
/* Now load the segments into the area we claimed. */
- auto grub_err_t offset_phdr (Elf64_Phdr *phdr, grub_addr_t *addr, int *do_load);
- grub_err_t offset_phdr (Elf64_Phdr *phdr, grub_addr_t *addr, int *do_load)
- {
- if (phdr->p_type != PT_LOAD)
- {
- *do_load = 0;
- return 0;
- }
- *do_load = 1;
-
- *addr = (phdr->p_paddr - base_addr) + seg_addr;
- return 0;
- }
- return grub_elf64_load (elf, filename, offset_phdr, 0, 0);
+ return grub_elf64_load (elf, filename, (void *) (grub_addr_t) (seg_addr - base_addr), GRUB_ELF_LOAD_FLAGS_NONE, 0, 0);
}
static grub_err_t
diff --git a/grub-core/loader/sparc64/ieee1275/linux.c b/grub-core/loader/sparc64/ieee1275/linux.c
index c85fcfd..d203377 100644
--- a/grub-core/loader/sparc64/ieee1275/linux.c
+++ b/grub-core/loader/sparc64/ieee1275/linux.c
@@ -261,7 +261,7 @@ grub_linux_load64 (grub_elf_t elf, const char *filename)
linux_entry = elf->ehdr.ehdr64.e_entry;
linux_addr = 0x40004000;
off = 0x4000;
- linux_size = grub_elf64_size (elf, filename, 0, 0);
+ linux_size = grub_elf64_size (elf, 0, 0);
if (linux_size == 0)
return grub_errno;
@@ -286,21 +286,7 @@ grub_linux_load64 (grub_elf_t elf, const char *filename)
base = linux_entry - off;
/* Now load the segments into the area we claimed. */
- auto grub_err_t offset_phdr (Elf64_Phdr *phdr, grub_addr_t *addr, int *do_load);
- grub_err_t offset_phdr (Elf64_Phdr *phdr, grub_addr_t *addr, int *do_load)
- {
- if (phdr->p_type != PT_LOAD)
- {
- *do_load = 0;
- return 0;
- }
- *do_load = 1;
-
- /* Adjust the program load address to linux_addr. */
- *addr = (phdr->p_paddr - base) + (linux_addr - off);
- return 0;
- }
- return grub_elf64_load (elf, filename, offset_phdr, 0, 0);
+ return grub_elf64_load (elf, filename, (void *) (linux_addr - off - base), GRUB_ELF_LOAD_FLAGS_NONE, 0, 0);
}
static grub_err_t
diff --git a/include/grub/elfload.h b/include/grub/elfload.h
index d1a8d54..f854d0b 100644
--- a/include/grub/elfload.h
+++ b/include/grub/elfload.h
@@ -33,14 +33,10 @@ struct grub_elf_file
Elf32_Ehdr ehdr32;
} ehdr;
void *phdrs;
+ char *filename;
};
typedef struct grub_elf_file *grub_elf_t;
-typedef grub_err_t (*grub_elf32_load_hook_t)
- (Elf32_Phdr *phdr, grub_addr_t *addr, int *load);
-typedef grub_err_t (*grub_elf64_load_hook_t)
- (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)
@@ -52,26 +48,31 @@ grub_err_t grub_elf_close (grub_elf_t);
int grub_elf_is_elf32 (grub_elf_t);
grub_size_t grub_elf32_size (grub_elf_t,
- const char *filename,
Elf32_Addr *, grub_uint32_t *);
+enum grub_elf_load_flags
+ {
+ GRUB_ELF_LOAD_FLAGS_NONE = 0,
+ GRUB_ELF_LOAD_FLAGS_LOAD_PT_DYNAMIC = 1,
+ GRUB_ELF_LOAD_FLAGS_28BITS = 2,
+ };
grub_err_t grub_elf32_load (grub_elf_t, const char *filename,
- grub_elf32_load_hook_t, grub_addr_t *,
+ void *load_offset, enum grub_elf_load_flags flags, grub_addr_t *,
grub_size_t *);
int grub_elf_is_elf64 (grub_elf_t);
grub_size_t grub_elf64_size (grub_elf_t,
- const char *filename,
Elf64_Addr *, grub_uint64_t *);
grub_err_t grub_elf64_load (grub_elf_t, const char *filename,
- grub_elf64_load_hook_t, grub_addr_t *,
+ void *load_offset, enum grub_elf_load_flags flags, grub_addr_t *,
grub_size_t *);
-grub_err_t
-grub_elf32_phdr_iterate (grub_elf_t elf,
- const char *filename,
- grub_elf32_phdr_iterate_hook_t hook, void *hook_arg);
-grub_err_t
-grub_elf64_phdr_iterate (grub_elf_t elf,
- const char *filename,
- grub_elf64_phdr_iterate_hook_t hook, void *hook_arg);
+grub_err_t grub_elf32_load_phdrs (grub_elf_t elf);
+grub_err_t grub_elf64_load_phdrs (grub_elf_t elf);
+
+#define FOR_ELF32_PHDRS(elf, phdr) \
+ for (grub_elf32_load_phdrs (elf), phdr = elf->phdrs; \
+ phdr && phdr < (Elf32_Phdr *) elf->phdrs + elf->ehdr.ehdr32.e_phnum; phdr++)
+#define FOR_ELF64_PHDRS(elf, phdr) \
+ for (grub_elf64_load_phdrs (elf), phdr = elf->phdrs; \
+ phdr && phdr < (Elf64_Phdr *) elf->phdrs + elf->ehdr.ehdr64.e_phnum; phdr++)
#endif /* ! GRUB_ELFLOAD_HEADER */
--
1.8.2.1
Reference in New Issue View Git Blame Copy Permalink