1 /* This is the Linux kernel elf-loading code, ported into user space */
15 /* this flag is uneffective under linux too, should be deleted */
17 #define MAP_DENYWRITE 0
20 /* should probably go in elf.h */
27 #define ELF_PLATFORM get_elf_platform()
29 static const char *get_elf_platform(void)
31 static char elf_platform
[] = "i386";
32 int family
= (global_env
->cpuid_version
>> 8) & 0xff;
36 elf_platform
[1] = '0' + family
;
40 #define ELF_HWCAP get_elf_hwcap()
42 static uint32_t get_elf_hwcap(void)
44 return global_env
->cpuid_features
;
48 #define ELF_START_MMAP 0x2aaaaab000ULL
49 #define elf_check_arch(x) ( ((x) == ELF_ARCH) )
51 #define ELF_CLASS ELFCLASS64
52 #define ELF_DATA ELFDATA2LSB
53 #define ELF_ARCH EM_X86_64
55 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
58 regs
->rsp
= infop
->start_stack
;
59 regs
->rip
= infop
->entry
;
64 #define ELF_START_MMAP 0x80000000
67 * This is used to ensure we don't load something for the wrong architecture.
69 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
72 * These are used to set parameters in the core dumps.
74 #define ELF_CLASS ELFCLASS32
75 #define ELF_DATA ELFDATA2LSB
76 #define ELF_ARCH EM_386
78 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
80 regs
->esp
= infop
->start_stack
;
81 regs
->eip
= infop
->entry
;
83 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
84 starts %edx contains a pointer to a function which might be
85 registered using `atexit'. This provides a mean for the
86 dynamic linker to call DT_FINI functions for shared libraries
87 that have been loaded before the code runs.
89 A value of 0 tells we have no such handler. */
94 #define USE_ELF_CORE_DUMP
95 #define ELF_EXEC_PAGESIZE 4096
101 #define ELF_START_MMAP 0x80000000
103 #define elf_check_arch(x) ( (x) == EM_ARM )
105 #define ELF_CLASS ELFCLASS32
106 #ifdef TARGET_WORDS_BIGENDIAN
107 #define ELF_DATA ELFDATA2MSB
109 #define ELF_DATA ELFDATA2LSB
111 #define ELF_ARCH EM_ARM
113 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
115 target_long stack
= infop
->start_stack
;
116 memset(regs
, 0, sizeof(*regs
));
117 regs
->ARM_cpsr
= 0x10;
118 if (infop
->entry
& 1)
119 regs
->ARM_cpsr
|= CPSR_T
;
120 regs
->ARM_pc
= infop
->entry
& 0xfffffffe;
121 regs
->ARM_sp
= infop
->start_stack
;
122 regs
->ARM_r2
= tgetl(stack
+ 8); /* envp */
123 regs
->ARM_r1
= tgetl(stack
+ 4); /* envp */
124 /* XXX: it seems that r0 is zeroed after ! */
126 /* For uClinux PIC binaries. */
127 regs
->ARM_r10
= infop
->start_data
;
130 #define USE_ELF_CORE_DUMP
131 #define ELF_EXEC_PAGESIZE 4096
135 ARM_HWCAP_ARM_SWP
= 1 << 0,
136 ARM_HWCAP_ARM_HALF
= 1 << 1,
137 ARM_HWCAP_ARM_THUMB
= 1 << 2,
138 ARM_HWCAP_ARM_26BIT
= 1 << 3,
139 ARM_HWCAP_ARM_FAST_MULT
= 1 << 4,
140 ARM_HWCAP_ARM_FPA
= 1 << 5,
141 ARM_HWCAP_ARM_VFP
= 1 << 6,
142 ARM_HWCAP_ARM_EDSP
= 1 << 7,
145 #define ELF_HWCAP (ARM_HWCAP_ARM_SWP | ARM_HWCAP_ARM_HALF \
146 | ARM_HWCAP_ARM_THUMB | ARM_HWCAP_ARM_FAST_MULT \
147 | ARM_HWCAP_ARM_FPA | ARM_HWCAP_ARM_VFP)
152 #ifdef TARGET_SPARC64
154 #define ELF_START_MMAP 0x80000000
156 #define elf_check_arch(x) ( (x) == EM_SPARCV9 )
158 #define ELF_CLASS ELFCLASS64
159 #define ELF_DATA ELFDATA2MSB
160 #define ELF_ARCH EM_SPARCV9
162 #define STACK_BIAS 2047
164 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
167 regs
->pc
= infop
->entry
;
168 regs
->npc
= regs
->pc
+ 4;
170 regs
->u_regs
[14] = infop
->start_stack
- 16 * 8 - STACK_BIAS
;
174 #define ELF_START_MMAP 0x80000000
176 #define elf_check_arch(x) ( (x) == EM_SPARC )
178 #define ELF_CLASS ELFCLASS32
179 #define ELF_DATA ELFDATA2MSB
180 #define ELF_ARCH EM_SPARC
182 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
185 regs
->pc
= infop
->entry
;
186 regs
->npc
= regs
->pc
+ 4;
188 regs
->u_regs
[14] = infop
->start_stack
- 16 * 4;
196 #define ELF_START_MMAP 0x80000000
200 #define elf_check_arch(x) ( (x) == EM_PPC64 )
202 #define ELF_CLASS ELFCLASS64
206 #define elf_check_arch(x) ( (x) == EM_PPC )
208 #define ELF_CLASS ELFCLASS32
212 #ifdef TARGET_WORDS_BIGENDIAN
213 #define ELF_DATA ELFDATA2MSB
215 #define ELF_DATA ELFDATA2LSB
217 #define ELF_ARCH EM_PPC
220 * We need to put in some extra aux table entries to tell glibc what
221 * the cache block size is, so it can use the dcbz instruction safely.
223 #define AT_DCACHEBSIZE 19
224 #define AT_ICACHEBSIZE 20
225 #define AT_UCACHEBSIZE 21
226 /* A special ignored type value for PPC, for glibc compatibility. */
227 #define AT_IGNOREPPC 22
229 * The requirements here are:
230 * - keep the final alignment of sp (sp & 0xf)
231 * - make sure the 32-bit value at the first 16 byte aligned position of
232 * AUXV is greater than 16 for glibc compatibility.
233 * AT_IGNOREPPC is used for that.
234 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
235 * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
237 #define DLINFO_ARCH_ITEMS 5
238 #define ARCH_DLINFO \
240 NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20); \
241 NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20); \
242 NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \
244 * Now handle glibc compatibility. \
246 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
247 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
250 static inline void init_thread(struct target_pt_regs
*_regs
, struct image_info
*infop
)
252 target_ulong pos
= infop
->start_stack
;
255 target_ulong entry
, toc
;
258 _regs
->msr
= 1 << MSR_PR
; /* Set user mode */
259 _regs
->gpr
[1] = infop
->start_stack
;
261 entry
= ldq_raw(infop
->entry
) + infop
->load_addr
;
262 toc
= ldq_raw(infop
->entry
+ 8) + infop
->load_addr
;
264 infop
->entry
= entry
;
266 _regs
->nip
= infop
->entry
;
267 /* Note that isn't exactly what regular kernel does
268 * but this is what the ABI wants and is needed to allow
269 * execution of PPC BSD programs.
271 _regs
->gpr
[3] = tgetl(pos
);
272 pos
+= sizeof(target_ulong
);
274 for (tmp
= 1; tmp
!= 0; pos
+= sizeof(target_ulong
))
279 #define USE_ELF_CORE_DUMP
280 #define ELF_EXEC_PAGESIZE 4096
286 #define ELF_START_MMAP 0x80000000
288 #define elf_check_arch(x) ( (x) == EM_MIPS )
290 #define ELF_CLASS ELFCLASS32
291 #ifdef TARGET_WORDS_BIGENDIAN
292 #define ELF_DATA ELFDATA2MSB
294 #define ELF_DATA ELFDATA2LSB
296 #define ELF_ARCH EM_MIPS
298 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
300 regs
->cp0_status
= CP0St_UM
;
301 regs
->cp0_epc
= infop
->entry
;
302 regs
->regs
[29] = infop
->start_stack
;
305 #endif /* TARGET_MIPS */
309 #define ELF_START_MMAP 0x80000000
311 #define elf_check_arch(x) ( (x) == EM_SH )
313 #define ELF_CLASS ELFCLASS32
314 #define ELF_DATA ELFDATA2LSB
315 #define ELF_ARCH EM_SH
317 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
319 /* Check other registers XXXXX */
320 regs
->pc
= infop
->entry
;
321 regs
->regs
[15] = infop
->start_stack
- 16 * 4;
324 #define USE_ELF_CORE_DUMP
325 #define ELF_EXEC_PAGESIZE 4096
331 #define ELF_START_MMAP 0x80000000
333 #define elf_check_arch(x) ( (x) == EM_68K )
335 #define ELF_CLASS ELFCLASS32
336 #define ELF_DATA ELFDATA2MSB
337 #define ELF_ARCH EM_68K
339 /* ??? Does this need to do anything?
340 #define ELF_PLAT_INIT(_r) */
342 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
344 regs
->usp
= infop
->start_stack
;
346 regs
->pc
= infop
->entry
;
349 #define USE_ELF_CORE_DUMP
350 #define ELF_EXEC_PAGESIZE 8192
356 #define ELF_START_MMAP (0x30000000000ULL)
358 #define elf_check_arch(x) ( (x) == ELF_ARCH )
360 #define ELF_CLASS ELFCLASS64
361 #define ELF_DATA ELFDATA2MSB
362 #define ELF_ARCH EM_ALPHA
364 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
366 regs
->pc
= infop
->entry
;
368 regs
->usp
= infop
->start_stack
;
369 regs
->unique
= infop
->start_data
; /* ? */
370 printf("Set unique value to " TARGET_FMT_lx
" (" TARGET_FMT_lx
")\n",
371 regs
->unique
, infop
->start_data
);
374 #define USE_ELF_CORE_DUMP
375 #define ELF_EXEC_PAGESIZE 8192
377 #endif /* TARGET_ALPHA */
380 #define ELF_PLATFORM (NULL)
391 unsigned int a_info
; /* Use macros N_MAGIC, etc for access */
392 unsigned int a_text
; /* length of text, in bytes */
393 unsigned int a_data
; /* length of data, in bytes */
394 unsigned int a_bss
; /* length of uninitialized data area, in bytes */
395 unsigned int a_syms
; /* length of symbol table data in file, in bytes */
396 unsigned int a_entry
; /* start address */
397 unsigned int a_trsize
; /* length of relocation info for text, in bytes */
398 unsigned int a_drsize
; /* length of relocation info for data, in bytes */
402 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
408 /* max code+data+bss space allocated to elf interpreter */
409 #define INTERP_MAP_SIZE (32 * 1024 * 1024)
411 /* max code+data+bss+brk space allocated to ET_DYN executables */
412 #define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
414 /* from personality.h */
416 /* Flags for bug emulation. These occupy the top three bytes. */
417 #define STICKY_TIMEOUTS 0x4000000
418 #define WHOLE_SECONDS 0x2000000
420 /* Personality types. These go in the low byte. Avoid using the top bit,
421 * it will conflict with error returns.
423 #define PER_MASK (0x00ff)
424 #define PER_LINUX (0x0000)
425 #define PER_SVR4 (0x0001 | STICKY_TIMEOUTS)
426 #define PER_SVR3 (0x0002 | STICKY_TIMEOUTS)
427 #define PER_SCOSVR3 (0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS)
428 #define PER_WYSEV386 (0x0004 | STICKY_TIMEOUTS)
429 #define PER_ISCR4 (0x0005 | STICKY_TIMEOUTS)
430 #define PER_BSD (0x0006)
431 #define PER_XENIX (0x0007 | STICKY_TIMEOUTS)
433 /* Necessary parameters */
434 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
435 #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
436 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
438 #define INTERPRETER_NONE 0
439 #define INTERPRETER_AOUT 1
440 #define INTERPRETER_ELF 2
442 #define DLINFO_ITEMS 12
444 static inline void memcpy_fromfs(void * to
, const void * from
, unsigned long n
)
449 extern unsigned long x86_stack_size
;
451 static int load_aout_interp(void * exptr
, int interp_fd
);
454 static void bswap_ehdr(struct elfhdr
*ehdr
)
456 bswap16s(&ehdr
->e_type
); /* Object file type */
457 bswap16s(&ehdr
->e_machine
); /* Architecture */
458 bswap32s(&ehdr
->e_version
); /* Object file version */
459 bswaptls(&ehdr
->e_entry
); /* Entry point virtual address */
460 bswaptls(&ehdr
->e_phoff
); /* Program header table file offset */
461 bswaptls(&ehdr
->e_shoff
); /* Section header table file offset */
462 bswap32s(&ehdr
->e_flags
); /* Processor-specific flags */
463 bswap16s(&ehdr
->e_ehsize
); /* ELF header size in bytes */
464 bswap16s(&ehdr
->e_phentsize
); /* Program header table entry size */
465 bswap16s(&ehdr
->e_phnum
); /* Program header table entry count */
466 bswap16s(&ehdr
->e_shentsize
); /* Section header table entry size */
467 bswap16s(&ehdr
->e_shnum
); /* Section header table entry count */
468 bswap16s(&ehdr
->e_shstrndx
); /* Section header string table index */
471 static void bswap_phdr(struct elf_phdr
*phdr
)
473 bswap32s(&phdr
->p_type
); /* Segment type */
474 bswaptls(&phdr
->p_offset
); /* Segment file offset */
475 bswaptls(&phdr
->p_vaddr
); /* Segment virtual address */
476 bswaptls(&phdr
->p_paddr
); /* Segment physical address */
477 bswaptls(&phdr
->p_filesz
); /* Segment size in file */
478 bswaptls(&phdr
->p_memsz
); /* Segment size in memory */
479 bswap32s(&phdr
->p_flags
); /* Segment flags */
480 bswaptls(&phdr
->p_align
); /* Segment alignment */
483 static void bswap_shdr(struct elf_shdr
*shdr
)
485 bswap32s(&shdr
->sh_name
);
486 bswap32s(&shdr
->sh_type
);
487 bswaptls(&shdr
->sh_flags
);
488 bswaptls(&shdr
->sh_addr
);
489 bswaptls(&shdr
->sh_offset
);
490 bswaptls(&shdr
->sh_size
);
491 bswap32s(&shdr
->sh_link
);
492 bswap32s(&shdr
->sh_info
);
493 bswaptls(&shdr
->sh_addralign
);
494 bswaptls(&shdr
->sh_entsize
);
497 static void bswap_sym(struct elf_sym
*sym
)
499 bswap32s(&sym
->st_name
);
500 bswaptls(&sym
->st_value
);
501 bswaptls(&sym
->st_size
);
502 bswap16s(&sym
->st_shndx
);
507 * 'copy_elf_strings()' copies argument/envelope strings from user
508 * memory to free pages in kernel mem. These are in a format ready
509 * to be put directly into the top of new user memory.
512 static unsigned long copy_elf_strings(int argc
,char ** argv
, void **page
,
515 char *tmp
, *tmp1
, *pag
= NULL
;
519 return 0; /* bullet-proofing */
524 fprintf(stderr
, "VFS: argc is wrong");
530 if (p
< len
) { /* this shouldn't happen - 128kB */
536 offset
= p
% TARGET_PAGE_SIZE
;
537 pag
= (char *)page
[p
/TARGET_PAGE_SIZE
];
539 pag
= (char *)malloc(TARGET_PAGE_SIZE
);
540 page
[p
/TARGET_PAGE_SIZE
] = pag
;
545 if (len
== 0 || offset
== 0) {
546 *(pag
+ offset
) = *tmp
;
549 int bytes_to_copy
= (len
> offset
) ? offset
: len
;
550 tmp
-= bytes_to_copy
;
552 offset
-= bytes_to_copy
;
553 len
-= bytes_to_copy
;
554 memcpy_fromfs(pag
+ offset
, tmp
, bytes_to_copy
+ 1);
561 unsigned long setup_arg_pages(target_ulong p
, struct linux_binprm
* bprm
,
562 struct image_info
* info
)
564 target_ulong stack_base
, size
, error
;
567 /* Create enough stack to hold everything. If we don't use
568 * it for args, we'll use it for something else...
570 size
= x86_stack_size
;
571 if (size
< MAX_ARG_PAGES
*TARGET_PAGE_SIZE
)
572 size
= MAX_ARG_PAGES
*TARGET_PAGE_SIZE
;
573 error
= target_mmap(0,
574 size
+ qemu_host_page_size
,
575 PROT_READ
| PROT_WRITE
,
576 MAP_PRIVATE
| MAP_ANONYMOUS
,
582 /* we reserve one extra page at the top of the stack as guard */
583 target_mprotect(error
+ size
, qemu_host_page_size
, PROT_NONE
);
585 stack_base
= error
+ size
- MAX_ARG_PAGES
*TARGET_PAGE_SIZE
;
588 for (i
= 0 ; i
< MAX_ARG_PAGES
; i
++) {
592 memcpy_to_target(stack_base
, bprm
->page
[i
], TARGET_PAGE_SIZE
);
595 stack_base
+= TARGET_PAGE_SIZE
;
600 static void set_brk(unsigned long start
, unsigned long end
)
602 /* page-align the start and end addresses... */
603 start
= HOST_PAGE_ALIGN(start
);
604 end
= HOST_PAGE_ALIGN(end
);
607 if(target_mmap(start
, end
- start
,
608 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
609 MAP_FIXED
| MAP_PRIVATE
| MAP_ANONYMOUS
, -1, 0) == -1) {
610 perror("cannot mmap brk");
616 /* We need to explicitly zero any fractional pages after the data
617 section (i.e. bss). This would contain the junk from the file that
618 should not be in memory. */
619 static void padzero(unsigned long elf_bss
, unsigned long last_bss
)
623 if (elf_bss
>= last_bss
)
626 /* XXX: this is really a hack : if the real host page size is
627 smaller than the target page size, some pages after the end
628 of the file may not be mapped. A better fix would be to
629 patch target_mmap(), but it is more complicated as the file
630 size must be known */
631 if (qemu_real_host_page_size
< qemu_host_page_size
) {
632 unsigned long end_addr
, end_addr1
;
633 end_addr1
= (elf_bss
+ qemu_real_host_page_size
- 1) &
634 ~(qemu_real_host_page_size
- 1);
635 end_addr
= HOST_PAGE_ALIGN(elf_bss
);
636 if (end_addr1
< end_addr
) {
637 mmap((void *)end_addr1
, end_addr
- end_addr1
,
638 PROT_READ
|PROT_WRITE
|PROT_EXEC
,
639 MAP_FIXED
|MAP_PRIVATE
|MAP_ANONYMOUS
, -1, 0);
643 nbyte
= elf_bss
& (qemu_host_page_size
-1);
645 nbyte
= qemu_host_page_size
- nbyte
;
654 static unsigned long create_elf_tables(target_ulong p
, int argc
, int envc
,
655 struct elfhdr
* exec
,
656 unsigned long load_addr
,
657 unsigned long load_bias
,
658 unsigned long interp_load_addr
, int ibcs
,
659 struct image_info
*info
)
663 target_ulong u_platform
;
664 const char *k_platform
;
665 const int n
= sizeof(target_ulong
);
669 k_platform
= ELF_PLATFORM
;
671 size_t len
= strlen(k_platform
) + 1;
672 sp
-= (len
+ n
- 1) & ~(n
- 1);
674 memcpy_to_target(sp
, k_platform
, len
);
677 * Force 16 byte _final_ alignment here for generality.
679 sp
= sp
&~ (target_ulong
)15;
680 size
= (DLINFO_ITEMS
+ 1) * 2;
683 #ifdef DLINFO_ARCH_ITEMS
684 size
+= DLINFO_ARCH_ITEMS
* 2;
686 size
+= envc
+ argc
+ 2;
687 size
+= (!ibcs
? 3 : 1); /* argc itself */
690 sp
-= 16 - (size
& 15);
692 #define NEW_AUX_ENT(id, val) do { \
693 sp -= n; tputl(sp, val); \
694 sp -= n; tputl(sp, id); \
696 NEW_AUX_ENT (AT_NULL
, 0);
698 /* There must be exactly DLINFO_ITEMS entries here. */
699 NEW_AUX_ENT(AT_PHDR
, (target_ulong
)(load_addr
+ exec
->e_phoff
));
700 NEW_AUX_ENT(AT_PHENT
, (target_ulong
)(sizeof (struct elf_phdr
)));
701 NEW_AUX_ENT(AT_PHNUM
, (target_ulong
)(exec
->e_phnum
));
702 NEW_AUX_ENT(AT_PAGESZ
, (target_ulong
)(TARGET_PAGE_SIZE
));
703 NEW_AUX_ENT(AT_BASE
, (target_ulong
)(interp_load_addr
));
704 NEW_AUX_ENT(AT_FLAGS
, (target_ulong
)0);
705 NEW_AUX_ENT(AT_ENTRY
, load_bias
+ exec
->e_entry
);
706 NEW_AUX_ENT(AT_UID
, (target_ulong
) getuid());
707 NEW_AUX_ENT(AT_EUID
, (target_ulong
) geteuid());
708 NEW_AUX_ENT(AT_GID
, (target_ulong
) getgid());
709 NEW_AUX_ENT(AT_EGID
, (target_ulong
) getegid());
710 NEW_AUX_ENT(AT_HWCAP
, (target_ulong
) ELF_HWCAP
);
712 NEW_AUX_ENT(AT_PLATFORM
, u_platform
);
715 * ARCH_DLINFO must come last so platform specific code can enforce
716 * special alignment requirements on the AUXV if necessary (eg. PPC).
722 sp
= loader_build_argptr(envc
, argc
, sp
, p
, !ibcs
);
727 static unsigned long load_elf_interp(struct elfhdr
* interp_elf_ex
,
729 unsigned long *interp_load_addr
)
731 struct elf_phdr
*elf_phdata
= NULL
;
732 struct elf_phdr
*eppnt
;
733 unsigned long load_addr
= 0;
734 int load_addr_set
= 0;
736 unsigned long last_bss
, elf_bss
;
745 bswap_ehdr(interp_elf_ex
);
747 /* First of all, some simple consistency checks */
748 if ((interp_elf_ex
->e_type
!= ET_EXEC
&&
749 interp_elf_ex
->e_type
!= ET_DYN
) ||
750 !elf_check_arch(interp_elf_ex
->e_machine
)) {
755 /* Now read in all of the header information */
757 if (sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
> TARGET_PAGE_SIZE
)
760 elf_phdata
= (struct elf_phdr
*)
761 malloc(sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
);
767 * If the size of this structure has changed, then punt, since
768 * we will be doing the wrong thing.
770 if (interp_elf_ex
->e_phentsize
!= sizeof(struct elf_phdr
)) {
775 retval
= lseek(interpreter_fd
, interp_elf_ex
->e_phoff
, SEEK_SET
);
777 retval
= read(interpreter_fd
,
779 sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
);
782 perror("load_elf_interp");
789 for (i
=0; i
<interp_elf_ex
->e_phnum
; i
++, eppnt
++) {
794 if (interp_elf_ex
->e_type
== ET_DYN
) {
795 /* in order to avoid harcoding the interpreter load
796 address in qemu, we allocate a big enough memory zone */
797 error
= target_mmap(0, INTERP_MAP_SIZE
,
798 PROT_NONE
, MAP_PRIVATE
| MAP_ANON
,
809 for(i
=0; i
<interp_elf_ex
->e_phnum
; i
++, eppnt
++)
810 if (eppnt
->p_type
== PT_LOAD
) {
811 int elf_type
= MAP_PRIVATE
| MAP_DENYWRITE
;
813 unsigned long vaddr
= 0;
816 if (eppnt
->p_flags
& PF_R
) elf_prot
= PROT_READ
;
817 if (eppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
818 if (eppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
819 if (interp_elf_ex
->e_type
== ET_EXEC
|| load_addr_set
) {
820 elf_type
|= MAP_FIXED
;
821 vaddr
= eppnt
->p_vaddr
;
823 error
= target_mmap(load_addr
+TARGET_ELF_PAGESTART(vaddr
),
824 eppnt
->p_filesz
+ TARGET_ELF_PAGEOFFSET(eppnt
->p_vaddr
),
828 eppnt
->p_offset
- TARGET_ELF_PAGEOFFSET(eppnt
->p_vaddr
));
832 close(interpreter_fd
);
837 if (!load_addr_set
&& interp_elf_ex
->e_type
== ET_DYN
) {
843 * Find the end of the file mapping for this phdr, and keep
844 * track of the largest address we see for this.
846 k
= load_addr
+ eppnt
->p_vaddr
+ eppnt
->p_filesz
;
847 if (k
> elf_bss
) elf_bss
= k
;
850 * Do the same thing for the memory mapping - between
851 * elf_bss and last_bss is the bss section.
853 k
= load_addr
+ eppnt
->p_memsz
+ eppnt
->p_vaddr
;
854 if (k
> last_bss
) last_bss
= k
;
857 /* Now use mmap to map the library into memory. */
859 close(interpreter_fd
);
862 * Now fill out the bss section. First pad the last page up
863 * to the page boundary, and then perform a mmap to make sure
864 * that there are zeromapped pages up to and including the last
867 padzero(elf_bss
, last_bss
);
868 elf_bss
= TARGET_ELF_PAGESTART(elf_bss
+ qemu_host_page_size
- 1); /* What we have mapped so far */
870 /* Map the last of the bss segment */
871 if (last_bss
> elf_bss
) {
872 target_mmap(elf_bss
, last_bss
-elf_bss
,
873 PROT_READ
|PROT_WRITE
|PROT_EXEC
,
874 MAP_FIXED
|MAP_PRIVATE
|MAP_ANONYMOUS
, -1, 0);
878 *interp_load_addr
= load_addr
;
879 return ((unsigned long) interp_elf_ex
->e_entry
) + load_addr
;
882 /* Best attempt to load symbols from this ELF object. */
883 static void load_symbols(struct elfhdr
*hdr
, int fd
)
886 struct elf_shdr sechdr
, symtab
, strtab
;
890 lseek(fd
, hdr
->e_shoff
, SEEK_SET
);
891 for (i
= 0; i
< hdr
->e_shnum
; i
++) {
892 if (read(fd
, &sechdr
, sizeof(sechdr
)) != sizeof(sechdr
))
897 if (sechdr
.sh_type
== SHT_SYMTAB
) {
899 lseek(fd
, hdr
->e_shoff
900 + sizeof(sechdr
) * sechdr
.sh_link
, SEEK_SET
);
901 if (read(fd
, &strtab
, sizeof(strtab
))
910 return; /* Shouldn't happen... */
913 /* Now know where the strtab and symtab are. Snarf them. */
914 s
= malloc(sizeof(*s
));
915 s
->disas_symtab
= malloc(symtab
.sh_size
);
916 s
->disas_strtab
= strings
= malloc(strtab
.sh_size
);
917 if (!s
->disas_symtab
|| !s
->disas_strtab
)
920 lseek(fd
, symtab
.sh_offset
, SEEK_SET
);
921 if (read(fd
, s
->disas_symtab
, symtab
.sh_size
) != symtab
.sh_size
)
925 for (i
= 0; i
< symtab
.sh_size
/ sizeof(struct elf_sym
); i
++)
926 bswap_sym(s
->disas_symtab
+ sizeof(struct elf_sym
)*i
);
929 lseek(fd
, strtab
.sh_offset
, SEEK_SET
);
930 if (read(fd
, strings
, strtab
.sh_size
) != strtab
.sh_size
)
932 s
->disas_num_syms
= symtab
.sh_size
/ sizeof(struct elf_sym
);
937 int load_elf_binary(struct linux_binprm
* bprm
, struct target_pt_regs
* regs
,
938 struct image_info
* info
)
940 struct elfhdr elf_ex
;
941 struct elfhdr interp_elf_ex
;
942 struct exec interp_ex
;
943 int interpreter_fd
= -1; /* avoid warning */
944 unsigned long load_addr
, load_bias
;
945 int load_addr_set
= 0;
946 unsigned int interpreter_type
= INTERPRETER_NONE
;
947 unsigned char ibcs2_interpreter
;
949 unsigned long mapped_addr
;
950 struct elf_phdr
* elf_ppnt
;
951 struct elf_phdr
*elf_phdata
;
952 unsigned long elf_bss
, k
, elf_brk
;
954 char * elf_interpreter
;
955 unsigned long elf_entry
, interp_load_addr
= 0;
957 unsigned long start_code
, end_code
, end_data
;
958 unsigned long reloc_func_desc
= 0;
959 unsigned long elf_stack
;
960 char passed_fileno
[6];
962 ibcs2_interpreter
= 0;
966 elf_ex
= *((struct elfhdr
*) bprm
->buf
); /* exec-header */
971 /* First of all, some simple consistency checks */
972 if ((elf_ex
.e_type
!= ET_EXEC
&& elf_ex
.e_type
!= ET_DYN
) ||
973 (! elf_check_arch(elf_ex
.e_machine
))) {
977 bprm
->p
= copy_elf_strings(1, &bprm
->filename
, bprm
->page
, bprm
->p
);
978 bprm
->p
= copy_elf_strings(bprm
->envc
,bprm
->envp
,bprm
->page
,bprm
->p
);
979 bprm
->p
= copy_elf_strings(bprm
->argc
,bprm
->argv
,bprm
->page
,bprm
->p
);
984 /* Now read in all of the header information */
985 elf_phdata
= (struct elf_phdr
*)malloc(elf_ex
.e_phentsize
*elf_ex
.e_phnum
);
986 if (elf_phdata
== NULL
) {
990 retval
= lseek(bprm
->fd
, elf_ex
.e_phoff
, SEEK_SET
);
992 retval
= read(bprm
->fd
, (char *) elf_phdata
,
993 elf_ex
.e_phentsize
* elf_ex
.e_phnum
);
997 perror("load_elf_binary");
1004 elf_ppnt
= elf_phdata
;
1005 for (i
=0; i
<elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
1006 bswap_phdr(elf_ppnt
);
1009 elf_ppnt
= elf_phdata
;
1016 elf_interpreter
= NULL
;
1021 for(i
=0;i
< elf_ex
.e_phnum
; i
++) {
1022 if (elf_ppnt
->p_type
== PT_INTERP
) {
1023 if ( elf_interpreter
!= NULL
)
1026 free(elf_interpreter
);
1031 /* This is the program interpreter used for
1032 * shared libraries - for now assume that this
1033 * is an a.out format binary
1036 elf_interpreter
= (char *)malloc(elf_ppnt
->p_filesz
);
1038 if (elf_interpreter
== NULL
) {
1044 retval
= lseek(bprm
->fd
, elf_ppnt
->p_offset
, SEEK_SET
);
1046 retval
= read(bprm
->fd
, elf_interpreter
, elf_ppnt
->p_filesz
);
1049 perror("load_elf_binary2");
1053 /* If the program interpreter is one of these two,
1054 then assume an iBCS2 image. Otherwise assume
1055 a native linux image. */
1057 /* JRP - Need to add X86 lib dir stuff here... */
1059 if (strcmp(elf_interpreter
,"/usr/lib/libc.so.1") == 0 ||
1060 strcmp(elf_interpreter
,"/usr/lib/ld.so.1") == 0) {
1061 ibcs2_interpreter
= 1;
1065 printf("Using ELF interpreter %s\n", elf_interpreter
);
1068 retval
= open(path(elf_interpreter
), O_RDONLY
);
1070 interpreter_fd
= retval
;
1073 perror(elf_interpreter
);
1075 /* retval = -errno; */
1080 retval
= lseek(interpreter_fd
, 0, SEEK_SET
);
1082 retval
= read(interpreter_fd
,bprm
->buf
,128);
1086 interp_ex
= *((struct exec
*) bprm
->buf
); /* aout exec-header */
1087 interp_elf_ex
=*((struct elfhdr
*) bprm
->buf
); /* elf exec-header */
1090 perror("load_elf_binary3");
1093 free(elf_interpreter
);
1101 /* Some simple consistency checks for the interpreter */
1102 if (elf_interpreter
){
1103 interpreter_type
= INTERPRETER_ELF
| INTERPRETER_AOUT
;
1105 /* Now figure out which format our binary is */
1106 if ((N_MAGIC(interp_ex
) != OMAGIC
) && (N_MAGIC(interp_ex
) != ZMAGIC
) &&
1107 (N_MAGIC(interp_ex
) != QMAGIC
)) {
1108 interpreter_type
= INTERPRETER_ELF
;
1111 if (interp_elf_ex
.e_ident
[0] != 0x7f ||
1112 strncmp(&interp_elf_ex
.e_ident
[1], "ELF",3) != 0) {
1113 interpreter_type
&= ~INTERPRETER_ELF
;
1116 if (!interpreter_type
) {
1117 free(elf_interpreter
);
1124 /* OK, we are done with that, now set up the arg stuff,
1125 and then start this sucker up */
1130 if (interpreter_type
== INTERPRETER_AOUT
) {
1131 snprintf(passed_fileno
, sizeof(passed_fileno
), "%d", bprm
->fd
);
1132 passed_p
= passed_fileno
;
1134 if (elf_interpreter
) {
1135 bprm
->p
= copy_elf_strings(1,&passed_p
,bprm
->page
,bprm
->p
);
1140 if (elf_interpreter
) {
1141 free(elf_interpreter
);
1149 /* OK, This is the point of no return */
1152 info
->start_mmap
= (unsigned long)ELF_START_MMAP
;
1154 elf_entry
= (unsigned long) elf_ex
.e_entry
;
1156 /* Do this so that we can load the interpreter, if need be. We will
1157 change some of these later */
1159 bprm
->p
= setup_arg_pages(bprm
->p
, bprm
, info
);
1160 info
->start_stack
= bprm
->p
;
1162 /* Now we do a little grungy work by mmaping the ELF image into
1163 * the correct location in memory. At this point, we assume that
1164 * the image should be loaded at fixed address, not at a variable
1168 for(i
= 0, elf_ppnt
= elf_phdata
; i
< elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
1171 unsigned long error
;
1173 if (elf_ppnt
->p_type
!= PT_LOAD
)
1176 if (elf_ppnt
->p_flags
& PF_R
) elf_prot
|= PROT_READ
;
1177 if (elf_ppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
1178 if (elf_ppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
1179 elf_flags
= MAP_PRIVATE
| MAP_DENYWRITE
;
1180 if (elf_ex
.e_type
== ET_EXEC
|| load_addr_set
) {
1181 elf_flags
|= MAP_FIXED
;
1182 } else if (elf_ex
.e_type
== ET_DYN
) {
1183 /* Try and get dynamic programs out of the way of the default mmap
1184 base, as well as whatever program they might try to exec. This
1185 is because the brk will follow the loader, and is not movable. */
1186 /* NOTE: for qemu, we do a big mmap to get enough space
1187 without harcoding any address */
1188 error
= target_mmap(0, ET_DYN_MAP_SIZE
,
1189 PROT_NONE
, MAP_PRIVATE
| MAP_ANON
,
1195 load_bias
= TARGET_ELF_PAGESTART(error
- elf_ppnt
->p_vaddr
);
1198 error
= target_mmap(TARGET_ELF_PAGESTART(load_bias
+ elf_ppnt
->p_vaddr
),
1199 (elf_ppnt
->p_filesz
+
1200 TARGET_ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)),
1202 (MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
),
1204 (elf_ppnt
->p_offset
-
1205 TARGET_ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)));
1211 #ifdef LOW_ELF_STACK
1212 if (TARGET_ELF_PAGESTART(elf_ppnt
->p_vaddr
) < elf_stack
)
1213 elf_stack
= TARGET_ELF_PAGESTART(elf_ppnt
->p_vaddr
);
1216 if (!load_addr_set
) {
1218 load_addr
= elf_ppnt
->p_vaddr
- elf_ppnt
->p_offset
;
1219 if (elf_ex
.e_type
== ET_DYN
) {
1220 load_bias
+= error
-
1221 TARGET_ELF_PAGESTART(load_bias
+ elf_ppnt
->p_vaddr
);
1222 load_addr
+= load_bias
;
1223 reloc_func_desc
= load_bias
;
1226 k
= elf_ppnt
->p_vaddr
;
1229 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_filesz
;
1232 if ((elf_ppnt
->p_flags
& PF_X
) && end_code
< k
)
1236 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_memsz
;
1237 if (k
> elf_brk
) elf_brk
= k
;
1240 elf_entry
+= load_bias
;
1241 elf_bss
+= load_bias
;
1242 elf_brk
+= load_bias
;
1243 start_code
+= load_bias
;
1244 end_code
+= load_bias
;
1245 // start_data += load_bias;
1246 end_data
+= load_bias
;
1248 if (elf_interpreter
) {
1249 if (interpreter_type
& 1) {
1250 elf_entry
= load_aout_interp(&interp_ex
, interpreter_fd
);
1252 else if (interpreter_type
& 2) {
1253 elf_entry
= load_elf_interp(&interp_elf_ex
, interpreter_fd
,
1256 reloc_func_desc
= interp_load_addr
;
1258 close(interpreter_fd
);
1259 free(elf_interpreter
);
1261 if (elf_entry
== ~0UL) {
1262 printf("Unable to load interpreter\n");
1272 load_symbols(&elf_ex
, bprm
->fd
);
1274 if (interpreter_type
!= INTERPRETER_AOUT
) close(bprm
->fd
);
1275 info
->personality
= (ibcs2_interpreter
? PER_SVR4
: PER_LINUX
);
1277 #ifdef LOW_ELF_STACK
1278 info
->start_stack
= bprm
->p
= elf_stack
- 4;
1280 bprm
->p
= create_elf_tables(bprm
->p
,
1284 load_addr
, load_bias
,
1286 (interpreter_type
== INTERPRETER_AOUT
? 0 : 1),
1288 info
->start_brk
= info
->brk
= elf_brk
;
1289 info
->end_code
= end_code
;
1290 info
->start_code
= start_code
;
1291 info
->start_data
= end_code
;
1292 info
->end_data
= end_data
;
1293 info
->start_stack
= bprm
->p
;
1295 /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1297 set_brk(elf_bss
, elf_brk
);
1299 padzero(elf_bss
, elf_brk
);
1302 printf("(start_brk) %x\n" , info
->start_brk
);
1303 printf("(end_code) %x\n" , info
->end_code
);
1304 printf("(start_code) %x\n" , info
->start_code
);
1305 printf("(end_data) %x\n" , info
->end_data
);
1306 printf("(start_stack) %x\n" , info
->start_stack
);
1307 printf("(brk) %x\n" , info
->brk
);
1310 if ( info
->personality
== PER_SVR4
)
1312 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1313 and some applications "depend" upon this behavior.
1314 Since we do not have the power to recompile these, we
1315 emulate the SVr4 behavior. Sigh. */
1316 mapped_addr
= target_mmap(0, qemu_host_page_size
, PROT_READ
| PROT_EXEC
,
1317 MAP_FIXED
| MAP_PRIVATE
, -1, 0);
1320 info
->entry
= elf_entry
;
1325 static int load_aout_interp(void * exptr
, int interp_fd
)
1327 printf("a.out interpreter not yet supported\n");
1331 void do_init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
1333 init_thread(regs
, infop
);