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