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)
101 regs->u_regs[0] = infop->entry;
102 regs->u_regs[1] = infop->start_stack;
109 #define ELF_START_MMAP 0x80000000
111 #define elf_check_arch(x) ( (x) == EM_PPC )
113 #define ELF_CLASS ELFCLASS32
114 #ifdef TARGET_WORDS_BIGENDIAN
115 #define ELF_DATA ELFDATA2MSB
117 #define ELF_DATA ELFDATA2LSB
119 #define ELF_ARCH EM_PPC
121 /* Note that isn't exactly what regular kernel does
122 * but this is what the ABI wants and is needed to allow
123 * execution of PPC BSD programs.
125 #define ELF_PLAT_INIT(_r) \
127 unsigned long *pos = (unsigned long *)bprm->p, tmp = 1; \
128 _r->gpr[3] = bprm->argc; \
129 _r->gpr[4] = (unsigned long)++pos; \
130 for (; tmp != 0; pos++) \
132 _r->gpr[5] = (unsigned long)pos; \
135 static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
137 _regs->msr = 1 << MSR_PR; /* Set user mode */
138 _regs->gpr[1] = infop->start_stack;
139 _regs->nip = infop->entry;
142 #define USE_ELF_CORE_DUMP
143 #define ELF_EXEC_PAGESIZE 4096
150 * MAX_ARG_PAGES defines the number of pages allocated for arguments
151 * and envelope for the new program. 32 should suffice, this gives
152 * a maximum env+arg of 128kB w/4KB pages!
154 #define MAX_ARG_PAGES 32
157 * This structure is used to hold the arguments that are
158 * used when loading binaries.
160 struct linux_binprm {
162 unsigned long page[MAX_ARG_PAGES];
168 char * filename; /* Name of binary */
169 unsigned long loader, exec;
170 int dont_iput; /* binfmt handler has put inode */
175 unsigned int a_info; /* Use macros N_MAGIC, etc for access */
176 unsigned int a_text; /* length of text, in bytes */
177 unsigned int a_data; /* length of data, in bytes */
178 unsigned int a_bss; /* length of uninitialized data area, in bytes */
179 unsigned int a_syms; /* length of symbol table data in file, in bytes */
180 unsigned int a_entry; /* start address */
181 unsigned int a_trsize; /* length of relocation info for text, in bytes */
182 unsigned int a_drsize; /* length of relocation info for data, in bytes */
186 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
192 /* max code+data+bss space allocated to elf interpreter */
193 #define INTERP_MAP_SIZE (32 * 1024 * 1024)
195 /* max code+data+bss+brk space allocated to ET_DYN executables */
196 #define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
198 /* from personality.h */
200 /* Flags for bug emulation. These occupy the top three bytes. */
201 #define STICKY_TIMEOUTS 0x4000000
202 #define WHOLE_SECONDS 0x2000000
204 /* Personality types. These go in the low byte. Avoid using the top bit,
205 * it will conflict with error returns.
207 #define PER_MASK (0x00ff)
208 #define PER_LINUX (0x0000)
209 #define PER_SVR4 (0x0001 | STICKY_TIMEOUTS)
210 #define PER_SVR3 (0x0002 | STICKY_TIMEOUTS)
211 #define PER_SCOSVR3 (0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS)
212 #define PER_WYSEV386 (0x0004 | STICKY_TIMEOUTS)
213 #define PER_ISCR4 (0x0005 | STICKY_TIMEOUTS)
214 #define PER_BSD (0x0006)
215 #define PER_XENIX (0x0007 | STICKY_TIMEOUTS)
217 /* Necessary parameters */
220 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
221 #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
222 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
224 #define INTERPRETER_NONE 0
225 #define INTERPRETER_AOUT 1
226 #define INTERPRETER_ELF 2
228 #define DLINFO_ITEMS 12
230 #define put_user(x,ptr) (void)(*(ptr) = (typeof(*ptr))(x))
231 #define get_user(ptr) (typeof(*ptr))(*(ptr))
233 static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
238 static inline void memcpy_tofs(void * to, const void * from, unsigned long n)
243 extern unsigned long x86_stack_size;
245 static int load_aout_interp(void * exptr, int interp_fd);
248 static void bswap_ehdr(Elf32_Ehdr *ehdr)
250 bswap16s(&ehdr->e_type); /* Object file type */
251 bswap16s(&ehdr->e_machine); /* Architecture */
252 bswap32s(&ehdr->e_version); /* Object file version */
253 bswap32s(&ehdr->e_entry); /* Entry point virtual address */
254 bswap32s(&ehdr->e_phoff); /* Program header table file offset */
255 bswap32s(&ehdr->e_shoff); /* Section header table file offset */
256 bswap32s(&ehdr->e_flags); /* Processor-specific flags */
257 bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
258 bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
259 bswap16s(&ehdr->e_phnum); /* Program header table entry count */
260 bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
261 bswap16s(&ehdr->e_shnum); /* Section header table entry count */
262 bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
265 static void bswap_phdr(Elf32_Phdr *phdr)
267 bswap32s(&phdr->p_type); /* Segment type */
268 bswap32s(&phdr->p_offset); /* Segment file offset */
269 bswap32s(&phdr->p_vaddr); /* Segment virtual address */
270 bswap32s(&phdr->p_paddr); /* Segment physical address */
271 bswap32s(&phdr->p_filesz); /* Segment size in file */
272 bswap32s(&phdr->p_memsz); /* Segment size in memory */
273 bswap32s(&phdr->p_flags); /* Segment flags */
274 bswap32s(&phdr->p_align); /* Segment alignment */
277 static void bswap_shdr(Elf32_Shdr *shdr)
279 bswap32s(&shdr->sh_name);
280 bswap32s(&shdr->sh_type);
281 bswap32s(&shdr->sh_flags);
282 bswap32s(&shdr->sh_addr);
283 bswap32s(&shdr->sh_offset);
284 bswap32s(&shdr->sh_size);
285 bswap32s(&shdr->sh_link);
286 bswap32s(&shdr->sh_info);
287 bswap32s(&shdr->sh_addralign);
288 bswap32s(&shdr->sh_entsize);
291 static void bswap_sym(Elf32_Sym *sym)
293 bswap32s(&sym->st_name);
294 bswap32s(&sym->st_value);
295 bswap32s(&sym->st_size);
296 bswap16s(&sym->st_shndx);
300 static void * get_free_page(void)
304 /* User-space version of kernel get_free_page. Returns a page-aligned
305 * page-sized chunk of memory.
307 retval = (void *)target_mmap(0, host_page_size, PROT_READ|PROT_WRITE,
308 MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
310 if((long)retval == -1) {
311 perror("get_free_page");
319 static void free_page(void * pageaddr)
321 target_munmap((unsigned long)pageaddr, host_page_size);
325 * 'copy_string()' copies argument/envelope strings from user
326 * memory to free pages in kernel mem. These are in a format ready
327 * to be put directly into the top of new user memory.
330 static unsigned long copy_strings(int argc,char ** argv,unsigned long *page,
333 char *tmp, *tmp1, *pag = NULL;
337 return 0; /* bullet-proofing */
340 if (!(tmp1 = tmp = get_user(argv+argc))) {
341 fprintf(stderr, "VFS: argc is wrong");
344 while (get_user(tmp++));
346 if (p < len) { /* this shouldn't happen - 128kB */
352 offset = p % TARGET_PAGE_SIZE;
353 if (!(pag = (char *) page[p/TARGET_PAGE_SIZE]) &&
354 !(pag = (char *) page[p/TARGET_PAGE_SIZE] =
355 (unsigned long *) get_free_page())) {
359 if (len == 0 || offset == 0) {
360 *(pag + offset) = get_user(tmp);
363 int bytes_to_copy = (len > offset) ? offset : len;
364 tmp -= bytes_to_copy;
366 offset -= bytes_to_copy;
367 len -= bytes_to_copy;
368 memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
375 static int in_group_p(gid_t g)
377 /* return TRUE if we're in the specified group, FALSE otherwise */
380 gid_t grouplist[NGROUPS];
382 ngroup = getgroups(NGROUPS, grouplist);
383 for(i = 0; i < ngroup; i++) {
384 if(grouplist[i] == g) {
391 static int count(char ** vec)
395 for(i = 0; *vec; i++) {
402 static int prepare_binprm(struct linux_binprm *bprm)
406 int retval, id_change;
408 if(fstat(bprm->fd, &st) < 0) {
413 if(!S_ISREG(mode)) { /* Must be regular file */
416 if(!(mode & 0111)) { /* Must have at least one execute bit set */
420 bprm->e_uid = geteuid();
421 bprm->e_gid = getegid();
426 bprm->e_uid = st.st_uid;
427 if(bprm->e_uid != geteuid()) {
434 * If setgid is set but no group execute bit then this
435 * is a candidate for mandatory locking, not a setgid
438 if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
439 bprm->e_gid = st.st_gid;
440 if (!in_group_p(bprm->e_gid)) {
445 memset(bprm->buf, 0, sizeof(bprm->buf));
446 retval = lseek(bprm->fd, 0L, SEEK_SET);
448 retval = read(bprm->fd, bprm->buf, 128);
451 perror("prepare_binprm");
453 /* return(-errno); */
460 unsigned long setup_arg_pages(unsigned long p, struct linux_binprm * bprm,
461 struct image_info * info)
463 unsigned long stack_base, size, error;
466 /* Create enough stack to hold everything. If we don't use
467 * it for args, we'll use it for something else...
469 size = x86_stack_size;
470 if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE)
471 size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;
472 error = target_mmap(0,
473 size + host_page_size,
474 PROT_READ | PROT_WRITE,
475 MAP_PRIVATE | MAP_ANONYMOUS,
481 /* we reserve one extra page at the top of the stack as guard */
482 target_mprotect(error + size, host_page_size, PROT_NONE);
484 stack_base = error + size - MAX_ARG_PAGES*TARGET_PAGE_SIZE;
488 bprm->loader += stack_base;
490 bprm->exec += stack_base;
492 for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
496 memcpy((void *)stack_base, (void *)bprm->page[i], TARGET_PAGE_SIZE);
497 free_page((void *)bprm->page[i]);
499 stack_base += TARGET_PAGE_SIZE;
504 static void set_brk(unsigned long start, unsigned long end)
506 /* page-align the start and end addresses... */
507 start = HOST_PAGE_ALIGN(start);
508 end = HOST_PAGE_ALIGN(end);
511 if(target_mmap(start, end - start,
512 PROT_READ | PROT_WRITE | PROT_EXEC,
513 MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == -1) {
514 perror("cannot mmap brk");
520 /* We need to explicitly zero any fractional pages after the data
521 section (i.e. bss). This would contain the junk from the file that
522 should not be in memory. */
523 static void padzero(unsigned long elf_bss)
528 /* XXX: this is really a hack : if the real host page size is
529 smaller than the target page size, some pages after the end
530 of the file may not be mapped. A better fix would be to
531 patch target_mmap(), but it is more complicated as the file
532 size must be known */
533 if (real_host_page_size < host_page_size) {
534 unsigned long end_addr, end_addr1;
535 end_addr1 = (elf_bss + real_host_page_size - 1) &
536 ~(real_host_page_size - 1);
537 end_addr = HOST_PAGE_ALIGN(elf_bss);
538 if (end_addr1 < end_addr) {
539 mmap((void *)end_addr1, end_addr - end_addr1,
540 PROT_READ|PROT_WRITE|PROT_EXEC,
541 MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
545 nbyte = elf_bss & (host_page_size-1);
547 nbyte = host_page_size - nbyte;
548 fpnt = (char *) elf_bss;
555 static unsigned int * create_elf_tables(char *p, int argc, int envc,
556 struct elfhdr * exec,
557 unsigned long load_addr,
558 unsigned long load_bias,
559 unsigned long interp_load_addr, int ibcs,
560 struct image_info *info)
562 target_ulong *argv, *envp, *dlinfo;
566 * Force 16 byte alignment here for generality.
568 sp = (unsigned int *) (~15UL & (unsigned long) p);
569 sp -= DLINFO_ITEMS*2;
576 put_user(tswapl((target_ulong)envp),--sp);
577 put_user(tswapl((target_ulong)argv),--sp);
580 #define NEW_AUX_ENT(id, val) \
581 put_user (tswapl(id), dlinfo++); \
582 put_user (tswapl(val), dlinfo++)
584 NEW_AUX_ENT (AT_PHDR, (target_ulong)(load_addr + exec->e_phoff));
585 NEW_AUX_ENT (AT_PHENT, (target_ulong)(sizeof (struct elf_phdr)));
586 NEW_AUX_ENT (AT_PHNUM, (target_ulong)(exec->e_phnum));
587 NEW_AUX_ENT (AT_PAGESZ, (target_ulong)(TARGET_PAGE_SIZE));
588 NEW_AUX_ENT (AT_BASE, (target_ulong)(interp_load_addr));
589 NEW_AUX_ENT (AT_FLAGS, (target_ulong)0);
590 NEW_AUX_ENT (AT_ENTRY, load_bias + exec->e_entry);
591 NEW_AUX_ENT (AT_UID, (target_ulong) getuid());
592 NEW_AUX_ENT (AT_EUID, (target_ulong) geteuid());
593 NEW_AUX_ENT (AT_GID, (target_ulong) getgid());
594 NEW_AUX_ENT (AT_EGID, (target_ulong) getegid());
595 NEW_AUX_ENT (AT_NULL, 0);
598 put_user(tswapl(argc),--sp);
599 info->arg_start = (unsigned int)((unsigned long)p & 0xffffffff);
601 put_user(tswapl((target_ulong)p),argv++);
602 while (get_user(p++)) /* nothing */ ;
605 info->arg_end = info->env_start = (unsigned int)((unsigned long)p & 0xffffffff);
607 put_user(tswapl((target_ulong)p),envp++);
608 while (get_user(p++)) /* nothing */ ;
611 info->env_end = (unsigned int)((unsigned long)p & 0xffffffff);
617 static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
619 unsigned long *interp_load_addr)
621 struct elf_phdr *elf_phdata = NULL;
622 struct elf_phdr *eppnt;
623 unsigned long load_addr = 0;
624 int load_addr_set = 0;
626 unsigned long last_bss, elf_bss;
635 bswap_ehdr(interp_elf_ex);
637 /* First of all, some simple consistency checks */
638 if ((interp_elf_ex->e_type != ET_EXEC &&
639 interp_elf_ex->e_type != ET_DYN) ||
640 !elf_check_arch(interp_elf_ex->e_machine)) {
645 /* Now read in all of the header information */
647 if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE)
650 elf_phdata = (struct elf_phdr *)
651 malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
657 * If the size of this structure has changed, then punt, since
658 * we will be doing the wrong thing.
660 if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) {
665 retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
667 retval = read(interpreter_fd,
669 sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
672 perror("load_elf_interp");
679 for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
684 if (interp_elf_ex->e_type == ET_DYN) {
685 /* in order to avoid harcoding the interpreter load
686 address in qemu, we allocate a big enough memory zone */
687 error = target_mmap(0, INTERP_MAP_SIZE,
688 PROT_NONE, MAP_PRIVATE | MAP_ANON,
699 for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++)
700 if (eppnt->p_type == PT_LOAD) {
701 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
703 unsigned long vaddr = 0;
706 if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
707 if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
708 if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
709 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set) {
710 elf_type |= MAP_FIXED;
711 vaddr = eppnt->p_vaddr;
713 error = target_mmap(load_addr+TARGET_ELF_PAGESTART(vaddr),
714 eppnt->p_filesz + TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr),
718 eppnt->p_offset - TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr));
720 if (error > -1024UL) {
722 close(interpreter_fd);
727 if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
733 * Find the end of the file mapping for this phdr, and keep
734 * track of the largest address we see for this.
736 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
737 if (k > elf_bss) elf_bss = k;
740 * Do the same thing for the memory mapping - between
741 * elf_bss and last_bss is the bss section.
743 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
744 if (k > last_bss) last_bss = k;
747 /* Now use mmap to map the library into memory. */
749 close(interpreter_fd);
752 * Now fill out the bss section. First pad the last page up
753 * to the page boundary, and then perform a mmap to make sure
754 * that there are zeromapped pages up to and including the last
758 elf_bss = TARGET_ELF_PAGESTART(elf_bss + host_page_size - 1); /* What we have mapped so far */
760 /* Map the last of the bss segment */
761 if (last_bss > elf_bss) {
762 target_mmap(elf_bss, last_bss-elf_bss,
763 PROT_READ|PROT_WRITE|PROT_EXEC,
764 MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
768 *interp_load_addr = load_addr;
769 return ((unsigned long) interp_elf_ex->e_entry) + load_addr;
772 /* Best attempt to load symbols from this ELF object. */
773 static void load_symbols(struct elfhdr *hdr, int fd)
776 struct elf_shdr sechdr, symtab, strtab;
779 lseek(fd, hdr->e_shoff, SEEK_SET);
780 for (i = 0; i < hdr->e_shnum; i++) {
781 if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr))
786 if (sechdr.sh_type == SHT_SYMTAB) {
788 lseek(fd, hdr->e_shoff
789 + sizeof(sechdr) * sechdr.sh_link, SEEK_SET);
790 if (read(fd, &strtab, sizeof(strtab))
799 return; /* Shouldn't happen... */
802 /* Now know where the strtab and symtab are. Snarf them. */
803 disas_symtab = malloc(symtab.sh_size);
804 disas_strtab = strings = malloc(strtab.sh_size);
805 if (!disas_symtab || !disas_strtab)
808 lseek(fd, symtab.sh_offset, SEEK_SET);
809 if (read(fd, disas_symtab, symtab.sh_size) != symtab.sh_size)
813 for (i = 0; i < symtab.sh_size / sizeof(struct elf_sym); i++)
814 bswap_sym(disas_symtab + sizeof(struct elf_sym)*i);
817 lseek(fd, strtab.sh_offset, SEEK_SET);
818 if (read(fd, strings, strtab.sh_size) != strtab.sh_size)
820 disas_num_syms = symtab.sh_size / sizeof(struct elf_sym);
823 static int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
824 struct image_info * info)
826 struct elfhdr elf_ex;
827 struct elfhdr interp_elf_ex;
828 struct exec interp_ex;
829 int interpreter_fd = -1; /* avoid warning */
830 unsigned long load_addr, load_bias;
831 int load_addr_set = 0;
832 unsigned int interpreter_type = INTERPRETER_NONE;
833 unsigned char ibcs2_interpreter;
835 unsigned long mapped_addr;
836 struct elf_phdr * elf_ppnt;
837 struct elf_phdr *elf_phdata;
838 unsigned long elf_bss, k, elf_brk;
840 char * elf_interpreter;
841 unsigned long elf_entry, interp_load_addr = 0;
843 unsigned long start_code, end_code, end_data;
844 unsigned long elf_stack;
845 char passed_fileno[6];
847 ibcs2_interpreter = 0;
851 elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
856 if (elf_ex.e_ident[0] != 0x7f ||
857 strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) {
861 /* First of all, some simple consistency checks */
862 if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
863 (! elf_check_arch(elf_ex.e_machine))) {
867 /* Now read in all of the header information */
868 elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);
869 if (elf_phdata == NULL) {
873 retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);
875 retval = read(bprm->fd, (char *) elf_phdata,
876 elf_ex.e_phentsize * elf_ex.e_phnum);
880 perror("load_elf_binary");
887 elf_ppnt = elf_phdata;
888 for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {
889 bswap_phdr(elf_ppnt);
892 elf_ppnt = elf_phdata;
899 elf_interpreter = NULL;
904 for(i=0;i < elf_ex.e_phnum; i++) {
905 if (elf_ppnt->p_type == PT_INTERP) {
906 if ( elf_interpreter != NULL )
909 free(elf_interpreter);
914 /* This is the program interpreter used for
915 * shared libraries - for now assume that this
916 * is an a.out format binary
919 elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
921 if (elf_interpreter == NULL) {
927 retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);
929 retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);
932 perror("load_elf_binary2");
936 /* If the program interpreter is one of these two,
937 then assume an iBCS2 image. Otherwise assume
938 a native linux image. */
940 /* JRP - Need to add X86 lib dir stuff here... */
942 if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
943 strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) {
944 ibcs2_interpreter = 1;
948 printf("Using ELF interpreter %s\n", elf_interpreter);
951 retval = open(path(elf_interpreter), O_RDONLY);
953 interpreter_fd = retval;
956 perror(elf_interpreter);
958 /* retval = -errno; */
963 retval = lseek(interpreter_fd, 0, SEEK_SET);
965 retval = read(interpreter_fd,bprm->buf,128);
969 interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */
970 interp_elf_ex=*((struct elfhdr *) bprm->buf); /* elf exec-header */
973 perror("load_elf_binary3");
976 free(elf_interpreter);
984 /* Some simple consistency checks for the interpreter */
985 if (elf_interpreter){
986 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
988 /* Now figure out which format our binary is */
989 if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&
990 (N_MAGIC(interp_ex) != QMAGIC)) {
991 interpreter_type = INTERPRETER_ELF;
994 if (interp_elf_ex.e_ident[0] != 0x7f ||
995 strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) {
996 interpreter_type &= ~INTERPRETER_ELF;
999 if (!interpreter_type) {
1000 free(elf_interpreter);
1007 /* OK, we are done with that, now set up the arg stuff,
1008 and then start this sucker up */
1010 if (!bprm->sh_bang) {
1013 if (interpreter_type == INTERPRETER_AOUT) {
1014 sprintf(passed_fileno, "%d", bprm->fd);
1015 passed_p = passed_fileno;
1017 if (elf_interpreter) {
1018 bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p);
1023 if (elf_interpreter) {
1024 free(elf_interpreter);
1032 /* OK, This is the point of no return */
1035 info->start_mmap = (unsigned long)ELF_START_MMAP;
1037 elf_entry = (unsigned long) elf_ex.e_entry;
1039 /* Do this so that we can load the interpreter, if need be. We will
1040 change some of these later */
1042 bprm->p = setup_arg_pages(bprm->p, bprm, info);
1043 info->start_stack = bprm->p;
1045 /* Now we do a little grungy work by mmaping the ELF image into
1046 * the correct location in memory. At this point, we assume that
1047 * the image should be loaded at fixed address, not at a variable
1051 for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
1054 unsigned long error;
1056 if (elf_ppnt->p_type != PT_LOAD)
1059 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
1060 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
1061 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
1062 elf_flags = MAP_PRIVATE | MAP_DENYWRITE;
1063 if (elf_ex.e_type == ET_EXEC || load_addr_set) {
1064 elf_flags |= MAP_FIXED;
1065 } else if (elf_ex.e_type == ET_DYN) {
1066 /* Try and get dynamic programs out of the way of the default mmap
1067 base, as well as whatever program they might try to exec. This
1068 is because the brk will follow the loader, and is not movable. */
1069 /* NOTE: for qemu, we do a big mmap to get enough space
1070 without harcoding any address */
1071 error = target_mmap(0, ET_DYN_MAP_SIZE,
1072 PROT_NONE, MAP_PRIVATE | MAP_ANON,
1078 load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr);
1081 error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),
1082 (elf_ppnt->p_filesz +
1083 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
1085 (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),
1087 (elf_ppnt->p_offset -
1088 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
1094 #ifdef LOW_ELF_STACK
1095 if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)
1096 elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr);
1099 if (!load_addr_set) {
1101 load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;
1102 if (elf_ex.e_type == ET_DYN) {
1103 load_bias += error -
1104 TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr);
1105 load_addr += load_bias;
1108 k = elf_ppnt->p_vaddr;
1111 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1114 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1118 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1119 if (k > elf_brk) elf_brk = k;
1122 elf_entry += load_bias;
1123 elf_bss += load_bias;
1124 elf_brk += load_bias;
1125 start_code += load_bias;
1126 end_code += load_bias;
1127 // start_data += load_bias;
1128 end_data += load_bias;
1130 if (elf_interpreter) {
1131 if (interpreter_type & 1) {
1132 elf_entry = load_aout_interp(&interp_ex, interpreter_fd);
1134 else if (interpreter_type & 2) {
1135 elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,
1139 close(interpreter_fd);
1140 free(elf_interpreter);
1142 if (elf_entry == ~0UL) {
1143 printf("Unable to load interpreter\n");
1153 load_symbols(&elf_ex, bprm->fd);
1155 if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);
1156 info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX);
1158 #ifdef LOW_ELF_STACK
1159 info->start_stack = bprm->p = elf_stack - 4;
1161 bprm->p = (unsigned long)
1162 create_elf_tables((char *)bprm->p,
1166 load_addr, load_bias,
1168 (interpreter_type == INTERPRETER_AOUT ? 0 : 1),
1170 if (interpreter_type == INTERPRETER_AOUT)
1171 info->arg_start += strlen(passed_fileno) + 1;
1172 info->start_brk = info->brk = elf_brk;
1173 info->end_code = end_code;
1174 info->start_code = start_code;
1175 info->end_data = end_data;
1176 info->start_stack = bprm->p;
1178 /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1180 set_brk(elf_bss, elf_brk);
1185 printf("(start_brk) %x\n" , info->start_brk);
1186 printf("(end_code) %x\n" , info->end_code);
1187 printf("(start_code) %x\n" , info->start_code);
1188 printf("(end_data) %x\n" , info->end_data);
1189 printf("(start_stack) %x\n" , info->start_stack);
1190 printf("(brk) %x\n" , info->brk);
1193 if ( info->personality == PER_SVR4 )
1195 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1196 and some applications "depend" upon this behavior.
1197 Since we do not have the power to recompile these, we
1198 emulate the SVr4 behavior. Sigh. */
1199 mapped_addr = target_mmap(0, host_page_size, PROT_READ | PROT_EXEC,
1200 MAP_FIXED | MAP_PRIVATE, -1, 0);
1203 #ifdef ELF_PLAT_INIT
1205 * The ABI may specify that certain registers be set up in special
1206 * ways (on i386 %edx is the address of a DT_FINI function, for
1207 * example. This macro performs whatever initialization to
1208 * the regs structure is required.
1210 ELF_PLAT_INIT(regs);
1214 info->entry = elf_entry;
1221 int elf_exec(const char * filename, char ** argv, char ** envp,
1222 struct target_pt_regs * regs, struct image_info *infop)
1224 struct linux_binprm bprm;
1228 bprm.p = TARGET_PAGE_SIZE*MAX_ARG_PAGES-sizeof(unsigned int);
1229 for (i=0 ; i<MAX_ARG_PAGES ; i++) /* clear page-table */
1231 retval = open(filename, O_RDONLY);
1235 /* return retval; */
1240 bprm.filename = (char *)filename;
1245 bprm.argc = count(argv);
1246 bprm.envc = count(envp);
1248 retval = prepare_binprm(&bprm);
1251 bprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p);
1253 bprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p);
1254 bprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p);
1261 retval = load_elf_binary(&bprm,regs,infop);
1264 /* success. Initialize important registers */
1265 init_thread(regs, infop);
1269 /* Something went wrong, return the inode and free the argument pages*/
1270 for (i=0 ; i<MAX_ARG_PAGES ; i++) {
1271 free_page((void *)bprm.page[i]);
1277 static int load_aout_interp(void * exptr, int interp_fd)
1279 printf("a.out interpreter not yet supported\n");