ppc: Fix sign extension issue in mtmsr(d) emulation
[qemu.git] / bsd-user / elfload.c
1 /* This is the Linux kernel elf-loading code, ported into user space */
2
3 #include "qemu/osdep.h"
4 #include <sys/mman.h>
5
6 #include "qemu.h"
7 #include "disas/disas.h"
8 #include "qemu/path.h"
9
10 #ifdef _ARCH_PPC64
11 #undef ARCH_DLINFO
12 #undef ELF_PLATFORM
13 #undef ELF_HWCAP
14 #undef ELF_CLASS
15 #undef ELF_DATA
16 #undef ELF_ARCH
17 #endif
18
19 /* from personality.h */
20
21 /*
22 * Flags for bug emulation.
23 *
24 * These occupy the top three bytes.
25 */
26 enum {
27 ADDR_NO_RANDOMIZE = 0x0040000, /* disable randomization of VA space */
28 FDPIC_FUNCPTRS = 0x0080000, /* userspace function ptrs point to descriptors
29 * (signal handling)
30 */
31 MMAP_PAGE_ZERO = 0x0100000,
32 ADDR_COMPAT_LAYOUT = 0x0200000,
33 READ_IMPLIES_EXEC = 0x0400000,
34 ADDR_LIMIT_32BIT = 0x0800000,
35 SHORT_INODE = 0x1000000,
36 WHOLE_SECONDS = 0x2000000,
37 STICKY_TIMEOUTS = 0x4000000,
38 ADDR_LIMIT_3GB = 0x8000000,
39 };
40
41 /*
42 * Personality types.
43 *
44 * These go in the low byte. Avoid using the top bit, it will
45 * conflict with error returns.
46 */
47 enum {
48 PER_LINUX = 0x0000,
49 PER_LINUX_32BIT = 0x0000 | ADDR_LIMIT_32BIT,
50 PER_LINUX_FDPIC = 0x0000 | FDPIC_FUNCPTRS,
51 PER_SVR4 = 0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
52 PER_SVR3 = 0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
53 PER_SCOSVR3 = 0x0003 | STICKY_TIMEOUTS |
54 WHOLE_SECONDS | SHORT_INODE,
55 PER_OSR5 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
56 PER_WYSEV386 = 0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
57 PER_ISCR4 = 0x0005 | STICKY_TIMEOUTS,
58 PER_BSD = 0x0006,
59 PER_SUNOS = 0x0006 | STICKY_TIMEOUTS,
60 PER_XENIX = 0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
61 PER_LINUX32 = 0x0008,
62 PER_LINUX32_3GB = 0x0008 | ADDR_LIMIT_3GB,
63 PER_IRIX32 = 0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */
64 PER_IRIXN32 = 0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */
65 PER_IRIX64 = 0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */
66 PER_RISCOS = 0x000c,
67 PER_SOLARIS = 0x000d | STICKY_TIMEOUTS,
68 PER_UW7 = 0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
69 PER_OSF4 = 0x000f, /* OSF/1 v4 */
70 PER_HPUX = 0x0010,
71 PER_MASK = 0x00ff,
72 };
73
74 /*
75 * Return the base personality without flags.
76 */
77 #define personality(pers) (pers & PER_MASK)
78
79 /* this flag is uneffective under linux too, should be deleted */
80 #ifndef MAP_DENYWRITE
81 #define MAP_DENYWRITE 0
82 #endif
83
84 /* should probably go in elf.h */
85 #ifndef ELIBBAD
86 #define ELIBBAD 80
87 #endif
88
89 #ifdef TARGET_I386
90
91 #define ELF_PLATFORM get_elf_platform()
92
93 static const char *get_elf_platform(void)
94 {
95 static char elf_platform[] = "i386";
96 int family = object_property_get_int(OBJECT(thread_cpu), "family", NULL);
97 if (family > 6)
98 family = 6;
99 if (family >= 3)
100 elf_platform[1] = '0' + family;
101 return elf_platform;
102 }
103
104 #define ELF_HWCAP get_elf_hwcap()
105
106 static uint32_t get_elf_hwcap(void)
107 {
108 X86CPU *cpu = X86_CPU(thread_cpu);
109
110 return cpu->env.features[FEAT_1_EDX];
111 }
112
113 #ifdef TARGET_X86_64
114 #define ELF_START_MMAP 0x2aaaaab000ULL
115 #define elf_check_arch(x) ( ((x) == ELF_ARCH) )
116
117 #define ELF_CLASS ELFCLASS64
118 #define ELF_DATA ELFDATA2LSB
119 #define ELF_ARCH EM_X86_64
120
121 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
122 {
123 regs->rax = 0;
124 regs->rsp = infop->start_stack;
125 regs->rip = infop->entry;
126 if (bsd_type == target_freebsd) {
127 regs->rdi = infop->start_stack;
128 }
129 }
130
131 #else
132
133 #define ELF_START_MMAP 0x80000000
134
135 /*
136 * This is used to ensure we don't load something for the wrong architecture.
137 */
138 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
139
140 /*
141 * These are used to set parameters in the core dumps.
142 */
143 #define ELF_CLASS ELFCLASS32
144 #define ELF_DATA ELFDATA2LSB
145 #define ELF_ARCH EM_386
146
147 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
148 {
149 regs->esp = infop->start_stack;
150 regs->eip = infop->entry;
151
152 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
153 starts %edx contains a pointer to a function which might be
154 registered using `atexit'. This provides a mean for the
155 dynamic linker to call DT_FINI functions for shared libraries
156 that have been loaded before the code runs.
157
158 A value of 0 tells we have no such handler. */
159 regs->edx = 0;
160 }
161 #endif
162
163 #define USE_ELF_CORE_DUMP
164 #define ELF_EXEC_PAGESIZE 4096
165
166 #endif
167
168 #ifdef TARGET_ARM
169
170 #define ELF_START_MMAP 0x80000000
171
172 #define elf_check_arch(x) ( (x) == EM_ARM )
173
174 #define ELF_CLASS ELFCLASS32
175 #ifdef TARGET_WORDS_BIGENDIAN
176 #define ELF_DATA ELFDATA2MSB
177 #else
178 #define ELF_DATA ELFDATA2LSB
179 #endif
180 #define ELF_ARCH EM_ARM
181
182 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
183 {
184 abi_long stack = infop->start_stack;
185 memset(regs, 0, sizeof(*regs));
186 regs->ARM_cpsr = 0x10;
187 if (infop->entry & 1)
188 regs->ARM_cpsr |= CPSR_T;
189 regs->ARM_pc = infop->entry & 0xfffffffe;
190 regs->ARM_sp = infop->start_stack;
191 /* FIXME - what to for failure of get_user()? */
192 get_user_ual(regs->ARM_r2, stack + 8); /* envp */
193 get_user_ual(regs->ARM_r1, stack + 4); /* envp */
194 /* XXX: it seems that r0 is zeroed after ! */
195 regs->ARM_r0 = 0;
196 /* For uClinux PIC binaries. */
197 /* XXX: Linux does this only on ARM with no MMU (do we care ?) */
198 regs->ARM_r10 = infop->start_data;
199 }
200
201 #define USE_ELF_CORE_DUMP
202 #define ELF_EXEC_PAGESIZE 4096
203
204 enum
205 {
206 ARM_HWCAP_ARM_SWP = 1 << 0,
207 ARM_HWCAP_ARM_HALF = 1 << 1,
208 ARM_HWCAP_ARM_THUMB = 1 << 2,
209 ARM_HWCAP_ARM_26BIT = 1 << 3,
210 ARM_HWCAP_ARM_FAST_MULT = 1 << 4,
211 ARM_HWCAP_ARM_FPA = 1 << 5,
212 ARM_HWCAP_ARM_VFP = 1 << 6,
213 ARM_HWCAP_ARM_EDSP = 1 << 7,
214 };
215
216 #define ELF_HWCAP (ARM_HWCAP_ARM_SWP | ARM_HWCAP_ARM_HALF \
217 | ARM_HWCAP_ARM_THUMB | ARM_HWCAP_ARM_FAST_MULT \
218 | ARM_HWCAP_ARM_FPA | ARM_HWCAP_ARM_VFP)
219
220 #endif
221
222 #ifdef TARGET_SPARC
223 #ifdef TARGET_SPARC64
224
225 #define ELF_START_MMAP 0x80000000
226
227 #ifndef TARGET_ABI32
228 #define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS )
229 #else
230 #define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC )
231 #endif
232
233 #define ELF_CLASS ELFCLASS64
234 #define ELF_DATA ELFDATA2MSB
235 #define ELF_ARCH EM_SPARCV9
236
237 #define STACK_BIAS 2047
238
239 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
240 {
241 #ifndef TARGET_ABI32
242 regs->tstate = 0;
243 #endif
244 regs->pc = infop->entry;
245 regs->npc = regs->pc + 4;
246 regs->y = 0;
247 #ifdef TARGET_ABI32
248 regs->u_regs[14] = infop->start_stack - 16 * 4;
249 #else
250 if (personality(infop->personality) == PER_LINUX32)
251 regs->u_regs[14] = infop->start_stack - 16 * 4;
252 else {
253 regs->u_regs[14] = infop->start_stack - 16 * 8 - STACK_BIAS;
254 if (bsd_type == target_freebsd) {
255 regs->u_regs[8] = infop->start_stack;
256 regs->u_regs[11] = infop->start_stack;
257 }
258 }
259 #endif
260 }
261
262 #else
263 #define ELF_START_MMAP 0x80000000
264
265 #define elf_check_arch(x) ( (x) == EM_SPARC )
266
267 #define ELF_CLASS ELFCLASS32
268 #define ELF_DATA ELFDATA2MSB
269 #define ELF_ARCH EM_SPARC
270
271 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
272 {
273 regs->psr = 0;
274 regs->pc = infop->entry;
275 regs->npc = regs->pc + 4;
276 regs->y = 0;
277 regs->u_regs[14] = infop->start_stack - 16 * 4;
278 }
279
280 #endif
281 #endif
282
283 #ifdef TARGET_PPC
284
285 #define ELF_START_MMAP 0x80000000
286
287 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
288
289 #define elf_check_arch(x) ( (x) == EM_PPC64 )
290
291 #define ELF_CLASS ELFCLASS64
292
293 #else
294
295 #define elf_check_arch(x) ( (x) == EM_PPC )
296
297 #define ELF_CLASS ELFCLASS32
298
299 #endif
300
301 #ifdef TARGET_WORDS_BIGENDIAN
302 #define ELF_DATA ELFDATA2MSB
303 #else
304 #define ELF_DATA ELFDATA2LSB
305 #endif
306 #define ELF_ARCH EM_PPC
307
308 /*
309 * We need to put in some extra aux table entries to tell glibc what
310 * the cache block size is, so it can use the dcbz instruction safely.
311 */
312 #define AT_DCACHEBSIZE 19
313 #define AT_ICACHEBSIZE 20
314 #define AT_UCACHEBSIZE 21
315 /* A special ignored type value for PPC, for glibc compatibility. */
316 #define AT_IGNOREPPC 22
317 /*
318 * The requirements here are:
319 * - keep the final alignment of sp (sp & 0xf)
320 * - make sure the 32-bit value at the first 16 byte aligned position of
321 * AUXV is greater than 16 for glibc compatibility.
322 * AT_IGNOREPPC is used for that.
323 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
324 * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
325 */
326 #define DLINFO_ARCH_ITEMS 5
327 #define ARCH_DLINFO \
328 do { \
329 NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20); \
330 NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20); \
331 NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \
332 /* \
333 * Now handle glibc compatibility. \
334 */ \
335 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
336 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
337 } while (0)
338
339 static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
340 {
341 abi_ulong pos = infop->start_stack;
342 abi_ulong tmp;
343 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
344 abi_ulong entry, toc;
345 #endif
346
347 _regs->gpr[1] = infop->start_stack;
348 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
349 get_user_u64(entry, infop->entry);
350 entry += infop->load_addr;
351 get_user_u64(toc, infop->entry + 8);
352 toc += infop->load_addr;
353 _regs->gpr[2] = toc;
354 infop->entry = entry;
355 #endif
356 _regs->nip = infop->entry;
357 /* Note that isn't exactly what regular kernel does
358 * but this is what the ABI wants and is needed to allow
359 * execution of PPC BSD programs.
360 */
361 /* FIXME - what to for failure of get_user()? */
362 get_user_ual(_regs->gpr[3], pos);
363 pos += sizeof(abi_ulong);
364 _regs->gpr[4] = pos;
365 for (tmp = 1; tmp != 0; pos += sizeof(abi_ulong)) {
366 get_user_ual(tmp, pos);
367 }
368 _regs->gpr[5] = pos;
369 }
370
371 #define USE_ELF_CORE_DUMP
372 #define ELF_EXEC_PAGESIZE 4096
373
374 #endif
375
376 #ifdef TARGET_MIPS
377
378 #define ELF_START_MMAP 0x80000000
379
380 #define elf_check_arch(x) ( (x) == EM_MIPS )
381
382 #ifdef TARGET_MIPS64
383 #define ELF_CLASS ELFCLASS64
384 #else
385 #define ELF_CLASS ELFCLASS32
386 #endif
387 #ifdef TARGET_WORDS_BIGENDIAN
388 #define ELF_DATA ELFDATA2MSB
389 #else
390 #define ELF_DATA ELFDATA2LSB
391 #endif
392 #define ELF_ARCH EM_MIPS
393
394 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
395 {
396 regs->cp0_status = 2 << CP0St_KSU;
397 regs->cp0_epc = infop->entry;
398 regs->regs[29] = infop->start_stack;
399 }
400
401 #define USE_ELF_CORE_DUMP
402 #define ELF_EXEC_PAGESIZE 4096
403
404 #endif /* TARGET_MIPS */
405
406 #ifdef TARGET_SH4
407
408 #define ELF_START_MMAP 0x80000000
409
410 #define elf_check_arch(x) ( (x) == EM_SH )
411
412 #define ELF_CLASS ELFCLASS32
413 #define ELF_DATA ELFDATA2LSB
414 #define ELF_ARCH EM_SH
415
416 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
417 {
418 /* Check other registers XXXXX */
419 regs->pc = infop->entry;
420 regs->regs[15] = infop->start_stack;
421 }
422
423 #define USE_ELF_CORE_DUMP
424 #define ELF_EXEC_PAGESIZE 4096
425
426 #endif
427
428 #ifdef TARGET_CRIS
429
430 #define ELF_START_MMAP 0x80000000
431
432 #define elf_check_arch(x) ( (x) == EM_CRIS )
433
434 #define ELF_CLASS ELFCLASS32
435 #define ELF_DATA ELFDATA2LSB
436 #define ELF_ARCH EM_CRIS
437
438 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
439 {
440 regs->erp = infop->entry;
441 }
442
443 #define USE_ELF_CORE_DUMP
444 #define ELF_EXEC_PAGESIZE 8192
445
446 #endif
447
448 #ifdef TARGET_M68K
449
450 #define ELF_START_MMAP 0x80000000
451
452 #define elf_check_arch(x) ( (x) == EM_68K )
453
454 #define ELF_CLASS ELFCLASS32
455 #define ELF_DATA ELFDATA2MSB
456 #define ELF_ARCH EM_68K
457
458 /* ??? Does this need to do anything?
459 #define ELF_PLAT_INIT(_r) */
460
461 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
462 {
463 regs->usp = infop->start_stack;
464 regs->sr = 0;
465 regs->pc = infop->entry;
466 }
467
468 #define USE_ELF_CORE_DUMP
469 #define ELF_EXEC_PAGESIZE 8192
470
471 #endif
472
473 #ifdef TARGET_ALPHA
474
475 #define ELF_START_MMAP (0x30000000000ULL)
476
477 #define elf_check_arch(x) ( (x) == ELF_ARCH )
478
479 #define ELF_CLASS ELFCLASS64
480 #define ELF_DATA ELFDATA2MSB
481 #define ELF_ARCH EM_ALPHA
482
483 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
484 {
485 regs->pc = infop->entry;
486 regs->ps = 8;
487 regs->usp = infop->start_stack;
488 regs->unique = infop->start_data; /* ? */
489 printf("Set unique value to " TARGET_FMT_lx " (" TARGET_FMT_lx ")\n",
490 regs->unique, infop->start_data);
491 }
492
493 #define USE_ELF_CORE_DUMP
494 #define ELF_EXEC_PAGESIZE 8192
495
496 #endif /* TARGET_ALPHA */
497
498 #ifndef ELF_PLATFORM
499 #define ELF_PLATFORM (NULL)
500 #endif
501
502 #ifndef ELF_HWCAP
503 #define ELF_HWCAP 0
504 #endif
505
506 #ifdef TARGET_ABI32
507 #undef ELF_CLASS
508 #define ELF_CLASS ELFCLASS32
509 #undef bswaptls
510 #define bswaptls(ptr) bswap32s(ptr)
511 #endif
512
513 #include "elf.h"
514
515 struct exec
516 {
517 unsigned int a_info; /* Use macros N_MAGIC, etc for access */
518 unsigned int a_text; /* length of text, in bytes */
519 unsigned int a_data; /* length of data, in bytes */
520 unsigned int a_bss; /* length of uninitialized data area, in bytes */
521 unsigned int a_syms; /* length of symbol table data in file, in bytes */
522 unsigned int a_entry; /* start address */
523 unsigned int a_trsize; /* length of relocation info for text, in bytes */
524 unsigned int a_drsize; /* length of relocation info for data, in bytes */
525 };
526
527
528 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
529 #define OMAGIC 0407
530 #define NMAGIC 0410
531 #define ZMAGIC 0413
532 #define QMAGIC 0314
533
534 /* max code+data+bss space allocated to elf interpreter */
535 #define INTERP_MAP_SIZE (32 * 1024 * 1024)
536
537 /* max code+data+bss+brk space allocated to ET_DYN executables */
538 #define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
539
540 /* Necessary parameters */
541 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
542 #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
543 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
544
545 #define INTERPRETER_NONE 0
546 #define INTERPRETER_AOUT 1
547 #define INTERPRETER_ELF 2
548
549 #define DLINFO_ITEMS 12
550
551 static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
552 {
553 memcpy(to, from, n);
554 }
555
556 static int load_aout_interp(void * exptr, int interp_fd);
557
558 #ifdef BSWAP_NEEDED
559 static void bswap_ehdr(struct elfhdr *ehdr)
560 {
561 bswap16s(&ehdr->e_type); /* Object file type */
562 bswap16s(&ehdr->e_machine); /* Architecture */
563 bswap32s(&ehdr->e_version); /* Object file version */
564 bswaptls(&ehdr->e_entry); /* Entry point virtual address */
565 bswaptls(&ehdr->e_phoff); /* Program header table file offset */
566 bswaptls(&ehdr->e_shoff); /* Section header table file offset */
567 bswap32s(&ehdr->e_flags); /* Processor-specific flags */
568 bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
569 bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
570 bswap16s(&ehdr->e_phnum); /* Program header table entry count */
571 bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
572 bswap16s(&ehdr->e_shnum); /* Section header table entry count */
573 bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
574 }
575
576 static void bswap_phdr(struct elf_phdr *phdr)
577 {
578 bswap32s(&phdr->p_type); /* Segment type */
579 bswaptls(&phdr->p_offset); /* Segment file offset */
580 bswaptls(&phdr->p_vaddr); /* Segment virtual address */
581 bswaptls(&phdr->p_paddr); /* Segment physical address */
582 bswaptls(&phdr->p_filesz); /* Segment size in file */
583 bswaptls(&phdr->p_memsz); /* Segment size in memory */
584 bswap32s(&phdr->p_flags); /* Segment flags */
585 bswaptls(&phdr->p_align); /* Segment alignment */
586 }
587
588 static void bswap_shdr(struct elf_shdr *shdr)
589 {
590 bswap32s(&shdr->sh_name);
591 bswap32s(&shdr->sh_type);
592 bswaptls(&shdr->sh_flags);
593 bswaptls(&shdr->sh_addr);
594 bswaptls(&shdr->sh_offset);
595 bswaptls(&shdr->sh_size);
596 bswap32s(&shdr->sh_link);
597 bswap32s(&shdr->sh_info);
598 bswaptls(&shdr->sh_addralign);
599 bswaptls(&shdr->sh_entsize);
600 }
601
602 static void bswap_sym(struct elf_sym *sym)
603 {
604 bswap32s(&sym->st_name);
605 bswaptls(&sym->st_value);
606 bswaptls(&sym->st_size);
607 bswap16s(&sym->st_shndx);
608 }
609 #endif
610
611 /*
612 * 'copy_elf_strings()' copies argument/envelope strings from user
613 * memory to free pages in kernel mem. These are in a format ready
614 * to be put directly into the top of new user memory.
615 *
616 */
617 static abi_ulong copy_elf_strings(int argc,char ** argv, void **page,
618 abi_ulong p)
619 {
620 char *tmp, *tmp1, *pag = NULL;
621 int len, offset = 0;
622
623 if (!p) {
624 return 0; /* bullet-proofing */
625 }
626 while (argc-- > 0) {
627 tmp = argv[argc];
628 if (!tmp) {
629 fprintf(stderr, "VFS: argc is wrong");
630 exit(-1);
631 }
632 tmp1 = tmp;
633 while (*tmp++);
634 len = tmp - tmp1;
635 if (p < len) { /* this shouldn't happen - 128kB */
636 return 0;
637 }
638 while (len) {
639 --p; --tmp; --len;
640 if (--offset < 0) {
641 offset = p % TARGET_PAGE_SIZE;
642 pag = (char *)page[p/TARGET_PAGE_SIZE];
643 if (!pag) {
644 pag = g_try_malloc0(TARGET_PAGE_SIZE);
645 page[p/TARGET_PAGE_SIZE] = pag;
646 if (!pag)
647 return 0;
648 }
649 }
650 if (len == 0 || offset == 0) {
651 *(pag + offset) = *tmp;
652 }
653 else {
654 int bytes_to_copy = (len > offset) ? offset : len;
655 tmp -= bytes_to_copy;
656 p -= bytes_to_copy;
657 offset -= bytes_to_copy;
658 len -= bytes_to_copy;
659 memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
660 }
661 }
662 }
663 return p;
664 }
665
666 static abi_ulong setup_arg_pages(abi_ulong p, struct linux_binprm *bprm,
667 struct image_info *info)
668 {
669 abi_ulong stack_base, size, error;
670 int i;
671
672 /* Create enough stack to hold everything. If we don't use
673 * it for args, we'll use it for something else...
674 */
675 size = x86_stack_size;
676 if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE)
677 size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;
678 error = target_mmap(0,
679 size + qemu_host_page_size,
680 PROT_READ | PROT_WRITE,
681 MAP_PRIVATE | MAP_ANON,
682 -1, 0);
683 if (error == -1) {
684 perror("stk mmap");
685 exit(-1);
686 }
687 /* we reserve one extra page at the top of the stack as guard */
688 target_mprotect(error + size, qemu_host_page_size, PROT_NONE);
689
690 stack_base = error + size - MAX_ARG_PAGES*TARGET_PAGE_SIZE;
691 p += stack_base;
692
693 for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
694 if (bprm->page[i]) {
695 info->rss++;
696 /* FIXME - check return value of memcpy_to_target() for failure */
697 memcpy_to_target(stack_base, bprm->page[i], TARGET_PAGE_SIZE);
698 g_free(bprm->page[i]);
699 }
700 stack_base += TARGET_PAGE_SIZE;
701 }
702 return p;
703 }
704
705 static void set_brk(abi_ulong start, abi_ulong end)
706 {
707 /* page-align the start and end addresses... */
708 start = HOST_PAGE_ALIGN(start);
709 end = HOST_PAGE_ALIGN(end);
710 if (end <= start)
711 return;
712 if(target_mmap(start, end - start,
713 PROT_READ | PROT_WRITE | PROT_EXEC,
714 MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0) == -1) {
715 perror("cannot mmap brk");
716 exit(-1);
717 }
718 }
719
720
721 /* We need to explicitly zero any fractional pages after the data
722 section (i.e. bss). This would contain the junk from the file that
723 should not be in memory. */
724 static void padzero(abi_ulong elf_bss, abi_ulong last_bss)
725 {
726 abi_ulong nbyte;
727
728 if (elf_bss >= last_bss)
729 return;
730
731 /* XXX: this is really a hack : if the real host page size is
732 smaller than the target page size, some pages after the end
733 of the file may not be mapped. A better fix would be to
734 patch target_mmap(), but it is more complicated as the file
735 size must be known */
736 if (qemu_real_host_page_size < qemu_host_page_size) {
737 abi_ulong end_addr, end_addr1;
738 end_addr1 = REAL_HOST_PAGE_ALIGN(elf_bss);
739 end_addr = HOST_PAGE_ALIGN(elf_bss);
740 if (end_addr1 < end_addr) {
741 mmap((void *)g2h(end_addr1), end_addr - end_addr1,
742 PROT_READ|PROT_WRITE|PROT_EXEC,
743 MAP_FIXED|MAP_PRIVATE|MAP_ANON, -1, 0);
744 }
745 }
746
747 nbyte = elf_bss & (qemu_host_page_size-1);
748 if (nbyte) {
749 nbyte = qemu_host_page_size - nbyte;
750 do {
751 /* FIXME - what to do if put_user() fails? */
752 put_user_u8(0, elf_bss);
753 elf_bss++;
754 } while (--nbyte);
755 }
756 }
757
758
759 static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,
760 struct elfhdr * exec,
761 abi_ulong load_addr,
762 abi_ulong load_bias,
763 abi_ulong interp_load_addr, int ibcs,
764 struct image_info *info)
765 {
766 abi_ulong sp;
767 int size;
768 abi_ulong u_platform;
769 const char *k_platform;
770 const int n = sizeof(elf_addr_t);
771
772 sp = p;
773 u_platform = 0;
774 k_platform = ELF_PLATFORM;
775 if (k_platform) {
776 size_t len = strlen(k_platform) + 1;
777 sp -= (len + n - 1) & ~(n - 1);
778 u_platform = sp;
779 /* FIXME - check return value of memcpy_to_target() for failure */
780 memcpy_to_target(sp, k_platform, len);
781 }
782 /*
783 * Force 16 byte _final_ alignment here for generality.
784 */
785 sp = sp &~ (abi_ulong)15;
786 size = (DLINFO_ITEMS + 1) * 2;
787 if (k_platform)
788 size += 2;
789 #ifdef DLINFO_ARCH_ITEMS
790 size += DLINFO_ARCH_ITEMS * 2;
791 #endif
792 size += envc + argc + 2;
793 size += (!ibcs ? 3 : 1); /* argc itself */
794 size *= n;
795 if (size & 15)
796 sp -= 16 - (size & 15);
797
798 /* This is correct because Linux defines
799 * elf_addr_t as Elf32_Off / Elf64_Off
800 */
801 #define NEW_AUX_ENT(id, val) do { \
802 sp -= n; put_user_ual(val, sp); \
803 sp -= n; put_user_ual(id, sp); \
804 } while(0)
805
806 NEW_AUX_ENT (AT_NULL, 0);
807
808 /* There must be exactly DLINFO_ITEMS entries here. */
809 NEW_AUX_ENT(AT_PHDR, (abi_ulong)(load_addr + exec->e_phoff));
810 NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr)));
811 NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));
812 NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(TARGET_PAGE_SIZE));
813 NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_load_addr));
814 NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);
815 NEW_AUX_ENT(AT_ENTRY, load_bias + exec->e_entry);
816 NEW_AUX_ENT(AT_UID, (abi_ulong) getuid());
817 NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid());
818 NEW_AUX_ENT(AT_GID, (abi_ulong) getgid());
819 NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid());
820 NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP);
821 NEW_AUX_ENT(AT_CLKTCK, (abi_ulong) sysconf(_SC_CLK_TCK));
822 if (k_platform)
823 NEW_AUX_ENT(AT_PLATFORM, u_platform);
824 #ifdef ARCH_DLINFO
825 /*
826 * ARCH_DLINFO must come last so platform specific code can enforce
827 * special alignment requirements on the AUXV if necessary (eg. PPC).
828 */
829 ARCH_DLINFO;
830 #endif
831 #undef NEW_AUX_ENT
832
833 sp = loader_build_argptr(envc, argc, sp, p, !ibcs);
834 return sp;
835 }
836
837
838 static abi_ulong load_elf_interp(struct elfhdr * interp_elf_ex,
839 int interpreter_fd,
840 abi_ulong *interp_load_addr)
841 {
842 struct elf_phdr *elf_phdata = NULL;
843 struct elf_phdr *eppnt;
844 abi_ulong load_addr = 0;
845 int load_addr_set = 0;
846 int retval;
847 abi_ulong last_bss, elf_bss;
848 abi_ulong error;
849 int i;
850
851 elf_bss = 0;
852 last_bss = 0;
853 error = 0;
854
855 #ifdef BSWAP_NEEDED
856 bswap_ehdr(interp_elf_ex);
857 #endif
858 /* First of all, some simple consistency checks */
859 if ((interp_elf_ex->e_type != ET_EXEC &&
860 interp_elf_ex->e_type != ET_DYN) ||
861 !elf_check_arch(interp_elf_ex->e_machine)) {
862 return ~((abi_ulong)0UL);
863 }
864
865
866 /* Now read in all of the header information */
867
868 if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE)
869 return ~(abi_ulong)0UL;
870
871 elf_phdata = (struct elf_phdr *)
872 malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
873
874 if (!elf_phdata)
875 return ~((abi_ulong)0UL);
876
877 /*
878 * If the size of this structure has changed, then punt, since
879 * we will be doing the wrong thing.
880 */
881 if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) {
882 free(elf_phdata);
883 return ~((abi_ulong)0UL);
884 }
885
886 retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
887 if(retval >= 0) {
888 retval = read(interpreter_fd,
889 (char *) elf_phdata,
890 sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
891 }
892 if (retval < 0) {
893 perror("load_elf_interp");
894 exit(-1);
895 free (elf_phdata);
896 return retval;
897 }
898 #ifdef BSWAP_NEEDED
899 eppnt = elf_phdata;
900 for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
901 bswap_phdr(eppnt);
902 }
903 #endif
904
905 if (interp_elf_ex->e_type == ET_DYN) {
906 /* in order to avoid hardcoding the interpreter load
907 address in qemu, we allocate a big enough memory zone */
908 error = target_mmap(0, INTERP_MAP_SIZE,
909 PROT_NONE, MAP_PRIVATE | MAP_ANON,
910 -1, 0);
911 if (error == -1) {
912 perror("mmap");
913 exit(-1);
914 }
915 load_addr = error;
916 load_addr_set = 1;
917 }
918
919 eppnt = elf_phdata;
920 for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++)
921 if (eppnt->p_type == PT_LOAD) {
922 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
923 int elf_prot = 0;
924 abi_ulong vaddr = 0;
925 abi_ulong k;
926
927 if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
928 if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
929 if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
930 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set) {
931 elf_type |= MAP_FIXED;
932 vaddr = eppnt->p_vaddr;
933 }
934 error = target_mmap(load_addr+TARGET_ELF_PAGESTART(vaddr),
935 eppnt->p_filesz + TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr),
936 elf_prot,
937 elf_type,
938 interpreter_fd,
939 eppnt->p_offset - TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr));
940
941 if (error == -1) {
942 /* Real error */
943 close(interpreter_fd);
944 free(elf_phdata);
945 return ~((abi_ulong)0UL);
946 }
947
948 if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
949 load_addr = error;
950 load_addr_set = 1;
951 }
952
953 /*
954 * Find the end of the file mapping for this phdr, and keep
955 * track of the largest address we see for this.
956 */
957 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
958 if (k > elf_bss) elf_bss = k;
959
960 /*
961 * Do the same thing for the memory mapping - between
962 * elf_bss and last_bss is the bss section.
963 */
964 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
965 if (k > last_bss) last_bss = k;
966 }
967
968 /* Now use mmap to map the library into memory. */
969
970 close(interpreter_fd);
971
972 /*
973 * Now fill out the bss section. First pad the last page up
974 * to the page boundary, and then perform a mmap to make sure
975 * that there are zeromapped pages up to and including the last
976 * bss page.
977 */
978 padzero(elf_bss, last_bss);
979 elf_bss = TARGET_ELF_PAGESTART(elf_bss + qemu_host_page_size - 1); /* What we have mapped so far */
980
981 /* Map the last of the bss segment */
982 if (last_bss > elf_bss) {
983 target_mmap(elf_bss, last_bss-elf_bss,
984 PROT_READ|PROT_WRITE|PROT_EXEC,
985 MAP_FIXED|MAP_PRIVATE|MAP_ANON, -1, 0);
986 }
987 free(elf_phdata);
988
989 *interp_load_addr = load_addr;
990 return ((abi_ulong) interp_elf_ex->e_entry) + load_addr;
991 }
992
993 static int symfind(const void *s0, const void *s1)
994 {
995 target_ulong addr = *(target_ulong *)s0;
996 struct elf_sym *sym = (struct elf_sym *)s1;
997 int result = 0;
998 if (addr < sym->st_value) {
999 result = -1;
1000 } else if (addr >= sym->st_value + sym->st_size) {
1001 result = 1;
1002 }
1003 return result;
1004 }
1005
1006 static const char *lookup_symbolxx(struct syminfo *s, target_ulong orig_addr)
1007 {
1008 #if ELF_CLASS == ELFCLASS32
1009 struct elf_sym *syms = s->disas_symtab.elf32;
1010 #else
1011 struct elf_sym *syms = s->disas_symtab.elf64;
1012 #endif
1013
1014 // binary search
1015 struct elf_sym *sym;
1016
1017 sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind);
1018 if (sym != NULL) {
1019 return s->disas_strtab + sym->st_name;
1020 }
1021
1022 return "";
1023 }
1024
1025 /* FIXME: This should use elf_ops.h */
1026 static int symcmp(const void *s0, const void *s1)
1027 {
1028 struct elf_sym *sym0 = (struct elf_sym *)s0;
1029 struct elf_sym *sym1 = (struct elf_sym *)s1;
1030 return (sym0->st_value < sym1->st_value)
1031 ? -1
1032 : ((sym0->st_value > sym1->st_value) ? 1 : 0);
1033 }
1034
1035 /* Best attempt to load symbols from this ELF object. */
1036 static void load_symbols(struct elfhdr *hdr, int fd)
1037 {
1038 unsigned int i, nsyms;
1039 struct elf_shdr sechdr, symtab, strtab;
1040 char *strings;
1041 struct syminfo *s;
1042 struct elf_sym *syms, *new_syms;
1043
1044 lseek(fd, hdr->e_shoff, SEEK_SET);
1045 for (i = 0; i < hdr->e_shnum; i++) {
1046 if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr))
1047 return;
1048 #ifdef BSWAP_NEEDED
1049 bswap_shdr(&sechdr);
1050 #endif
1051 if (sechdr.sh_type == SHT_SYMTAB) {
1052 symtab = sechdr;
1053 lseek(fd, hdr->e_shoff
1054 + sizeof(sechdr) * sechdr.sh_link, SEEK_SET);
1055 if (read(fd, &strtab, sizeof(strtab))
1056 != sizeof(strtab))
1057 return;
1058 #ifdef BSWAP_NEEDED
1059 bswap_shdr(&strtab);
1060 #endif
1061 goto found;
1062 }
1063 }
1064 return; /* Shouldn't happen... */
1065
1066 found:
1067 /* Now know where the strtab and symtab are. Snarf them. */
1068 s = malloc(sizeof(*s));
1069 syms = malloc(symtab.sh_size);
1070 if (!syms) {
1071 free(s);
1072 return;
1073 }
1074 s->disas_strtab = strings = malloc(strtab.sh_size);
1075 if (!s->disas_strtab) {
1076 free(s);
1077 free(syms);
1078 return;
1079 }
1080
1081 lseek(fd, symtab.sh_offset, SEEK_SET);
1082 if (read(fd, syms, symtab.sh_size) != symtab.sh_size) {
1083 free(s);
1084 free(syms);
1085 free(strings);
1086 return;
1087 }
1088
1089 nsyms = symtab.sh_size / sizeof(struct elf_sym);
1090
1091 i = 0;
1092 while (i < nsyms) {
1093 #ifdef BSWAP_NEEDED
1094 bswap_sym(syms + i);
1095 #endif
1096 // Throw away entries which we do not need.
1097 if (syms[i].st_shndx == SHN_UNDEF ||
1098 syms[i].st_shndx >= SHN_LORESERVE ||
1099 ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) {
1100 nsyms--;
1101 if (i < nsyms) {
1102 syms[i] = syms[nsyms];
1103 }
1104 continue;
1105 }
1106 #if defined(TARGET_ARM) || defined (TARGET_MIPS)
1107 /* The bottom address bit marks a Thumb or MIPS16 symbol. */
1108 syms[i].st_value &= ~(target_ulong)1;
1109 #endif
1110 i++;
1111 }
1112
1113 /* Attempt to free the storage associated with the local symbols
1114 that we threw away. Whether or not this has any effect on the
1115 memory allocation depends on the malloc implementation and how
1116 many symbols we managed to discard. */
1117 new_syms = realloc(syms, nsyms * sizeof(*syms));
1118 if (new_syms == NULL) {
1119 free(s);
1120 free(syms);
1121 free(strings);
1122 return;
1123 }
1124 syms = new_syms;
1125
1126 qsort(syms, nsyms, sizeof(*syms), symcmp);
1127
1128 lseek(fd, strtab.sh_offset, SEEK_SET);
1129 if (read(fd, strings, strtab.sh_size) != strtab.sh_size) {
1130 free(s);
1131 free(syms);
1132 free(strings);
1133 return;
1134 }
1135 s->disas_num_syms = nsyms;
1136 #if ELF_CLASS == ELFCLASS32
1137 s->disas_symtab.elf32 = syms;
1138 s->lookup_symbol = (lookup_symbol_t)lookup_symbolxx;
1139 #else
1140 s->disas_symtab.elf64 = syms;
1141 s->lookup_symbol = (lookup_symbol_t)lookup_symbolxx;
1142 #endif
1143 s->next = syminfos;
1144 syminfos = s;
1145 }
1146
1147 int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
1148 struct image_info * info)
1149 {
1150 struct elfhdr elf_ex;
1151 struct elfhdr interp_elf_ex;
1152 struct exec interp_ex;
1153 int interpreter_fd = -1; /* avoid warning */
1154 abi_ulong load_addr, load_bias;
1155 int load_addr_set = 0;
1156 unsigned int interpreter_type = INTERPRETER_NONE;
1157 unsigned char ibcs2_interpreter;
1158 int i;
1159 abi_ulong mapped_addr;
1160 struct elf_phdr * elf_ppnt;
1161 struct elf_phdr *elf_phdata;
1162 abi_ulong elf_bss, k, elf_brk;
1163 int retval;
1164 char * elf_interpreter;
1165 abi_ulong elf_entry, interp_load_addr = 0;
1166 int status;
1167 abi_ulong start_code, end_code, start_data, end_data;
1168 abi_ulong reloc_func_desc = 0;
1169 abi_ulong elf_stack;
1170 char passed_fileno[6];
1171
1172 ibcs2_interpreter = 0;
1173 status = 0;
1174 load_addr = 0;
1175 load_bias = 0;
1176 elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
1177 #ifdef BSWAP_NEEDED
1178 bswap_ehdr(&elf_ex);
1179 #endif
1180
1181 /* First of all, some simple consistency checks */
1182 if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
1183 (! elf_check_arch(elf_ex.e_machine))) {
1184 return -ENOEXEC;
1185 }
1186
1187 bprm->p = copy_elf_strings(1, &bprm->filename, bprm->page, bprm->p);
1188 bprm->p = copy_elf_strings(bprm->envc,bprm->envp,bprm->page,bprm->p);
1189 bprm->p = copy_elf_strings(bprm->argc,bprm->argv,bprm->page,bprm->p);
1190 if (!bprm->p) {
1191 retval = -E2BIG;
1192 }
1193
1194 /* Now read in all of the header information */
1195 elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);
1196 if (elf_phdata == NULL) {
1197 return -ENOMEM;
1198 }
1199
1200 retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);
1201 if(retval > 0) {
1202 retval = read(bprm->fd, (char *) elf_phdata,
1203 elf_ex.e_phentsize * elf_ex.e_phnum);
1204 }
1205
1206 if (retval < 0) {
1207 perror("load_elf_binary");
1208 exit(-1);
1209 free (elf_phdata);
1210 return -errno;
1211 }
1212
1213 #ifdef BSWAP_NEEDED
1214 elf_ppnt = elf_phdata;
1215 for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {
1216 bswap_phdr(elf_ppnt);
1217 }
1218 #endif
1219 elf_ppnt = elf_phdata;
1220
1221 elf_bss = 0;
1222 elf_brk = 0;
1223
1224
1225 elf_stack = ~((abi_ulong)0UL);
1226 elf_interpreter = NULL;
1227 start_code = ~((abi_ulong)0UL);
1228 end_code = 0;
1229 start_data = 0;
1230 end_data = 0;
1231 interp_ex.a_info = 0;
1232
1233 for(i=0;i < elf_ex.e_phnum; i++) {
1234 if (elf_ppnt->p_type == PT_INTERP) {
1235 if ( elf_interpreter != NULL )
1236 {
1237 free (elf_phdata);
1238 free(elf_interpreter);
1239 close(bprm->fd);
1240 return -EINVAL;
1241 }
1242
1243 /* This is the program interpreter used for
1244 * shared libraries - for now assume that this
1245 * is an a.out format binary
1246 */
1247
1248 elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
1249
1250 if (elf_interpreter == NULL) {
1251 free (elf_phdata);
1252 close(bprm->fd);
1253 return -ENOMEM;
1254 }
1255
1256 retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);
1257 if(retval >= 0) {
1258 retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);
1259 }
1260 if(retval < 0) {
1261 perror("load_elf_binary2");
1262 exit(-1);
1263 }
1264
1265 /* If the program interpreter is one of these two,
1266 then assume an iBCS2 image. Otherwise assume
1267 a native linux image. */
1268
1269 /* JRP - Need to add X86 lib dir stuff here... */
1270
1271 if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
1272 strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) {
1273 ibcs2_interpreter = 1;
1274 }
1275
1276 #if 0
1277 printf("Using ELF interpreter %s\n", path(elf_interpreter));
1278 #endif
1279 if (retval >= 0) {
1280 retval = open(path(elf_interpreter), O_RDONLY);
1281 if(retval >= 0) {
1282 interpreter_fd = retval;
1283 }
1284 else {
1285 perror(elf_interpreter);
1286 exit(-1);
1287 /* retval = -errno; */
1288 }
1289 }
1290
1291 if (retval >= 0) {
1292 retval = lseek(interpreter_fd, 0, SEEK_SET);
1293 if(retval >= 0) {
1294 retval = read(interpreter_fd,bprm->buf,128);
1295 }
1296 }
1297 if (retval >= 0) {
1298 interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */
1299 interp_elf_ex = *((struct elfhdr *) bprm->buf); /* elf exec-header */
1300 }
1301 if (retval < 0) {
1302 perror("load_elf_binary3");
1303 exit(-1);
1304 free (elf_phdata);
1305 free(elf_interpreter);
1306 close(bprm->fd);
1307 return retval;
1308 }
1309 }
1310 elf_ppnt++;
1311 }
1312
1313 /* Some simple consistency checks for the interpreter */
1314 if (elf_interpreter){
1315 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
1316
1317 /* Now figure out which format our binary is */
1318 if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&
1319 (N_MAGIC(interp_ex) != QMAGIC)) {
1320 interpreter_type = INTERPRETER_ELF;
1321 }
1322
1323 if (interp_elf_ex.e_ident[0] != 0x7f ||
1324 strncmp((char *)&interp_elf_ex.e_ident[1], "ELF",3) != 0) {
1325 interpreter_type &= ~INTERPRETER_ELF;
1326 }
1327
1328 if (!interpreter_type) {
1329 free(elf_interpreter);
1330 free(elf_phdata);
1331 close(bprm->fd);
1332 return -ELIBBAD;
1333 }
1334 }
1335
1336 /* OK, we are done with that, now set up the arg stuff,
1337 and then start this sucker up */
1338
1339 {
1340 char * passed_p;
1341
1342 if (interpreter_type == INTERPRETER_AOUT) {
1343 snprintf(passed_fileno, sizeof(passed_fileno), "%d", bprm->fd);
1344 passed_p = passed_fileno;
1345
1346 if (elf_interpreter) {
1347 bprm->p = copy_elf_strings(1,&passed_p,bprm->page,bprm->p);
1348 bprm->argc++;
1349 }
1350 }
1351 if (!bprm->p) {
1352 free(elf_interpreter);
1353 free (elf_phdata);
1354 close(bprm->fd);
1355 return -E2BIG;
1356 }
1357 }
1358
1359 /* OK, This is the point of no return */
1360 info->end_data = 0;
1361 info->end_code = 0;
1362 info->start_mmap = (abi_ulong)ELF_START_MMAP;
1363 info->mmap = 0;
1364 elf_entry = (abi_ulong) elf_ex.e_entry;
1365
1366 /*
1367 * In case where user has not explicitly set the guest_base, we
1368 * probe here that should we set it automatically.
1369 */
1370 if (!have_guest_base) {
1371 /*
1372 * Go through ELF program header table and find out whether
1373 * any of the segments drop below our current mmap_min_addr and
1374 * in that case set guest_base to corresponding address.
1375 */
1376 for (i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum;
1377 i++, elf_ppnt++) {
1378 if (elf_ppnt->p_type != PT_LOAD)
1379 continue;
1380 if (HOST_PAGE_ALIGN(elf_ppnt->p_vaddr) < mmap_min_addr) {
1381 guest_base = HOST_PAGE_ALIGN(mmap_min_addr);
1382 break;
1383 }
1384 }
1385 }
1386
1387 /* Do this so that we can load the interpreter, if need be. We will
1388 change some of these later */
1389 info->rss = 0;
1390 bprm->p = setup_arg_pages(bprm->p, bprm, info);
1391 info->start_stack = bprm->p;
1392
1393 /* Now we do a little grungy work by mmaping the ELF image into
1394 * the correct location in memory. At this point, we assume that
1395 * the image should be loaded at fixed address, not at a variable
1396 * address.
1397 */
1398
1399 for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
1400 int elf_prot = 0;
1401 int elf_flags = 0;
1402 abi_ulong error;
1403
1404 if (elf_ppnt->p_type != PT_LOAD)
1405 continue;
1406
1407 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
1408 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
1409 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
1410 elf_flags = MAP_PRIVATE | MAP_DENYWRITE;
1411 if (elf_ex.e_type == ET_EXEC || load_addr_set) {
1412 elf_flags |= MAP_FIXED;
1413 } else if (elf_ex.e_type == ET_DYN) {
1414 /* Try and get dynamic programs out of the way of the default mmap
1415 base, as well as whatever program they might try to exec. This
1416 is because the brk will follow the loader, and is not movable. */
1417 /* NOTE: for qemu, we do a big mmap to get enough space
1418 without hardcoding any address */
1419 error = target_mmap(0, ET_DYN_MAP_SIZE,
1420 PROT_NONE, MAP_PRIVATE | MAP_ANON,
1421 -1, 0);
1422 if (error == -1) {
1423 perror("mmap");
1424 exit(-1);
1425 }
1426 load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr);
1427 }
1428
1429 error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),
1430 (elf_ppnt->p_filesz +
1431 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
1432 elf_prot,
1433 (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),
1434 bprm->fd,
1435 (elf_ppnt->p_offset -
1436 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
1437 if (error == -1) {
1438 perror("mmap");
1439 exit(-1);
1440 }
1441
1442 #ifdef LOW_ELF_STACK
1443 if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)
1444 elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr);
1445 #endif
1446
1447 if (!load_addr_set) {
1448 load_addr_set = 1;
1449 load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;
1450 if (elf_ex.e_type == ET_DYN) {
1451 load_bias += error -
1452 TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr);
1453 load_addr += load_bias;
1454 reloc_func_desc = load_bias;
1455 }
1456 }
1457 k = elf_ppnt->p_vaddr;
1458 if (k < start_code)
1459 start_code = k;
1460 if (start_data < k)
1461 start_data = k;
1462 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1463 if (k > elf_bss)
1464 elf_bss = k;
1465 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1466 end_code = k;
1467 if (end_data < k)
1468 end_data = k;
1469 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1470 if (k > elf_brk) elf_brk = k;
1471 }
1472
1473 elf_entry += load_bias;
1474 elf_bss += load_bias;
1475 elf_brk += load_bias;
1476 start_code += load_bias;
1477 end_code += load_bias;
1478 start_data += load_bias;
1479 end_data += load_bias;
1480
1481 if (elf_interpreter) {
1482 if (interpreter_type & 1) {
1483 elf_entry = load_aout_interp(&interp_ex, interpreter_fd);
1484 }
1485 else if (interpreter_type & 2) {
1486 elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,
1487 &interp_load_addr);
1488 }
1489 reloc_func_desc = interp_load_addr;
1490
1491 close(interpreter_fd);
1492 free(elf_interpreter);
1493
1494 if (elf_entry == ~((abi_ulong)0UL)) {
1495 printf("Unable to load interpreter\n");
1496 free(elf_phdata);
1497 exit(-1);
1498 return 0;
1499 }
1500 }
1501
1502 free(elf_phdata);
1503
1504 if (qemu_log_enabled())
1505 load_symbols(&elf_ex, bprm->fd);
1506
1507 if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);
1508 info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX);
1509
1510 #ifdef LOW_ELF_STACK
1511 info->start_stack = bprm->p = elf_stack - 4;
1512 #endif
1513 bprm->p = create_elf_tables(bprm->p,
1514 bprm->argc,
1515 bprm->envc,
1516 &elf_ex,
1517 load_addr, load_bias,
1518 interp_load_addr,
1519 (interpreter_type == INTERPRETER_AOUT ? 0 : 1),
1520 info);
1521 info->load_addr = reloc_func_desc;
1522 info->start_brk = info->brk = elf_brk;
1523 info->end_code = end_code;
1524 info->start_code = start_code;
1525 info->start_data = start_data;
1526 info->end_data = end_data;
1527 info->start_stack = bprm->p;
1528
1529 /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1530 sections */
1531 set_brk(elf_bss, elf_brk);
1532
1533 padzero(elf_bss, elf_brk);
1534
1535 #if 0
1536 printf("(start_brk) %x\n" , info->start_brk);
1537 printf("(end_code) %x\n" , info->end_code);
1538 printf("(start_code) %x\n" , info->start_code);
1539 printf("(end_data) %x\n" , info->end_data);
1540 printf("(start_stack) %x\n" , info->start_stack);
1541 printf("(brk) %x\n" , info->brk);
1542 #endif
1543
1544 if ( info->personality == PER_SVR4 )
1545 {
1546 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1547 and some applications "depend" upon this behavior.
1548 Since we do not have the power to recompile these, we
1549 emulate the SVr4 behavior. Sigh. */
1550 mapped_addr = target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
1551 MAP_FIXED | MAP_PRIVATE, -1, 0);
1552 }
1553
1554 info->entry = elf_entry;
1555
1556 return 0;
1557 }
1558
1559 static int load_aout_interp(void * exptr, int interp_fd)
1560 {
1561 printf("a.out interpreter not yet supported\n");
1562 return(0);
1563 }
1564
1565 void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
1566 {
1567 init_thread(regs, infop);
1568 }