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

* grub-core/loader/machoXX.c: Remove nested functions.

Browse source
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2013-02-27 20:56:23 +01:00
parent 4eb8b75659
commit 43c918828d
2 changed files with 148 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
ChangeLog
View file

@ -1,3 +1,7 @@
2013-02-27 Vladimir Serbinenko <phcoder@gmail.com>
* grub-core/loader/machoXX.c: Remove nested functions.
2013-02-27 Colin Watson <cjwatson@ubuntu.com> 2013-02-27 Colin Watson <cjwatson@ubuntu.com>
Remove nested functions from disk and file read hooks. Remove nested functions from disk and file read hooks.

129
grub-core/loader/machoXX.c
View file

@ -79,7 +79,7 @@ SUFFIX (grub_macho_parse) (grub_macho_t macho, const char *filename)
} }
} }
typedef int NESTED_FUNC_ATTR (*grub_macho_iter_hook_t) typedef int (*grub_macho_iter_hook_t)
(grub_macho_t , struct grub_macho_cmd *, (grub_macho_t , struct grub_macho_cmd *,
void *); void *);
@ -200,46 +200,59 @@ SUFFIX (grub_macho_readfile) (grub_macho_t macho,
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
/* Calculate the amount of memory spanned by the segments. */ struct calcsize_ctx
grub_err_t
SUFFIX (grub_macho_size) (grub_macho_t macho, grub_macho_addr_t *segments_start,
grub_macho_addr_t *segments_end, int flags,
const char *filename)
{ {
int nr_phdrs = 0; int flags;
int nr_phdrs;
grub_macho_addr_t *segments_start;
grub_macho_addr_t *segments_end;
};
/* Run through the program headers to calculate the total memory size we /* Run through the program headers to calculate the total memory size we
should claim. */ should claim. */
auto int NESTED_FUNC_ATTR calcsize (grub_macho_t _macho, static int
struct grub_macho_cmd *phdr, void *_arg); calcsize (grub_macho_t _macho __attribute__ ((unused)),
int NESTED_FUNC_ATTR calcsize (grub_macho_t _macho __attribute__ ((unused)),
struct grub_macho_cmd *hdr0, struct grub_macho_cmd *hdr0,
void *_arg __attribute__ ((unused))) void *_arg)
{ {
grub_macho_segment_t *hdr = (grub_macho_segment_t *) hdr0; grub_macho_segment_t *hdr = (grub_macho_segment_t *) hdr0;
struct calcsize_ctx *ctx = _arg;
if (hdr->cmd != GRUB_MACHO_CMD_SEGMENT) if (hdr->cmd != GRUB_MACHO_CMD_SEGMENT)
return 0; return 0;
if (! hdr->vmsize) if (! hdr->vmsize)
return 0; return 0;
if (! hdr->filesize && (flags & GRUB_MACHO_NOBSS)) if (! hdr->filesize && (ctx->flags & GRUB_MACHO_NOBSS))
return 0; return 0;
nr_phdrs++; ctx->nr_phdrs++;
if (hdr->vmaddr < *segments_start) if (hdr->vmaddr < *ctx->segments_start)
*segments_start = hdr->vmaddr; *ctx->segments_start = hdr->vmaddr;
if (hdr->vmaddr + hdr->vmsize > *segments_end) if (hdr->vmaddr + hdr->vmsize > *ctx->segments_end)
*segments_end = hdr->vmaddr + hdr->vmsize; *ctx->segments_end = hdr->vmaddr + hdr->vmsize;
return 0; return 0;
} }
/* Calculate the amount of memory spanned by the segments. */
grub_err_t
SUFFIX (grub_macho_size) (grub_macho_t macho, grub_macho_addr_t *segments_start,
grub_macho_addr_t *segments_end, int flags,
const char *filename)
{
struct calcsize_ctx ctx = {
.flags = flags,
.nr_phdrs = 0,
.segments_start = segments_start,
.segments_end = segments_end,
};
*segments_start = (grub_macho_addr_t) -1; *segments_start = (grub_macho_addr_t) -1;
*segments_end = 0; *segments_end = 0;
grub_macho_cmds_iterate (macho, calcsize, 0, filename); grub_macho_cmds_iterate (macho, calcsize, &ctx, filename);
if (nr_phdrs == 0) if (ctx.nr_phdrs == 0)
return grub_error (GRUB_ERR_BAD_OS, "no program headers present"); return grub_error (GRUB_ERR_BAD_OS, "no program headers present");
if (*segments_end < *segments_start) if (*segments_end < *segments_start)
@ -249,24 +262,26 @@ SUFFIX (grub_macho_size) (grub_macho_t macho, grub_macho_addr_t *segments_start,
return GRUB_ERR_NONE; return GRUB_ERR_NONE;
} }
/* Load every loadable segment into memory specified by `_load_hook'. */ struct do_load_ctx
grub_err_t
SUFFIX (grub_macho_load) (grub_macho_t macho, const char *filename,
char *offset, int flags, int *darwin_version)
{ {
auto int NESTED_FUNC_ATTR do_load(grub_macho_t _macho, int flags;
char *offset;
const char *filename;
int *darwin_version;
};
static int
do_load(grub_macho_t _macho,
struct grub_macho_cmd *hdr0, struct grub_macho_cmd *hdr0,
void *_arg __attribute__ ((unused))); void *_arg)
int NESTED_FUNC_ATTR do_load(grub_macho_t _macho,
struct grub_macho_cmd *hdr0,
void *_arg __attribute__ ((unused)))
{ {
grub_macho_segment_t *hdr = (grub_macho_segment_t *) hdr0; grub_macho_segment_t *hdr = (grub_macho_segment_t *) hdr0;
struct do_load_ctx *ctx = _arg;
if (hdr->cmd != GRUB_MACHO_CMD_SEGMENT) if (hdr->cmd != GRUB_MACHO_CMD_SEGMENT)
return 0; return 0;
if (! hdr->filesize && (flags & GRUB_MACHO_NOBSS)) if (! hdr->filesize && (ctx->flags & GRUB_MACHO_NOBSS))
return 0; return 0;
if (! hdr->vmsize) if (! hdr->vmsize)
return 0; return 0;
@ -274,7 +289,7 @@ SUFFIX (grub_macho_load) (grub_macho_t macho, const char *filename,
if (hdr->filesize) if (hdr->filesize)
{ {
grub_ssize_t read, toread = min (hdr->filesize, hdr->vmsize); grub_ssize_t read, toread = min (hdr->filesize, hdr->vmsize);
if (macho->uncompressedXX) if (_macho->uncompressedXX)
{ {
if (hdr->fileoff + (grub_size_t) toread if (hdr->fileoff + (grub_size_t) toread
> _macho->uncompressed_sizeXX) > _macho->uncompressed_sizeXX)
@ -282,7 +297,7 @@ SUFFIX (grub_macho_load) (grub_macho_t macho, const char *filename,
else else
{ {
read = toread; read = toread;
grub_memcpy (offset + hdr->vmaddr, grub_memcpy (ctx->offset + hdr->vmaddr,
_macho->uncompressedXX + hdr->fileoff, read); _macho->uncompressedXX + hdr->fileoff, read);
} }
} }
@ -291,7 +306,7 @@ SUFFIX (grub_macho_load) (grub_macho_t macho, const char *filename,
if (grub_file_seek (_macho->file, hdr->fileoff if (grub_file_seek (_macho->file, hdr->fileoff
+ _macho->offsetXX) == (grub_off_t) -1) + _macho->offsetXX) == (grub_off_t) -1)
return 1; return 1;
read = grub_file_read (_macho->file, offset + hdr->vmaddr, read = grub_file_read (_macho->file, ctx->offset + hdr->vmaddr,
toread); toread);
} }
@ -300,13 +315,13 @@ SUFFIX (grub_macho_load) (grub_macho_t macho, const char *filename,
/* XXX How can we free memory from `load_hook'? */ /* XXX How can we free memory from `load_hook'? */
if (!grub_errno) if (!grub_errno)
grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"), grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
filename); ctx->filename);
return 1; return 1;
} }
if (darwin_version) if (ctx->darwin_version)
{ {
const char *ptr = offset + hdr->vmaddr; const char *ptr = ctx->offset + hdr->vmaddr;
const char *end = ptr + min (hdr->filesize, hdr->vmsize) const char *end = ptr + min (hdr->filesize, hdr->vmsize)
- (sizeof ("Darwin Kernel Version ") - 1); - (sizeof ("Darwin Kernel Version ") - 1);
for (; ptr < end; ptr++) for (; ptr < end; ptr++)
@ -314,44 +329,56 @@ SUFFIX (grub_macho_load) (grub_macho_t macho, const char *filename,
sizeof ("Darwin Kernel Version ") - 1) == 0) sizeof ("Darwin Kernel Version ") - 1) == 0)
{ {
ptr += sizeof ("Darwin Kernel Version ") - 1; ptr += sizeof ("Darwin Kernel Version ") - 1;
*darwin_version = 0; *ctx->darwin_version = 0;
end += (sizeof ("Darwin Kernel Version ") - 1); end += (sizeof ("Darwin Kernel Version ") - 1);
while (ptr < end && grub_isdigit (*ptr)) while (ptr < end && grub_isdigit (*ptr))
*darwin_version = (*ptr++ - '0') + *darwin_version * 10; *ctx->darwin_version = (*ptr++ - '0') + *ctx->darwin_version * 10;
break; break;
} }
} }
} }
if (hdr->filesize < hdr->vmsize) if (hdr->filesize < hdr->vmsize)
grub_memset (offset + hdr->vmaddr + hdr->filesize, grub_memset (ctx->offset + hdr->vmaddr + hdr->filesize,
0, hdr->vmsize - hdr->filesize); 0, hdr->vmsize - hdr->filesize);
return 0; return 0;
} }
/* Load every loadable segment into memory specified by `_load_hook'. */
grub_err_t
SUFFIX (grub_macho_load) (grub_macho_t macho, const char *filename,
char *offset, int flags, int *darwin_version)
{
struct do_load_ctx ctx = {
.flags = flags,
.offset = offset,
.filename = filename,
.darwin_version = darwin_version
};
if (darwin_version) if (darwin_version)
*darwin_version = 0; *darwin_version = 0;
grub_macho_cmds_iterate (macho, do_load, 0, filename); grub_macho_cmds_iterate (macho, do_load, &ctx, filename);
return grub_errno; return grub_errno;
} }
static int
find_entry_point (grub_macho_t _macho __attribute__ ((unused)),
struct grub_macho_cmd *hdr,
void *_arg)
{
grub_macho_addr_t *entry_point = _arg;
if (hdr->cmd == GRUB_MACHO_CMD_THREAD)
*entry_point = ((grub_macho_thread_t *) hdr)->entry_point;
return 0;
}
grub_macho_addr_t grub_macho_addr_t
SUFFIX (grub_macho_get_entry_point) (grub_macho_t macho, const char *filename) SUFFIX (grub_macho_get_entry_point) (grub_macho_t macho, const char *filename)
{ {
grub_macho_addr_t entry_point = 0; grub_macho_addr_t entry_point = 0;
auto int NESTED_FUNC_ATTR hook(grub_macho_t _macho, grub_macho_cmds_iterate (macho, find_entry_point, &entry_point, filename);
struct grub_macho_cmd *hdr,
void *_arg __attribute__ ((unused)));
int NESTED_FUNC_ATTR hook(grub_macho_t _macho __attribute__ ((unused)),
struct grub_macho_cmd *hdr,
void *_arg __attribute__ ((unused)))
{
if (hdr->cmd == GRUB_MACHO_CMD_THREAD)
entry_point = ((grub_macho_thread_t *) hdr)->entry_point;
return 0;
}
grub_macho_cmds_iterate (macho, hook, 0, filename);
return entry_point; return entry_point;
} }