linux-user/elfload.c

   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
 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             memcpy_to_target(sp, k_platform, len);
 764         }
 765         /*
 766          * Force 16 byte _final_ alignment here for generality.
 767          */
 768         sp = sp &~ (abi_ulong)15;
 769         size = (DLINFO_ITEMS + 1) * 2;
 770         if (k_platform)
 771           size += 2;
 772 #ifdef DLINFO_ARCH_ITEMS
 773         size += DLINFO_ARCH_ITEMS * 2;
 774 #endif
 775         size += envc + argc + 2;
 776         size += (!ibcs ? 3 : 1);        /* argc itself */
 777         size *= n;
 778         if (size & 15)
 779             sp -= 16 - (size & 15);
 780
 781         /* This is correct because Linux defines
 782          * elf_addr_t as Elf32_Off / Elf64_Off
 783          */
 784 #if ELF_CLASS == ELFCLASS32
 785 #define NEW_AUX_ENT(id, val) do { \
 786             sp -= n; tput32(sp, val); \
 787             sp -= n; tput32(sp, id); \
 788           } while(0)
 789 #else
 790 #define NEW_AUX_ENT(id, val) do { \
 791             sp -= n; tput64(sp, val); \
 792             sp -= n; tput64(sp, id); \
 793           } while(0)
 794 #endif
 795         NEW_AUX_ENT (AT_NULL, 0);
 796
 797         /* There must be exactly DLINFO_ITEMS entries here.  */
 798         NEW_AUX_ENT(AT_PHDR, (abi_ulong)(load_addr + exec->e_phoff));
 799         NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr)));
 800         NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));
 801         NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(TARGET_PAGE_SIZE));
 802         NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_load_addr));
 803         NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);
 804         NEW_AUX_ENT(AT_ENTRY, load_bias + exec->e_entry);
 805         NEW_AUX_ENT(AT_UID, (abi_ulong) getuid());
 806         NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid());
 807         NEW_AUX_ENT(AT_GID, (abi_ulong) getgid());
 808         NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid());
 809         NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP);
 810         if (k_platform)
 811             NEW_AUX_ENT(AT_PLATFORM, u_platform);
 812 #ifdef ARCH_DLINFO
 813         /*
 814          * ARCH_DLINFO must come last so platform specific code can enforce
 815          * special alignment requirements on the AUXV if necessary (eg. PPC).
 816          */
 817         ARCH_DLINFO;
 818 #endif
 819 #undef NEW_AUX_ENT
 820
 821         sp = loader_build_argptr(envc, argc, sp, p, !ibcs);
 822         return sp;
 823 }
 824
 825
 826 static abi_ulong load_elf_interp(struct elfhdr * interp_elf_ex,
 827                                  int interpreter_fd,
 828                                  abi_ulong *interp_load_addr)
 829 {
 830         struct elf_phdr *elf_phdata  =  NULL;
 831         struct elf_phdr *eppnt;
 832         abi_ulong load_addr = 0;
 833         int load_addr_set = 0;
 834         int retval;
 835         abi_ulong last_bss, elf_bss;
 836         abi_ulong error;
 837         int i;
 838
 839         elf_bss = 0;
 840         last_bss = 0;
 841         error = 0;
 842
 843 #ifdef BSWAP_NEEDED
 844         bswap_ehdr(interp_elf_ex);
 845 #endif
 846         /* First of all, some simple consistency checks */
 847         if ((interp_elf_ex->e_type != ET_EXEC &&
 848              interp_elf_ex->e_type != ET_DYN) ||
 849            !elf_check_arch(interp_elf_ex->e_machine)) {
 850                 return ~((abi_ulong)0UL);
 851         }
 852
 853
 854         /* Now read in all of the header information */
 855
 856         if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE)
 857             return ~(abi_ulong)0UL;
 858
 859         elf_phdata =  (struct elf_phdr *)
 860                 malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
 861
 862         if (!elf_phdata)
 863           return ~((abi_ulong)0UL);
 864
 865         /*
 866          * If the size of this structure has changed, then punt, since
 867          * we will be doing the wrong thing.
 868          */
 869         if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) {
 870             free(elf_phdata);
 871             return ~((abi_ulong)0UL);
 872         }
 873
 874         retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
 875         if(retval >= 0) {
 876             retval = read(interpreter_fd,
 877                            (char *) elf_phdata,
 878                            sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
 879         }
 880         if (retval < 0) {
 881                 perror("load_elf_interp");
 882                 exit(-1);
 883                 free (elf_phdata);
 884                 return retval;
 885         }
 886 #ifdef BSWAP_NEEDED
 887         eppnt = elf_phdata;
 888         for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
 889             bswap_phdr(eppnt);
 890         }
 891 #endif
 892
 893         if (interp_elf_ex->e_type == ET_DYN) {
 894             /* in order to avoid hardcoding the interpreter load
 895                address in qemu, we allocate a big enough memory zone */
 896             error = target_mmap(0, INTERP_MAP_SIZE,
 897                                 PROT_NONE, MAP_PRIVATE | MAP_ANON,
 898                                 -1, 0);
 899             if (error == -1) {
 900                 perror("mmap");
 901                 exit(-1);
 902             }
 903             load_addr = error;
 904             load_addr_set = 1;
 905         }
 906
 907         eppnt = elf_phdata;
 908         for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++)
 909           if (eppnt->p_type == PT_LOAD) {
 910             int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
 911             int elf_prot = 0;
 912             abi_ulong vaddr = 0;
 913             abi_ulong k;
 914
 915             if (eppnt->p_flags & PF_R) elf_prot =  PROT_READ;
 916             if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
 917             if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
 918             if (interp_elf_ex->e_type == ET_EXEC || load_addr_set) {
 919                 elf_type |= MAP_FIXED;
 920                 vaddr = eppnt->p_vaddr;
 921             }
 922             error = target_mmap(load_addr+TARGET_ELF_PAGESTART(vaddr),
 923                  eppnt->p_filesz + TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr),
 924                  elf_prot,
 925                  elf_type,
 926                  interpreter_fd,
 927                  eppnt->p_offset - TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr));
 928
 929             if (error == -1) {
 930               /* Real error */
 931               close(interpreter_fd);
 932               free(elf_phdata);
 933               return ~((abi_ulong)0UL);
 934             }
 935
 936             if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
 937               load_addr = error;
 938               load_addr_set = 1;
 939             }
 940
 941             /*
 942              * Find the end of the file  mapping for this phdr, and keep
 943              * track of the largest address we see for this.
 944              */
 945             k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
 946             if (k > elf_bss) elf_bss = k;
 947
 948             /*
 949              * Do the same thing for the memory mapping - between
 950              * elf_bss and last_bss is the bss section.
 951              */
 952             k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
 953             if (k > last_bss) last_bss = k;
 954           }
 955
 956         /* Now use mmap to map the library into memory. */
 957
 958         close(interpreter_fd);
 959
 960         /*
 961          * Now fill out the bss section.  First pad the last page up
 962          * to the page boundary, and then perform a mmap to make sure
 963          * that there are zeromapped pages up to and including the last
 964          * bss page.
 965          */
 966         padzero(elf_bss, last_bss);
 967         elf_bss = TARGET_ELF_PAGESTART(elf_bss + qemu_host_page_size - 1); /* What we have mapped so far */
 968
 969         /* Map the last of the bss segment */
 970         if (last_bss > elf_bss) {
 971             target_mmap(elf_bss, last_bss-elf_bss,
 972                         PROT_READ|PROT_WRITE|PROT_EXEC,
 973                         MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 974         }
 975         free(elf_phdata);
 976
 977         *interp_load_addr = load_addr;
 978         return ((abi_ulong) interp_elf_ex->e_entry) + load_addr;
 979 }
 980
 981 /* Best attempt to load symbols from this ELF object. */
 982 static void load_symbols(struct elfhdr *hdr, int fd)
 983 {
 984     unsigned int i;
 985     struct elf_shdr sechdr, symtab, strtab;
 986     char *strings;
 987     struct syminfo *s;
 988 #if (ELF_CLASS == ELFCLASS64)
 989     // Disas uses 32 bit symbols
 990     struct elf32_sym *syms32 = NULL;
 991     struct elf_sym *sym;
 992 #endif
 993
 994     lseek(fd, hdr->e_shoff, SEEK_SET);
 995     for (i = 0; i < hdr->e_shnum; i++) {
 996         if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr))
 997             return;
 998 #ifdef BSWAP_NEEDED
 999         bswap_shdr(&sechdr);
