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