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/disas.h" 14 15 #ifdef _ARCH_PPC64 16 #undef ARCH_DLINFO 17 #undef ELF_PLATFORM 18 #undef ELF_HWCAP 19 #undef ELF_CLASS 20 #undef ELF_DATA 21 #undef ELF_ARCH 22 #endif 23 24 /* from personality.h */ 25 26 /* 27 * Flags for bug emulation. 28 * 29 * These occupy the top three bytes. 30 */ 31 enum { 32 ADDR_NO_RANDOMIZE = 0x0040000, /* disable randomization of VA space */ 33 FDPIC_FUNCPTRS = 0x0080000, /* userspace function ptrs point to descriptors 34 * (signal handling) 35 */ 36 MMAP_PAGE_ZERO = 0x0100000, 37 ADDR_COMPAT_LAYOUT = 0x0200000, 38 READ_IMPLIES_EXEC = 0x0400000, 39 ADDR_LIMIT_32BIT = 0x0800000, 40 SHORT_INODE = 0x1000000, 41 WHOLE_SECONDS = 0x2000000, 42 STICKY_TIMEOUTS = 0x4000000, 43 ADDR_LIMIT_3GB = 0x8000000, 44 }; 45 46 /* 47 * Personality types. 48 * 49 * These go in the low byte. Avoid using the top bit, it will 50 * conflict with error returns. 51 */ 52 enum { 53 PER_LINUX = 0x0000, 54 PER_LINUX_32BIT = 0x0000 | ADDR_LIMIT_32BIT, 55 PER_LINUX_FDPIC = 0x0000 | FDPIC_FUNCPTRS, 56 PER_SVR4 = 0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO, 57 PER_SVR3 = 0x0002 | STICKY_TIMEOUTS | SHORT_INODE, 58 PER_SCOSVR3 = 0x0003 | STICKY_TIMEOUTS | 59 WHOLE_SECONDS | SHORT_INODE, 60 PER_OSR5 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS, 61 PER_WYSEV386 = 0x0004 | STICKY_TIMEOUTS | SHORT_INODE, 62 PER_ISCR4 = 0x0005 | STICKY_TIMEOUTS, 63 PER_BSD = 0x0006, 64 PER_SUNOS = 0x0006 | STICKY_TIMEOUTS, 65 PER_XENIX = 0x0007 | STICKY_TIMEOUTS | SHORT_INODE, 66 PER_LINUX32 = 0x0008, 67 PER_LINUX32_3GB = 0x0008 | ADDR_LIMIT_3GB, 68 PER_IRIX32 = 0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */ 69 PER_IRIXN32 = 0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */ 70 PER_IRIX64 = 0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */ 71 PER_RISCOS = 0x000c, 72 PER_SOLARIS = 0x000d | STICKY_TIMEOUTS, 73 PER_UW7 = 0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO, 74 PER_OSF4 = 0x000f, /* OSF/1 v4 */ 75 PER_HPUX = 0x0010, 76 PER_MASK = 0x00ff, 77 }; 78 79 /* 80 * Return the base personality without flags. 81 */ 82 #define personality(pers) (pers & PER_MASK) 83 84 /* this flag is uneffective under linux too, should be deleted */ 85 #ifndef MAP_DENYWRITE 86 #define MAP_DENYWRITE 0 87 #endif 88 89 /* should probably go in elf.h */ 90 #ifndef ELIBBAD 91 #define ELIBBAD 80 92 #endif 93 94 #ifdef TARGET_I386 95 96 #define ELF_PLATFORM get_elf_platform() 97 98 static const char *get_elf_platform(void) 99 { 100 static char elf_platform[] = "i386"; 101 int family = (thread_env->cpuid_version >> 8) & 0xff; 102 if (family > 6) 103 family = 6; 104 if (family >= 3) 105 elf_platform[1] = '0' + family; 106 return elf_platform; 107 } 108 109 #define ELF_HWCAP get_elf_hwcap() 110 111 static uint32_t get_elf_hwcap(void) 112 { 113 return thread_env->cpuid_features; 114 } 115 116 #ifdef TARGET_X86_64 117 #define ELF_START_MMAP 0x2aaaaab000ULL 118 #define elf_check_arch(x) ( ((x) == ELF_ARCH) ) 119 120 #define ELF_CLASS ELFCLASS64 121 #define ELF_DATA ELFDATA2LSB 122 #define ELF_ARCH EM_X86_64 123 124 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop) 125 { 126 regs->rax = 0; 127 regs->rsp = infop->start_stack; 128 regs->rip = infop->entry; 129 if (bsd_type == target_freebsd) { 130 regs->rdi = infop->start_stack; 131 } 132 } 133 134 #else 135 136 #define ELF_START_MMAP 0x80000000 137 138 /* 139 * This is used to ensure we don't load something for the wrong architecture. 140 */ 141 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) ) 142 143 /* 144 * These are used to set parameters in the core dumps. 145 */ 146 #define ELF_CLASS ELFCLASS32 147 #define ELF_DATA ELFDATA2LSB 148 #define ELF_ARCH EM_386 149 150 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop) 151 { 152 regs->esp = infop->start_stack; 153 regs->eip = infop->entry; 154 155 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program 156 starts %edx contains a pointer to a function which might be 157 registered using `atexit'. This provides a mean for the 158 dynamic linker to call DT_FINI functions for shared libraries 159 that have been loaded before the code runs. 160 161 A value of 0 tells we have no such handler. */ 162 regs->edx = 0; 163 } 164 #endif 165 166 #define USE_ELF_CORE_DUMP 167 #define ELF_EXEC_PAGESIZE 4096 168 169 #endif 170 171 #ifdef TARGET_ARM 172 173 #define ELF_START_MMAP 0x80000000 174 175 #define elf_check_arch(x) ( (x) == EM_ARM ) 176 177 #define ELF_CLASS ELFCLASS32 178 #ifdef TARGET_WORDS_BIGENDIAN 179 #define ELF_DATA ELFDATA2MSB 180 #else 181 #define ELF_DATA ELFDATA2LSB 182 #endif 183 #define ELF_ARCH EM_ARM 184 185 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop) 186 { 187 abi_long stack = infop->start_stack; 188 memset(regs, 0, sizeof(*regs)); 189 regs->ARM_cpsr = 0x10; 190 if (infop->entry & 1) 191 regs->ARM_cpsr |= CPSR_T; 192 regs->ARM_pc = infop->entry & 0xfffffffe; 193 regs->ARM_sp = infop->start_stack; 194 /* FIXME - what to for failure of get_user()? */ 195 get_user_ual(regs->ARM_r2, stack + 8); /* envp */ 196 get_user_ual(regs->ARM_r1, stack + 4); /* envp */ 197 /* XXX: it seems that r0 is zeroed after ! */ 198 regs->ARM_r0 = 0; 199 /* For uClinux PIC binaries. */ 200 /* XXX: Linux does this only on ARM with no MMU (do we care ?) */ 201 regs->ARM_r10 = infop->start_data; 202 } 203 204 #define USE_ELF_CORE_DUMP 205 #define ELF_EXEC_PAGESIZE 4096 206 207 enum 208 { 209 ARM_HWCAP_ARM_SWP = 1 << 0, 210 ARM_HWCAP_ARM_HALF = 1 << 1, 211 ARM_HWCAP_ARM_THUMB = 1 << 2, 212 ARM_HWCAP_ARM_26BIT = 1 << 3, 213 ARM_HWCAP_ARM_FAST_MULT = 1 << 4, 214 ARM_HWCAP_ARM_FPA = 1 << 5, 215 ARM_HWCAP_ARM_VFP = 1 << 6, 216 ARM_HWCAP_ARM_EDSP = 1 << 7, 217 }; 218 219 #define ELF_HWCAP (ARM_HWCAP_ARM_SWP | ARM_HWCAP_ARM_HALF \ 220 | ARM_HWCAP_ARM_THUMB | ARM_HWCAP_ARM_FAST_MULT \ 221 | ARM_HWCAP_ARM_FPA | ARM_HWCAP_ARM_VFP) 222 223 #endif 224 225 #ifdef TARGET_SPARC 226 #ifdef TARGET_SPARC64 227 228 #define ELF_START_MMAP 0x80000000 229 230 #ifndef TARGET_ABI32 231 #define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS ) 232 #else 233 #define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC ) 234 #endif 235 236 #define ELF_CLASS ELFCLASS64 237 #define ELF_DATA ELFDATA2MSB 238 #define ELF_ARCH EM_SPARCV9 239 240 #define STACK_BIAS 2047 241 242 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop) 243 { 244 #ifndef TARGET_ABI32 245 regs->tstate = 0; 246 #endif 247 regs->pc = infop->entry; 248 regs->npc = regs->pc + 4; 249 regs->y = 0; 250 #ifdef TARGET_ABI32 251 regs->u_regs[14] = infop->start_stack - 16 * 4; 252 #else 253 if (personality(infop->personality) == PER_LINUX32) 254 regs->u_regs[14] = infop->start_stack - 16 * 4; 255 else { 256 regs->u_regs[14] = infop->start_stack - 16 * 8 - STACK_BIAS; 257 if (bsd_type == target_freebsd) { 258 regs->u_regs[8] = infop->start_stack; 259 regs->u_regs[11] = infop->start_stack; 260 } 261 } 262 #endif 263 } 264 265 #else 266 #define ELF_START_MMAP 0x80000000 267 268 #define elf_check_arch(x) ( (x) == EM_SPARC ) 269 270 #define ELF_CLASS ELFCLASS32 271 #define ELF_DATA ELFDATA2MSB 272 #define ELF_ARCH EM_SPARC 273 274 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop) 275 { 276 regs->psr = 0; 277 regs->pc = infop->entry; 278 regs->npc = regs->pc + 4; 279 regs->y = 0; 280 regs->u_regs[14] = infop->start_stack - 16 * 4; 281 } 282 283 #endif 284 #endif 285 286 #ifdef TARGET_PPC 287 288 #define ELF_START_MMAP 0x80000000 289 290 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32) 291 292 #define elf_check_arch(x) ( (x) == EM_PPC64 ) 293 294 #define ELF_CLASS ELFCLASS64 295 296 #else 297 298 #define elf_check_arch(x) ( (x) == EM_PPC ) 299 300 #define ELF_CLASS ELFCLASS32 301 302 #endif 303 304 #ifdef TARGET_WORDS_BIGENDIAN 305 #define ELF_DATA ELFDATA2MSB 306 #else 307 #define ELF_DATA ELFDATA2LSB 308 #endif 309 #define ELF_ARCH EM_PPC 310 311 /* 312 * We need to put in some extra aux table entries to tell glibc what 313 * the cache block size is, so it can use the dcbz instruction safely. 314 */ 315 #define AT_DCACHEBSIZE 19 316 #define AT_ICACHEBSIZE 20 317 #define AT_UCACHEBSIZE 21 318 /* A special ignored type value for PPC, for glibc compatibility. */ 319 #define AT_IGNOREPPC 22 320 /* 321 * The requirements here are: 322 * - keep the final alignment of sp (sp & 0xf) 323 * - make sure the 32-bit value at the first 16 byte aligned position of 324 * AUXV is greater than 16 for glibc compatibility. 325 * AT_IGNOREPPC is used for that. 326 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC, 327 * even if DLINFO_ARCH_ITEMS goes to zero or is undefined. 328 */ 329 #define DLINFO_ARCH_ITEMS 5 330 #define ARCH_DLINFO \ 331 do { \ 332 NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20); \ 333 NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20); \ 334 NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \ 335 /* \ 336 * Now handle glibc compatibility. \ 337 */ \ 338 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \ 339 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \ 340 } while (0) 341 342 static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop) 343 { 344 abi_ulong pos = infop->start_stack; 345 abi_ulong tmp; 346 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32) 347 abi_ulong entry, toc; 348 #endif 349 350 _regs->gpr[1] = infop->start_stack; 351 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32) 352 entry = ldq_raw(infop->entry) + infop->load_addr; 353 toc = ldq_raw(infop->entry + 8) + infop->load_addr; 354 _regs->gpr[2] = toc; 355 infop->entry = entry; 356 #endif 357 _regs->nip = infop->entry; 358 /* Note that isn't exactly what regular kernel does 359 * but this is what the ABI wants and is needed to allow 360 * execution of PPC BSD programs. 361 */ 362 /* FIXME - what to for failure of get_user()? */ 363 get_user_ual(_regs->gpr[3], pos); 364 pos += sizeof(abi_ulong); 365 _regs->gpr[4] = pos; 366 for (tmp = 1; tmp != 0; pos += sizeof(abi_ulong)) 367 tmp = ldl(pos); 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 = (elf_bss + qemu_real_host_page_size - 1) & 739 ~(qemu_real_host_page_size - 1); 740 end_addr = HOST_PAGE_ALIGN(elf_bss); 741 if (end_addr1 < end_addr) { 742 mmap((void *)g2h(end_addr1), end_addr - end_addr1, 743 PROT_READ|PROT_WRITE|PROT_EXEC, 744 MAP_FIXED|MAP_PRIVATE|MAP_ANON, -1, 0); 745 } 746 } 747 748 nbyte = elf_bss & (qemu_host_page_size-1); 749 if (nbyte) { 750 nbyte = qemu_host_page_size - nbyte; 751 do { 752 /* FIXME - what to do if put_user() fails? */ 753 put_user_u8(0, elf_bss); 754 elf_bss++; 755 } while (--nbyte); 756 } 757 } 758 759 760 static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc, 761 struct elfhdr * exec, 762 abi_ulong load_addr, 763 abi_ulong load_bias, 764 abi_ulong interp_load_addr, int ibcs, 765 struct image_info *info) 766 { 767 abi_ulong sp; 768 int size; 769 abi_ulong u_platform; 770 const char *k_platform; 771 const int n = sizeof(elf_addr_t); 772 773 sp = p; 774 u_platform = 0; 775 k_platform = ELF_PLATFORM; 776 if (k_platform) { 777 size_t len = strlen(k_platform) + 1; 778 sp -= (len + n - 1) & ~(n - 1); 779 u_platform = sp; 780 /* FIXME - check return value of memcpy_to_target() for failure */ 781 memcpy_to_target(sp, k_platform, len); 782 } 783 /* 784 * Force 16 byte _final_ alignment here for generality. 785 */ 786 sp = sp &~ (abi_ulong)15; 787 size = (DLINFO_ITEMS + 1) * 2; 788 if (k_platform) 789 size += 2; 790 #ifdef DLINFO_ARCH_ITEMS 791 size += DLINFO_ARCH_ITEMS * 2; 792 #endif 793 size += envc + argc + 2; 794 size += (!ibcs ? 3 : 1); /* argc itself */ 795 size *= n; 796 if (size & 15) 797 sp -= 16 - (size & 15); 798 799 /* This is correct because Linux defines 800 * elf_addr_t as Elf32_Off / Elf64_Off 801 */ 802 #define NEW_AUX_ENT(id, val) do { \ 803 sp -= n; put_user_ual(val, sp); \ 804 sp -= n; put_user_ual(id, sp); \ 805 } while(0) 806 807 NEW_AUX_ENT (AT_NULL, 0); 808 809 /* There must be exactly DLINFO_ITEMS entries here. */ 810 NEW_AUX_ENT(AT_PHDR, (abi_ulong)(load_addr + exec->e_phoff)); 811 NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr))); 812 NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum)); 813 NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(TARGET_PAGE_SIZE)); 814 NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_load_addr)); 815 NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0); 816 NEW_AUX_ENT(AT_ENTRY, load_bias + exec->e_entry); 817 NEW_AUX_ENT(AT_UID, (abi_ulong) getuid()); 818 NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid()); 819 NEW_AUX_ENT(AT_GID, (abi_ulong) getgid()); 820 NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid()); 821 NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP); 822 NEW_AUX_ENT(AT_CLKTCK, (abi_ulong) sysconf(_SC_CLK_TCK)); 823 if (k_platform) 824 NEW_AUX_ENT(AT_PLATFORM, u_platform); 825 #ifdef ARCH_DLINFO 826 /* 827 * ARCH_DLINFO must come last so platform specific code can enforce 828 * special alignment requirements on the AUXV if necessary (eg. PPC). 829 */ 830 ARCH_DLINFO; 831 #endif 832 #undef NEW_AUX_ENT 833 834 sp = loader_build_argptr(envc, argc, sp, p, !ibcs); 835 return sp; 836 } 837 838 839 static abi_ulong load_elf_interp(struct elfhdr * interp_elf_ex, 840 int interpreter_fd, 841 abi_ulong *interp_load_addr) 842 { 843 struct elf_phdr *elf_phdata = NULL; 844 struct elf_phdr *eppnt; 845 abi_ulong load_addr = 0; 846 int load_addr_set = 0; 847 int retval; 848 abi_ulong last_bss, elf_bss; 849 abi_ulong error; 850 int i; 851 852 elf_bss = 0; 853 last_bss = 0; 854 error = 0; 855 856 #ifdef BSWAP_NEEDED 857 bswap_ehdr(interp_elf_ex); 858 #endif 859 /* First of all, some simple consistency checks */ 860 if ((interp_elf_ex->e_type != ET_EXEC && 861 interp_elf_ex->e_type != ET_DYN) || 862 !elf_check_arch(interp_elf_ex->e_machine)) { 863 return ~((abi_ulong)0UL); 864 } 865 866 867 /* Now read in all of the header information */ 868 869 if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE) 870 return ~(abi_ulong)0UL; 871 872 elf_phdata = (struct elf_phdr *) 873 malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum); 874 875 if (!elf_phdata) 876 return ~((abi_ulong)0UL); 877 878 /* 879 * If the size of this structure has changed, then punt, since 880 * we will be doing the wrong thing. 881 */ 882 if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) { 883 free(elf_phdata); 884 return ~((abi_ulong)0UL); 885 } 886 887 retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET); 888 if(retval >= 0) { 889 retval = read(interpreter_fd, 890 (char *) elf_phdata, 891 sizeof(struct elf_phdr) * interp_elf_ex->e_phnum); 892 } 893 if (retval < 0) { 894 perror("load_elf_interp"); 895 exit(-1); 896 free (elf_phdata); 897 return retval; 898 } 899 #ifdef BSWAP_NEEDED 900 eppnt = elf_phdata; 901 for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) { 902 bswap_phdr(eppnt); 903 } 904 #endif 905 906 if (interp_elf_ex->e_type == ET_DYN) { 907 /* in order to avoid hardcoding the interpreter load 908 address in qemu, we allocate a big enough memory zone */ 909 error = target_mmap(0, INTERP_MAP_SIZE, 910 PROT_NONE, MAP_PRIVATE | MAP_ANON, 911 -1, 0); 912 if (error == -1) { 913 perror("mmap"); 914 exit(-1); 915 } 916 load_addr = error; 917 load_addr_set = 1; 918 } 919 920 eppnt = elf_phdata; 921 for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) 922 if (eppnt->p_type == PT_LOAD) { 923 int elf_type = MAP_PRIVATE | MAP_DENYWRITE; 924 int elf_prot = 0; 925 abi_ulong vaddr = 0; 926 abi_ulong k; 927 928 if (eppnt->p_flags & PF_R) elf_prot = PROT_READ; 929 if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE; 930 if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC; 931 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set) { 932 elf_type |= MAP_FIXED; 933 vaddr = eppnt->p_vaddr; 934 } 935 error = target_mmap(load_addr+TARGET_ELF_PAGESTART(vaddr), 936 eppnt->p_filesz + TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr), 937 elf_prot, 938 elf_type, 939 interpreter_fd, 940 eppnt->p_offset - TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr)); 941 942 if (error == -1) { 943 /* Real error */ 944 close(interpreter_fd); 945 free(elf_phdata); 946 return ~((abi_ulong)0UL); 947 } 948 949 if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) { 950 load_addr = error; 951 load_addr_set = 1; 952 } 953 954 /* 955 * Find the end of the file mapping for this phdr, and keep 956 * track of the largest address we see for this. 957 */ 958 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz; 959 if (k > elf_bss) elf_bss = k; 960 961 /* 962 * Do the same thing for the memory mapping - between 963 * elf_bss and last_bss is the bss section. 964 */ 965 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr; 966 if (k > last_bss) last_bss = k; 967 } 968 969 /* Now use mmap to map the library into memory. */ 970 971 close(interpreter_fd); 972 973 /* 974 * Now fill out the bss section. First pad the last page up 975 * to the page boundary, and then perform a mmap to make sure 976 * that there are zeromapped pages up to and including the last 977 * bss page. 978 */ 979 padzero(elf_bss, last_bss); 980 elf_bss = TARGET_ELF_PAGESTART(elf_bss + qemu_host_page_size - 1); /* What we have mapped so far */ 981 982 /* Map the last of the bss segment */ 983 if (last_bss > elf_bss) { 984 target_mmap(elf_bss, last_bss-elf_bss, 985 PROT_READ|PROT_WRITE|PROT_EXEC, 986 MAP_FIXED|MAP_PRIVATE|MAP_ANON, -1, 0); 987 } 988 free(elf_phdata); 989 990 *interp_load_addr = load_addr; 991 return ((abi_ulong) interp_elf_ex->e_entry) + load_addr; 992 } 993 994 static int symfind(const void *s0, const void *s1) 995 { 996 target_ulong addr = *(target_ulong *)s0; 997 struct elf_sym *sym = (struct elf_sym *)s1; 998 int result = 0; 999 if (addr < sym->st_value) { 1000 result = -1; 1001 } else if (addr >= sym->st_value + sym->st_size) { 1002 result = 1; 1003 } 1004 return result; 1005 } 1006 1007 static const char *lookup_symbolxx(struct syminfo *s, target_ulong orig_addr) 1008 { 1009 #if ELF_CLASS == ELFCLASS32 1010 struct elf_sym *syms = s->disas_symtab.elf32; 1011 #else 1012 struct elf_sym *syms = s->disas_symtab.elf64; 1013 #endif 1014 1015 // binary search 1016 struct elf_sym *sym; 1017 1018 sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind); 1019 if (sym != NULL) { 1020 return s->disas_strtab + sym->st_name; 1021 } 1022 1023 return ""; 1024 } 1025 1026 /* FIXME: This should use elf_ops.h */ 1027 static int symcmp(const void *s0, const void *s1) 1028 { 1029 struct elf_sym *sym0 = (struct elf_sym *)s0; 1030 struct elf_sym *sym1 = (struct elf_sym *)s1; 1031 return (sym0->st_value < sym1->st_value) 1032 ? -1 1033 : ((sym0->st_value > sym1->st_value) ? 1 : 0); 1034 } 1035 1036 /* Best attempt to load symbols from this ELF object. */ 1037 static void load_symbols(struct elfhdr *hdr, int fd) 1038 { 1039 unsigned int i, nsyms; 1040 struct elf_shdr sechdr, symtab, strtab; 1041 char *strings; 1042 struct syminfo *s; 1043 struct elf_sym *syms, *new_syms; 1044 1045 lseek(fd, hdr->e_shoff, SEEK_SET); 1046 for (i = 0; i < hdr->e_shnum; i++) { 1047 if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr)) 1048 return; 1049 #ifdef BSWAP_NEEDED 1050 bswap_shdr(&sechdr); 1051 #endif 1052 if (sechdr.sh_type == SHT_SYMTAB) { 1053 symtab = sechdr; 1054 lseek(fd, hdr->e_shoff 1055 + sizeof(sechdr) * sechdr.sh_link, SEEK_SET); 1056 if (read(fd, &strtab, sizeof(strtab)) 1057 != sizeof(strtab)) 1058 return; 1059 #ifdef BSWAP_NEEDED 1060 bswap_shdr(&strtab); 1061 #endif 1062 goto found; 1063 } 1064 } 1065 return; /* Shouldn't happen... */ 1066 1067 found: 1068 /* Now know where the strtab and symtab are. Snarf them. */ 1069 s = malloc(sizeof(*s)); 1070 syms = malloc(symtab.sh_size); 1071 if (!syms) { 1072 free(s); 1073 return; 1074 } 1075 s->disas_strtab = strings = malloc(strtab.sh_size); 1076 if (!s->disas_strtab) { 1077 free(s); 1078 free(syms); 1079 return; 1080 } 1081 1082 lseek(fd, symtab.sh_offset, SEEK_SET); 1083 if (read(fd, syms, symtab.sh_size) != symtab.sh_size) { 1084 free(s); 1085 free(syms); 1086 free(strings); 1087 return; 1088 } 1089 1090 nsyms = symtab.sh_size / sizeof(struct elf_sym); 1091 1092 i = 0; 1093 while (i < nsyms) { 1094 #ifdef BSWAP_NEEDED 1095 bswap_sym(syms + i); 1096 #endif 1097 // Throw away entries which we do not need. 1098 if (syms[i].st_shndx == SHN_UNDEF || 1099 syms[i].st_shndx >= SHN_LORESERVE || 1100 ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) { 1101 nsyms--; 1102 if (i < nsyms) { 1103 syms[i] = syms[nsyms]; 1104 } 1105 continue; 1106 } 1107 #if defined(TARGET_ARM) || defined (TARGET_MIPS) 1108 /* The bottom address bit marks a Thumb or MIPS16 symbol. */ 1109 syms[i].st_value &= ~(target_ulong)1; 1110 #endif 1111 i++; 1112 } 1113 1114 /* Attempt to free the storage associated with the local symbols 1115 that we threw away. Whether or not this has any effect on the 1116 memory allocation depends on the malloc implementation and how 1117 many symbols we managed to discard. */ 1118 new_syms = realloc(syms, nsyms * sizeof(*syms)); 1119 if (new_syms == NULL) { 1120 free(s); 1121 free(syms); 1122 free(strings); 1123 return; 1124 } 1125 syms = new_syms; 1126 1127 qsort(syms, nsyms, sizeof(*syms), symcmp); 1128 1129 lseek(fd, strtab.sh_offset, SEEK_SET); 1130 if (read(fd, strings, strtab.sh_size) != strtab.sh_size) { 1131 free(s); 1132 free(syms); 1133 free(strings); 1134 return; 1135 } 1136 s->disas_num_syms = nsyms; 1137 #if ELF_CLASS == ELFCLASS32 1138 s->disas_symtab.elf32 = syms; 1139 s->lookup_symbol = (lookup_symbol_t)lookup_symbolxx; 1140 #else 1141 s->disas_symtab.elf64 = syms; 1142 s->lookup_symbol = (lookup_symbol_t)lookup_symbolxx; 1143 #endif 1144 s->next = syminfos; 1145 syminfos = s; 1146 } 1147 1148 int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs, 1149 struct image_info * info) 1150 { 1151 struct elfhdr elf_ex; 1152 struct elfhdr interp_elf_ex; 1153 struct exec interp_ex; 1154 int interpreter_fd = -1; /* avoid warning */ 1155 abi_ulong load_addr, load_bias; 1156 int load_addr_set = 0; 1157 unsigned int interpreter_type = INTERPRETER_NONE; 1158 unsigned char ibcs2_interpreter; 1159 int i; 1160 abi_ulong mapped_addr; 1161 struct elf_phdr * elf_ppnt; 1162 struct elf_phdr *elf_phdata; 1163 abi_ulong elf_bss, k, elf_brk; 1164 int retval; 1165 char * elf_interpreter; 1166 abi_ulong elf_entry, interp_load_addr = 0; 1167 int status; 1168 abi_ulong start_code, end_code, start_data, end_data; 1169 abi_ulong reloc_func_desc = 0; 1170 abi_ulong elf_stack; 1171 char passed_fileno[6]; 1172 1173 ibcs2_interpreter = 0; 1174 status = 0; 1175 load_addr = 0; 1176 load_bias = 0; 1177 elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */ 1178 #ifdef BSWAP_NEEDED 1179 bswap_ehdr(&elf_ex); 1180 #endif 1181 1182 /* First of all, some simple consistency checks */ 1183 if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) || 1184 (! elf_check_arch(elf_ex.e_machine))) { 1185 return -ENOEXEC; 1186 } 1187 1188 bprm->p = copy_elf_strings(1, &bprm->filename, bprm->page, bprm->p); 1189 bprm->p = copy_elf_strings(bprm->envc,bprm->envp,bprm->page,bprm->p); 1190 bprm->p = copy_elf_strings(bprm->argc,bprm->argv,bprm->page,bprm->p); 1191 if (!bprm->p) { 1192 retval = -E2BIG; 1193 } 1194 1195 /* Now read in all of the header information */ 1196 elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum); 1197 if (elf_phdata == NULL) { 1198 return -ENOMEM; 1199 } 1200 1201 retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET); 1202 if(retval > 0) { 1203 retval = read(bprm->fd, (char *) elf_phdata, 1204 elf_ex.e_phentsize * elf_ex.e_phnum); 1205 } 1206 1207 if (retval < 0) { 1208 perror("load_elf_binary"); 1209 exit(-1); 1210 free (elf_phdata); 1211 return -errno; 1212 } 1213 1214 #ifdef BSWAP_NEEDED 1215 elf_ppnt = elf_phdata; 1216 for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) { 1217 bswap_phdr(elf_ppnt); 1218 } 1219 #endif 1220 elf_ppnt = elf_phdata; 1221 1222 elf_bss = 0; 1223 elf_brk = 0; 1224 1225 1226 elf_stack = ~((abi_ulong)0UL); 1227 elf_interpreter = NULL; 1228 start_code = ~((abi_ulong)0UL); 1229 end_code = 0; 1230 start_data = 0; 1231 end_data = 0; 1232 interp_ex.a_info = 0; 1233 1234 for(i=0;i < elf_ex.e_phnum; i++) { 1235 if (elf_ppnt->p_type == PT_INTERP) { 1236 if ( elf_interpreter != NULL ) 1237 { 1238 free (elf_phdata); 1239 free(elf_interpreter); 1240 close(bprm->fd); 1241 return -EINVAL; 1242 } 1243 1244 /* This is the program interpreter used for 1245 * shared libraries - for now assume that this 1246 * is an a.out format binary 1247 */ 1248 1249 elf_interpreter = (char *)malloc(elf_ppnt->p_filesz); 1250 1251 if (elf_interpreter == NULL) { 1252 free (elf_phdata); 1253 close(bprm->fd); 1254 return -ENOMEM; 1255 } 1256 1257 retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET); 1258 if(retval >= 0) { 1259 retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz); 1260 } 1261 if(retval < 0) { 1262 perror("load_elf_binary2"); 1263 exit(-1); 1264 } 1265 1266 /* If the program interpreter is one of these two, 1267 then assume an iBCS2 image. Otherwise assume 1268 a native linux image. */ 1269 1270 /* JRP - Need to add X86 lib dir stuff here... */ 1271 1272 if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 || 1273 strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) { 1274 ibcs2_interpreter = 1; 1275 } 1276 1277 #if 0 1278 printf("Using ELF interpreter %s\n", path(elf_interpreter)); 1279 #endif 1280 if (retval >= 0) { 1281 retval = open(path(elf_interpreter), O_RDONLY); 1282 if(retval >= 0) { 1283 interpreter_fd = retval; 1284 } 1285 else { 1286 perror(elf_interpreter); 1287 exit(-1); 1288 /* retval = -errno; */ 1289 } 1290 } 1291 1292 if (retval >= 0) { 1293 retval = lseek(interpreter_fd, 0, SEEK_SET); 1294 if(retval >= 0) { 1295 retval = read(interpreter_fd,bprm->buf,128); 1296 } 1297 } 1298 if (retval >= 0) { 1299 interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */ 1300 interp_elf_ex = *((struct elfhdr *) bprm->buf); /* elf exec-header */ 1301 } 1302 if (retval < 0) { 1303 perror("load_elf_binary3"); 1304 exit(-1); 1305 free (elf_phdata); 1306 free(elf_interpreter); 1307 close(bprm->fd); 1308 return retval; 1309 } 1310 } 1311 elf_ppnt++; 1312 } 1313 1314 /* Some simple consistency checks for the interpreter */ 1315 if (elf_interpreter){ 1316 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT; 1317 1318 /* Now figure out which format our binary is */ 1319 if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) && 1320 (N_MAGIC(interp_ex) != QMAGIC)) { 1321 interpreter_type = INTERPRETER_ELF; 1322 } 1323 1324 if (interp_elf_ex.e_ident[0] != 0x7f || 1325 strncmp((char *)&interp_elf_ex.e_ident[1], "ELF",3) != 0) { 1326 interpreter_type &= ~INTERPRETER_ELF; 1327 } 1328 1329 if (!interpreter_type) { 1330 free(elf_interpreter); 1331 free(elf_phdata); 1332 close(bprm->fd); 1333 return -ELIBBAD; 1334 } 1335 } 1336 1337 /* OK, we are done with that, now set up the arg stuff, 1338 and then start this sucker up */ 1339 1340 { 1341 char * passed_p; 1342 1343 if (interpreter_type == INTERPRETER_AOUT) { 1344 snprintf(passed_fileno, sizeof(passed_fileno), "%d", bprm->fd); 1345 passed_p = passed_fileno; 1346 1347 if (elf_interpreter) { 1348 bprm->p = copy_elf_strings(1,&passed_p,bprm->page,bprm->p); 1349 bprm->argc++; 1350 } 1351 } 1352 if (!bprm->p) { 1353 if (elf_interpreter) { 1354 free(elf_interpreter); 1355 } 1356 free (elf_phdata); 1357 close(bprm->fd); 1358 return -E2BIG; 1359 } 1360 } 1361 1362 /* OK, This is the point of no return */ 1363 info->end_data = 0; 1364 info->end_code = 0; 1365 info->start_mmap = (abi_ulong)ELF_START_MMAP; 1366 info->mmap = 0; 1367 elf_entry = (abi_ulong) elf_ex.e_entry; 1368 1369 #if defined(CONFIG_USE_GUEST_BASE) 1370 /* 1371 * In case where user has not explicitly set the guest_base, we 1372 * probe here that should we set it automatically. 1373 */ 1374 if (!have_guest_base) { 1375 /* 1376 * Go through ELF program header table and find out whether 1377 * any of the segments drop below our current mmap_min_addr and 1378 * in that case set guest_base to corresponding address. 1379 */ 1380 for (i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; 1381 i++, elf_ppnt++) { 1382 if (elf_ppnt->p_type != PT_LOAD) 1383 continue; 1384 if (HOST_PAGE_ALIGN(elf_ppnt->p_vaddr) < mmap_min_addr) { 1385 guest_base = HOST_PAGE_ALIGN(mmap_min_addr); 1386 break; 1387 } 1388 } 1389 } 1390 #endif /* CONFIG_USE_GUEST_BASE */ 1391 1392 /* Do this so that we can load the interpreter, if need be. We will 1393 change some of these later */ 1394 info->rss = 0; 1395 bprm->p = setup_arg_pages(bprm->p, bprm, info); 1396 info->start_stack = bprm->p; 1397 1398 /* Now we do a little grungy work by mmaping the ELF image into 1399 * the correct location in memory. At this point, we assume that 1400 * the image should be loaded at fixed address, not at a variable 1401 * address. 1402 */ 1403 1404 for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) { 1405 int elf_prot = 0; 1406 int elf_flags = 0; 1407 abi_ulong error; 1408 1409 if (elf_ppnt->p_type != PT_LOAD) 1410 continue; 1411 1412 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ; 1413 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE; 1414 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC; 1415 elf_flags = MAP_PRIVATE | MAP_DENYWRITE; 1416 if (elf_ex.e_type == ET_EXEC || load_addr_set) { 1417 elf_flags |= MAP_FIXED; 1418 } else if (elf_ex.e_type == ET_DYN) { 1419 /* Try and get dynamic programs out of the way of the default mmap 1420 base, as well as whatever program they might try to exec. This 1421 is because the brk will follow the loader, and is not movable. */ 1422 /* NOTE: for qemu, we do a big mmap to get enough space 1423 without hardcoding any address */ 1424 error = target_mmap(0, ET_DYN_MAP_SIZE, 1425 PROT_NONE, MAP_PRIVATE | MAP_ANON, 1426 -1, 0); 1427 if (error == -1) { 1428 perror("mmap"); 1429 exit(-1); 1430 } 1431 load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr); 1432 } 1433 1434 error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr), 1435 (elf_ppnt->p_filesz + 1436 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)), 1437 elf_prot, 1438 (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE), 1439 bprm->fd, 1440 (elf_ppnt->p_offset - 1441 TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr))); 1442 if (error == -1) { 1443 perror("mmap"); 1444 exit(-1); 1445 } 1446 1447 #ifdef LOW_ELF_STACK 1448 if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack) 1449 elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr); 1450 #endif 1451 1452 if (!load_addr_set) { 1453 load_addr_set = 1; 1454 load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset; 1455 if (elf_ex.e_type == ET_DYN) { 1456 load_bias += error - 1457 TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr); 1458 load_addr += load_bias; 1459 reloc_func_desc = load_bias; 1460 } 1461 } 1462 k = elf_ppnt->p_vaddr; 1463 if (k < start_code) 1464 start_code = k; 1465 if (start_data < k) 1466 start_data = k; 1467 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz; 1468 if (k > elf_bss) 1469 elf_bss = k; 1470 if ((elf_ppnt->p_flags & PF_X) && end_code < k) 1471 end_code = k; 1472 if (end_data < k) 1473 end_data = k; 1474 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz; 1475 if (k > elf_brk) elf_brk = k; 1476 } 1477 1478 elf_entry += load_bias; 1479 elf_bss += load_bias; 1480 elf_brk += load_bias; 1481 start_code += load_bias; 1482 end_code += load_bias; 1483 start_data += load_bias; 1484 end_data += load_bias; 1485 1486 if (elf_interpreter) { 1487 if (interpreter_type & 1) { 1488 elf_entry = load_aout_interp(&interp_ex, interpreter_fd); 1489 } 1490 else if (interpreter_type & 2) { 1491 elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd, 1492 &interp_load_addr); 1493 } 1494 reloc_func_desc = interp_load_addr; 1495 1496 close(interpreter_fd); 1497 free(elf_interpreter); 1498 1499 if (elf_entry == ~((abi_ulong)0UL)) { 1500 printf("Unable to load interpreter\n"); 1501 free(elf_phdata); 1502 exit(-1); 1503 return 0; 1504 } 1505 } 1506 1507 free(elf_phdata); 1508 1509 if (qemu_log_enabled()) 1510 load_symbols(&elf_ex, bprm->fd); 1511 1512 if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd); 1513 info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX); 1514 1515 #ifdef LOW_ELF_STACK 1516 info->start_stack = bprm->p = elf_stack - 4; 1517 #endif 1518 bprm->p = create_elf_tables(bprm->p, 1519 bprm->argc, 1520 bprm->envc, 1521 &elf_ex, 1522 load_addr, load_bias, 1523 interp_load_addr, 1524 (interpreter_type == INTERPRETER_AOUT ? 0 : 1), 1525 info); 1526 info->load_addr = reloc_func_desc; 1527 info->start_brk = info->brk = elf_brk; 1528 info->end_code = end_code; 1529 info->start_code = start_code; 1530 info->start_data = start_data; 1531 info->end_data = end_data; 1532 info->start_stack = bprm->p; 1533 1534 /* Calling set_brk effectively mmaps the pages that we need for the bss and break 1535 sections */ 1536 set_brk(elf_bss, elf_brk); 1537 1538 padzero(elf_bss, elf_brk); 1539 1540 #if 0 1541 printf("(start_brk) %x\n" , info->start_brk); 1542 printf("(end_code) %x\n" , info->end_code); 1543 printf("(start_code) %x\n" , info->start_code); 1544 printf("(end_data) %x\n" , info->end_data); 1545 printf("(start_stack) %x\n" , info->start_stack); 1546 printf("(brk) %x\n" , info->brk); 1547 #endif 1548 1549 if ( info->personality == PER_SVR4 ) 1550 { 1551 /* Why this, you ask??? Well SVr4 maps page 0 as read-only, 1552 and some applications "depend" upon this behavior. 1553 Since we do not have the power to recompile these, we 1554 emulate the SVr4 behavior. Sigh. */ 1555 mapped_addr = target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC, 1556 MAP_FIXED | MAP_PRIVATE, -1, 0); 1557 } 1558 1559 info->entry = elf_entry; 1560 1561 return 0; 1562 } 1563 1564 static int load_aout_interp(void * exptr, int interp_fd) 1565 { 1566 printf("a.out interpreter not yet supported\n"); 1567 return(0); 1568 } 1569 1570 void do_init_thread(struct target_pt_regs *regs, struct image_info *infop) 1571 { 1572 init_thread(regs, infop); 1573 } 1574