1000 #endif
1001         if (sechdr.sh_type == SHT_SYMTAB) {
1002             symtab = sechdr;
1003             lseek(fd, hdr->e_shoff
1004                   + sizeof(sechdr) * sechdr.sh_link, SEEK_SET);
1005             if (read(fd, &strtab, sizeof(strtab))
1006                 != sizeof(strtab))
1007                 return;
1008 #ifdef BSWAP_NEEDED
1009             bswap_shdr(&strtab);
1010 #endif
1011             goto found;
1012         }
1013     }
1014     return; /* Shouldn't happen... */
1015
1016  found:
1017     /* Now know where the strtab and symtab are.  Snarf them. */
1018     s = malloc(sizeof(*s));
1019     s->disas_symtab = malloc(symtab.sh_size);
1020 #if (ELF_CLASS == ELFCLASS64)
1021     syms32 = malloc(symtab.sh_size / sizeof(struct elf_sym)
1022                     * sizeof(struct elf32_sym));
1023 #endif
1024     s->disas_strtab = strings = malloc(strtab.sh_size);
1025     if (!s->disas_symtab || !s->disas_strtab)
1026         return;
1027
1028     lseek(fd, symtab.sh_offset, SEEK_SET);
1029     if (read(fd, s->disas_symtab, symtab.sh_size) != symtab.sh_size)
1030         return;
1031
1032     for (i = 0; i < symtab.sh_size / sizeof(struct elf_sym); i++) {
1033 #ifdef BSWAP_NEEDED
1034         bswap_sym(s->disas_symtab + sizeof(struct elf_sym)*i);
1035 #endif
1036 #if (ELF_CLASS == ELFCLASS64)
1037         sym = s->disas_symtab + sizeof(struct elf_sym)*i;
1038         syms32[i].st_name = sym->st_name;
1039         syms32[i].st_info = sym->st_info;
1040         syms32[i].st_other = sym->st_other;
1041         syms32[i].st_shndx = sym->st_shndx;
1042         syms32[i].st_value = sym->st_value & 0xffffffff;
1043         syms32[i].st_size = sym->st_size & 0xffffffff;
1044 #endif
1045     }
1046
1047 #if (ELF_CLASS == ELFCLASS64)
1048     free(s->disas_symtab);
1049     s->disas_symtab = syms32;
1050 #endif
1051     lseek(fd, strtab.sh_offset, SEEK_SET);
1052     if (read(fd, strings, strtab.sh_size) != strtab.sh_size)
1053         return;
1054     s->disas_num_syms = symtab.sh_size / sizeof(struct elf_sym);
1055     s->next = syminfos;
1056     syminfos = s;
1057 }
1058
1059 int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
1060                     struct image_info * info)
1061 {
1062     struct elfhdr elf_ex;
1063     struct elfhdr interp_elf_ex;
1064     struct exec interp_ex;
1065     int interpreter_fd = -1; /* avoid warning */
1066     abi_ulong load_addr, load_bias;
1067     int load_addr_set = 0;
1068     unsigned int interpreter_type = INTERPRETER_NONE;
1069     unsigned char ibcs2_interpreter;
1070     int i;
1071     abi_ulong mapped_addr;
1072     struct elf_phdr * elf_ppnt;
1073     struct elf_phdr *elf_phdata;
1074     abi_ulong elf_bss, k, elf_brk;
1075     int retval;
1076     char * elf_interpreter;
1077     abi_ulong elf_entry, interp_load_addr = 0;
1078     int status;
1079     abi_ulong start_code, end_code, start_data, end_data;
1080     abi_ulong reloc_func_desc = 0;
1081     abi_ulong elf_stack;
1082     char passed_fileno[6];
1083
1084     ibcs2_interpreter = 0;
1085     status = 0;
1086     load_addr = 0;
1087     load_bias = 0;
1088     elf_ex = *((struct elfhdr *) bprm->buf);          /* exec-header */
1089 #ifdef BSWAP_NEEDED
1090     bswap_ehdr(&elf_ex);
1091 #endif
1092
1093     /* First of all, some simple consistency checks */
1094     if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
1095                                 (! elf_check_arch(elf_ex.e_machine))) {
1096             return -ENOEXEC;
1097     }
1098
1099     bprm->p = copy_elf_strings(1, &bprm->filename, bprm->page, bprm->p);
1100     bprm->p = copy_elf_strings(bprm->envc,bprm->envp,bprm->page,bprm->p);
1101     bprm->p = copy_elf_strings(bprm->argc,bprm->argv,bprm->page,bprm->p);
1102     if (!bprm->p) {
1103         retval = -E2BIG;
1104     }
1105
1106     /* Now read in all of the header information */
1107     elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);
1108     if (elf_phdata == NULL) {
1109         return -ENOMEM;
1110     }
1111
1112     retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);
1113     if(retval > 0) {
1114         retval = read(bprm->fd, (char *) elf_phdata,
1115                                 elf_ex.e_phentsize * elf_ex.e_phnum);
1116     }
1117
1118     if (retval < 0) {
1119         perror("load_elf_binary");
1120         exit(-1);
1121         free (elf_phdata);
1122         return -errno;
1123     }
1124
1125 #ifdef BSWAP_NEEDED
1126     elf_ppnt = elf_phdata;
1127     for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {
1128         bswap_phdr(elf_ppnt);
1129     }
1130 #endif
1131     elf_ppnt = elf_phdata;
1132
1133     elf_bss = 0;
1134     elf_brk = 0;
1135
1136
1137     elf_stack = ~((abi_ulong)0UL);
1138     elf_interpreter = NULL;
1139     start_code = ~((abi_ulong)0UL);
1140     end_code = 0;
1141     start_data = 0;
1142     end_data = 0;
1143
1144     for(i=0;i < elf_ex.e_phnum; i++) {
1145         if (elf_ppnt->p_type == PT_INTERP) {
1146             if ( elf_interpreter != NULL )
1147             {
1148                 free (elf_phdata);
1149                 free(elf_interpreter);
1150                 close(bprm->fd);
1151                 return -EINVAL;
1152             }
1153
1154             /* This is the program interpreter used for
1155              * shared libraries - for now assume that this
1156              * is an a.out format binary
1157              */
1158
1159             elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
1160
1161             if (elf_interpreter == NULL) {
1162                 free (elf_phdata);
1163                 close(bprm->fd);
1164                 return -ENOMEM;
1165             }
1166
1167             retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);
1168             if(retval >= 0) {
1169                 retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);
1170             }
1171             if(retval < 0) {
1172                 perror("load_elf_binary2");
1173                 exit(-1);
1174             }
1175
1176             /* If the program interpreter is one of these two,
1177                then assume an iBCS2 image. Otherwise assume
1178                a native linux image. */
1179
1180             /* JRP - Need to add X86 lib dir stuff here... */
1181
1182             if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
1183                 strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) {
1184               ibcs2_interpreter = 1;
1185             }
1186
1187 #if 0
1188             printf("Using ELF interpreter %s\n", elf_interpreter);
1189 #endif
1190             if (retval >= 0) {
1191                 retval = open(path(elf_interpreter), O_RDONLY);
1192                 if(retval >= 0) {
1193                     interpreter_fd = retval;
1194                 }
1195                 else {
1196                     perror(elf_interpreter);
1197                     exit(-1);
1198                     /* retval = -errno; */
1199                 }
1200             }
1201
1202             if (retval >= 0) {
1203                 retval = lseek(interpreter_fd, 0, SEEK_SET);
1204                 if(retval >= 0) {
1205                     retval = read(interpreter_fd,bprm->buf,128);
1206                 }
1207             }
1208             if (retval >= 0) {
1209                 interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */
1210                 interp_elf_ex=*((struct elfhdr *) bprm->buf); /* elf exec-header */
1211             }
1212             if (retval < 0) {
1213                 perror("load_elf_binary3");
1214                 exit(-1);
1215                 free (elf_phdata);
1216                 free(elf_interpreter);
1217                 close(bprm->fd);
1218                 return retval;
1219             }
1220         }
1221         elf_ppnt++;
1222     }
1223
1224     /* Some simple consistency checks for the interpreter */
1225     if (elf_interpreter){
1226         interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
1227
1228         /* Now figure out which format our binary is */
1229         if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&
1230                 (N_MAGIC(interp_ex) != QMAGIC)) {
1231           interpreter_type = INTERPRETER_ELF;
1232         }
1233
1234         if (interp_elf_ex.e_ident[0] != 0x7f ||
1235                 strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) {
1236             interpreter_type &= ~INTERPRETER_ELF;
1237         }
1238
1239         if (!interpreter_type) {
1240             free(elf_interpreter);
1241             free(elf_phdata);
1242             close(bprm->fd);
1243             return -ELIBBAD;
1244         }
1245     }
1246
1247     /* OK, we are done with that, now set up the arg stuff,
1248        and then start this sucker up */
1249
1250     {
1251         char * passed_p;
1252
1253         if (interpreter_type == INTERPRETER_AOUT) {
1254             snprintf(passed_fileno, sizeof(passed_fileno), "%d", bprm->fd);
1255             passed_p = passed_fileno;
1256
1257             if (elf_interpreter) {
1258                 bprm->p = copy_elf_strings(1,&passed_p,bprm->page,bprm->p);
1259                 bprm->argc++;
1260             }
1261         }
1262         if (!bprm->p) {
1263             if (elf_interpreter) {
1264                 free(elf_interpreter);
1265             }
1266             free (elf_phdata);
1267             close(bprm->fd);
1268             return -E2BIG;
1269         }
1270     }
1271
1272     /* OK, This is the point of no return */
1273     info->end_data = 0;
1274     info->end_code = 0;
1275     info->start_mmap = (abi_ulong)ELF_START_MMAP;
1276     info->mmap = 0;
1277     elf_entry = (abi_ulong) elf_ex.e_entry;
1278
1279     /* Do this so that we can load the interpreter, if need be.  We will
1280        change some of these later */
1281     info->rss = 0;
1282     bprm->p = setup_arg_pages(bprm->p, bprm, info);
1283     info->start_stack = bprm->p;
1284
1285     /* Now we do a little grungy work by mmaping the ELF image into
1286      * the correct location in memory.  At this point, we assume that
1287      * the image should be loaded at fixed address, not at a variable
1288      * address.
1289      */
1290
1291     for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
1292         int elf_prot = 0;
1293         int elf_flags = 0;
1294         abi_ulong error;
1295
1296         if (elf_ppnt->p_type != PT_LOAD)
1297             continue;
1298
1299         if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
1300         if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
1301         if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
1302         elf_flags = MAP_PRIVATE | MAP_DENYWRITE;
1303         if (elf_ex.e_type == ET_EXEC || load_addr_set) {
1304             elf_flags |= MAP_FIXED;
1305         } else if (elf_ex.e_type == ET_DYN) {
1306             /* Try and get dynamic programs out of the way of the default mmap
1307                base, as well as whatever program they might try to exec.  This
1308                is because the brk will follow the loader, and is not movable.  */
1309             /* NOTE: for qemu, we do a big mmap to get enough space
1310                without hardcoding any address */
1311             error = target_mmap(0, ET_DYN_MAP_SIZE,
1312                                 PROT_NONE, MAP_PRIVATE | MAP_ANON,
1313                                 -1, 0);
1314             if (error == -1) {
1315                 perror("mmap");
1316                 exit(-1);
1317             }
1318             load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr);
1319         }
1320
1321         error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),
1322                             (elf_ppnt->p_filesz +
1323                              TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
1324                             elf_prot,
1325                             (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),
1326                             bprm->fd,
1327                             (elf_ppnt->p_offset -
1328                              TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
1329         if (error == -1) {
1330             perror("mmap");
1331             exit(-1);
1332         }
1333
1334 #ifdef LOW_ELF_STACK
1335         if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)
1336             elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr);
1337 #endif
1338
1339         if (!load_addr_set) {
1340             load_addr_set = 1;
1341             load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;
1342             if (elf_ex.e_type == ET_DYN) {
1343                 load_bias += error -
1344                     TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr);
1345                 load_addr += load_bias;
1346                 reloc_func_desc = load_bias;
1347             }
1348         }
1349         k = elf_ppnt->p_vaddr;
1350         if (k < start_code)
1351             start_code = k;
1352         if (start_data < k)
1353             start_data = k;
1354         k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1355         if (k > elf_bss)
1356             elf_bss = k;
1357         if ((elf_ppnt->p_flags & PF_X) && end_code <  k)
1358             end_code = k;
1359         if (end_data < k)
1360             end_data = k;
1361         k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1362         if (k > elf_brk) elf_brk = k;
1363     }
1364
1365     elf_entry += load_bias;
1366     elf_bss += load_bias;
1367     elf_brk += load_bias;
1368     start_code += load_bias;
1369     end_code += load_bias;
1370     start_data += load_bias;
1371     end_data += load_bias;
1372
1373     if (elf_interpreter) {
1374         if (interpreter_type & 1) {
1375             elf_entry = load_aout_interp(&interp_ex, interpreter_fd);
1376         }
1377         else if (interpreter_type & 2) {
1378             elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,
1379                                             &interp_load_addr);
1380         }
1381         reloc_func_desc = interp_load_addr;
1382
1383         close(interpreter_fd);
1384         free(elf_interpreter);
1385
1386         if (elf_entry == ~((abi_ulong)0UL)) {
1387             printf("Unable to load interpreter\n");
1388             free(elf_phdata);
1389             exit(-1);
1390             return 0;
1391         }
1392     }
1393
1394     free(elf_phdata);
1395
1396     if (loglevel)
1397         load_symbols(&elf_ex, bprm->fd);
1398
1399     if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);
1400     info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX);
1401
1402 #ifdef LOW_ELF_STACK
1403     info->start_stack = bprm->p = elf_stack - 4;
1404 #endif
1405     bprm->p = create_elf_tables(bprm->p,
1406                     bprm->argc,
1407                     bprm->envc,
1408                     &elf_ex,
1409                     load_addr, load_bias,
1410                     interp_load_addr,
1411                     (interpreter_type == INTERPRETER_AOUT ? 0 : 1),
1412                     info);
1413     info->load_addr = reloc_func_desc;
1414     info->start_brk = info->brk = elf_brk;
1415     info->end_code = end_code;
1416     info->start_code = start_code;
1417     info->start_data = start_data;
1418     info->end_data = end_data;
1419     info->start_stack = bprm->p;
1420
1421     /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1422        sections */
1423     set_brk(elf_bss, elf_brk);
1424
1425     padzero(elf_bss, elf_brk);
1426
1427 #if 0
1428     printf("(start_brk) %x\n" , info->start_brk);
1429     printf("(end_code) %x\n" , info->end_code);
1430     printf("(start_code) %x\n" , info->start_code);
1431     printf("(end_data) %x\n" , info->end_data);
1432     printf("(start_stack) %x\n" , info->start_stack);
1433     printf("(brk) %x\n" , info->brk);
1434 #endif
1435
1436     if ( info->personality == PER_SVR4 )
1437     {
1438             /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
1439                and some applications "depend" upon this behavior.
1440                Since we do not have the power to recompile these, we
1441                emulate the SVr4 behavior.  Sigh.  */
1442             mapped_addr = target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
1443                                       MAP_FIXED | MAP_PRIVATE, -1, 0);
1444     }
1445
1446     info->entry = elf_entry;
1447
1448     return 0;
1449 }
1450
1451 static int load_aout_interp(void * exptr, int interp_fd)
1452 {
1453     printf("a.out interpreter not yet supported\n");
1454     return(0);
1455 }
1456
1457 void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
1458 {
1459     init_thread(regs, infop);
1460 }