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