OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

bsd-user: elfload.c style catch up patch

Browse Source 
Various style fixes to elfload.c that were too painful to make earlier
in this series.

Signed-off-by: Warner Losh <imp@bsdimp.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Warner Losh 2021-08-06 14:38:48 -06:00 committed by Warner Losh
parent 0475f8fac5
commit 0456a1772b
1 changed files with 104 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

208
bsd-user/elfload.c
View File

@ -143,10 +143,12 @@ static abi_ulong copy_elf_strings(int argc, char **argv, void **page,
exit(-1); exit(-1);
} }
tmp1 = tmp; tmp1 = tmp;
while (*tmp++); while (*tmp++) {
continue;
}
len = tmp - tmp1; len = tmp - tmp1;
if (p < len) { /* this shouldn't happen - 128kB */ if (p < len) { /* this shouldn't happen - 128kB */
return 0; return 0;
} }
while (len) { while (len) {
--p; --tmp; --len; --p; --tmp; --len;
@ -156,14 +158,14 @@ static abi_ulong copy_elf_strings(int argc, char **argv, void **page,
if (!pag) { if (!pag) {
pag = g_try_malloc0(TARGET_PAGE_SIZE); pag = g_try_malloc0(TARGET_PAGE_SIZE);
page[p / TARGET_PAGE_SIZE] = pag; page[p / TARGET_PAGE_SIZE] = pag;
if (!pag) if (!pag) {
return 0; return 0;
}
} }
} }
if (len == 0 || offset == 0) { if (len == 0 || offset == 0) {
*(pag + offset) = *tmp; *(pag + offset) = *tmp;
} } else {
else {
int bytes_to_copy = (len > offset) ? offset : len; int bytes_to_copy = (len > offset) ? offset : len;
tmp -= bytes_to_copy; tmp -= bytes_to_copy;
p -= bytes_to_copy; p -= bytes_to_copy;
@ -182,16 +184,14 @@ static void setup_arg_pages(struct bsd_binprm *bprm, struct image_info *info,
abi_ulong stack_base, size; abi_ulong stack_base, size;
abi_long addr; abi_long addr;
/* Create enough stack to hold everything. If we don't use /*
* it for args, we'll use it for something else... * Create enough stack to hold everything. If we don't use it for args,
* we'll use it for something else...
*/ */
size = target_dflssiz; size = target_dflssiz;
stack_base = TARGET_USRSTACK - size; stack_base = TARGET_USRSTACK - size;
addr = target_mmap(stack_base, addr = target_mmap(stack_base , size + qemu_host_page_size,
size + qemu_host_page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON,
-1, 0);
if (addr == -1) { if (addr == -1) {
perror("stk mmap"); perror("stk mmap");
exit(-1); exit(-1);
@ -210,55 +210,60 @@ static void setup_arg_pages(struct bsd_binprm *bprm, struct image_info *info,
static void set_brk(abi_ulong start, abi_ulong end) static void set_brk(abi_ulong start, abi_ulong end)
{ {
/* page-align the start and end addresses... */ /* page-align the start and end addresses... */
start = HOST_PAGE_ALIGN(start); start = HOST_PAGE_ALIGN(start);
end = HOST_PAGE_ALIGN(end); end = HOST_PAGE_ALIGN(end);
if (end <= start) if (end <= start) {
return; return;
if (target_mmap(start, end - start, }
PROT_READ | PROT_WRITE | PROT_EXEC, if (target_mmap(start, end - start, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0) == -1) { MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0) == -1) {
perror("cannot mmap brk"); perror("cannot mmap brk");
exit(-1); exit(-1);
} }
} }
/* We need to explicitly zero any fractional pages after the data /*
section (i.e. bss). This would contain the junk from the file that * We need to explicitly zero any fractional pages after the data
should not be in memory. */ * section (i.e. bss). This would contain the junk from the file that
* should not be in memory.
*/
static void padzero(abi_ulong elf_bss, abi_ulong last_bss) static void padzero(abi_ulong elf_bss, abi_ulong last_bss)
{ {
abi_ulong nbyte; abi_ulong nbyte;
if (elf_bss >= last_bss) if (elf_bss >= last_bss) {
return; return;
}
/* XXX: this is really a hack : if the real host page size is /*
smaller than the target page size, some pages after the end * XXX: this is really a hack : if the real host page size is
of the file may not be mapped. A better fix would be to * smaller than the target page size, some pages after the end
patch target_mmap(), but it is more complicated as the file * of the file may not be mapped. A better fix would be to
size must be known */ * patch target_mmap(), but it is more complicated as the file
if (qemu_real_host_page_size < qemu_host_page_size) { * size must be known.
abi_ulong end_addr, end_addr1; */
end_addr1 = REAL_HOST_PAGE_ALIGN(elf_bss); if (qemu_real_host_page_size < qemu_host_page_size) {
end_addr = HOST_PAGE_ALIGN(elf_bss); abi_ulong end_addr, end_addr1;
if (end_addr1 < end_addr) { end_addr1 = REAL_HOST_PAGE_ALIGN(elf_bss);
mmap((void *)g2h_untagged(end_addr1), end_addr - end_addr1, end_addr = HOST_PAGE_ALIGN(elf_bss);
PROT_READ | PROT_WRITE | PROT_EXEC, if (end_addr1 < end_addr) {
MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0); mmap((void *)g2h_untagged(end_addr1), end_addr - end_addr1,
} PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0);
} }
}
nbyte = elf_bss & (qemu_host_page_size - 1); nbyte = elf_bss & (qemu_host_page_size - 1);
if (nbyte) { if (nbyte) {
nbyte = qemu_host_page_size - nbyte; nbyte = qemu_host_page_size - nbyte;
do { do {
/* FIXME - what to do if put_user() fails? */ /* FIXME - what to do if put_user() fails? */
put_user_u8(0, elf_bss); put_user_u8(0, elf_bss);
elf_bss++; elf_bss++;
} while (--nbyte); } while (--nbyte);
} }
} }
static abi_ulong load_elf_interp(struct elfhdr *interp_elf_ex, static abi_ulong load_elf_interp(struct elfhdr *interp_elf_ex,
@ -280,23 +285,23 @@ static abi_ulong load_elf_interp(struct elfhdr *interp_elf_ex,
bswap_ehdr(interp_elf_ex); bswap_ehdr(interp_elf_ex);
/* First of all, some simple consistency checks */ /* First of all, some simple consistency checks */
if ((interp_elf_ex->e_type != ET_EXEC && if ((interp_elf_ex->e_type != ET_EXEC && interp_elf_ex->e_type != ET_DYN) ||
interp_elf_ex->e_type != ET_DYN) || !elf_check_arch(interp_elf_ex->e_machine)) {
!elf_check_arch(interp_elf_ex->e_machine)) {
return ~((abi_ulong)0UL); return ~((abi_ulong)0UL);
} }
/* Now read in all of the header information */ /* Now read in all of the header information */
if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE) {
if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE)
return ~(abi_ulong)0UL; return ~(abi_ulong)0UL;
}
elf_phdata = (struct elf_phdr *) elf_phdata = (struct elf_phdr *) malloc(sizeof(struct elf_phdr) *
malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum); interp_elf_ex->e_phnum);
if (!elf_phdata) if (!elf_phdata) {
return ~((abi_ulong)0UL); return ~((abi_ulong)0UL);
}
/* /*
* If the size of this structure has changed, then punt, since * If the size of this structure has changed, then punt, since
@ -309,9 +314,8 @@ static abi_ulong load_elf_interp(struct elfhdr *interp_elf_ex,
retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET); retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
if (retval >= 0) { if (retval >= 0) {
retval = read(interpreter_fd, retval = read(interpreter_fd, (char *) elf_phdata,
(char *) elf_phdata, sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
} }
if (retval < 0) { if (retval < 0) {
perror("load_elf_interp"); perror("load_elf_interp");
@ -322,11 +326,12 @@ static abi_ulong load_elf_interp(struct elfhdr *interp_elf_ex,
bswap_phdr(elf_phdata, interp_elf_ex->e_phnum); bswap_phdr(elf_phdata, interp_elf_ex->e_phnum);
if (interp_elf_ex->e_type == ET_DYN) { if (interp_elf_ex->e_type == ET_DYN) {
/* in order to avoid hardcoding the interpreter load /*
address in qemu, we allocate a big enough memory zone */ * In order to avoid hardcoding the interpreter load
error = target_mmap(0, INTERP_MAP_SIZE, * address in qemu, we allocate a big enough memory zone.
PROT_NONE, MAP_PRIVATE | MAP_ANON, */
-1, 0); error = target_mmap(0, INTERP_MAP_SIZE, PROT_NONE,
MAP_PRIVATE | MAP_ANON, -1, 0);
if (error == -1) { if (error == -1) {
perror("mmap"); perror("mmap");
exit(-1); exit(-1);
@ -430,7 +435,7 @@ static const char *lookup_symbolxx(struct syminfo *s, target_ulong orig_addr)
struct elf_sym *syms = s->disas_symtab.elf64; struct elf_sym *syms = s->disas_symtab.elf64;
#endif #endif
// binary search /* binary search */
struct elf_sym *sym; struct elf_sym *sym;
sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind); sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind);
@ -446,9 +451,8 @@ static int symcmp(const void *s0, const void *s1)
{ {
struct elf_sym *sym0 = (struct elf_sym *)s0; struct elf_sym *sym0 = (struct elf_sym *)s0;
struct elf_sym *sym1 = (struct elf_sym *)s1; struct elf_sym *sym1 = (struct elf_sym *)s1;
return (sym0->st_value < sym1->st_value) return (sym0->st_value < sym1->st_value) ? -1 :
? -1 ((sym0->st_value > sym1->st_value) ? 1 : 0);
: ((sym0->st_value > sym1->st_value) ? 1 : 0);
} }
/* Best attempt to load symbols from this ELF object. */ /* Best attempt to load symbols from this ELF object. */
@ -462,23 +466,24 @@ static void load_symbols(struct elfhdr *hdr, int fd)
lseek(fd, hdr->e_shoff, SEEK_SET); lseek(fd, hdr->e_shoff, SEEK_SET);
for (i = 0; i < hdr->e_shnum; i++) { for (i = 0; i < hdr->e_shnum; i++) {
if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr)) if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr)) {
return; return;
}
bswap_shdr(&sechdr, 1); bswap_shdr(&sechdr, 1);
if (sechdr.sh_type == SHT_SYMTAB) { if (sechdr.sh_type == SHT_SYMTAB) {
symtab = sechdr; symtab = sechdr;
lseek(fd, hdr->e_shoff lseek(fd, hdr->e_shoff + sizeof(sechdr) * sechdr.sh_link,
+ sizeof(sechdr) * sechdr.sh_link, SEEK_SET); SEEK_SET);
if (read(fd, &strtab, sizeof(strtab)) if (read(fd, &strtab, sizeof(strtab)) != sizeof(strtab)) {
!= sizeof(strtab))
return; return;
}
bswap_shdr(&strtab, 1); bswap_shdr(&strtab, 1);
goto found; goto found;
} }
} }
return; /* Shouldn't happen... */ return; /* Shouldn't happen... */
found: found:
/* Now know where the strtab and symtab are. Snarf them. */ /* Now know where the strtab and symtab are. Snarf them. */
s = malloc(sizeof(*s)); s = malloc(sizeof(*s));
syms = malloc(symtab.sh_size); syms = malloc(symtab.sh_size);
@ -506,7 +511,7 @@ static void load_symbols(struct elfhdr *hdr, int fd)
i = 0; i = 0;
while (i < nsyms) { while (i < nsyms) {
bswap_sym(syms + i); bswap_sym(syms + i);
// Throw away entries which we do not need. /* Throw away entries which we do not need. */
if (syms[i].st_shndx == SHN_UNDEF || if (syms[i].st_shndx == SHN_UNDEF ||
syms[i].st_shndx >= SHN_LORESERVE || syms[i].st_shndx >= SHN_LORESERVE ||
ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) { ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) {
@ -519,10 +524,12 @@ static void load_symbols(struct elfhdr *hdr, int fd)
i++; i++;
} }
/* Attempt to free the storage associated with the local symbols /*
that we threw away. Whether or not this has any effect on the * Attempt to free the storage associated with the local symbols
memory allocation depends on the malloc implementation and how * that we threw away. Whether or not this has any effect on the
many symbols we managed to discard. */ * memory allocation depends on the malloc implementation and how
* many symbols we managed to discard.
*/
new_syms = realloc(syms, nsyms * sizeof(*syms)); new_syms = realloc(syms, nsyms * sizeof(*syms));
if (new_syms == NULL) { if (new_syms == NULL) {
free(s); free(s);
@ -578,19 +585,19 @@ int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
/* First of all, some simple consistency checks */ /* First of all, some simple consistency checks */
if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) || if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
(!elf_check_arch(elf_ex.e_machine))) { (!elf_check_arch(elf_ex.e_machine))) {
return -ENOEXEC; return -ENOEXEC;
} }
bprm->p = copy_elf_strings(1, &bprm->filename, bprm->page, bprm->p); bprm->p = copy_elf_strings(1, &bprm->filename, bprm->page, bprm->p);
bprm->p = copy_elf_strings(bprm->envc, bprm->envp, bprm->page,bprm->p); bprm->p = copy_elf_strings(bprm->envc, bprm->envp, bprm->page, bprm->p);
bprm->p = copy_elf_strings(bprm->argc, bprm->argv, bprm->page,bprm->p); bprm->p = copy_elf_strings(bprm->argc, bprm->argv, bprm->page, bprm->p);
if (!bprm->p) { if (!bprm->p) {
retval = -E2BIG; retval = -E2BIG;
} }
/* Now read in all of the header information */ /* Now read in all of the header information */
elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum); elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize * elf_ex.e_phnum);
if (elf_phdata == NULL) { if (elf_phdata == NULL) {
return -ENOMEM; return -ENOMEM;
} }
@ -609,7 +616,6 @@ int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
} }
bswap_phdr(elf_phdata, elf_ex.e_phnum); bswap_phdr(elf_phdata, elf_ex.e_phnum);
elf_ppnt = elf_phdata; elf_ppnt = elf_phdata;
elf_bss = 0; elf_bss = 0;
@ -622,23 +628,16 @@ int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
start_data = 0; start_data = 0;
end_data = 0; end_data = 0;
for (i = 0;i < elf_ex.e_phnum; i++) { for (i = 0; i < elf_ex.e_phnum; i++) {
if (elf_ppnt->p_type == PT_INTERP) { if (elf_ppnt->p_type == PT_INTERP) {
if (elf_interpreter != NULL) if (elf_interpreter != NULL) {
{
free(elf_phdata); free(elf_phdata);
free(elf_interpreter); free(elf_interpreter);
close(bprm->fd); close(bprm->fd);
return -EINVAL; return -EINVAL;
} }
/* This is the program interpreter used for
* shared libraries - for now assume that this
* is an a.out format binary
*/
elf_interpreter = (char *)malloc(elf_ppnt->p_filesz); elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
if (elf_interpreter == NULL) { if (elf_interpreter == NULL) {
free(elf_phdata); free(elf_phdata);
close(bprm->fd); close(bprm->fd);
@ -658,8 +657,7 @@ int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
retval = open(path(elf_interpreter), O_RDONLY); retval = open(path(elf_interpreter), O_RDONLY);
if (retval >= 0) { if (retval >= 0) {
interpreter_fd = retval; interpreter_fd = retval;
} } else {
else {
perror(elf_interpreter); perror(elf_interpreter);
exit(-1); exit(-1);
/* retval = -errno; */ /* retval = -errno; */
@ -673,7 +671,7 @@ int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
} }
} }
if (retval >= 0) { if (retval >= 0) {
interp_elf_ex = *((struct elfhdr *) bprm->buf); /* elf exec-header */ interp_elf_ex = *((struct elfhdr *) bprm->buf);
} }
if (retval < 0) { if (retval < 0) {
perror("load_elf_binary3"); perror("load_elf_binary3");
@ -698,9 +696,10 @@ int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
} }
} }
/* OK, we are done with that, now set up the arg stuff, /*
and then start this sucker up */ * OK, we are done with that, now set up the arg stuff, and then start this
* sucker up
*/
if (!bprm->p) { if (!bprm->p) {
free(elf_interpreter); free(elf_interpreter);
free(elf_phdata); free(elf_phdata);
@ -822,8 +821,9 @@ int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
free(elf_phdata); free(elf_phdata);
if (qemu_log_enabled()) if (qemu_log_enabled()) {
load_symbols(&elf_ex, bprm->fd); load_symbols(&elf_ex, bprm->fd);
}
close(bprm->fd); close(bprm->fd);