1 /* This is the Linux kernel elf-loading code, ported into user space */
16 /* this flag is uneffective under linux too, should be deleted */
18 #define MAP_DENYWRITE 0
21 /* should probably go in elf.h */
28 #define ELF_PLATFORM get_elf_platform()
30 static const char *get_elf_platform(void)
32 static char elf_platform[] = "i386";
33 int family = (global_env->cpuid_version >> 8) & 0xff;
37 elf_platform[1] = '0' + family;
41 #define ELF_HWCAP get_elf_hwcap()
43 static uint32_t get_elf_hwcap(void)
45 return global_env->cpuid_features;
48 #define ELF_START_MMAP 0x80000000
51 * This is used to ensure we don't load something for the wrong architecture.
53 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
56 * These are used to set parameters in the core dumps.
58 #define ELF_CLASS ELFCLASS32
59 #define ELF_DATA ELFDATA2LSB
60 #define ELF_ARCH EM_386
62 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
63 starts %edx contains a pointer to a function which might be
64 registered using `atexit'. This provides a mean for the
65 dynamic linker to call DT_FINI functions for shared libraries
66 that have been loaded before the code runs.
68 A value of 0 tells we have no such handler. */
69 #define ELF_PLAT_INIT(_r) _r->edx = 0
71 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
73 regs->esp = infop->start_stack;
74 regs->eip = infop->entry;
77 #define USE_ELF_CORE_DUMP
78 #define ELF_EXEC_PAGESIZE 4096
84 #define ELF_START_MMAP 0x80000000
86 #define elf_check_arch(x) ( (x) == EM_ARM )
88 #define ELF_CLASS ELFCLASS32
89 #ifdef TARGET_WORDS_BIGENDIAN
90 #define ELF_DATA ELFDATA2MSB
92 #define ELF_DATA ELFDATA2LSB
94 #define ELF_ARCH EM_ARM
96 #define ELF_PLAT_INIT(_r) _r->ARM_r0 = 0
98 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
100 target_long *stack = (void *)infop->start_stack;
101 memset(regs, 0, sizeof(*regs));
102 regs->ARM_cpsr = 0x10;
103 if (infop->entry & 1)
104 regs->ARM_cpsr |= CPSR_T;
105 regs->ARM_pc = infop->entry & 0xfffffffe;
106 regs->ARM_sp = infop->start_stack;
107 regs->ARM_r2 = tswapl(stack[2]); /* envp */
108 regs->ARM_r1 = tswapl(stack[1]); /* argv */
109 /* XXX: it seems that r0 is zeroed after ! */
110 // regs->ARM_r0 = tswapl(stack[0]); /* argc */
113 #define USE_ELF_CORE_DUMP
114 #define ELF_EXEC_PAGESIZE 4096
118 ARM_HWCAP_ARM_SWP = 1 << 0,
119 ARM_HWCAP_ARM_HALF = 1 << 1,
120 ARM_HWCAP_ARM_THUMB = 1 << 2,
121 ARM_HWCAP_ARM_26BIT = 1 << 3,
122 ARM_HWCAP_ARM_FAST_MULT = 1 << 4,
123 ARM_HWCAP_ARM_FPA = 1 << 5,
124 ARM_HWCAP_ARM_VFP = 1 << 6,
125 ARM_HWCAP_ARM_EDSP = 1 << 7,
128 #define ELF_HWCAP (ARM_HWCAP_ARM_SWP | ARM_HWCAP_ARM_HALF \
129 | ARM_HWCAP_ARM_THUMB | ARM_HWCAP_ARM_FAST_MULT \
130 | ARM_HWCAP_ARM_FPA | ARM_HWCAP_ARM_VFP)
135 #ifdef TARGET_SPARC64
137 #define ELF_START_MMAP 0x80000000
139 #define elf_check_arch(x) ( (x) == EM_SPARC )
141 #define ELF_CLASS ELFCLASS64
142 #define ELF_DATA ELFDATA2MSB
143 #define ELF_ARCH EM_SPARC
146 #define ELF_PLAT_INIT(_r)
148 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
151 regs->pc = infop->entry;
152 regs->npc = regs->pc + 4;
154 regs->u_regs[14] = infop->start_stack - 16 * 4;
158 #define ELF_START_MMAP 0x80000000
160 #define elf_check_arch(x) ( (x) == EM_SPARC )
162 #define ELF_CLASS ELFCLASS32
163 #define ELF_DATA ELFDATA2MSB
164 #define ELF_ARCH EM_SPARC
167 #define ELF_PLAT_INIT(_r)
169 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
172 regs->pc = infop->entry;
173 regs->npc = regs->pc + 4;
175 regs->u_regs[14] = infop->start_stack - 16 * 4;
183 #define ELF_START_MMAP 0x80000000
185 #define elf_check_arch(x) ( (x) == EM_PPC )
187 #define ELF_CLASS ELFCLASS32
188 #ifdef TARGET_WORDS_BIGENDIAN
189 #define ELF_DATA ELFDATA2MSB
191 #define ELF_DATA ELFDATA2LSB
193 #define ELF_ARCH EM_PPC
195 /* Note that isn't exactly what regular kernel does
196 * but this is what the ABI wants and is needed to allow
197 * execution of PPC BSD programs.
199 #define ELF_PLAT_INIT(_r) \
201 target_ulong *pos = (target_ulong *)bprm->p, tmp = 1; \
202 _r->gpr[3] = bprm->argc; \
203 _r->gpr[4] = (unsigned long)++pos; \
204 for (; tmp != 0; pos++) \
206 _r->gpr[5] = (unsigned long)pos; \
210 * We need to put in some extra aux table entries to tell glibc what
211 * the cache block size is, so it can use the dcbz instruction safely.
213 #define AT_DCACHEBSIZE 19
214 #define AT_ICACHEBSIZE 20
215 #define AT_UCACHEBSIZE 21
216 /* A special ignored type value for PPC, for glibc compatibility. */
217 #define AT_IGNOREPPC 22
219 * The requirements here are:
220 * - keep the final alignment of sp (sp & 0xf)
221 * - make sure the 32-bit value at the first 16 byte aligned position of
222 * AUXV is greater than 16 for glibc compatibility.
223 * AT_IGNOREPPC is used for that.
224 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
225 * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
227 #define DLINFO_ARCH_ITEMS 5
228 #define ARCH_DLINFO \
230 NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20); \
231 NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20); \
232 NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \
234 * Now handle glibc compatibility. \
236 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
237 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
240 static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
242 _regs->msr = 1 << MSR_PR; /* Set user mode */
243 _regs->gpr[1] = infop->start_stack;
244 _regs->nip = infop->entry;
247 #define USE_ELF_CORE_DUMP
248 #define ELF_EXEC_PAGESIZE 4096
254 #define ELF_START_MMAP 0x80000000
256 #define elf_check_arch(x) ( (x) == EM_MIPS )
258 #define ELF_CLASS ELFCLASS32
259 #ifdef TARGET_WORDS_BIGENDIAN
260 #define ELF_DATA ELFDATA2MSB
262 #define ELF_DATA ELFDATA2LSB
264 #define ELF_ARCH EM_MIPS
266 #define ELF_PLAT_INIT(_r)
268 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
270 regs->cp0_status = CP0St_UM;
271 regs->cp0_epc = infop->entry;
272 regs->regs[29] = infop->start_stack;
275 #endif /* TARGET_MIPS */
278 #define ELF_PLATFORM (NULL)
288 * MAX_ARG_PAGES defines the number of pages allocated for arguments
289 * and envelope for the new program. 32 should suffice, this gives
290 * a maximum env+arg of 128kB w/4KB pages!
292 #define MAX_ARG_PAGES 32
295 * This structure is used to hold the arguments that are
296 * used when loading binaries.
298 struct linux_binprm {
300 unsigned long page[MAX_ARG_PAGES];
306 char * filename; /* Name of binary */
307 unsigned long loader, exec;
308 int dont_iput; /* binfmt handler has put inode */
313 unsigned int a_info; /* Use macros N_MAGIC, etc for access */
314 unsigned int a_text; /* length of text, in bytes */
315 unsigned int a_data; /* length of data, in bytes */
316 unsigned int a_bss; /* length of uninitialized data area, in bytes */
317 unsigned int a_syms; /* length of symbol table data in file, in bytes */
318 unsigned int a_entry; /* start address */
319 unsigned int a_trsize; /* length of relocation info for text, in bytes */
320 unsigned int a_drsize; /* length of relocation info for data, in bytes */
324 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
330 /* max code+data+bss space allocated to elf interpreter */
331 #define INTERP_MAP_SIZE (32 * 1024 * 1024)
333 /* max code+data+bss+brk space allocated to ET_DYN executables */
334 #define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
336 /* from personality.h */
338 /* Flags for bug emulation. These occupy the top three bytes. */
339 #define STICKY_TIMEOUTS 0x4000000
340 #define WHOLE_SECONDS 0x2000000
342 /* Personality types. These go in the low byte. Avoid using the top bit,
343 * it will conflict with error returns.
345 #define PER_MASK (0x00ff)
346 #define PER_LINUX (0x0000)
347 #define PER_SVR4 (0x0001 | STICKY_TIMEOUTS)
348 #define PER_SVR3 (0x0002 | STICKY_TIMEOUTS)
349 #define PER_SCOSVR3 (0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS)
350 #define PER_WYSEV386 (0x0004 | STICKY_TIMEOUTS)
351 #define PER_ISCR4 (0x0005 | STICKY_TIMEOUTS)
352 #define PER_BSD (0x0006)
353 #define PER_XENIX (0x0007 | STICKY_TIMEOUTS)
355 /* Necessary parameters */
358 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
359 #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
360 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
362 #define INTERPRETER_NONE 0
363 #define INTERPRETER_AOUT 1
364 #define INTERPRETER_ELF 2
366 #define DLINFO_ITEMS 12
368 static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
373 extern unsigned long x86_stack_size;
375 static int load_aout_interp(void * exptr, int interp_fd);
378 static void bswap_ehdr(struct elfhdr *ehdr)
380 bswap16s(&ehdr->e_type); /* Object file type */
381 bswap16s(&ehdr->e_machine); /* Architecture */
382 bswap32s(&ehdr->e_version); /* Object file version */
383 bswaptls(&ehdr->e_entry); /* Entry point virtual address */
384 bswaptls(&ehdr->e_phoff); /* Program header table file offset */
385 bswaptls(&ehdr->e_shoff); /* Section header table file offset */
386 bswap32s(&ehdr->e_flags); /* Processor-specific flags */
387 bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
388 bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
389 bswap16s(&ehdr->e_phnum); /* Program header table entry count */
390 bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
391 bswap16s(&ehdr->e_shnum); /* Section header table entry count */
392 bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
395 static void bswap_phdr(struct elf_phdr *phdr)
397 bswap32s(&phdr->p_type); /* Segment type */
398 bswaptls(&phdr->p_offset); /* Segment file offset */
399 bswaptls(&phdr->p_vaddr); /* Segment virtual address */
400 bswaptls(&phdr->p_paddr); /* Segment physical address */
401 bswaptls(&phdr->p_filesz); /* Segment size in file */
402 bswaptls(&phdr->p_memsz); /* Segment size in memory */
403 bswap32s(&phdr->p_flags); /* Segment flags */
404 bswaptls(&phdr->p_align); /* Segment alignment */
407 static void bswap_shdr(struct elf_shdr *shdr)
409 bswap32s(&shdr->sh_name);
410 bswap32s(&shdr->sh_type);
411 bswaptls(&shdr->sh_flags);
412 bswaptls(&shdr->sh_addr);
413 bswaptls(&shdr->sh_offset);
414 bswaptls(&shdr->sh_size);
415 bswap32s(&shdr->sh_link);
416 bswap32s(&shdr->sh_info);
417 bswaptls(&shdr->sh_addralign);
418 bswaptls(&shdr->sh_entsize);
421 static void bswap_sym(Elf32_Sym *sym)
423 bswap32s(&sym->st_name);
424 bswap32s(&sym->st_value);
425 bswap32s(&sym->st_size);
426 bswap16s(&sym->st_shndx);
430 static void * get_free_page(void)
434 /* User-space version of kernel get_free_page. Returns a page-aligned
435 * page-sized chunk of memory.
437 retval = (void *)target_mmap(0, qemu_host_page_size, PROT_READ|PROT_WRITE,
438 MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
440 if((long)retval == -1) {
441 perror("get_free_page");
449 static void free_page(void * pageaddr)
451 target_munmap((unsigned long)pageaddr, qemu_host_page_size);
455 * 'copy_string()' copies argument/envelope strings from user
456 * memory to free pages in kernel mem. These are in a format ready
457 * to be put directly into the top of new user memory.
460 static unsigned long copy_strings(int argc,char ** argv,unsigned long *page,
463 char *tmp, *tmp1, *pag = NULL;
467 return 0; /* bullet-proofing */
472 fprintf(stderr, "VFS: argc is wrong");
478 if (p < len) { /* this shouldn't happen - 128kB */
484 offset = p % TARGET_PAGE_SIZE;
485 pag = (char *) page[p/TARGET_PAGE_SIZE];
487 pag = (char *)get_free_page();
488 page[p/TARGET_PAGE_SIZE] = (unsigned long)pag;
493 if (len == 0 || offset == 0) {
494 *(pag + offset) = *tmp;
497 int bytes_to_copy = (len > offset) ? offset : len;
498 tmp -= bytes_to_copy;
500 offset -= bytes_to_copy;
501 len -= bytes_to_copy;
502 memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
509 static int in_group_p(gid_t g)
511 /* return TRUE if we're in the specified group, FALSE otherwise */
514 gid_t grouplist[NGROUPS];
516 ngroup = getgroups(NGROUPS, grouplist);
517 for(i = 0; i < ngroup; i++) {
518 if(grouplist[i] == g) {
525 static int count(char ** vec)
529 for(i = 0; *vec; i++) {
536 static int prepare_binprm(struct linux_binprm *bprm)
540 int retval, id_change;
542 if(fstat(bprm->fd, &st) < 0) {
547 if(!S_ISREG(mode)) { /* Must be regular file */
550 if(!(mode & 0111)) { /* Must have at least one execute bit set */
554 bprm->e_uid = geteuid();
555 bprm->e_gid = getegid();
560 bprm->e_uid = st.st_uid;
561 if(bprm->e_uid != geteuid()) {
568 * If setgid is set but no group execute bit then this
569 * is a candidate for mandatory locking, not a setgid
572 if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
573 bprm->e_gid = st.st_gid;
574 if (!in_group_p(bprm->e_gid)) {
579 memset(bprm->buf, 0, sizeof(bprm->buf));
580 retval = lseek(bprm->fd, 0L, SEEK_SET);
582 retval = read(bprm->fd, bprm->buf, 128);
585 perror("prepare_binprm");
587 /* return(-errno); */
594 unsigned long setup_arg_pages(unsigned long p, struct linux_binprm * bprm,
595 struct image_info * info)
597 unsigned long stack_base, size, error;
600 /* Create enough stack to hold everything. If we don't use
601 * it for args, we'll use it for something else...
603 size = x86_stack_size;
604 if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE)
605 size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;
606 error = target_mmap(0,
607 size + qemu_host_page_size,
608 PROT_READ | PROT_WRITE,
609 MAP_PRIVATE | MAP_ANONYMOUS,
615 /* we reserve one extra page at the top of the stack as guard */
616 target_mprotect(error + size, qemu_host_page_size, PROT_NONE);
618 stack_base = error + size - MAX_ARG_PAGES*TARGET_PAGE_SIZE;
622 bprm->loader += stack_base;
624 bprm->exec += stack_base;
626 for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
630 memcpy((void *)stack_base, (void *)bprm->page[i], TARGET_PAGE_SIZE);
631 free_page((void *)bprm->page[i]);
633 stack_base += TARGET_PAGE_SIZE;
638 static void set_brk(unsigned long start, unsigned long end)
640 /* page-align the start and end addresses... */
641 start = HOST_PAGE_ALIGN(start);
642 end = HOST_PAGE_ALIGN(end);
645 if(target_mmap(start, end - start,
646 PROT_READ | PROT_WRITE | PROT_EXEC,
647 MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == -1) {
648 perror("cannot mmap brk");
654 /* We need to explicitly zero any fractional pages after the data
655 section (i.e. bss). This would contain the junk from the file that
656 should not be in memory. */
657 static void padzero(unsigned long elf_bss)
662 /* XXX: this is really a hack : if the real host page size is
663 smaller than the target page size, some pages after the end
664 of the file may not be mapped. A better fix would be to
665 patch target_mmap(), but it is more complicated as the file
666 size must be known */
667 if (qemu_real_host_page_size < qemu_host_page_size) {
668 unsigned long end_addr, end_addr1;
669 end_addr1 = (elf_bss + qemu_real_host_page_size - 1) &
670 ~(qemu_real_host_page_size - 1);
671 end_addr = HOST_PAGE_ALIGN(elf_bss);
672 if (end_addr1 < end_addr) {
673 mmap((void *)end_addr1, end_addr - end_addr1,
674 PROT_READ|PROT_WRITE|PROT_EXEC,
675 MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
679 nbyte = elf_bss & (qemu_host_page_size-1);
681 nbyte = qemu_host_page_size - nbyte;
682 fpnt = (char *) elf_bss;
689 static unsigned int * create_elf_tables(char *p, int argc, int envc,
690 struct elfhdr * exec,
691 unsigned long load_addr,
692 unsigned long load_bias,
693 unsigned long interp_load_addr, int ibcs,
694 struct image_info *info)
696 target_ulong *argv, *envp;
697 target_ulong *sp, *csp;
698 target_ulong *u_platform;
699 const char *k_platform;
703 * Force 16 byte _final_ alignment here for generality.
705 sp = (unsigned int *) (~15UL & (unsigned long) p);
707 k_platform = ELF_PLATFORM;
709 size_t len = strlen(k_platform) + 1;
710 sp -= (len + sizeof(target_ulong) - 1) / sizeof(target_ulong);
711 u_platform = (target_ulong *)sp;
712 __copy_to_user(u_platform, k_platform, len);
715 csp -= (DLINFO_ITEMS + 1) * 2;
718 #ifdef DLINFO_ARCH_ITEMS
719 csp -= DLINFO_ARCH_ITEMS*2;
723 csp -= (!ibcs ? 3 : 1); /* argc itself */
724 if ((unsigned long)csp & 15UL)
725 sp -= ((unsigned long)csp & 15UL) / sizeof(*sp);
727 #define NEW_AUX_ENT(id, val) \
730 put_user (val, sp + 1)
731 NEW_AUX_ENT (AT_NULL, 0);
733 /* There must be exactly DLINFO_ITEMS entries here. */
734 NEW_AUX_ENT(AT_PHDR, (target_ulong)(load_addr + exec->e_phoff));
735 NEW_AUX_ENT(AT_PHENT, (target_ulong)(sizeof (struct elf_phdr)));
736 NEW_AUX_ENT(AT_PHNUM, (target_ulong)(exec->e_phnum));
737 NEW_AUX_ENT(AT_PAGESZ, (target_ulong)(TARGET_PAGE_SIZE));
738 NEW_AUX_ENT(AT_BASE, (target_ulong)(interp_load_addr));
739 NEW_AUX_ENT(AT_FLAGS, (target_ulong)0);
740 NEW_AUX_ENT(AT_ENTRY, load_bias + exec->e_entry);
741 NEW_AUX_ENT(AT_UID, (target_ulong) getuid());
742 NEW_AUX_ENT(AT_EUID, (target_ulong) geteuid());
743 NEW_AUX_ENT(AT_GID, (target_ulong) getgid());
744 NEW_AUX_ENT(AT_EGID, (target_ulong) getegid());
745 NEW_AUX_ENT(AT_HWCAP, (target_ulong) ELF_HWCAP);
747 NEW_AUX_ENT(AT_PLATFORM, (target_ulong) u_platform);
750 * ARCH_DLINFO must come last so platform specific code can enforce
751 * special alignment requirements on the AUXV if necessary (eg. PPC).
762 put_user((target_ulong)envp,--sp);
763 put_user((target_ulong)argv,--sp);
766 info->arg_start = (unsigned int)((unsigned long)p & 0xffffffff);
768 put_user((target_ulong)p,argv++);
775 info->arg_end = info->env_start = (unsigned int)((unsigned long)p & 0xffffffff);
777 put_user((target_ulong)p,envp++);
784 info->env_end = (unsigned int)((unsigned long)p & 0xffffffff);
790 static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
792 unsigned long *interp_load_addr)
794 struct elf_phdr *elf_phdata = NULL;
795 struct elf_phdr *eppnt;
796 unsigned long load_addr = 0;
797 int load_addr_set = 0;
799 unsigned long last_bss, elf_bss;
808 bswap_ehdr(interp_elf_ex);
810 /* First of all, some simple consistency checks */
811 if ((interp_elf_ex->e_type != ET_EXEC &&
812 interp_elf_ex->e_type != ET_DYN) ||
813 !elf_check_arch(interp_elf_ex->e_machine)) {
818 /* Now read in all of the header information */
820 if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE)
823 elf_phdata = (struct elf_phdr *)
824 malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
830 * If the size of this structure has changed, then punt, since
831 * we will be doing the wrong thing.
833 if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) {
838 retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
840 retval = read(interpreter_fd,
842 sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
845 perror("load_elf_interp");
852 for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
857 if (interp_elf_ex->e_type == ET_DYN) {
858 /* in order to avoid harcoding the interpreter load
859 address in qemu, we allocate a big enough memory zone */
860 error = target_mmap(0, INTERP_MAP_SIZE,
861 PROT_NONE, MAP_PRIVATE | MAP_ANON,
872 for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++)
873 if (eppnt->p_type == PT_LOAD) {
874 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
876 unsigned long vaddr = 0;
879 if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
880 if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
881 if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
882 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set) {
883 elf_type |= MAP_FIXED;
884 vaddr = eppnt->p_vaddr;
886 error = target_mmap(load_addr+TARGET_ELF_PAGESTART(vaddr),
887 eppnt->p_filesz + TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr),
891 eppnt->p_offset - TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr));
895 close(interpreter_fd);
900 if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
906 * Find the end of the file mapping for this phdr, and keep
907 * track of the largest address we see for this.
909 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
910 if (k > elf_bss) elf_bss = k;
913 * Do the same thing for the memory mapping - between
914 * elf_bss and last_bss is the bss section.
916 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
917 if (k > last_bss) last_bss = k;
920 /* Now use mmap to map the library into memory. */
922 close(interpreter_fd);
925 * Now fill out the bss section. First pad the last page up
926 * to the page boundary, and then perform a mmap to make sure
927 * that there are zeromapped pages up to and including the last
931 elf_bss = TARGET_ELF_PAGESTART(elf_bss + qemu_host_page_size - 1); /* What we have mapped so far */
933 /* Map the last of the bss segment */
934 if (last_bss > elf_bss) {
935 target_mmap(elf_bss, last_bss-elf_bss,
936 PROT_READ|PROT_WRITE|PROT_EXEC,
937 MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
941 *interp_load_addr = load_addr;
942 return ((unsigned long) interp_elf_ex->e_entry) + load_addr;
945 /* Best attempt to load symbols from this ELF object. */
946 static void load_symbols(struct elfhdr *hdr, int fd)
949 struct elf_shdr sechdr, symtab, strtab;
953 lseek(fd, hdr->e_shoff, SEEK_SET);
954 for (i = 0; i < hdr->e_shnum; i++) {
955 if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr))
960 if (sechdr.sh_type == SHT_SYMTAB) {
962 lseek(fd, hdr->e_shoff
963 + sizeof(sechdr) * sechdr.sh_link, SEEK_SET);
964 if (read(fd, &strtab, sizeof(strtab))
973 return; /* Shouldn't happen... */
976 /* Now know where the strtab and symtab are. Snarf them. */
977 s = malloc(sizeof(*s));
978 s->disas_symtab = malloc(symtab.sh_size);
979 s->disas_strtab = strings = malloc(strtab.sh_size);
980 if (!s->disas_symtab || !s->disas_strtab)
983 lseek(fd, symtab.sh_offset, SEEK_SET);
984 if (read(fd, s->disas_symtab, symtab.sh_size) != symtab.sh_size)
988 for (i = 0; i < symtab.sh_size / sizeof(struct elf_sym); i++)
989 bswap_sym(s->disas_symtab + sizeof(struct elf_sym)*i);
992 lseek(fd, strtab.sh_offset, SEEK_SET);
993 if (read(fd, strings, strtab.sh_size) != strtab.sh_size)
995 s->disas_num_syms = symtab.sh_size / sizeof(struct elf_sym);
1000 static int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
1001 struct image_info * info)
1003 struct elfhdr elf_ex;
1004 struct elfhdr interp_elf_ex;
1005 struct exec interp_ex;
1006 int interpreter_fd = -1; /* avoid warning */
1007 unsigned long load_addr, load_bias;
1008 int load_addr_set = 0;
1009 unsigned int interpreter_type = INTERPRETER_NONE;
1010 unsigned char ibcs2_interpreter;
1012 unsigned long mapped_addr;
1013 struct elf_phdr * elf_ppnt;
1014 struct elf_phdr *elf_phdata;
1015 unsigned long elf_bss, k, elf_brk;
1017 char * elf_interpreter;
1018 unsigned long elf_entry, interp_load_addr = 0;
1020 unsigned long start_code, end_code, end_data;
1021 unsigned long elf_stack;
1022 char passed_fileno[6];
1024 ibcs2_interpreter = 0;
1028 elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
1030 bswap_ehdr(&elf_ex);
1033 if (elf_ex.e_ident[0] != 0x7f ||
1034 strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) {
1038 /* First of all, some simple consistency checks */
1039 if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
1040 (! elf_check_arch(elf_ex.e_machine))) {
1044 /* Now read in all of the header information */
1045 elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);
1046 if (elf_phdata == NULL) {
1050 retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);
1052 retval = read(bprm->fd, (char *) elf_phdata,
1053 elf_ex.e_phentsize * elf_ex.e_phnum);
1057 perror("load_elf_binary");
1064 elf_ppnt = elf_phdata;
1065 for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {
1066 bswap_phdr(elf_ppnt);
1069 elf_ppnt = elf_phdata;
1076 elf_interpreter = NULL;
1081 for(i=0;i < elf_ex.e_phnum; i++) {
1082 if (elf_ppnt->p_type == PT_INTERP) {
1083 if ( elf_interpreter != NULL )
1086 free(elf_interpreter);
1091 /* This is the program interpreter used for
1092 * shared libraries - for now assume that this
1093 * is an a.out format binary
1096 elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
1098 if (elf_interpreter == NULL) {
1104 retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);
1106 retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);
1109 perror("load_elf_binary2");
1113 /* If the program interpreter is one of these two,
1114 then assume an iBCS2 image. Otherwise assume
1115 a native linux image. */
1117 /* JRP - Need to add X86 lib dir stuff here... */
1119 if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
1120 strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) {
1121 ibcs2_interpreter = 1;
1125 printf("Using ELF interpreter %s\n", elf_interpreter);
1128 retval = open(path(elf_interpreter), O_RDONLY);
1130 interpreter_fd = retval;
1133 perror(elf_interpreter);
1135 /* retval = -errno; */
1140 retval = lseek(interpreter_fd, 0, SEEK_SET);
1142 retval = read(interpreter_fd,bprm->buf,128);
1146 interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */
1147 interp_elf_ex=*((struct elfhdr *) bprm->buf); /* elf exec-header */
1150 perror("load_elf_binary3");
1153 free(elf_interpreter);
1161 /* Some simple consistency checks for the interpreter */
1162 if (elf_interpreter){
1163 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
1165 /* Now figure out which format our binary is */
1166 if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&
1167 (N_MAGIC(interp_ex) != QMAGIC)) {
1168 interpreter_type = INTERPRETER_ELF;
1171 if (interp_elf_ex.e_ident[0] != 0x7f ||
1172 strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) {
1173 interpreter_type &= ~INTERPRETER_ELF;
1176 if (!interpreter_type) {
1177 free(elf_interpreter);
1184 /* OK, we are done with that, now set up the arg stuff,
1185 and then start this sucker up */
1187 if (!bprm->sh_bang) {
1190 if (interpreter_type == INTERPRETER_AOUT) {
1191 snprintf(passed_fileno, sizeof(passed_fileno), "%d", bprm->fd);
1192 passed_p = passed_fileno;
1194 if (elf_interpreter) {
1195 bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p);
1200 if (elf_interpreter) {
1201 free(elf_interpreter);
1209 /* OK, This is the point of no return */
1212 info->start_mmap = (unsigned long)ELF_START_MMAP;
1214 elf_entry = (unsigned long) elf_ex.e_entry;
1216 /* Do this so that we can load the interpreter, if need be. We will
1217 change some of these later */
1219 bprm->p = setup_arg_pages(bprm->p, bprm, info);
1220 info->start_stack = bprm->p;
1222 /* Now we do a little grungy work by mmaping the ELF image into
1223 * the correct location in memory. At this point, we assume that
1224 * the image should be loaded at fixed address, not at a variable
1228 for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
1231 unsigned long error;
1233 if (elf_ppnt->p_type != PT_LOAD)
1236 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
1237 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
1238 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
1239 elf_flags = MAP_PRIVATE | MAP_DENYWRITE;
1240 if (elf_ex.e_type == ET_EXEC || load_addr_set) {
1241 elf_flags |= MAP_FIXED;
1242 } else if (elf_ex.e_type == ET_DYN) {
1243 /* Try and get dynamic programs out of the way of the default mmap
1244 base, as well as whatever program they might try to exec. This
1245 is because the brk will follow the loader, and is not movable. */
1246 /* NOTE: for qemu, we do a big mmap to get enough space
1247 without harcoding any address */
1248 error = target_mmap(0, ET_DYN_MAP_SIZE,
1249 PROT_NONE, MAP_PRIVATE | MAP_ANON,
1255 load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr);
1258 error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),
1259 (elf_ppnt->p_filesz +
1260 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
1262 (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),
1264 (elf_ppnt->p_offset -
1265 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
1271 #ifdef LOW_ELF_STACK
1272 if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)
1273 elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr);
1276 if (!load_addr_set) {
1278 load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;
1279 if (elf_ex.e_type == ET_DYN) {
1280 load_bias += error -
1281 TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr);
1282 load_addr += load_bias;
1285 k = elf_ppnt->p_vaddr;
1288 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1291 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1295 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1296 if (k > elf_brk) elf_brk = k;
1299 elf_entry += load_bias;
1300 elf_bss += load_bias;
1301 elf_brk += load_bias;
1302 start_code += load_bias;
1303 end_code += load_bias;
1304 // start_data += load_bias;
1305 end_data += load_bias;
1307 if (elf_interpreter) {
1308 if (interpreter_type & 1) {
1309 elf_entry = load_aout_interp(&interp_ex, interpreter_fd);
1311 else if (interpreter_type & 2) {
1312 elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,
1316 close(interpreter_fd);
1317 free(elf_interpreter);
1319 if (elf_entry == ~0UL) {
1320 printf("Unable to load interpreter\n");
1330 load_symbols(&elf_ex, bprm->fd);
1332 if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);
1333 info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX);
1335 #ifdef LOW_ELF_STACK
1336 info->start_stack = bprm->p = elf_stack - 4;
1338 bprm->p = (unsigned long)
1339 create_elf_tables((char *)bprm->p,
1343 load_addr, load_bias,
1345 (interpreter_type == INTERPRETER_AOUT ? 0 : 1),
1347 if (interpreter_type == INTERPRETER_AOUT)
1348 info->arg_start += strlen(passed_fileno) + 1;
1349 info->start_brk = info->brk = elf_brk;
1350 info->end_code = end_code;
1351 info->start_code = start_code;
1352 info->end_data = end_data;
1353 info->start_stack = bprm->p;
1355 /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1357 set_brk(elf_bss, elf_brk);
1362 printf("(start_brk) %x\n" , info->start_brk);
1363 printf("(end_code) %x\n" , info->end_code);
1364 printf("(start_code) %x\n" , info->start_code);
1365 printf("(end_data) %x\n" , info->end_data);
1366 printf("(start_stack) %x\n" , info->start_stack);
1367 printf("(brk) %x\n" , info->brk);
1370 if ( info->personality == PER_SVR4 )
1372 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1373 and some applications "depend" upon this behavior.
1374 Since we do not have the power to recompile these, we
1375 emulate the SVr4 behavior. Sigh. */
1376 mapped_addr = target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
1377 MAP_FIXED | MAP_PRIVATE, -1, 0);
1380 #ifdef ELF_PLAT_INIT
1382 * The ABI may specify that certain registers be set up in special
1383 * ways (on i386 %edx is the address of a DT_FINI function, for
1384 * example. This macro performs whatever initialization to
1385 * the regs structure is required.
1387 ELF_PLAT_INIT(regs);
1391 info->entry = elf_entry;
1398 int elf_exec(const char * filename, char ** argv, char ** envp,
1399 struct target_pt_regs * regs, struct image_info *infop)
1401 struct linux_binprm bprm;
1405 bprm.p = TARGET_PAGE_SIZE*MAX_ARG_PAGES-sizeof(unsigned int);
1406 for (i=0 ; i<MAX_ARG_PAGES ; i++) /* clear page-table */
1408 retval = open(filename, O_RDONLY);
1412 bprm.filename = (char *)filename;
1417 bprm.argc = count(argv);
1418 bprm.envc = count(envp);
1420 retval = prepare_binprm(&bprm);
1423 bprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p);
1425 bprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p);
1426 bprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p);
1433 retval = load_elf_binary(&bprm,regs,infop);
1436 /* success. Initialize important registers */
1437 init_thread(regs, infop);
1441 /* Something went wrong, return the inode and free the argument pages*/
1442 for (i=0 ; i<MAX_ARG_PAGES ; i++) {
1443 free_page((void *)bprm.page[i]);
1449 static int load_aout_interp(void * exptr, int interp_fd)
1451 printf("a.out interpreter not yet supported\n");