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