835 lines
24 KiB
C
835 lines
24 KiB
C
/*
|
|
* ELF loading code
|
|
*
|
|
* Copyright (c) 2013 Stacey D. Son
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
#include "qemu.h"
|
|
#include "disas/disas.h"
|
|
#include "qemu/path.h"
|
|
|
|
static abi_ulong target_auxents; /* Where the AUX entries are in target */
|
|
static size_t target_auxents_sz; /* Size of AUX entries including AT_NULL */
|
|
|
|
#include "target_arch_reg.h"
|
|
#include "target_os_elf.h"
|
|
#include "target_os_stack.h"
|
|
#include "target_os_thread.h"
|
|
#include "target_os_user.h"
|
|
|
|
abi_ulong target_stksiz;
|
|
abi_ulong target_stkbas;
|
|
|
|
static int elf_core_dump(int signr, CPUArchState *env);
|
|
static int load_elf_sections(const struct elfhdr *hdr, struct elf_phdr *phdr,
|
|
int fd, abi_ulong rbase, abi_ulong *baddrp);
|
|
|
|
static inline void memcpy_fromfs(void *to, const void *from, unsigned long n)
|
|
{
|
|
memcpy(to, from, n);
|
|
}
|
|
|
|
#ifdef BSWAP_NEEDED
|
|
static void bswap_ehdr(struct elfhdr *ehdr)
|
|
{
|
|
bswap16s(&ehdr->e_type); /* Object file type */
|
|
bswap16s(&ehdr->e_machine); /* Architecture */
|
|
bswap32s(&ehdr->e_version); /* Object file version */
|
|
bswaptls(&ehdr->e_entry); /* Entry point virtual address */
|
|
bswaptls(&ehdr->e_phoff); /* Program header table file offset */
|
|
bswaptls(&ehdr->e_shoff); /* Section header table file offset */
|
|
bswap32s(&ehdr->e_flags); /* Processor-specific flags */
|
|
bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
|
|
bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
|
|
bswap16s(&ehdr->e_phnum); /* Program header table entry count */
|
|
bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
|
|
bswap16s(&ehdr->e_shnum); /* Section header table entry count */
|
|
bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
|
|
}
|
|
|
|
static void bswap_phdr(struct elf_phdr *phdr, int phnum)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < phnum; i++, phdr++) {
|
|
bswap32s(&phdr->p_type); /* Segment type */
|
|
bswap32s(&phdr->p_flags); /* Segment flags */
|
|
bswaptls(&phdr->p_offset); /* Segment file offset */
|
|
bswaptls(&phdr->p_vaddr); /* Segment virtual address */
|
|
bswaptls(&phdr->p_paddr); /* Segment physical address */
|
|
bswaptls(&phdr->p_filesz); /* Segment size in file */
|
|
bswaptls(&phdr->p_memsz); /* Segment size in memory */
|
|
bswaptls(&phdr->p_align); /* Segment alignment */
|
|
}
|
|
}
|
|
|
|
static void bswap_shdr(struct elf_shdr *shdr, int shnum)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < shnum; i++, shdr++) {
|
|
bswap32s(&shdr->sh_name);
|
|
bswap32s(&shdr->sh_type);
|
|
bswaptls(&shdr->sh_flags);
|
|
bswaptls(&shdr->sh_addr);
|
|
bswaptls(&shdr->sh_offset);
|
|
bswaptls(&shdr->sh_size);
|
|
bswap32s(&shdr->sh_link);
|
|
bswap32s(&shdr->sh_info);
|
|
bswaptls(&shdr->sh_addralign);
|
|
bswaptls(&shdr->sh_entsize);
|
|
}
|
|
}
|
|
|
|
static void bswap_sym(struct elf_sym *sym)
|
|
{
|
|
bswap32s(&sym->st_name);
|
|
bswaptls(&sym->st_value);
|
|
bswaptls(&sym->st_size);
|
|
bswap16s(&sym->st_shndx);
|
|
}
|
|
|
|
static void bswap_note(struct elf_note *en)
|
|
{
|
|
bswap32s(&en->n_namesz);
|
|
bswap32s(&en->n_descsz);
|
|
bswap32s(&en->n_type);
|
|
}
|
|
|
|
#else /* ! BSWAP_NEEDED */
|
|
|
|
static void bswap_ehdr(struct elfhdr *ehdr) { }
|
|
static void bswap_phdr(struct elf_phdr *phdr, int phnum) { }
|
|
static void bswap_shdr(struct elf_shdr *shdr, int shnum) { }
|
|
static void bswap_sym(struct elf_sym *sym) { }
|
|
static void bswap_note(struct elf_note *en) { }
|
|
|
|
#endif /* ! BSWAP_NEEDED */
|
|
|
|
#include "elfcore.c"
|
|
|
|
/*
|
|
* 'copy_elf_strings()' copies argument/envelope strings from user
|
|
* memory to free pages in kernel mem. These are in a format ready
|
|
* to be put directly into the top of new user memory.
|
|
*
|
|
*/
|
|
static abi_ulong copy_elf_strings(int argc, char **argv, void **page,
|
|
abi_ulong p)
|
|
{
|
|
char *tmp, *tmp1, *pag = NULL;
|
|
int len, offset = 0;
|
|
|
|
if (!p) {
|
|
return 0; /* bullet-proofing */
|
|
}
|
|
while (argc-- > 0) {
|
|
tmp = argv[argc];
|
|
if (!tmp) {
|
|
fprintf(stderr, "VFS: argc is wrong");
|
|
exit(-1);
|
|
}
|
|
tmp1 = tmp;
|
|
while (*tmp++) {
|
|
continue;
|
|
}
|
|
len = tmp - tmp1;
|
|
if (p < len) { /* this shouldn't happen - 128kB */
|
|
return 0;
|
|
}
|
|
while (len) {
|
|
--p; --tmp; --len;
|
|
if (--offset < 0) {
|
|
offset = p % TARGET_PAGE_SIZE;
|
|
pag = (char *)page[p / TARGET_PAGE_SIZE];
|
|
if (!pag) {
|
|
pag = g_try_malloc0(TARGET_PAGE_SIZE);
|
|
page[p / TARGET_PAGE_SIZE] = pag;
|
|
if (!pag) {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
if (len == 0 || offset == 0) {
|
|
*(pag + offset) = *tmp;
|
|
} else {
|
|
int bytes_to_copy = (len > offset) ? offset : len;
|
|
tmp -= bytes_to_copy;
|
|
p -= bytes_to_copy;
|
|
offset -= bytes_to_copy;
|
|
len -= bytes_to_copy;
|
|
memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
|
|
}
|
|
}
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static void setup_arg_pages(struct bsd_binprm *bprm, struct image_info *info,
|
|
abi_ulong *stackp, abi_ulong *stringp)
|
|
{
|
|
abi_ulong stack_base, size;
|
|
abi_long addr;
|
|
|
|
/*
|
|
* Create enough stack to hold everything. If we don't use it for args,
|
|
* we'll use it for something else...
|
|
*/
|
|
size = target_dflssiz;
|
|
stack_base = TARGET_USRSTACK - size;
|
|
addr = target_mmap(stack_base , size + qemu_host_page_size,
|
|
PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
if (addr == -1) {
|
|
perror("stk mmap");
|
|
exit(-1);
|
|
}
|
|
/* we reserve one extra page at the top of the stack as guard */
|
|
target_mprotect(addr + size, qemu_host_page_size, PROT_NONE);
|
|
|
|
target_stksiz = size;
|
|
target_stkbas = addr;
|
|
|
|
if (setup_initial_stack(bprm, stackp, stringp) != 0) {
|
|
perror("stk setup");
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
static void set_brk(abi_ulong start, abi_ulong end)
|
|
{
|
|
/* page-align the start and end addresses... */
|
|
start = HOST_PAGE_ALIGN(start);
|
|
end = HOST_PAGE_ALIGN(end);
|
|
if (end <= start) {
|
|
return;
|
|
}
|
|
if (target_mmap(start, end - start, PROT_READ | PROT_WRITE | PROT_EXEC,
|
|
MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0) == -1) {
|
|
perror("cannot mmap brk");
|
|
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
|
|
* should not be in memory.
|
|
*/
|
|
static void padzero(abi_ulong elf_bss, abi_ulong last_bss)
|
|
{
|
|
abi_ulong nbyte;
|
|
|
|
if (elf_bss >= last_bss) {
|
|
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
|
|
* of the file may not be mapped. A better fix would be to
|
|
* patch target_mmap(), but it is more complicated as the file
|
|
* size must be known.
|
|
*/
|
|
if (qemu_real_host_page_size < qemu_host_page_size) {
|
|
abi_ulong end_addr, end_addr1;
|
|
end_addr1 = REAL_HOST_PAGE_ALIGN(elf_bss);
|
|
end_addr = HOST_PAGE_ALIGN(elf_bss);
|
|
if (end_addr1 < end_addr) {
|
|
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);
|
|
if (nbyte) {
|
|
nbyte = qemu_host_page_size - nbyte;
|
|
do {
|
|
/* FIXME - what to do if put_user() fails? */
|
|
put_user_u8(0, elf_bss);
|
|
elf_bss++;
|
|
} while (--nbyte);
|
|
}
|
|
}
|
|
|
|
static abi_ulong load_elf_interp(struct elfhdr *interp_elf_ex,
|
|
int interpreter_fd,
|
|
abi_ulong *interp_load_addr)
|
|
{
|
|
struct elf_phdr *elf_phdata = NULL;
|
|
abi_ulong rbase;
|
|
int retval;
|
|
abi_ulong baddr, error;
|
|
|
|
error = 0;
|
|
|
|
bswap_ehdr(interp_elf_ex);
|
|
/* First of all, some simple consistency checks */
|
|
if ((interp_elf_ex->e_type != ET_EXEC && interp_elf_ex->e_type != ET_DYN) ||
|
|
!elf_check_arch(interp_elf_ex->e_machine)) {
|
|
return ~((abi_ulong)0UL);
|
|
}
|
|
|
|
|
|
/* Now read in all of the header information */
|
|
if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE) {
|
|
return ~(abi_ulong)0UL;
|
|
}
|
|
|
|
elf_phdata = (struct elf_phdr *) malloc(sizeof(struct elf_phdr) *
|
|
interp_elf_ex->e_phnum);
|
|
|
|
if (!elf_phdata) {
|
|
return ~((abi_ulong)0UL);
|
|
}
|
|
|
|
/*
|
|
* If the size of this structure has changed, then punt, since
|
|
* we will be doing the wrong thing.
|
|
*/
|
|
if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) {
|
|
free(elf_phdata);
|
|
return ~((abi_ulong)0UL);
|
|
}
|
|
|
|
retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
|
|
if (retval >= 0) {
|
|
retval = read(interpreter_fd, (char *) elf_phdata,
|
|
sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
|
|
}
|
|
if (retval < 0) {
|
|
perror("load_elf_interp");
|
|
exit(-1);
|
|
free(elf_phdata);
|
|
return retval;
|
|
}
|
|
bswap_phdr(elf_phdata, interp_elf_ex->e_phnum);
|
|
|
|
rbase = 0;
|
|
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.
|
|
*/
|
|
rbase = target_mmap(0, INTERP_MAP_SIZE, PROT_NONE,
|
|
MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
if (rbase == -1) {
|
|
perror("mmap");
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
error = load_elf_sections(interp_elf_ex, elf_phdata, interpreter_fd, rbase,
|
|
&baddr);
|
|
if (error != 0) {
|
|
perror("load_elf_sections");
|
|
exit(-1);
|
|
}
|
|
|
|
/* Now use mmap to map the library into memory. */
|
|
close(interpreter_fd);
|
|
free(elf_phdata);
|
|
|
|
*interp_load_addr = baddr;
|
|
return ((abi_ulong) interp_elf_ex->e_entry) + rbase;
|
|
}
|
|
|
|
static int symfind(const void *s0, const void *s1)
|
|
{
|
|
target_ulong addr = *(target_ulong *)s0;
|
|
struct elf_sym *sym = (struct elf_sym *)s1;
|
|
int result = 0;
|
|
if (addr < sym->st_value) {
|
|
result = -1;
|
|
} else if (addr >= sym->st_value + sym->st_size) {
|
|
result = 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static const char *lookup_symbolxx(struct syminfo *s, target_ulong orig_addr)
|
|
{
|
|
#if ELF_CLASS == ELFCLASS32
|
|
struct elf_sym *syms = s->disas_symtab.elf32;
|
|
#else
|
|
struct elf_sym *syms = s->disas_symtab.elf64;
|
|
#endif
|
|
|
|
/* binary search */
|
|
struct elf_sym *sym;
|
|
|
|
sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind);
|
|
if (sym != NULL) {
|
|
return s->disas_strtab + sym->st_name;
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
/* FIXME: This should use elf_ops.h */
|
|
static int symcmp(const void *s0, const void *s1)
|
|
{
|
|
struct elf_sym *sym0 = (struct elf_sym *)s0;
|
|
struct elf_sym *sym1 = (struct elf_sym *)s1;
|
|
return (sym0->st_value < sym1->st_value) ? -1 :
|
|
((sym0->st_value > sym1->st_value) ? 1 : 0);
|
|
}
|
|
|
|
/* Best attempt to load symbols from this ELF object. */
|
|
static void load_symbols(struct elfhdr *hdr, int fd)
|
|
{
|
|
unsigned int i, nsyms;
|
|
struct elf_shdr sechdr, symtab, strtab;
|
|
char *strings;
|
|
struct syminfo *s;
|
|
struct elf_sym *syms, *new_syms;
|
|
|
|
lseek(fd, hdr->e_shoff, SEEK_SET);
|
|
for (i = 0; i < hdr->e_shnum; i++) {
|
|
if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr)) {
|
|
return;
|
|
}
|
|
bswap_shdr(&sechdr, 1);
|
|
if (sechdr.sh_type == SHT_SYMTAB) {
|
|
symtab = sechdr;
|
|
lseek(fd, hdr->e_shoff + sizeof(sechdr) * sechdr.sh_link,
|
|
SEEK_SET);
|
|
if (read(fd, &strtab, sizeof(strtab)) != sizeof(strtab)) {
|
|
return;
|
|
}
|
|
bswap_shdr(&strtab, 1);
|
|
goto found;
|
|
}
|
|
}
|
|
return; /* Shouldn't happen... */
|
|
|
|
found:
|
|
/* Now know where the strtab and symtab are. Snarf them. */
|
|
s = malloc(sizeof(*s));
|
|
syms = malloc(symtab.sh_size);
|
|
if (!syms) {
|
|
free(s);
|
|
return;
|
|
}
|
|
s->disas_strtab = strings = malloc(strtab.sh_size);
|
|
if (!s->disas_strtab) {
|
|
free(s);
|
|
free(syms);
|
|
return;
|
|
}
|
|
|
|
lseek(fd, symtab.sh_offset, SEEK_SET);
|
|
if (read(fd, syms, symtab.sh_size) != symtab.sh_size) {
|
|
free(s);
|
|
free(syms);
|
|
free(strings);
|
|
return;
|
|
}
|
|
|
|
nsyms = symtab.sh_size / sizeof(struct elf_sym);
|
|
|
|
i = 0;
|
|
while (i < nsyms) {
|
|
bswap_sym(syms + i);
|
|
/* Throw away entries which we do not need. */
|
|
if (syms[i].st_shndx == SHN_UNDEF ||
|
|
syms[i].st_shndx >= SHN_LORESERVE ||
|
|
ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) {
|
|
nsyms--;
|
|
if (i < nsyms) {
|
|
syms[i] = syms[nsyms];
|
|
}
|
|
continue;
|
|
}
|
|
#if defined(TARGET_ARM) || defined(TARGET_MIPS)
|
|
/* The bottom address bit marks a Thumb or MIPS16 symbol. */
|
|
syms[i].st_value &= ~(target_ulong)1;
|
|
#endif
|
|
i++;
|
|
}
|
|
|
|
/*
|
|
* Attempt to free the storage associated with the local symbols
|
|
* that we threw away. Whether or not this has any effect on the
|
|
* memory allocation depends on the malloc implementation and how
|
|
* many symbols we managed to discard.
|
|
*/
|
|
new_syms = realloc(syms, nsyms * sizeof(*syms));
|
|
if (new_syms == NULL) {
|
|
free(s);
|
|
free(syms);
|
|
free(strings);
|
|
return;
|
|
}
|
|
syms = new_syms;
|
|
|
|
qsort(syms, nsyms, sizeof(*syms), symcmp);
|
|
|
|
lseek(fd, strtab.sh_offset, SEEK_SET);
|
|
if (read(fd, strings, strtab.sh_size) != strtab.sh_size) {
|
|
free(s);
|
|
free(syms);
|
|
free(strings);
|
|
return;
|
|
}
|
|
s->disas_num_syms = nsyms;
|
|
#if ELF_CLASS == ELFCLASS32
|
|
s->disas_symtab.elf32 = syms;
|
|
s->lookup_symbol = (lookup_symbol_t)lookup_symbolxx;
|
|
#else
|
|
s->disas_symtab.elf64 = syms;
|
|
s->lookup_symbol = (lookup_symbol_t)lookup_symbolxx;
|
|
#endif
|
|
s->next = syminfos;
|
|
syminfos = s;
|
|
}
|
|
|
|
/* Check the elf header and see if this a target elf binary. */
|
|
int is_target_elf_binary(int fd)
|
|
{
|
|
uint8_t buf[128];
|
|
struct elfhdr elf_ex;
|
|
|
|
if (lseek(fd, 0L, SEEK_SET) < 0) {
|
|
return 0;
|
|
}
|
|
if (read(fd, buf, sizeof(buf)) < 0) {
|
|
return 0;
|
|
}
|
|
|
|
elf_ex = *((struct elfhdr *)buf);
|
|
bswap_ehdr(&elf_ex);
|
|
|
|
if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
|
|
(!elf_check_arch(elf_ex.e_machine))) {
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static int
|
|
load_elf_sections(const struct elfhdr *hdr, struct elf_phdr *phdr, int fd,
|
|
abi_ulong rbase, abi_ulong *baddrp)
|
|
{
|
|
struct elf_phdr *elf_ppnt;
|
|
abi_ulong baddr;
|
|
int i;
|
|
bool first;
|
|
|
|
/*
|
|
* Now we do a little grungy work by mmaping the ELF image into
|
|
* the correct location in memory. At this point, we assume that
|
|
* the image should be loaded at fixed address, not at a variable
|
|
* address.
|
|
*/
|
|
first = true;
|
|
for (i = 0, elf_ppnt = phdr; i < hdr->e_phnum; i++, elf_ppnt++) {
|
|
int elf_prot = 0;
|
|
abi_ulong error;
|
|
|
|
/* XXX Skip memsz == 0. */
|
|
if (elf_ppnt->p_type != PT_LOAD) {
|
|
continue;
|
|
}
|
|
|
|
if (elf_ppnt->p_flags & PF_R) {
|
|
elf_prot |= PROT_READ;
|
|
}
|
|
if (elf_ppnt->p_flags & PF_W) {
|
|
elf_prot |= PROT_WRITE;
|
|
}
|
|
if (elf_ppnt->p_flags & PF_X) {
|
|
elf_prot |= PROT_EXEC;
|
|
}
|
|
|
|
error = target_mmap(TARGET_ELF_PAGESTART(rbase + elf_ppnt->p_vaddr),
|
|
(elf_ppnt->p_filesz +
|
|
TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
|
|
elf_prot,
|
|
(MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),
|
|
fd,
|
|
(elf_ppnt->p_offset -
|
|
TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
|
|
if (error == -1) {
|
|
perror("mmap");
|
|
exit(-1);
|
|
} else if (elf_ppnt->p_memsz != elf_ppnt->p_filesz) {
|
|
abi_ulong start_bss, end_bss;
|
|
|
|
start_bss = rbase + elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
|
|
end_bss = rbase + elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
|
|
|
|
/*
|
|
* Calling set_brk effectively mmaps the pages that we need for the
|
|
* bss and break sections.
|
|
*/
|
|
set_brk(start_bss, end_bss);
|
|
padzero(start_bss, end_bss);
|
|
}
|
|
|
|
if (first) {
|
|
baddr = TARGET_ELF_PAGESTART(rbase + elf_ppnt->p_vaddr);
|
|
first = false;
|
|
}
|
|
}
|
|
|
|
if (baddrp != NULL) {
|
|
*baddrp = baddr;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
|
|
struct image_info *info)
|
|
{
|
|
struct elfhdr elf_ex;
|
|
struct elfhdr interp_elf_ex;
|
|
int interpreter_fd = -1; /* avoid warning */
|
|
abi_ulong load_addr;
|
|
int i;
|
|
struct elf_phdr *elf_ppnt;
|
|
struct elf_phdr *elf_phdata;
|
|
abi_ulong elf_brk;
|
|
int error, retval;
|
|
char *elf_interpreter;
|
|
abi_ulong baddr, elf_entry, et_dyn_addr, interp_load_addr = 0;
|
|
abi_ulong reloc_func_desc = 0;
|
|
|
|
load_addr = 0;
|
|
elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
|
|
bswap_ehdr(&elf_ex);
|
|
|
|
/* First of all, some simple consistency checks */
|
|
if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
|
|
(!elf_check_arch(elf_ex.e_machine))) {
|
|
return -ENOEXEC;
|
|
}
|
|
|
|
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->argc, bprm->argv, bprm->page, bprm->p);
|
|
if (!bprm->p) {
|
|
retval = -E2BIG;
|
|
}
|
|
|
|
/* Now read in all of the header information */
|
|
elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize * elf_ex.e_phnum);
|
|
if (elf_phdata == NULL) {
|
|
return -ENOMEM;
|
|
}
|
|
|
|
retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);
|
|
if (retval > 0) {
|
|
retval = read(bprm->fd, (char *)elf_phdata,
|
|
elf_ex.e_phentsize * elf_ex.e_phnum);
|
|
}
|
|
|
|
if (retval < 0) {
|
|
perror("load_elf_binary");
|
|
exit(-1);
|
|
free(elf_phdata);
|
|
return -errno;
|
|
}
|
|
|
|
bswap_phdr(elf_phdata, elf_ex.e_phnum);
|
|
elf_ppnt = elf_phdata;
|
|
|
|
elf_brk = 0;
|
|
|
|
|
|
elf_interpreter = NULL;
|
|
for (i = 0; i < elf_ex.e_phnum; i++) {
|
|
if (elf_ppnt->p_type == PT_INTERP) {
|
|
if (elf_interpreter != NULL) {
|
|
free(elf_phdata);
|
|
free(elf_interpreter);
|
|
close(bprm->fd);
|
|
return -EINVAL;
|
|
}
|
|
|
|
elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
|
|
if (elf_interpreter == NULL) {
|
|
free(elf_phdata);
|
|
close(bprm->fd);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);
|
|
if (retval >= 0) {
|
|
retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);
|
|
}
|
|
if (retval < 0) {
|
|
perror("load_elf_binary2");
|
|
exit(-1);
|
|
}
|
|
|
|
if (retval >= 0) {
|
|
retval = open(path(elf_interpreter), O_RDONLY);
|
|
if (retval >= 0) {
|
|
interpreter_fd = retval;
|
|
} else {
|
|
perror(elf_interpreter);
|
|
exit(-1);
|
|
/* retval = -errno; */
|
|
}
|
|
}
|
|
|
|
if (retval >= 0) {
|
|
retval = lseek(interpreter_fd, 0, SEEK_SET);
|
|
if (retval >= 0) {
|
|
retval = read(interpreter_fd, bprm->buf, 128);
|
|
}
|
|
}
|
|
if (retval >= 0) {
|
|
interp_elf_ex = *((struct elfhdr *) bprm->buf);
|
|
}
|
|
if (retval < 0) {
|
|
perror("load_elf_binary3");
|
|
exit(-1);
|
|
free(elf_phdata);
|
|
free(elf_interpreter);
|
|
close(bprm->fd);
|
|
return retval;
|
|
}
|
|
}
|
|
elf_ppnt++;
|
|
}
|
|
|
|
/* Some simple consistency checks for the interpreter */
|
|
if (elf_interpreter) {
|
|
if (interp_elf_ex.e_ident[0] != 0x7f ||
|
|
strncmp((char *)&interp_elf_ex.e_ident[1], "ELF", 3) != 0) {
|
|
free(elf_interpreter);
|
|
free(elf_phdata);
|
|
close(bprm->fd);
|
|
return -ELIBBAD;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* OK, we are done with that, now set up the arg stuff, and then start this
|
|
* sucker up
|
|
*/
|
|
if (!bprm->p) {
|
|
free(elf_interpreter);
|
|
free(elf_phdata);
|
|
close(bprm->fd);
|
|
return -E2BIG;
|
|
}
|
|
|
|
/* OK, This is the point of no return */
|
|
info->end_data = 0;
|
|
info->end_code = 0;
|
|
info->start_mmap = (abi_ulong)ELF_START_MMAP;
|
|
info->mmap = 0;
|
|
elf_entry = (abi_ulong) elf_ex.e_entry;
|
|
|
|
/* XXX Join this with PT_INTERP search? */
|
|
baddr = 0;
|
|
for (i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
|
|
if (elf_ppnt->p_type != PT_LOAD) {
|
|
continue;
|
|
}
|
|
baddr = elf_ppnt->p_vaddr;
|
|
break;
|
|
}
|
|
|
|
et_dyn_addr = 0;
|
|
if (elf_ex.e_type == ET_DYN && baddr == 0) {
|
|
et_dyn_addr = ELF_ET_DYN_LOAD_ADDR;
|
|
}
|
|
|
|
/*
|
|
* Do this so that we can load the interpreter, if need be. We will
|
|
* change some of these later
|
|
*/
|
|
info->rss = 0;
|
|
setup_arg_pages(bprm, info, &bprm->p, &bprm->stringp);
|
|
info->start_stack = bprm->p;
|
|
|
|
info->elf_flags = elf_ex.e_flags;
|
|
|
|
error = load_elf_sections(&elf_ex, elf_phdata, bprm->fd, et_dyn_addr,
|
|
&load_addr);
|
|
for (i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
|
|
if (elf_ppnt->p_type != PT_LOAD) {
|
|
continue;
|
|
}
|
|
if (elf_ppnt->p_memsz > elf_ppnt->p_filesz)
|
|
elf_brk = MAX(elf_brk, et_dyn_addr + elf_ppnt->p_vaddr +
|
|
elf_ppnt->p_memsz);
|
|
}
|
|
if (error != 0) {
|
|
perror("load_elf_sections");
|
|
exit(-1);
|
|
}
|
|
|
|
if (elf_interpreter) {
|
|
elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,
|
|
&interp_load_addr);
|
|
reloc_func_desc = interp_load_addr;
|
|
|
|
close(interpreter_fd);
|
|
free(elf_interpreter);
|
|
|
|
if (elf_entry == ~((abi_ulong)0UL)) {
|
|
printf("Unable to load interpreter\n");
|
|
free(elf_phdata);
|
|
exit(-1);
|
|
return 0;
|
|
}
|
|
} else {
|
|
interp_load_addr = et_dyn_addr;
|
|
elf_entry += interp_load_addr;
|
|
}
|
|
|
|
free(elf_phdata);
|
|
|
|
if (qemu_log_enabled()) {
|
|
load_symbols(&elf_ex, bprm->fd);
|
|
}
|
|
|
|
close(bprm->fd);
|
|
|
|
bprm->p = target_create_elf_tables(bprm->p, bprm->argc, bprm->envc,
|
|
bprm->stringp, &elf_ex, load_addr,
|
|
et_dyn_addr, interp_load_addr, info);
|
|
info->load_addr = reloc_func_desc;
|
|
info->start_brk = info->brk = elf_brk;
|
|
info->start_stack = bprm->p;
|
|
info->load_bias = 0;
|
|
|
|
info->entry = elf_entry;
|
|
|
|
#ifdef USE_ELF_CORE_DUMP
|
|
bprm->core_dump = &elf_core_dump;
|
|
#else
|
|
bprm->core_dump = NULL;
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
|
|
{
|
|
|
|
target_thread_init(regs, infop);
|
|
}
|