1 /* This is the Linux kernel elf-loading code, ported into user space */
18 #define ELF_START_MMAP 0x80000000
21 * This is used to ensure we don't load something for the wrong architecture.
23 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
26 * These are used to set parameters in the core dumps.
28 #define ELF_CLASS ELFCLASS32
29 #define ELF_DATA ELFDATA2LSB
30 #define ELF_ARCH EM_386
32 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
33 starts %edx contains a pointer to a function which might be
34 registered using `atexit'. This provides a mean for the
35 dynamic linker to call DT_FINI functions for shared libraries
36 that have been loaded before the code runs.
38 A value of 0 tells we have no such handler. */
39 #define ELF_PLAT_INIT(_r) _r->edx = 0
41 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
43 regs->esp = infop->start_stack;
44 regs->eip = infop->entry;
47 #define USE_ELF_CORE_DUMP
48 #define ELF_EXEC_PAGESIZE 4096
54 #define ELF_START_MMAP 0x80000000
56 #define elf_check_arch(x) ( (x) == EM_ARM )
58 #define ELF_CLASS ELFCLASS32
59 #ifdef TARGET_WORDS_BIGENDIAN
60 #define ELF_DATA ELFDATA2MSB
62 #define ELF_DATA ELFDATA2LSB
64 #define ELF_ARCH EM_ARM
66 #define ELF_PLAT_INIT(_r) _r->ARM_r0 = 0
68 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
70 target_long *stack = (void *)infop->start_stack;
71 memset(regs, 0, sizeof(*regs));
72 regs->ARM_cpsr = 0x10;
73 regs->ARM_pc = infop->entry;
74 regs->ARM_sp = infop->start_stack;
75 regs->ARM_r2 = tswapl(stack[2]); /* envp */
76 regs->ARM_r1 = tswapl(stack[1]); /* argv */
77 /* XXX: it seems that r0 is zeroed after ! */
78 // regs->ARM_r0 = tswapl(stack[0]); /* argc */
81 #define USE_ELF_CORE_DUMP
82 #define ELF_EXEC_PAGESIZE 4096
88 #define ELF_START_MMAP 0x80000000
90 #define elf_check_arch(x) ( (x) == EM_SPARC )
92 #define ELF_CLASS ELFCLASS32
93 #define ELF_DATA ELFDATA2MSB
94 #define ELF_ARCH EM_SPARC
97 #define ELF_PLAT_INIT(_r)
99 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
102 regs->pc = infop->entry;
103 regs->npc = regs->pc + 4;
105 regs->u_regs[14] = infop->start_stack - 16 * 4;
112 #define ELF_START_MMAP 0x80000000
114 #define elf_check_arch(x) ( (x) == EM_PPC )
116 #define ELF_CLASS ELFCLASS32
117 #ifdef TARGET_WORDS_BIGENDIAN
118 #define ELF_DATA ELFDATA2MSB
120 #define ELF_DATA ELFDATA2LSB
122 #define ELF_ARCH EM_PPC
124 /* Note that isn't exactly what regular kernel does
125 * but this is what the ABI wants and is needed to allow
126 * execution of PPC BSD programs.
128 #define ELF_PLAT_INIT(_r) \
130 target_ulong *pos = (target_ulong *)bprm->p, tmp = 1; \
131 _r->gpr[3] = bprm->argc; \
132 _r->gpr[4] = (unsigned long)++pos; \
133 for (; tmp != 0; pos++) \
135 _r->gpr[5] = (unsigned long)pos; \
139 * We need to put in some extra aux table entries to tell glibc what
140 * the cache block size is, so it can use the dcbz instruction safely.
142 #define AT_DCACHEBSIZE 19
143 #define AT_ICACHEBSIZE 20
144 #define AT_UCACHEBSIZE 21
145 /* A special ignored type value for PPC, for glibc compatibility. */
146 #define AT_IGNOREPPC 22
148 * The requirements here are:
149 * - keep the final alignment of sp (sp & 0xf)
150 * - make sure the 32-bit value at the first 16 byte aligned position of
151 * AUXV is greater than 16 for glibc compatibility.
152 * AT_IGNOREPPC is used for that.
153 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
154 * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
156 #define DLINFO_ARCH_ITEMS 3
157 #define ARCH_DLINFO \
159 sp -= DLINFO_ARCH_ITEMS * 2; \
160 NEW_AUX_ENT(0, AT_DCACHEBSIZE, 0x20); \
161 NEW_AUX_ENT(1, AT_ICACHEBSIZE, 0x20); \
162 NEW_AUX_ENT(2, AT_UCACHEBSIZE, 0); \
164 * Now handle glibc compatibility. \
167 NEW_AUX_ENT(0, AT_IGNOREPPC, AT_IGNOREPPC); \
168 NEW_AUX_ENT(1, AT_IGNOREPPC, AT_IGNOREPPC); \
171 static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
173 _regs->msr = 1 << MSR_PR; /* Set user mode */
174 _regs->gpr[1] = infop->start_stack;
175 _regs->nip = infop->entry;
178 #define USE_ELF_CORE_DUMP
179 #define ELF_EXEC_PAGESIZE 4096
186 * MAX_ARG_PAGES defines the number of pages allocated for arguments
187 * and envelope for the new program. 32 should suffice, this gives
188 * a maximum env+arg of 128kB w/4KB pages!
190 #define MAX_ARG_PAGES 32
193 * This structure is used to hold the arguments that are
194 * used when loading binaries.
196 struct linux_binprm {
198 unsigned long page[MAX_ARG_PAGES];
204 char * filename; /* Name of binary */
205 unsigned long loader, exec;
206 int dont_iput; /* binfmt handler has put inode */
211 unsigned int a_info; /* Use macros N_MAGIC, etc for access */
212 unsigned int a_text; /* length of text, in bytes */
213 unsigned int a_data; /* length of data, in bytes */
214 unsigned int a_bss; /* length of uninitialized data area, in bytes */
215 unsigned int a_syms; /* length of symbol table data in file, in bytes */
216 unsigned int a_entry; /* start address */
217 unsigned int a_trsize; /* length of relocation info for text, in bytes */
218 unsigned int a_drsize; /* length of relocation info for data, in bytes */
222 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
228 /* max code+data+bss space allocated to elf interpreter */
229 #define INTERP_MAP_SIZE (32 * 1024 * 1024)
231 /* max code+data+bss+brk space allocated to ET_DYN executables */
232 #define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
234 /* from personality.h */
236 /* Flags for bug emulation. These occupy the top three bytes. */
237 #define STICKY_TIMEOUTS 0x4000000
238 #define WHOLE_SECONDS 0x2000000
240 /* Personality types. These go in the low byte. Avoid using the top bit,
241 * it will conflict with error returns.
243 #define PER_MASK (0x00ff)
244 #define PER_LINUX (0x0000)
245 #define PER_SVR4 (0x0001 | STICKY_TIMEOUTS)
246 #define PER_SVR3 (0x0002 | STICKY_TIMEOUTS)
247 #define PER_SCOSVR3 (0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS)
248 #define PER_WYSEV386 (0x0004 | STICKY_TIMEOUTS)
249 #define PER_ISCR4 (0x0005 | STICKY_TIMEOUTS)
250 #define PER_BSD (0x0006)
251 #define PER_XENIX (0x0007 | STICKY_TIMEOUTS)
253 /* Necessary parameters */
256 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
257 #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
258 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
260 #define INTERPRETER_NONE 0
261 #define INTERPRETER_AOUT 1
262 #define INTERPRETER_ELF 2
264 #define DLINFO_ITEMS 11
266 static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
271 extern unsigned long x86_stack_size;
273 static int load_aout_interp(void * exptr, int interp_fd);
276 static void bswap_ehdr(Elf32_Ehdr *ehdr)
278 bswap16s(&ehdr->e_type); /* Object file type */
279 bswap16s(&ehdr->e_machine); /* Architecture */
280 bswap32s(&ehdr->e_version); /* Object file version */
281 bswap32s(&ehdr->e_entry); /* Entry point virtual address */
282 bswap32s(&ehdr->e_phoff); /* Program header table file offset */
283 bswap32s(&ehdr->e_shoff); /* Section header table file offset */
284 bswap32s(&ehdr->e_flags); /* Processor-specific flags */
285 bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
286 bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
287 bswap16s(&ehdr->e_phnum); /* Program header table entry count */
288 bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
289 bswap16s(&ehdr->e_shnum); /* Section header table entry count */
290 bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
293 static void bswap_phdr(Elf32_Phdr *phdr)
295 bswap32s(&phdr->p_type); /* Segment type */
296 bswap32s(&phdr->p_offset); /* Segment file offset */
297 bswap32s(&phdr->p_vaddr); /* Segment virtual address */
298 bswap32s(&phdr->p_paddr); /* Segment physical address */
299 bswap32s(&phdr->p_filesz); /* Segment size in file */
300 bswap32s(&phdr->p_memsz); /* Segment size in memory */
301 bswap32s(&phdr->p_flags); /* Segment flags */
302 bswap32s(&phdr->p_align); /* Segment alignment */
305 static void bswap_shdr(Elf32_Shdr *shdr)
307 bswap32s(&shdr->sh_name);
308 bswap32s(&shdr->sh_type);
309 bswap32s(&shdr->sh_flags);
310 bswap32s(&shdr->sh_addr);
311 bswap32s(&shdr->sh_offset);
312 bswap32s(&shdr->sh_size);
313 bswap32s(&shdr->sh_link);
314 bswap32s(&shdr->sh_info);
315 bswap32s(&shdr->sh_addralign);
316 bswap32s(&shdr->sh_entsize);
319 static void bswap_sym(Elf32_Sym *sym)
321 bswap32s(&sym->st_name);
322 bswap32s(&sym->st_value);
323 bswap32s(&sym->st_size);
324 bswap16s(&sym->st_shndx);
328 static void * get_free_page(void)
332 /* User-space version of kernel get_free_page. Returns a page-aligned
333 * page-sized chunk of memory.
335 retval = (void *)target_mmap(0, host_page_size, PROT_READ|PROT_WRITE,
336 MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
338 if((long)retval == -1) {
339 perror("get_free_page");
347 static void free_page(void * pageaddr)
349 target_munmap((unsigned long)pageaddr, host_page_size);
353 * 'copy_string()' copies argument/envelope strings from user
354 * memory to free pages in kernel mem. These are in a format ready
355 * to be put directly into the top of new user memory.
358 static unsigned long copy_strings(int argc,char ** argv,unsigned long *page,
361 char *tmp, *tmp1, *pag = NULL;
365 return 0; /* bullet-proofing */
370 fprintf(stderr, "VFS: argc is wrong");
376 if (p < len) { /* this shouldn't happen - 128kB */
382 offset = p % TARGET_PAGE_SIZE;
383 pag = (char *) page[p/TARGET_PAGE_SIZE];
385 pag = (char *)get_free_page();
386 page[p/TARGET_PAGE_SIZE] = (unsigned long)pag;
391 if (len == 0 || offset == 0) {
392 *(pag + offset) = *tmp;
395 int bytes_to_copy = (len > offset) ? offset : len;
396 tmp -= bytes_to_copy;
398 offset -= bytes_to_copy;
399 len -= bytes_to_copy;
400 memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
407 static int in_group_p(gid_t g)
409 /* return TRUE if we're in the specified group, FALSE otherwise */
412 gid_t grouplist[NGROUPS];
414 ngroup = getgroups(NGROUPS, grouplist);
415 for(i = 0; i < ngroup; i++) {
416 if(grouplist[i] == g) {
423 static int count(char ** vec)
427 for(i = 0; *vec; i++) {
434 static int prepare_binprm(struct linux_binprm *bprm)
438 int retval, id_change;
440 if(fstat(bprm->fd, &st) < 0) {
445 if(!S_ISREG(mode)) { /* Must be regular file */
448 if(!(mode & 0111)) { /* Must have at least one execute bit set */
452 bprm->e_uid = geteuid();
453 bprm->e_gid = getegid();
458 bprm->e_uid = st.st_uid;
459 if(bprm->e_uid != geteuid()) {
466 * If setgid is set but no group execute bit then this
467 * is a candidate for mandatory locking, not a setgid
470 if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
471 bprm->e_gid = st.st_gid;
472 if (!in_group_p(bprm->e_gid)) {
477 memset(bprm->buf, 0, sizeof(bprm->buf));
478 retval = lseek(bprm->fd, 0L, SEEK_SET);
480 retval = read(bprm->fd, bprm->buf, 128);
483 perror("prepare_binprm");
485 /* return(-errno); */
492 unsigned long setup_arg_pages(unsigned long p, struct linux_binprm * bprm,
493 struct image_info * info)
495 unsigned long stack_base, size, error;
498 /* Create enough stack to hold everything. If we don't use
499 * it for args, we'll use it for something else...
501 size = x86_stack_size;
502 if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE)
503 size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;
504 error = target_mmap(0,
505 size + host_page_size,
506 PROT_READ | PROT_WRITE,
507 MAP_PRIVATE | MAP_ANONYMOUS,
513 /* we reserve one extra page at the top of the stack as guard */
514 target_mprotect(error + size, host_page_size, PROT_NONE);
516 stack_base = error + size - MAX_ARG_PAGES*TARGET_PAGE_SIZE;
520 bprm->loader += stack_base;
522 bprm->exec += stack_base;
524 for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
528 memcpy((void *)stack_base, (void *)bprm->page[i], TARGET_PAGE_SIZE);
529 free_page((void *)bprm->page[i]);
531 stack_base += TARGET_PAGE_SIZE;
536 static void set_brk(unsigned long start, unsigned long end)
538 /* page-align the start and end addresses... */
539 start = HOST_PAGE_ALIGN(start);
540 end = HOST_PAGE_ALIGN(end);
543 if(target_mmap(start, end - start,
544 PROT_READ | PROT_WRITE | PROT_EXEC,
545 MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == -1) {
546 perror("cannot mmap brk");
552 /* We need to explicitly zero any fractional pages after the data
553 section (i.e. bss). This would contain the junk from the file that
554 should not be in memory. */
555 static void padzero(unsigned long elf_bss)
560 /* XXX: this is really a hack : if the real host page size is
561 smaller than the target page size, some pages after the end
562 of the file may not be mapped. A better fix would be to
563 patch target_mmap(), but it is more complicated as the file
564 size must be known */
565 if (real_host_page_size < host_page_size) {
566 unsigned long end_addr, end_addr1;
567 end_addr1 = (elf_bss + real_host_page_size - 1) &
568 ~(real_host_page_size - 1);
569 end_addr = HOST_PAGE_ALIGN(elf_bss);
570 if (end_addr1 < end_addr) {
571 mmap((void *)end_addr1, end_addr - end_addr1,
572 PROT_READ|PROT_WRITE|PROT_EXEC,
573 MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
577 nbyte = elf_bss & (host_page_size-1);
579 nbyte = host_page_size - nbyte;
580 fpnt = (char *) elf_bss;
587 static unsigned int * create_elf_tables(char *p, int argc, int envc,
588 struct elfhdr * exec,
589 unsigned long load_addr,
590 unsigned long load_bias,
591 unsigned long interp_load_addr, int ibcs,
592 struct image_info *info)
594 target_ulong *argv, *envp;
595 target_ulong *sp, *csp;
599 * Force 16 byte _final_ alignment here for generality.
601 sp = (unsigned int *) (~15UL & (unsigned long) p);
603 csp -= (DLINFO_ITEMS + 1) * 2;
604 #ifdef DLINFO_ARCH_ITEMS
605 csp -= DLINFO_ARCH_ITEMS*2;
609 csp -= (!ibcs ? 3 : 1); /* argc itself */
610 if ((unsigned long)csp & 15UL)
611 sp -= ((unsigned long)csp & 15UL) / sizeof(*sp);
613 #define NEW_AUX_ENT(nr, id, val) \
614 put_user (id, sp + (nr * 2)); \
615 put_user (val, sp + (nr * 2 + 1))
617 NEW_AUX_ENT (0, AT_NULL, 0);
619 sp -= DLINFO_ITEMS*2;
620 NEW_AUX_ENT( 0, AT_PHDR, (target_ulong)(load_addr + exec->e_phoff));
621 NEW_AUX_ENT( 1, AT_PHENT, (target_ulong)(sizeof (struct elf_phdr)));
622 NEW_AUX_ENT( 2, AT_PHNUM, (target_ulong)(exec->e_phnum));
623 NEW_AUX_ENT( 3, AT_PAGESZ, (target_ulong)(TARGET_PAGE_SIZE));
624 NEW_AUX_ENT( 4, AT_BASE, (target_ulong)(interp_load_addr));
625 NEW_AUX_ENT( 5, AT_FLAGS, (target_ulong)0);
626 NEW_AUX_ENT( 6, AT_ENTRY, load_bias + exec->e_entry);
627 NEW_AUX_ENT( 7, AT_UID, (target_ulong) getuid());
628 NEW_AUX_ENT( 8, AT_EUID, (target_ulong) geteuid());
629 NEW_AUX_ENT( 9, AT_GID, (target_ulong) getgid());
630 NEW_AUX_ENT(11, AT_EGID, (target_ulong) getegid());
633 * ARCH_DLINFO must come last so platform specific code can enforce
634 * special alignment requirements on the AUXV if necessary (eg. PPC).
645 put_user((target_ulong)envp,--sp);
646 put_user((target_ulong)argv,--sp);
649 info->arg_start = (unsigned int)((unsigned long)p & 0xffffffff);
651 put_user((target_ulong)p,argv++);
658 info->arg_end = info->env_start = (unsigned int)((unsigned long)p & 0xffffffff);
660 put_user((target_ulong)p,envp++);
667 info->env_end = (unsigned int)((unsigned long)p & 0xffffffff);
673 static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
675 unsigned long *interp_load_addr)
677 struct elf_phdr *elf_phdata = NULL;
678 struct elf_phdr *eppnt;
679 unsigned long load_addr = 0;
680 int load_addr_set = 0;
682 unsigned long last_bss, elf_bss;
691 bswap_ehdr(interp_elf_ex);
693 /* First of all, some simple consistency checks */
694 if ((interp_elf_ex->e_type != ET_EXEC &&
695 interp_elf_ex->e_type != ET_DYN) ||
696 !elf_check_arch(interp_elf_ex->e_machine)) {
701 /* Now read in all of the header information */
703 if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE)
706 elf_phdata = (struct elf_phdr *)
707 malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
713 * If the size of this structure has changed, then punt, since
714 * we will be doing the wrong thing.
716 if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) {
721 retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
723 retval = read(interpreter_fd,
725 sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
728 perror("load_elf_interp");
735 for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
740 if (interp_elf_ex->e_type == ET_DYN) {
741 /* in order to avoid harcoding the interpreter load
742 address in qemu, we allocate a big enough memory zone */
743 error = target_mmap(0, INTERP_MAP_SIZE,
744 PROT_NONE, MAP_PRIVATE | MAP_ANON,
755 for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++)
756 if (eppnt->p_type == PT_LOAD) {
757 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
759 unsigned long vaddr = 0;
762 if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
763 if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
764 if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
765 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set) {
766 elf_type |= MAP_FIXED;
767 vaddr = eppnt->p_vaddr;
769 error = target_mmap(load_addr+TARGET_ELF_PAGESTART(vaddr),
770 eppnt->p_filesz + TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr),
774 eppnt->p_offset - TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr));
776 if (error > -1024UL) {
778 close(interpreter_fd);
783 if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
789 * Find the end of the file mapping for this phdr, and keep
790 * track of the largest address we see for this.
792 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
793 if (k > elf_bss) elf_bss = k;
796 * Do the same thing for the memory mapping - between
797 * elf_bss and last_bss is the bss section.
799 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
800 if (k > last_bss) last_bss = k;
803 /* Now use mmap to map the library into memory. */
805 close(interpreter_fd);
808 * Now fill out the bss section. First pad the last page up
809 * to the page boundary, and then perform a mmap to make sure
810 * that there are zeromapped pages up to and including the last
814 elf_bss = TARGET_ELF_PAGESTART(elf_bss + host_page_size - 1); /* What we have mapped so far */
816 /* Map the last of the bss segment */
817 if (last_bss > elf_bss) {
818 target_mmap(elf_bss, last_bss-elf_bss,
819 PROT_READ|PROT_WRITE|PROT_EXEC,
820 MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
824 *interp_load_addr = load_addr;
825 return ((unsigned long) interp_elf_ex->e_entry) + load_addr;
828 /* Best attempt to load symbols from this ELF object. */
829 static void load_symbols(struct elfhdr *hdr, int fd)
832 struct elf_shdr sechdr, symtab, strtab;
835 lseek(fd, hdr->e_shoff, SEEK_SET);
836 for (i = 0; i < hdr->e_shnum; i++) {
837 if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr))
842 if (sechdr.sh_type == SHT_SYMTAB) {
844 lseek(fd, hdr->e_shoff
845 + sizeof(sechdr) * sechdr.sh_link, SEEK_SET);
846 if (read(fd, &strtab, sizeof(strtab))
855 return; /* Shouldn't happen... */
858 /* Now know where the strtab and symtab are. Snarf them. */
859 disas_symtab = malloc(symtab.sh_size);
860 disas_strtab = strings = malloc(strtab.sh_size);
861 if (!disas_symtab || !disas_strtab)
864 lseek(fd, symtab.sh_offset, SEEK_SET);
865 if (read(fd, disas_symtab, symtab.sh_size) != symtab.sh_size)
869 for (i = 0; i < symtab.sh_size / sizeof(struct elf_sym); i++)
870 bswap_sym(disas_symtab + sizeof(struct elf_sym)*i);
873 lseek(fd, strtab.sh_offset, SEEK_SET);
874 if (read(fd, strings, strtab.sh_size) != strtab.sh_size)
876 disas_num_syms = symtab.sh_size / sizeof(struct elf_sym);
879 static int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
880 struct image_info * info)
882 struct elfhdr elf_ex;
883 struct elfhdr interp_elf_ex;
884 struct exec interp_ex;
885 int interpreter_fd = -1; /* avoid warning */
886 unsigned long load_addr, load_bias;
887 int load_addr_set = 0;
888 unsigned int interpreter_type = INTERPRETER_NONE;
889 unsigned char ibcs2_interpreter;
891 unsigned long mapped_addr;
892 struct elf_phdr * elf_ppnt;
893 struct elf_phdr *elf_phdata;
894 unsigned long elf_bss, k, elf_brk;
896 char * elf_interpreter;
897 unsigned long elf_entry, interp_load_addr = 0;
899 unsigned long start_code, end_code, end_data;
900 unsigned long elf_stack;
901 char passed_fileno[6];
903 ibcs2_interpreter = 0;
907 elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
912 if (elf_ex.e_ident[0] != 0x7f ||
913 strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) {
917 /* First of all, some simple consistency checks */
918 if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
919 (! elf_check_arch(elf_ex.e_machine))) {
923 /* Now read in all of the header information */
924 elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);
925 if (elf_phdata == NULL) {
929 retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);
931 retval = read(bprm->fd, (char *) elf_phdata,
932 elf_ex.e_phentsize * elf_ex.e_phnum);
936 perror("load_elf_binary");
943 elf_ppnt = elf_phdata;
944 for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {
945 bswap_phdr(elf_ppnt);
948 elf_ppnt = elf_phdata;
955 elf_interpreter = NULL;
960 for(i=0;i < elf_ex.e_phnum; i++) {
961 if (elf_ppnt->p_type == PT_INTERP) {
962 if ( elf_interpreter != NULL )
965 free(elf_interpreter);
970 /* This is the program interpreter used for
971 * shared libraries - for now assume that this
972 * is an a.out format binary
975 elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
977 if (elf_interpreter == NULL) {
983 retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);
985 retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);
988 perror("load_elf_binary2");
992 /* If the program interpreter is one of these two,
993 then assume an iBCS2 image. Otherwise assume
994 a native linux image. */
996 /* JRP - Need to add X86 lib dir stuff here... */
998 if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
999 strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) {
1000 ibcs2_interpreter = 1;
1004 printf("Using ELF interpreter %s\n", elf_interpreter);
1007 retval = open(path(elf_interpreter), O_RDONLY);
1009 interpreter_fd = retval;
1012 perror(elf_interpreter);
1014 /* retval = -errno; */
1019 retval = lseek(interpreter_fd, 0, SEEK_SET);
1021 retval = read(interpreter_fd,bprm->buf,128);
1025 interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */
1026 interp_elf_ex=*((struct elfhdr *) bprm->buf); /* elf exec-header */
1029 perror("load_elf_binary3");
1032 free(elf_interpreter);
1040 /* Some simple consistency checks for the interpreter */
1041 if (elf_interpreter){
1042 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
1044 /* Now figure out which format our binary is */
1045 if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&
1046 (N_MAGIC(interp_ex) != QMAGIC)) {
1047 interpreter_type = INTERPRETER_ELF;
1050 if (interp_elf_ex.e_ident[0] != 0x7f ||
1051 strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) {
1052 interpreter_type &= ~INTERPRETER_ELF;
1055 if (!interpreter_type) {
1056 free(elf_interpreter);
1063 /* OK, we are done with that, now set up the arg stuff,
1064 and then start this sucker up */
1066 if (!bprm->sh_bang) {
1069 if (interpreter_type == INTERPRETER_AOUT) {
1070 sprintf(passed_fileno, "%d", bprm->fd);
1071 passed_p = passed_fileno;
1073 if (elf_interpreter) {
1074 bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p);
1079 if (elf_interpreter) {
1080 free(elf_interpreter);
1088 /* OK, This is the point of no return */
1091 info->start_mmap = (unsigned long)ELF_START_MMAP;
1093 elf_entry = (unsigned long) elf_ex.e_entry;
1095 /* Do this so that we can load the interpreter, if need be. We will
1096 change some of these later */
1098 bprm->p = setup_arg_pages(bprm->p, bprm, info);
1099 info->start_stack = bprm->p;
1101 /* Now we do a little grungy work by mmaping the ELF image into
1102 * the correct location in memory. At this point, we assume that
1103 * the image should be loaded at fixed address, not at a variable
1107 for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
1110 unsigned long error;
1112 if (elf_ppnt->p_type != PT_LOAD)
1115 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
1116 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
1117 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
1118 elf_flags = MAP_PRIVATE | MAP_DENYWRITE;
1119 if (elf_ex.e_type == ET_EXEC || load_addr_set) {
1120 elf_flags |= MAP_FIXED;
1121 } else if (elf_ex.e_type == ET_DYN) {
1122 /* Try and get dynamic programs out of the way of the default mmap
1123 base, as well as whatever program they might try to exec. This
1124 is because the brk will follow the loader, and is not movable. */
1125 /* NOTE: for qemu, we do a big mmap to get enough space
1126 without harcoding any address */
1127 error = target_mmap(0, ET_DYN_MAP_SIZE,
1128 PROT_NONE, MAP_PRIVATE | MAP_ANON,
1134 load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr);
1137 error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),
1138 (elf_ppnt->p_filesz +
1139 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
1141 (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),
1143 (elf_ppnt->p_offset -
1144 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
1150 #ifdef LOW_ELF_STACK
1151 if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)
1152 elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr);
1155 if (!load_addr_set) {
1157 load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;
1158 if (elf_ex.e_type == ET_DYN) {
1159 load_bias += error -
1160 TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr);
1161 load_addr += load_bias;
1164 k = elf_ppnt->p_vaddr;
1167 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1170 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1174 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1175 if (k > elf_brk) elf_brk = k;
1178 elf_entry += load_bias;
1179 elf_bss += load_bias;
1180 elf_brk += load_bias;
1181 start_code += load_bias;
1182 end_code += load_bias;
1183 // start_data += load_bias;
1184 end_data += load_bias;
1186 if (elf_interpreter) {
1187 if (interpreter_type & 1) {
1188 elf_entry = load_aout_interp(&interp_ex, interpreter_fd);
1190 else if (interpreter_type & 2) {
1191 elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,
1195 close(interpreter_fd);
1196 free(elf_interpreter);
1198 if (elf_entry == ~0UL) {
1199 printf("Unable to load interpreter\n");
1209 load_symbols(&elf_ex, bprm->fd);
1211 if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);
1212 info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX);
1214 #ifdef LOW_ELF_STACK
1215 info->start_stack = bprm->p = elf_stack - 4;
1217 bprm->p = (unsigned long)
1218 create_elf_tables((char *)bprm->p,
1222 load_addr, load_bias,
1224 (interpreter_type == INTERPRETER_AOUT ? 0 : 1),
1226 if (interpreter_type == INTERPRETER_AOUT)
1227 info->arg_start += strlen(passed_fileno) + 1;
1228 info->start_brk = info->brk = elf_brk;
1229 info->end_code = end_code;
1230 info->start_code = start_code;
1231 info->end_data = end_data;
1232 info->start_stack = bprm->p;
1234 /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1236 set_brk(elf_bss, elf_brk);
1241 printf("(start_brk) %x\n" , info->start_brk);
1242 printf("(end_code) %x\n" , info->end_code);
1243 printf("(start_code) %x\n" , info->start_code);
1244 printf("(end_data) %x\n" , info->end_data);
1245 printf("(start_stack) %x\n" , info->start_stack);
1246 printf("(brk) %x\n" , info->brk);
1249 if ( info->personality == PER_SVR4 )
1251 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1252 and some applications "depend" upon this behavior.
1253 Since we do not have the power to recompile these, we
1254 emulate the SVr4 behavior. Sigh. */
1255 mapped_addr = target_mmap(0, host_page_size, PROT_READ | PROT_EXEC,
1256 MAP_FIXED | MAP_PRIVATE, -1, 0);
1259 #ifdef ELF_PLAT_INIT
1261 * The ABI may specify that certain registers be set up in special
1262 * ways (on i386 %edx is the address of a DT_FINI function, for
1263 * example. This macro performs whatever initialization to
1264 * the regs structure is required.
1266 ELF_PLAT_INIT(regs);
1270 info->entry = elf_entry;
1277 int elf_exec(const char * filename, char ** argv, char ** envp,
1278 struct target_pt_regs * regs, struct image_info *infop)
1280 struct linux_binprm bprm;
1284 bprm.p = TARGET_PAGE_SIZE*MAX_ARG_PAGES-sizeof(unsigned int);
1285 for (i=0 ; i<MAX_ARG_PAGES ; i++) /* clear page-table */
1287 retval = open(filename, O_RDONLY);
1291 bprm.filename = (char *)filename;
1296 bprm.argc = count(argv);
1297 bprm.envc = count(envp);
1299 retval = prepare_binprm(&bprm);
1302 bprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p);
1304 bprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p);
1305 bprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p);
1312 retval = load_elf_binary(&bprm,regs,infop);
1315 /* success. Initialize important registers */
1316 init_thread(regs, infop);
1320 /* Something went wrong, return the inode and free the argument pages*/
1321 for (i=0 ; i<MAX_ARG_PAGES ; i++) {
1322 free_page((void *)bprm.page[i]);
1328 static int load_aout_interp(void * exptr, int interp_fd)
1330 printf("a.out interpreter not yet supported\n");