grub_err_t
grub_elf32_phdr_iterate (grub_elf_t elf,
const char *filename,
- int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf32_Phdr *, void *),
- void *hook_arg)
+ grub_elf32_phdr_iterate_hook_t hook, void *hook_arg)
{
Elf32_Phdr *phdrs;
unsigned int i;
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)
{
- Elf32_Addr segments_start = (Elf32_Addr) -1;
- Elf32_Addr segments_end = 0;
- int nr_phdrs = 0;
- grub_uint32_t curr_align = 1;
-
- /* Run through the program headers to calculate the total memory size we
- * 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;
- }
+ 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, calcsize, 0);
+ grub_elf32_phdr_iterate (elf, filename, grub_elf32_calcsize, &ctx);
if (base)
*base = 0;
- if (nr_phdrs == 0)
+ if (ctx.nr_phdrs == 0)
{
grub_error (GRUB_ERR_BAD_OS, "no program headers present");
return 0;
}
- if (segments_end < segments_start)
+ if (ctx.segments_end < ctx.segments_start)
{
/* Very bad addresses. */
grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");
}
if (base)
- *base = segments_start;
+ *base = ctx.segments_start;
if (max_align)
- *max_align = curr_align;
- return segments_end - segments_start;
+ *max_align = ctx.curr_align;
+ return ctx.segments_end - ctx.segments_start;
}
-/* 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
{
- grub_addr_t load_base = (grub_addr_t) -1ULL;
- grub_size_t load_size = 0;
- grub_err_t err;
+ 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;
- auto int NESTED_FUNC_ATTR grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *hook);
- int NESTED_FUNC_ATTR grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *hook)
- {
- grub_elf32_load_hook_t load_hook = (grub_elf32_load_hook_t) hook;
- 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;
- load_addr = phdr->p_paddr;
- if (load_hook && load_hook (phdr, &load_addr, &do_load))
- return 1;
+ if (! do_load)
+ return 0;
- if (! do_load)
- return 0;
+ if (load_addr < ctx->load_base)
+ ctx->load_base = load_addr;
- 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);
- 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 (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)
- {
- 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 `load_hook'? */
- 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 (phdr->p_filesz < phdr->p_memsz)
+ grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
+ 0, phdr->p_memsz - phdr->p_filesz);
- return 0;
- }
+ 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, _load_hook);
+ err = grub_elf32_phdr_iterate (elf, filename, grub_elf32_load_segment, &ctx);
if (base)
- *base = load_base;
+ *base = ctx.load_base;
if (size)
- *size = load_size;
+ *size = ctx.load_size;
return err;
}
grub_err_t
grub_elf64_phdr_iterate (grub_elf_t elf,
const char *filename,
- int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf64_Phdr *, void *),
- void *hook_arg)
+ grub_elf64_phdr_iterate_hook_t hook, void *hook_arg)
{
Elf64_Phdr *phdrs;
unsigned int i;
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)
{
- Elf64_Addr segments_start = (Elf64_Addr) -1;
- Elf64_Addr segments_end = 0;
- int nr_phdrs = 0;
- grub_uint64_t curr_align = 1;
-
- /* Run through the program headers to calculate the total memory size we
- * 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;
- }
+ 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, calcsize, 0);
+ grub_elf64_phdr_iterate (elf, filename, grub_elf64_calcsize, &ctx);
if (base)
*base = 0;
- if (nr_phdrs == 0)
+ if (ctx.nr_phdrs == 0)
{
grub_error (GRUB_ERR_BAD_OS, "no program headers present");
return 0;
}
- if (segments_end < segments_start)
+ if (ctx.segments_end < ctx.segments_start)
{
/* Very bad addresses. */
grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");
}
if (base)
- *base = segments_start;
+ *base = ctx.segments_start;
if (max_align)
- *max_align = curr_align;
- return segments_end - segments_start;
+ *max_align = ctx.curr_align;
+ return ctx.segments_end - ctx.segments_start;
}
-/* 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
{
- grub_addr_t load_base = (grub_addr_t) -1ULL;
- grub_size_t load_size = 0;
- grub_err_t err;
+ 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;
- auto int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr,
- void *hook);
- int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr, void *hook)
- {
- grub_elf64_load_hook_t load_hook = (grub_elf64_load_hook_t) hook;
- 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;
- load_addr = phdr->p_paddr;
- if (load_hook && load_hook (phdr, &load_addr, &do_load))
- return 1;
+ if (! do_load)
+ return 0;
- if (! do_load)
- return 0;
+ if (load_addr < ctx->load_base)
+ ctx->load_base = load_addr;
- 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);
- 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 (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)
- {
- 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 `load_hook'? */
- 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 (phdr->p_filesz < phdr->p_memsz)
+ grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
+ 0, phdr->p_memsz - phdr->p_filesz);
- return 0;
- }
+ 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, _load_hook);
+ err = grub_elf64_phdr_iterate (elf, filename, grub_elf64_load_segment, &ctx);
if (base)
- *base = load_base;
+ *base = ctx.load_base;
if (size)
- *size = load_size;
+ *size = ctx.load_size;
return err;
}