linux-user/elfload.c

   1 /* This is the Linux kernel elf-loading code, ported into user space */
   2 #include "qemu/osdep.h"
   3 #include <sys/param.h>
   4
   5 #include <sys/resource.h>
   6
   7 #include "qemu.h"
   8 #include "disas/disas.h"
   9 #include "qemu/path.h"
  10
  11 #ifdef _ARCH_PPC64
  12 #undef ARCH_DLINFO
  13 #undef ELF_PLATFORM
  14 #undef ELF_HWCAP
  15 #undef ELF_HWCAP2
  16 #undef ELF_CLASS
  17 #undef ELF_DATA
  18 #undef ELF_ARCH
  19 #endif
  20
  21 #define ELF_OSABI   ELFOSABI_SYSV
  22
  23 /* from personality.h */
  24
  25 /*
  26  * Flags for bug emulation.
  27  *
  28  * These occupy the top three bytes.
  29  */
  30 enum {
  31     ADDR_NO_RANDOMIZE = 0x0040000,      /* disable randomization of VA space */
  32     FDPIC_FUNCPTRS =    0x0080000,      /* userspace function ptrs point to
  33                                            descriptors (signal handling) */
  34     MMAP_PAGE_ZERO =    0x0100000,
  35     ADDR_COMPAT_LAYOUT = 0x0200000,
  36     READ_IMPLIES_EXEC = 0x0400000,
  37     ADDR_LIMIT_32BIT =  0x0800000,
  38     SHORT_INODE =       0x1000000,
  39     WHOLE_SECONDS =     0x2000000,
  40     STICKY_TIMEOUTS =   0x4000000,
  41     ADDR_LIMIT_3GB =    0x8000000,
  42 };
  43
  44 /*
  45  * Personality types.
  46  *
  47  * These go in the low byte.  Avoid using the top bit, it will
  48  * conflict with error returns.
  49  */
  50 enum {
  51     PER_LINUX =         0x0000,
  52     PER_LINUX_32BIT =   0x0000 | ADDR_LIMIT_32BIT,
  53     PER_LINUX_FDPIC =   0x0000 | FDPIC_FUNCPTRS,
  54     PER_SVR4 =          0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
  55     PER_SVR3 =          0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
  56     PER_SCOSVR3 =       0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS | SHORT_INODE,
  57     PER_OSR5 =          0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
  58     PER_WYSEV386 =      0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
  59     PER_ISCR4 =         0x0005 | STICKY_TIMEOUTS,
  60     PER_BSD =           0x0006,
  61     PER_SUNOS =         0x0006 | STICKY_TIMEOUTS,
  62     PER_XENIX =         0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
  63     PER_LINUX32 =       0x0008,
  64     PER_LINUX32_3GB =   0x0008 | ADDR_LIMIT_3GB,
  65     PER_IRIX32 =        0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */
  66     PER_IRIXN32 =       0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */
  67     PER_IRIX64 =        0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */
  68     PER_RISCOS =        0x000c,
  69     PER_SOLARIS =       0x000d | STICKY_TIMEOUTS,
  70     PER_UW7 =           0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
  71     PER_OSF4 =          0x000f,                  /* OSF/1 v4 */
  72     PER_HPUX =          0x0010,
  73     PER_MASK =          0x00ff,
  74 };
  75
  76 /*
  77  * Return the base personality without flags.
  78  */
  79 #define personality(pers)       (pers & PER_MASK)
  80
  81 /* this flag is uneffective under linux too, should be deleted */
  82 #ifndef MAP_DENYWRITE
  83 #define MAP_DENYWRITE 0
  84 #endif
  85
  86 /* should probably go in elf.h */
  87 #ifndef ELIBBAD
  88 #define ELIBBAD 80
  89 #endif
  90
  91 #ifdef TARGET_WORDS_BIGENDIAN
  92 #define ELF_DATA        ELFDATA2MSB
  93 #else
  94 #define ELF_DATA        ELFDATA2LSB
  95 #endif
  96
  97 #ifdef TARGET_ABI_MIPSN32
  98 typedef abi_ullong      target_elf_greg_t;
  99 #define tswapreg(ptr)   tswap64(ptr)
 100 #else
 101 typedef abi_ulong       target_elf_greg_t;
 102 #define tswapreg(ptr)   tswapal(ptr)
 103 #endif
 104
 105 #ifdef USE_UID16
 106 typedef abi_ushort      target_uid_t;
 107 typedef abi_ushort      target_gid_t;
 108 #else
 109 typedef abi_uint        target_uid_t;
 110 typedef abi_uint        target_gid_t;
 111 #endif
 112 typedef abi_int         target_pid_t;
 113
 114 #ifdef TARGET_I386
 115
 116 #define ELF_PLATFORM get_elf_platform()
 117
 118 static const char *get_elf_platform(void)
 119 {
 120     static char elf_platform[] = "i386";
 121     int family = object_property_get_int(OBJECT(thread_cpu), "family", NULL);
 122     if (family > 6)
 123         family = 6;
 124     if (family >= 3)
 125         elf_platform[1] = '0' + family;
 126     return elf_platform;
 127 }
 128
 129 #define ELF_HWCAP get_elf_hwcap()
 130
 131 static uint32_t get_elf_hwcap(void)
 132 {
 133     X86CPU *cpu = X86_CPU(thread_cpu);
 134
 135     return cpu->env.features[FEAT_1_EDX];
 136 }
 137
 138 #ifdef TARGET_X86_64
 139 #define ELF_START_MMAP 0x2aaaaab000ULL
 140
 141 #define ELF_CLASS      ELFCLASS64
 142 #define ELF_ARCH       EM_X86_64
 143
 144 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
 145 {
 146     regs->rax = 0;
 147     regs->rsp = infop->start_stack;
 148     regs->rip = infop->entry;
 149 }
 150
 151 #define ELF_NREG    27
 152 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
 153
 154 /*
 155  * Note that ELF_NREG should be 29 as there should be place for
 156  * TRAPNO and ERR "registers" as well but linux doesn't dump
 157  * those.
 158  *
 159  * See linux kernel: arch/x86/include/asm/elf.h
 160  */
 161 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
 162 {
 163     (*regs)[0] = env->regs[15];
 164     (*regs)[1] = env->regs[14];
 165     (*regs)[2] = env->regs[13];
 166     (*regs)[3] = env->regs[12];
 167     (*regs)[4] = env->regs[R_EBP];
 168     (*regs)[5] = env->regs[R_EBX];
 169     (*regs)[6] = env->regs[11];
 170     (*regs)[7] = env->regs[10];
 171     (*regs)[8] = env->regs[9];
 172     (*regs)[9] = env->regs[8];
 173     (*regs)[10] = env->regs[R_EAX];
 174     (*regs)[11] = env->regs[R_ECX];
 175     (*regs)[12] = env->regs[R_EDX];
 176     (*regs)[13] = env->regs[R_ESI];
 177     (*regs)[14] = env->regs[R_EDI];
 178     (*regs)[15] = env->regs[R_EAX]; /* XXX */
 179     (*regs)[16] = env->eip;
 180     (*regs)[17] = env->segs[R_CS].selector & 0xffff;
 181     (*regs)[18] = env->eflags;
 182     (*regs)[19] = env->regs[R_ESP];
 183     (*regs)[20] = env->segs[R_SS].selector & 0xffff;
 184     (*regs)[21] = env->segs[R_FS].selector & 0xffff;
 185     (*regs)[22] = env->segs[R_GS].selector & 0xffff;
 186     (*regs)[23] = env->segs[R_DS].selector & 0xffff;
 187     (*regs)[24] = env->segs[R_ES].selector & 0xffff;
 188     (*regs)[25] = env->segs[R_FS].selector & 0xffff;
 189     (*regs)[26] = env->segs[R_GS].selector & 0xffff;
 190 }
 191
 192 #else
 193
 194 #define ELF_START_MMAP 0x80000000
 195
 196 /*
 197  * This is used to ensure we don't load something for the wrong architecture.
 198  */
 199 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
 200
 201 /*
 202  * These are used to set parameters in the core dumps.
 203  */
 204 #define ELF_CLASS       ELFCLASS32
 205 #define ELF_ARCH        EM_386
 206
 207 static inline void init_thread(struct target_pt_regs *regs,
 208                                struct image_info *infop)
 209 {
 210     regs->esp = infop->start_stack;
 211     regs->eip = infop->entry;
 212
 213     /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
 214        starts %edx contains a pointer to a function which might be
 215        registered using `atexit'.  This provides a mean for the
 216        dynamic linker to call DT_FINI functions for shared libraries
 217        that have been loaded before the code runs.
 218
 219        A value of 0 tells we have no such handler.  */
 220     regs->edx = 0;
 221 }
 222
 223 #define ELF_NREG    17
 224 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
 225
 226 /*
 227  * Note that ELF_NREG should be 19 as there should be place for
 228  * TRAPNO and ERR "registers" as well but linux doesn't dump
 229  * those.
 230  *
 231  * See linux kernel: arch/x86/include/asm/elf.h
 232  */
 233 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
 234 {
 235     (*regs)[0] = env->regs[R_EBX];
 236     (*regs)[1] = env->regs[R_ECX];
 237     (*regs)[2] = env->regs[R_EDX];
 238     (*regs)[3] = env->regs[R_ESI];
 239     (*regs)[4] = env->regs[R_EDI];
 240     (*regs)[5] = env->regs[R_EBP];
 241     (*regs)[6] = env->regs[R_EAX];
 242     (*regs)[7] = env->segs[R_DS].selector & 0xffff;
 243     (*regs)[8] = env->segs[R_ES].selector & 0xffff;
 244     (*regs)[9] = env->segs[R_FS].selector & 0xffff;
 245     (*regs)[10] = env->segs[R_GS].selector & 0xffff;
 246     (*regs)[11] = env->regs[R_EAX]; /* XXX */
 247     (*regs)[12] = env->eip;
 248     (*regs)[13] = env->segs[R_CS].selector & 0xffff;
 249     (*regs)[14] = env->eflags;
 250     (*regs)[15] = env->regs[R_ESP];
 251     (*regs)[16] = env->segs[R_SS].selector & 0xffff;
 252 }
 253 #endif
 254
 255 #define USE_ELF_CORE_DUMP
 256 #define ELF_EXEC_PAGESIZE       4096
 257
 258 #endif
 259
 260 #ifdef TARGET_ARM
 261
 262 #ifndef TARGET_AARCH64
 263 /* 32 bit ARM definitions */
 264
 265 #define ELF_START_MMAP 0x80000000
 266
 267 #define ELF_ARCH        EM_ARM
 268 #define ELF_CLASS       ELFCLASS32
 269
 270 static inline void init_thread(struct target_pt_regs *regs,
 271                                struct image_info *infop)
 272 {
 273     abi_long stack = infop->start_stack;
 274     memset(regs, 0, sizeof(*regs));
 275
 276     regs->uregs[16] = ARM_CPU_MODE_USR;
 277     if (infop->entry & 1) {
 278         regs->uregs[16] |= CPSR_T;
 279     }
 280     regs->uregs[15] = infop->entry & 0xfffffffe;
 281     regs->uregs[13] = infop->start_stack;
 282     /* FIXME - what to for failure of get_user()? */
 283     get_user_ual(regs->uregs[2], stack + 8); /* envp */
 284     get_user_ual(regs->uregs[1], stack + 4); /* envp */
 285     /* XXX: it seems that r0 is zeroed after ! */
 286     regs->uregs[0] = 0;
 287     /* For uClinux PIC binaries.  */
 288     /* XXX: Linux does this only on ARM with no MMU (do we care ?) */
 289     regs->uregs[10] = infop->start_data;
 290 }
 291
 292 #define ELF_NREG    18
 293 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
 294
 295 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUARMState *env)
 296 {
 297     (*regs)[0] = tswapreg(env->regs[0]);
 298     (*regs)[1] = tswapreg(env->regs[1]);
 299     (*regs)[2] = tswapreg(env->regs[2]);
 300     (*regs)[3] = tswapreg(env->regs[3]);
 301     (*regs)[4] = tswapreg(env->regs[4]);
 302     (*regs)[5] = tswapreg(env->regs[5]);
 303     (*regs)[6] = tswapreg(env->regs[6]);
 304     (*regs)[7] = tswapreg(env->regs[7]);
 305     (*regs)[8] = tswapreg(env->regs[8]);
 306     (*regs)[9] = tswapreg(env->regs[9]);
 307     (*regs)[10] = tswapreg(env->regs[10]);
 308     (*regs)[11] = tswapreg(env->regs[11]);
 309     (*regs)[12] = tswapreg(env->regs[12]);
 310     (*regs)[13] = tswapreg(env->regs[13]);
 311     (*regs)[14] = tswapreg(env->regs[14]);
 312     (*regs)[15] = tswapreg(env->regs[15]);
 313
 314     (*regs)[16] = tswapreg(cpsr_read((CPUARMState *)env));
 315     (*regs)[17] = tswapreg(env->regs[0]); /* XXX */
 316 }
 317
 318 #define USE_ELF_CORE_DUMP
 319 #define ELF_EXEC_PAGESIZE       4096
 320
 321 enum
 322 {
 323     ARM_HWCAP_ARM_SWP       = 1 << 0,
 324     ARM_HWCAP_ARM_HALF      = 1 << 1,
 325     ARM_HWCAP_ARM_THUMB     = 1 << 2,
 326     ARM_HWCAP_ARM_26BIT     = 1 << 3,
 327     ARM_HWCAP_ARM_FAST_MULT = 1 << 4,
 328     ARM_HWCAP_ARM_FPA       = 1 << 5,
 329     ARM_HWCAP_ARM_VFP       = 1 << 6,
 330     ARM_HWCAP_ARM_EDSP      = 1 << 7,
 331     ARM_HWCAP_ARM_JAVA      = 1 << 8,
 332     ARM_HWCAP_ARM_IWMMXT    = 1 << 9,
 333     ARM_HWCAP_ARM_CRUNCH    = 1 << 10,
 334     ARM_HWCAP_ARM_THUMBEE   = 1 << 11,
 335     ARM_HWCAP_ARM_NEON      = 1 << 12,
 336     ARM_HWCAP_ARM_VFPv3     = 1 << 13,
 337     ARM_HWCAP_ARM_VFPv3D16  = 1 << 14,
 338     ARM_HWCAP_ARM_TLS       = 1 << 15,
 339     ARM_HWCAP_ARM_VFPv4     = 1 << 16,
 340     ARM_HWCAP_ARM_IDIVA     = 1 << 17,
 341     ARM_HWCAP_ARM_IDIVT     = 1 << 18,
 342     ARM_HWCAP_ARM_VFPD32    = 1 << 19,
 343     ARM_HWCAP_ARM_LPAE      = 1 << 20,
 344     ARM_HWCAP_ARM_EVTSTRM   = 1 << 21,
 345 };
 346
 347 enum {
 348     ARM_HWCAP2_ARM_AES      = 1 << 0,
 349     ARM_HWCAP2_ARM_PMULL    = 1 << 1,
 350     ARM_HWCAP2_ARM_SHA1     = 1 << 2,
 351     ARM_HWCAP2_ARM_SHA2     = 1 << 3,
 352     ARM_HWCAP2_ARM_CRC32    = 1 << 4,
 353 };
 354
 355 /* The commpage only exists for 32 bit kernels */
 356
 357 #define TARGET_HAS_VALIDATE_GUEST_SPACE
 358 /* Return 1 if the proposed guest space is suitable for the guest.
 359  * Return 0 if the proposed guest space isn't suitable, but another
 360  * address space should be tried.
 361  * Return -1 if there is no way the proposed guest space can be
 362  * valid regardless of the base.
 363  * The guest code may leave a page mapped and populate it if the
 364  * address is suitable.
 365  */
 366 static int validate_guest_space(unsigned long guest_base,
 367                                 unsigned long guest_size)
 368 {
 369     unsigned long real_start, test_page_addr;
 370
 371     /* We need to check that we can force a fault on access to the
 372      * commpage at 0xffff0fxx
 373      */
 374     test_page_addr = guest_base + (0xffff0f00 & qemu_host_page_mask);
 375
 376     /* If the commpage lies within the already allocated guest space,
 377      * then there is no way we can allocate it.
 378      */
 379     if (test_page_addr >= guest_base
 380         && test_page_addr <= (guest_base + guest_size)) {
 381         return -1;
 382     }
 383
 384     /* Note it needs to be writeable to let us initialise it */
 385     real_start = (unsigned long)
 386                  mmap((void *)test_page_addr, qemu_host_page_size,
 387                      PROT_READ | PROT_WRITE,
 388                      MAP_ANONYMOUS | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 389
 390     /* If we can't map it then try another address */
 391     if (real_start == -1ul) {
 392         return 0;
 393     }
 394
 395     if (real_start != test_page_addr) {
 396         /* OS didn't put the page where we asked - unmap and reject */
 397         munmap((void *)real_start, qemu_host_page_size);
 398         return 0;
 399     }
 400
 401     /* Leave the page mapped
 402      * Populate it (mmap should have left it all 0'd)
 403      */
 404
 405     /* Kernel helper versions */
 406     __put_user(5, (uint32_t *)g2h(0xffff0ffcul));
 407
 408     /* Now it's populated make it RO */
 409     if (mprotect((void *)test_page_addr, qemu_host_page_size, PROT_READ)) {
 410         perror("Protecting guest commpage");
 411         exit(-1);
 412     }
 413
 414     return 1; /* All good */
 415 }
 416
 417 #define ELF_HWCAP get_elf_hwcap()
 418 #define ELF_HWCAP2 get_elf_hwcap2()
 419
 420 static uint32_t get_elf_hwcap(void)
 421 {
 422     ARMCPU *cpu = ARM_CPU(thread_cpu);
 423     uint32_t hwcaps = 0;
 424
 425     hwcaps |= ARM_HWCAP_ARM_SWP;
 426     hwcaps |= ARM_HWCAP_ARM_HALF;
 427     hwcaps |= ARM_HWCAP_ARM_THUMB;
 428     hwcaps |= ARM_HWCAP_ARM_FAST_MULT;
 429
 430     /* probe for the extra features */
 431 #define GET_FEATURE(feat, hwcap) \
 432     do { if (arm_feature(&cpu->env, feat)) { hwcaps |= hwcap; } } while (0)
 433     /* EDSP is in v5TE and above, but all our v5 CPUs are v5TE */
 434     GET_FEATURE(ARM_FEATURE_V5, ARM_HWCAP_ARM_EDSP);
 435     GET_FEATURE(ARM_FEATURE_VFP, ARM_HWCAP_ARM_VFP);
 436     GET_FEATURE(ARM_FEATURE_IWMMXT, ARM_HWCAP_ARM_IWMMXT);
 437     GET_FEATURE(ARM_FEATURE_THUMB2EE, ARM_HWCAP_ARM_THUMBEE);
 438     GET_FEATURE(ARM_FEATURE_NEON, ARM_HWCAP_ARM_NEON);
 439     GET_FEATURE(ARM_FEATURE_VFP3, ARM_HWCAP_ARM_VFPv3);
 440     GET_FEATURE(ARM_FEATURE_V6K, ARM_HWCAP_ARM_TLS);
 441     GET_FEATURE(ARM_FEATURE_VFP4, ARM_HWCAP_ARM_VFPv4);
 442     GET_FEATURE(ARM_FEATURE_ARM_DIV, ARM_HWCAP_ARM_IDIVA);
 443     GET_FEATURE(ARM_FEATURE_THUMB_DIV, ARM_HWCAP_ARM_IDIVT);
 444     /* All QEMU's VFPv3 CPUs have 32 registers, see VFP_DREG in translate.c.
 445      * Note that the ARM_HWCAP_ARM_VFPv3D16 bit is always the inverse of
 446      * ARM_HWCAP_ARM_VFPD32 (and so always clear for QEMU); it is unrelated
 447      * to our VFP_FP16 feature bit.
 448      */
 449     GET_FEATURE(ARM_FEATURE_VFP3, ARM_HWCAP_ARM_VFPD32);
 450     GET_FEATURE(ARM_FEATURE_LPAE, ARM_HWCAP_ARM_LPAE);
 451
 452     return hwcaps;
 453 }
 454
 455 static uint32_t get_elf_hwcap2(void)
 456 {
 457     ARMCPU *cpu = ARM_CPU(thread_cpu);
 458     uint32_t hwcaps = 0;
 459
 460     GET_FEATURE(ARM_FEATURE_V8_AES, ARM_HWCAP2_ARM_AES);
 461     GET_FEATURE(ARM_FEATURE_V8_PMULL, ARM_HWCAP2_ARM_PMULL);
 462     GET_FEATURE(ARM_FEATURE_V8_SHA1, ARM_HWCAP2_ARM_SHA1);
 463     GET_FEATURE(ARM_FEATURE_V8_SHA256, ARM_HWCAP2_ARM_SHA2);
 464     GET_FEATURE(ARM_FEATURE_CRC, ARM_HWCAP2_ARM_CRC32);
 465     return hwcaps;
 466 }
 467
 468 #undef GET_FEATURE
 469
 470 #else
 471 /* 64 bit ARM definitions */
 472 #define ELF_START_MMAP 0x80000000
 473
 474 #define ELF_ARCH        EM_AARCH64
 475 #define ELF_CLASS       ELFCLASS64
 476 #define ELF_PLATFORM    "aarch64"
 477
 478 static inline void init_thread(struct target_pt_regs *regs,
 479                                struct image_info *infop)
 480 {
 481     abi_long stack = infop->start_stack;
 482     memset(regs, 0, sizeof(*regs));
 483
 484     regs->pc = infop->entry & ~0x3ULL;
 485     regs->sp = stack;
 486 }
 487
 488 #define ELF_NREG    34
 489 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
 490
 491 static void elf_core_copy_regs(target_elf_gregset_t *regs,
 492                                const CPUARMState *env)
 493 {
 494     int i;
 495
 496     for (i = 0; i < 32; i++) {
 497         (*regs)[i] = tswapreg(env->xregs[i]);
 498     }
 499     (*regs)[32] = tswapreg(env->pc);
 500     (*regs)[33] = tswapreg(pstate_read((CPUARMState *)env));
 501 }
 502
 503 #define USE_ELF_CORE_DUMP
 504 #define ELF_EXEC_PAGESIZE       4096
 505
 506 enum {
 507     ARM_HWCAP_A64_FP            = 1 << 0,
 508     ARM_HWCAP_A64_ASIMD         = 1 << 1,
 509     ARM_HWCAP_A64_EVTSTRM       = 1 << 2,
 510     ARM_HWCAP_A64_AES           = 1 << 3,
 511     ARM_HWCAP_A64_PMULL         = 1 << 4,
 512     ARM_HWCAP_A64_SHA1          = 1 << 5,
 513     ARM_HWCAP_A64_SHA2          = 1 << 6,
 514     ARM_HWCAP_A64_CRC32         = 1 << 7,
 515 };
 516
 517 #define ELF_HWCAP get_elf_hwcap()
 518
 519 static uint32_t get_elf_hwcap(void)
 520 {
 521     ARMCPU *cpu = ARM_CPU(thread_cpu);
 522     uint32_t hwcaps = 0;
 523
 524     hwcaps |= ARM_HWCAP_A64_FP;
 525     hwcaps |= ARM_HWCAP_A64_ASIMD;
 526
 527     /* probe for the extra features */
 528 #define GET_FEATURE(feat, hwcap) \
 529     do { if (arm_feature(&cpu->env, feat)) { hwcaps |= hwcap; } } while (0)
 530     GET_FEATURE(ARM_FEATURE_V8_AES, ARM_HWCAP_A64_AES);
 531     GET_FEATURE(ARM_FEATURE_V8_PMULL, ARM_HWCAP_A64_PMULL);
 532     GET_FEATURE(ARM_FEATURE_V8_SHA1, ARM_HWCAP_A64_SHA1);
 533     GET_FEATURE(ARM_FEATURE_V8_SHA256, ARM_HWCAP_A64_SHA2);
 534     GET_FEATURE(ARM_FEATURE_CRC, ARM_HWCAP_A64_CRC32);
 535 #undef GET_FEATURE
 536
 537     return hwcaps;
 538 }
 539
 540 #endif /* not TARGET_AARCH64 */
 541 #endif /* TARGET_ARM */
 542
 543 #ifdef TARGET_UNICORE32
 544
 545 #define ELF_START_MMAP          0x80000000
 546
 547 #define ELF_CLASS               ELFCLASS32
 548 #define ELF_DATA                ELFDATA2LSB
 549 #define ELF_ARCH                EM_UNICORE32
 550
 551 static inline void init_thread(struct target_pt_regs *regs,
 552         struct image_info *infop)
 553 {
 554     abi_long stack = infop->start_stack;
 555     memset(regs, 0, sizeof(*regs));
 556     regs->UC32_REG_asr = 0x10;
 557     regs->UC32_REG_pc = infop->entry & 0xfffffffe;
 558     regs->UC32_REG_sp = infop->start_stack;
 559     /* FIXME - what to for failure of get_user()? */
 560     get_user_ual(regs->UC32_REG_02, stack + 8); /* envp */
 561     get_user_ual(regs->UC32_REG_01, stack + 4); /* envp */
 562     /* XXX: it seems that r0 is zeroed after ! */
 563     regs->UC32_REG_00 = 0;
 564 }
 565
 566 #define ELF_NREG    34
 567 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
 568
 569 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUUniCore32State *env)
 570 {
 571     (*regs)[0] = env->regs[0];
 572     (*regs)[1] = env->regs[1];
 573     (*regs)[2] = env->regs[2];
 574     (*regs)[3] = env->regs[3];
 575     (*regs)[4] = env->regs[4];
 576     (*regs)[5] = env->regs[5];
 577     (*regs)[6] = env->regs[6];
 578     (*regs)[7] = env->regs[7];
 579     (*regs)[8] = env->regs[8];
 580     (*regs)[9] = env->regs[9];
 581     (*regs)[10] = env->regs[10];
 582     (*regs)[11] = env->regs[11];
 583     (*regs)[12] = env->regs[12];
 584     (*regs)[13] = env->regs[13];
 585     (*regs)[14] = env->regs[14];
 586     (*regs)[15] = env->regs[15];
 587     (*regs)[16] = env->regs[16];
 588     (*regs)[17] = env->regs[17];
 589     (*regs)[18] = env->regs[18];
 590     (*regs)[19] = env->regs[19];
 591     (*regs)[20] = env->regs[20];
 592     (*regs)[21] = env->regs[21];
 593     (*regs)[22] = env->regs[22];
 594     (*regs)[23] = env->regs[23];
 595     (*regs)[24] = env->regs[24];
 596     (*regs)[25] = env->regs[25];
 597     (*regs)[26] = env->regs[26];
 598     (*regs)[27] = env->regs[27];
 599     (*regs)[28] = env->regs[28];
 600     (*regs)[29] = env->regs[29];
 601     (*regs)[30] = env->regs[30];
 602     (*regs)[31] = env->regs[31];
 603
 604     (*regs)[32] = cpu_asr_read((CPUUniCore32State *)env);
 605     (*regs)[33] = env->regs[0]; /* XXX */
 606 }
 607
 608 #define USE_ELF_CORE_DUMP
 609 #define ELF_EXEC_PAGESIZE               4096
 610
 611 #define ELF_HWCAP                       (UC32_HWCAP_CMOV | UC32_HWCAP_UCF64)
 612
 613 #endif
 614
 615 #ifdef TARGET_SPARC
 616 #ifdef TARGET_SPARC64
 617
 618 #define ELF_START_MMAP 0x80000000
 619 #define ELF_HWCAP  (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
 620                     | HWCAP_SPARC_MULDIV | HWCAP_SPARC_V9)
 621 #ifndef TARGET_ABI32
 622 #define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS )
 623 #else
 624 #define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC )
 625 #endif
 626
 627 #define ELF_CLASS   ELFCLASS64
 628 #define ELF_ARCH    EM_SPARCV9
 629
 630 #define STACK_BIAS              2047
 631
 632 static inline void init_thread(struct target_pt_regs *regs,
 633                                struct image_info *infop)
 634 {
 635 #ifndef TARGET_ABI32
 636     regs->tstate = 0;
 637 #endif
 638     regs->pc = infop->entry;
 639     regs->npc = regs->pc + 4;
 640     regs->y = 0;
 641 #ifdef TARGET_ABI32
 642     regs->u_regs[14] = infop->start_stack - 16 * 4;
 643 #else
 644     if (personality(infop->personality) == PER_LINUX32)
 645         regs->u_regs[14] = infop->start_stack - 16 * 4;
 646     else
 647         regs->u_regs[14] = infop->start_stack - 16 * 8 - STACK_BIAS;
 648 #endif
 649 }
 650
 651 #else
 652 #define ELF_START_MMAP 0x80000000
 653 #define ELF_HWCAP  (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
 654                     | HWCAP_SPARC_MULDIV)
 655
 656 #define ELF_CLASS   ELFCLASS32
 657 #define ELF_ARCH    EM_SPARC
 658
 659 static inline void init_thread(struct target_pt_regs *regs,
 660                                struct image_info *infop)
 661 {
 662     regs->psr = 0;
 663     regs->pc = infop->entry;
 664     regs->npc = regs->pc + 4;
 665     regs->y = 0;
 666     regs->u_regs[14] = infop->start_stack - 16 * 4;
 667 }
 668
 669 #endif
 670 #endif
 671
 672 #ifdef TARGET_PPC
 673
 674 #define ELF_MACHINE    PPC_ELF_MACHINE
 675 #define ELF_START_MMAP 0x80000000
 676
 677 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
 678
 679 #define elf_check_arch(x) ( (x) == EM_PPC64 )
 680
 681 #define ELF_CLASS       ELFCLASS64
 682
 683 #else
 684
 685 #define ELF_CLASS       ELFCLASS32
 686
 687 #endif
 688
 689 #define ELF_ARCH        EM_PPC
 690
 691 /* Feature masks for the Aux Vector Hardware Capabilities (AT_HWCAP).
 692    See arch/powerpc/include/asm/cputable.h.  */
 693 enum {
 694     QEMU_PPC_FEATURE_32 = 0x80000000,
 695     QEMU_PPC_FEATURE_64 = 0x40000000,
 696     QEMU_PPC_FEATURE_601_INSTR = 0x20000000,
 697     QEMU_PPC_FEATURE_HAS_ALTIVEC = 0x10000000,
 698     QEMU_PPC_FEATURE_HAS_FPU = 0x08000000,
 699     QEMU_PPC_FEATURE_HAS_MMU = 0x04000000,
 700     QEMU_PPC_FEATURE_HAS_4xxMAC = 0x02000000,
 701     QEMU_PPC_FEATURE_UNIFIED_CACHE = 0x01000000,
 702     QEMU_PPC_FEATURE_HAS_SPE = 0x00800000,
 703     QEMU_PPC_FEATURE_HAS_EFP_SINGLE = 0x00400000,
 704     QEMU_PPC_FEATURE_HAS_EFP_DOUBLE = 0x00200000,
 705     QEMU_PPC_FEATURE_NO_TB = 0x00100000,
 706     QEMU_PPC_FEATURE_POWER4 = 0x00080000,
 707     QEMU_PPC_FEATURE_POWER5 = 0x00040000,
 708     QEMU_PPC_FEATURE_POWER5_PLUS = 0x00020000,
 709     QEMU_PPC_FEATURE_CELL = 0x00010000,
 710     QEMU_PPC_FEATURE_BOOKE = 0x00008000,
 711     QEMU_PPC_FEATURE_SMT = 0x00004000,
 712     QEMU_PPC_FEATURE_ICACHE_SNOOP = 0x00002000,
 713     QEMU_PPC_FEATURE_ARCH_2_05 = 0x00001000,
 714     QEMU_PPC_FEATURE_PA6T = 0x00000800,
 715     QEMU_PPC_FEATURE_HAS_DFP = 0x00000400,
 716     QEMU_PPC_FEATURE_POWER6_EXT = 0x00000200,
 717     QEMU_PPC_FEATURE_ARCH_2_06 = 0x00000100,
 718     QEMU_PPC_FEATURE_HAS_VSX = 0x00000080,
 719     QEMU_PPC_FEATURE_PSERIES_PERFMON_COMPAT = 0x00000040,
 720
 721     QEMU_PPC_FEATURE_TRUE_LE = 0x00000002,
 722     QEMU_PPC_FEATURE_PPC_LE = 0x00000001,
 723
 724     /* Feature definitions in AT_HWCAP2.  */
 725     QEMU_PPC_FEATURE2_ARCH_2_07 = 0x80000000, /* ISA 2.07 */
 726     QEMU_PPC_FEATURE2_HAS_HTM = 0x40000000, /* Hardware Transactional Memory */
 727     QEMU_PPC_FEATURE2_HAS_DSCR = 0x20000000, /* Data Stream Control Register */
 728     QEMU_PPC_FEATURE2_HAS_EBB = 0x10000000, /* Event Base Branching */
 729     QEMU_PPC_FEATURE2_HAS_ISEL = 0x08000000, /* Integer Select */
 730     QEMU_PPC_FEATURE2_HAS_TAR = 0x04000000, /* Target Address Register */
 731 };
 732
 733 #define ELF_HWCAP get_elf_hwcap()
 734
 735 static uint32_t get_elf_hwcap(void)
 736 {
 737     PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);
 738     uint32_t features = 0;
 739
 740     /* We don't have to be terribly complete here; the high points are
 741        Altivec/FP/SPE support.  Anything else is just a bonus.  */
 742 #define GET_FEATURE(flag, feature)                                      \
 743     do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
 744 #define GET_FEATURE2(flags, feature) \
 745     do { \
 746         if ((cpu->env.insns_flags2 & flags) == flags) { \
 747             features |= feature; \
 748         } \
 749     } while (0)
 750     GET_FEATURE(PPC_64B, QEMU_PPC_FEATURE_64);
 751     GET_FEATURE(PPC_FLOAT, QEMU_PPC_FEATURE_HAS_FPU);
 752     GET_FEATURE(PPC_ALTIVEC, QEMU_PPC_FEATURE_HAS_ALTIVEC);
 753     GET_FEATURE(PPC_SPE, QEMU_PPC_FEATURE_HAS_SPE);
 754     GET_FEATURE(PPC_SPE_SINGLE, QEMU_PPC_FEATURE_HAS_EFP_SINGLE);
 755     GET_FEATURE(PPC_SPE_DOUBLE, QEMU_PPC_FEATURE_HAS_EFP_DOUBLE);
 756     GET_FEATURE(PPC_BOOKE, QEMU_PPC_FEATURE_BOOKE);
 757     GET_FEATURE(PPC_405_MAC, QEMU_PPC_FEATURE_HAS_4xxMAC);
 758     GET_FEATURE2(PPC2_DFP, QEMU_PPC_FEATURE_HAS_DFP);
 759     GET_FEATURE2(PPC2_VSX, QEMU_PPC_FEATURE_HAS_VSX);
 760     GET_FEATURE2((PPC2_PERM_ISA206 | PPC2_DIVE_ISA206 | PPC2_ATOMIC_ISA206 |
 761                   PPC2_FP_CVT_ISA206 | PPC2_FP_TST_ISA206),
 762                   QEMU_PPC_FEATURE_ARCH_2_06);
 763 #undef GET_FEATURE
 764 #undef GET_FEATURE2
 765
 766     return features;
 767 }
 768
 769 #define ELF_HWCAP2 get_elf_hwcap2()
 770
 771 static uint32_t get_elf_hwcap2(void)
 772 {
 773     PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);
 774     uint32_t features = 0;
 775
 776 #define GET_FEATURE(flag, feature)                                      \
 777     do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
 778 #define GET_FEATURE2(flag, feature)                                      \
 779     do { if (cpu->env.insns_flags2 & flag) { features |= feature; } } while (0)
 780
 781     GET_FEATURE(PPC_ISEL, QEMU_PPC_FEATURE2_HAS_ISEL);
 782     GET_FEATURE2(PPC2_BCTAR_ISA207, QEMU_PPC_FEATURE2_HAS_TAR);
 783     GET_FEATURE2((PPC2_BCTAR_ISA207 | PPC2_LSQ_ISA207 | PPC2_ALTIVEC_207 |
 784                   PPC2_ISA207S), QEMU_PPC_FEATURE2_ARCH_2_07);
 785
 786 #undef GET_FEATURE
 787 #undef GET_FEATURE2
 788
 789     return features;
 790 }
 791
 792 /*
 793  * The requirements here are:
 794  * - keep the final alignment of sp (sp & 0xf)
 795  * - make sure the 32-bit value at the first 16 byte aligned position of
 796  *   AUXV is greater than 16 for glibc compatibility.
 797  *   AT_IGNOREPPC is used for that.
 798  * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
 799  *   even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
 800  */
 801 #define DLINFO_ARCH_ITEMS       5
 802 #define ARCH_DLINFO                                     \
 803     do {                                                \
 804         PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);              \
 805         NEW_AUX_ENT(AT_DCACHEBSIZE, cpu->env.dcache_line_size); \
 806         NEW_AUX_ENT(AT_ICACHEBSIZE, cpu->env.icache_line_size); \
 807         NEW_AUX_ENT(AT_UCACHEBSIZE, 0);                 \
 808         /*                                              \
 809          * Now handle glibc compatibility.              \
 810          */                                             \
 811         NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC);        \
 812         NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC);        \
 813     } while (0)
 814
 815 static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
 816 {
 817     _regs->gpr[1] = infop->start_stack;
 818 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
 819     if (get_ppc64_abi(infop) < 2) {
 820         uint64_t val;
 821         get_user_u64(val, infop->entry + 8);
 822         _regs->gpr[2] = val + infop->load_bias;
 823         get_user_u64(val, infop->entry);
 824         infop->entry = val + infop->load_bias;
 825     } else {
 826         _regs->gpr[12] = infop->entry;  /* r12 set to global entry address */
 827     }
 828 #endif
 829     _regs->nip = infop->entry;
 830 }
 831
 832 /* See linux kernel: arch/powerpc/include/asm/elf.h.  */
 833 #define ELF_NREG 48
 834 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
 835
 836 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUPPCState *env)
 837 {
 838     int i;
 839     target_ulong ccr = 0;
 840
 841     for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
 842         (*regs)[i] = tswapreg(env->gpr[i]);
 843     }
 844
 845     (*regs)[32] = tswapreg(env->nip);
 846     (*regs)[33] = tswapreg(env->msr);
 847     (*regs)[35] = tswapreg(env->ctr);
 848     (*regs)[36] = tswapreg(env->lr);
 849     (*regs)[37] = tswapreg(env->xer);
 850
 851     for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
 852         ccr |= env->crf[i] << (32 - ((i + 1) * 4));
 853     }
 854     (*regs)[38] = tswapreg(ccr);
 855 }
 856
 857 #define USE_ELF_CORE_DUMP
 858 #define ELF_EXEC_PAGESIZE       4096
 859
 860 #endif
 861
 862 #ifdef TARGET_MIPS
 863
 864 #define ELF_START_MMAP 0x80000000
 865
 866 #ifdef TARGET_MIPS64
 867 #define ELF_CLASS   ELFCLASS64
 868 #else
 869 #define ELF_CLASS   ELFCLASS32
 870 #endif
 871 #define ELF_ARCH    EM_MIPS
 872
 873 static inline void init_thread(struct target_pt_regs *regs,
 874                                struct image_info *infop)
 875 {
 876     regs->cp0_status = 2 << CP0St_KSU;
 877     regs->cp0_epc = infop->entry;
 878     regs->regs[29] = infop->start_stack;
 879 }
 880
 881 /* See linux kernel: arch/mips/include/asm/elf.h.  */
 882 #define ELF_NREG 45
 883 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
 884
 885 /* See linux kernel: arch/mips/include/asm/reg.h.  */
 886 enum {
 887 #ifdef TARGET_MIPS64
 888     TARGET_EF_R0 = 0,
 889 #else
 890     TARGET_EF_R0 = 6,
 891 #endif
 892     TARGET_EF_R26 = TARGET_EF_R0 + 26,
 893     TARGET_EF_R27 = TARGET_EF_R0 + 27,
 894     TARGET_EF_LO = TARGET_EF_R0 + 32,
 895     TARGET_EF_HI = TARGET_EF_R0 + 33,
 896     TARGET_EF_CP0_EPC = TARGET_EF_R0 + 34,
 897     TARGET_EF_CP0_BADVADDR = TARGET_EF_R0 + 35,
 898     TARGET_EF_CP0_STATUS = TARGET_EF_R0 + 36,
 899     TARGET_EF_CP0_CAUSE = TARGET_EF_R0 + 37
 900 };
 901
 902 /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs.  */
 903 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMIPSState *env)
 904 {
 905     int i;
 906
 907     for (i = 0; i < TARGET_EF_R0; i++) {
 908         (*regs)[i] = 0;
 909     }
 910     (*regs)[TARGET_EF_R0] = 0;
 911
 912     for (i = 1; i < ARRAY_SIZE(env->active_tc.gpr); i++) {
 913         (*regs)[TARGET_EF_R0 + i] = tswapreg(env->active_tc.gpr[i]);
 914     }
 915
 916     (*regs)[TARGET_EF_R26] = 0;
 917     (*regs)[TARGET_EF_R27] = 0;
 918     (*regs)[TARGET_EF_LO] = tswapreg(env->active_tc.LO[0]);
 919     (*regs)[TARGET_EF_HI] = tswapreg(env->active_tc.HI[0]);
 920     (*regs)[TARGET_EF_CP0_EPC] = tswapreg(env->active_tc.PC);
 921     (*regs)[TARGET_EF_CP0_BADVADDR] = tswapreg(env->CP0_BadVAddr);
 922     (*regs)[TARGET_EF_CP0_STATUS] = tswapreg(env->CP0_Status);
 923     (*regs)[TARGET_EF_CP0_CAUSE] = tswapreg(env->CP0_Cause);
 924 }
 925
 926 #define USE_ELF_CORE_DUMP
 927 #define ELF_EXEC_PAGESIZE        4096
 928
 929 #endif /* TARGET_MIPS */
 930
 931 #ifdef TARGET_MICROBLAZE
 932
 933 #define ELF_START_MMAP 0x80000000
 934
 935 #define elf_check_arch(x) ( (x) == EM_MICROBLAZE || (x) == EM_MICROBLAZE_OLD)
 936
 937 #define ELF_CLASS   ELFCLASS32
 938 #define ELF_ARCH    EM_MICROBLAZE
 939
 940 static inline void init_thread(struct target_pt_regs *regs,
 941                                struct image_info *infop)
 942 {
 943     regs->pc = infop->entry;
 944     regs->r1 = infop->start_stack;
 945
 946 }
 947
 948 #define ELF_EXEC_PAGESIZE        4096
 949
 950 #define USE_ELF_CORE_DUMP
 951 #define ELF_NREG 38
 952 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
 953
 954 /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs.  */
 955 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMBState *env)
 956 {
 957     int i, pos = 0;
 958
 959     for (i = 0; i < 32; i++) {
 960         (*regs)[pos++] = tswapreg(env->regs[i]);
 961     }
 962
 963     for (i = 0; i < 6; i++) {
 964         (*regs)[pos++] = tswapreg(env->sregs[i]);
 965     }
 966 }
 967
 968 #endif /* TARGET_MICROBLAZE */
 969
 970 #ifdef TARGET_OPENRISC
 971
 972 #define ELF_START_MMAP 0x08000000
 973
 974 #define ELF_ARCH EM_OPENRISC
 975 #define ELF_CLASS ELFCLASS32
 976 #define ELF_DATA  ELFDATA2MSB
 977
 978 static inline void init_thread(struct target_pt_regs *regs,
 979                                struct image_info *infop)
 980 {
 981     regs->pc = infop->entry;
 982     regs->gpr[1] = infop->start_stack;
 983 }
 984
 985 #define USE_ELF_CORE_DUMP
 986 #define ELF_EXEC_PAGESIZE 8192
 987
 988 /* See linux kernel arch/openrisc/include/asm/elf.h.  */
 989 #define ELF_NREG 34 /* gprs and pc, sr */
 990 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
 991
 992 static void elf_core_copy_regs(target_elf_gregset_t *regs,
 993                                const CPUOpenRISCState *env)
 994 {
 995     int i;
 996
 997     for (i = 0; i < 32; i++) {
 998         (*regs)[i] = tswapreg(env->gpr[i]);
 999     }
1000
1001     (*regs)[32] = tswapreg(env->pc);
1002     (*regs)[33] = tswapreg(env->sr);
1003 }
1004 #define ELF_HWCAP 0
1005 #define ELF_PLATFORM NULL
1006
1007 #endif /* TARGET_OPENRISC */
1008
1009 #ifdef TARGET_SH4
1010
1011 #define ELF_START_MMAP 0x80000000
1012
1013 #define ELF_CLASS ELFCLASS32
1014 #define ELF_ARCH  EM_SH
1015
1016 static inline void init_thread(struct target_pt_regs *regs,
1017                                struct image_info *infop)
1018 {
1019     /* Check other registers XXXXX */
1020     regs->pc = infop->entry;
1021     regs->regs[15] = infop->start_stack;
1022 }
1023
1024 /* See linux kernel: arch/sh/include/asm/elf.h.  */
1025 #define ELF_NREG 23
1026 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1027
1028 /* See linux kernel: arch/sh/include/asm/ptrace.h.  */
1029 enum {
1030     TARGET_REG_PC = 16,
1031     TARGET_REG_PR = 17,
1032     TARGET_REG_SR = 18,
1033     TARGET_REG_GBR = 19,
1034     TARGET_REG_MACH = 20,
1035     TARGET_REG_MACL = 21,
1036     TARGET_REG_SYSCALL = 22
1037 };
1038
1039 static inline void elf_core_copy_regs(target_elf_gregset_t *regs,
1040                                       const CPUSH4State *env)
1041 {
1042     int i;
1043
1044     for (i = 0; i < 16; i++) {
1045         (*regs[i]) = tswapreg(env->gregs[i]);
1046     }
1047
1048     (*regs)[TARGET_REG_PC] = tswapreg(env->pc);
1049     (*regs)[TARGET_REG_PR] = tswapreg(env->pr);
1050     (*regs)[TARGET_REG_SR] = tswapreg(env->sr);
1051     (*regs)[TARGET_REG_GBR] = tswapreg(env->gbr);
1052     (*regs)[TARGET_REG_MACH] = tswapreg(env->mach);
1053     (*regs)[TARGET_REG_MACL] = tswapreg(env->macl);
1054     (*regs)[TARGET_REG_SYSCALL] = 0; /* FIXME */
1055 }
1056
1057 #define USE_ELF_CORE_DUMP
1058 #define ELF_EXEC_PAGESIZE        4096
1059
1060 enum {
1061     SH_CPU_HAS_FPU            = 0x0001, /* Hardware FPU support */
1062     SH_CPU_HAS_P2_FLUSH_BUG   = 0x0002, /* Need to flush the cache in P2 area */
1063     SH_CPU_HAS_MMU_PAGE_ASSOC = 0x0004, /* SH3: TLB way selection bit support */
1064     SH_CPU_HAS_DSP            = 0x0008, /* SH-DSP: DSP support */
1065     SH_CPU_HAS_PERF_COUNTER   = 0x0010, /* Hardware performance counters */
1066     SH_CPU_HAS_PTEA           = 0x0020, /* PTEA register */
1067     SH_CPU_HAS_LLSC           = 0x0040, /* movli.l/movco.l */
1068     SH_CPU_HAS_L2_CACHE       = 0x0080, /* Secondary cache / URAM */
1069     SH_CPU_HAS_OP32           = 0x0100, /* 32-bit instruction support */
1070     SH_CPU_HAS_PTEAEX         = 0x0200, /* PTE ASID Extension support */
1071 };
1072
1073 #define ELF_HWCAP get_elf_hwcap()
1074
1075 static uint32_t get_elf_hwcap(void)
1076 {
1077     SuperHCPU *cpu = SUPERH_CPU(thread_cpu);
1078     uint32_t hwcap = 0;
1079
1080     hwcap |= SH_CPU_HAS_FPU;
1081
1082     if (cpu->env.features & SH_FEATURE_SH4A) {
1083         hwcap |= SH_CPU_HAS_LLSC;
1084     }
1085
1086     return hwcap;
1087 }
1088
1089 #endif
1090
1091 #ifdef TARGET_CRIS
1092
1093 #define ELF_START_MMAP 0x80000000
1094
1095 #define ELF_CLASS ELFCLASS32
1096 #define ELF_ARCH  EM_CRIS
1097
1098 static inline void init_thread(struct target_pt_regs *regs,
1099                                struct image_info *infop)
1100 {
1101     regs->erp = infop->entry;
1102 }
1103
1104 #define ELF_EXEC_PAGESIZE        8192
1105
1106 #endif
1107
1108 #ifdef TARGET_M68K
1109
1110 #define ELF_START_MMAP 0x80000000
1111
1112 #define ELF_CLASS       ELFCLASS32
1113 #define ELF_ARCH        EM_68K
1114
1115 /* ??? Does this need to do anything?
1116    #define ELF_PLAT_INIT(_r) */
1117
1118 static inline void init_thread(struct target_pt_regs *regs,
1119                                struct image_info *infop)
1120 {
1121     regs->usp = infop->start_stack;
1122     regs->sr = 0;
1123     regs->pc = infop->entry;
1124 }
1125
1126 /* See linux kernel: arch/m68k/include/asm/elf.h.  */
1127 #define ELF_NREG 20
1128 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1129
1130 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUM68KState *env)
1131 {
1132     (*regs)[0] = tswapreg(env->dregs[1]);
1133     (*regs)[1] = tswapreg(env->dregs[2]);
1134     (*regs)[2] = tswapreg(env->dregs[3]);
1135     (*regs)[3] = tswapreg(env->dregs[4]);
1136     (*regs)[4] = tswapreg(env->dregs[5]);
1137     (*regs)[5] = tswapreg(env->dregs[6]);
1138     (*regs)[6] = tswapreg(env->dregs[7]);
1139     (*regs)[7] = tswapreg(env->aregs[0]);
1140     (*regs)[8] = tswapreg(env->aregs[1]);
1141     (*regs)[9] = tswapreg(env->aregs[2]);
1142     (*regs)[10] = tswapreg(env->aregs[3]);
1143     (*regs)[11] = tswapreg(env->aregs[4]);
1144     (*regs)[12] = tswapreg(env->aregs[5]);
1145     (*regs)[13] = tswapreg(env->aregs[6]);
1146     (*regs)[14] = tswapreg(env->dregs[0]);
1147     (*regs)[15] = tswapreg(env->aregs[7]);
1148     (*regs)[16] = tswapreg(env->dregs[0]); /* FIXME: orig_d0 */
1149     (*regs)[17] = tswapreg(env->sr);
1150     (*regs)[18] = tswapreg(env->pc);
1151     (*regs)[19] = 0;  /* FIXME: regs->format | regs->vector */
1152 }
1153
1154 #define USE_ELF_CORE_DUMP
1155 #define ELF_EXEC_PAGESIZE       8192
1156
1157 #endif
1158
1159 #ifdef TARGET_ALPHA
1160
1161 #define ELF_START_MMAP (0x30000000000ULL)
1162
1163 #define ELF_CLASS      ELFCLASS64
1164 #define ELF_ARCH       EM_ALPHA
1165
1166 static inline void init_thread(struct target_pt_regs *regs,
1167                                struct image_info *infop)
1168 {
1169     regs->pc = infop->entry;
1170     regs->ps = 8;
1171     regs->usp = infop->start_stack;
1172 }
1173
1174 #define ELF_EXEC_PAGESIZE        8192
1175
1176 #endif /* TARGET_ALPHA */
1177
1178 #ifdef TARGET_S390X
1179
1180 #define ELF_START_MMAP (0x20000000000ULL)
1181
1182 #define ELF_CLASS       ELFCLASS64
1183 #define ELF_DATA        ELFDATA2MSB
1184 #define ELF_ARCH        EM_S390
1185
1186 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
1187 {
1188     regs->psw.addr = infop->entry;
1189     regs->psw.mask = PSW_MASK_64 | PSW_MASK_32;
1190     regs->gprs[15] = infop->start_stack;
1191 }
1192
1193 #endif /* TARGET_S390X */
1194
1195 #ifdef TARGET_TILEGX
1196
1197 /* 42 bits real used address, a half for user mode */
1198 #define ELF_START_MMAP (0x00000020000000000ULL)
1199
1200 #define elf_check_arch(x) ((x) == EM_TILEGX)
1201
1202 #define ELF_CLASS   ELFCLASS64
1203 #define ELF_DATA    ELFDATA2LSB
1204 #define ELF_ARCH    EM_TILEGX
1205
1206 static inline void init_thread(struct target_pt_regs *regs,
1207                                struct image_info *infop)
1208 {
1209     regs->pc = infop->entry;
1210     regs->sp = infop->start_stack;
1211
1212 }
1213
1214 #define ELF_EXEC_PAGESIZE        65536 /* TILE-Gx page size is 64KB */
1215
1216 #endif /* TARGET_TILEGX */
1217
1218 #ifndef ELF_PLATFORM
1219 #define ELF_PLATFORM (NULL)
1220 #endif
1221
1222 #ifndef ELF_MACHINE
1223 #define ELF_MACHINE ELF_ARCH
1224 #endif
1225
1226 #ifndef elf_check_arch
1227 #define elf_check_arch(x) ((x) == ELF_ARCH)
1228 #endif
1229
1230 #ifndef ELF_HWCAP
1231 #define ELF_HWCAP 0
1232 #endif
1233
1234 #ifdef TARGET_ABI32
1235 #undef ELF_CLASS
1236 #define ELF_CLASS ELFCLASS32
1237 #undef bswaptls
1238 #define bswaptls(ptr) bswap32s(ptr)
1239 #endif
1240
1241 #include "elf.h"
1242
1243 struct exec
1244 {
1245     unsigned int a_info;   /* Use macros N_MAGIC, etc for access */
1246     unsigned int a_text;   /* length of text, in bytes */
1247     unsigned int a_data;   /* length of data, in bytes */
1248     unsigned int a_bss;    /* length of uninitialized data area, in bytes */
1249     unsigned int a_syms;   /* length of symbol table data in file, in bytes */
1250     unsigned int a_entry;  /* start address */
1251     unsigned int a_trsize; /* length of relocation info for text, in bytes */
1252     unsigned int a_drsize; /* length of relocation info for data, in bytes */
1253 };
1254
1255
1256 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
1257 #define OMAGIC 0407
1258 #define NMAGIC 0410
1259 #define ZMAGIC 0413
1260 #define QMAGIC 0314
1261
1262 /* Necessary parameters */
1263 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
1264 #define TARGET_ELF_PAGESTART(_v) ((_v) & \
1265                                  ~(abi_ulong)(TARGET_ELF_EXEC_PAGESIZE-1))
1266 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
1267
1268 #define DLINFO_ITEMS 14
1269
1270 static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
1271 {
1272     memcpy(to, from, n);
1273 }
1274
1275 #ifdef BSWAP_NEEDED
1276 static void bswap_ehdr(struct elfhdr *ehdr)
1277 {
1278     bswap16s(&ehdr->e_type);            /* Object file type */
1279     bswap16s(&ehdr->e_machine);         /* Architecture */
1280     bswap32s(&ehdr->e_version);         /* Object file version */
1281     bswaptls(&ehdr->e_entry);           /* Entry point virtual address */
1282     bswaptls(&ehdr->e_phoff);           /* Program header table file offset */
1283     bswaptls(&ehdr->e_shoff);           /* Section header table file offset */
1284     bswap32s(&ehdr->e_flags);           /* Processor-specific flags */
1285     bswap16s(&ehdr->e_ehsize);          /* ELF header size in bytes */
1286     bswap16s(&ehdr->e_phentsize);       /* Program header table entry size */
1287     bswap16s(&ehdr->e_phnum);           /* Program header table entry count */
1288     bswap16s(&ehdr->e_shentsize);       /* Section header table entry size */
1289     bswap16s(&ehdr->e_shnum);           /* Section header table entry count */
1290     bswap16s(&ehdr->e_shstrndx);        /* Section header string table index */
1291 }
1292
1293 static void bswap_phdr(struct elf_phdr *phdr, int phnum)
1294 {
1295     int i;
1296     for (i = 0; i < phnum; ++i, ++phdr) {
1297         bswap32s(&phdr->p_type);        /* Segment type */
1298         bswap32s(&phdr->p_flags);       /* Segment flags */
1299         bswaptls(&phdr->p_offset);      /* Segment file offset */
1300         bswaptls(&phdr->p_vaddr);       /* Segment virtual address */
1301         bswaptls(&phdr->p_paddr);       /* Segment physical address */
1302         bswaptls(&phdr->p_filesz);      /* Segment size in file */
1303         bswaptls(&phdr->p_memsz);       /* Segment size in memory */
1304         bswaptls(&phdr->p_align);       /* Segment alignment */
1305     }
1306 }
1307
1308 static void bswap_shdr(struct elf_shdr *shdr, int shnum)
1309 {
1310     int i;
1311     for (i = 0; i < shnum; ++i, ++shdr) {
1312         bswap32s(&shdr->sh_name);
1313         bswap32s(&shdr->sh_type);
1314         bswaptls(&shdr->sh_flags);
1315         bswaptls(&shdr->sh_addr);
1316         bswaptls(&shdr->sh_offset);
1317         bswaptls(&shdr->sh_size);
1318         bswap32s(&shdr->sh_link);
1319         bswap32s(&shdr->sh_info);
1320         bswaptls(&shdr->sh_addralign);
1321         bswaptls(&shdr->sh_entsize);
1322     }
1323 }
1324
1325 static void bswap_sym(struct elf_sym *sym)
1326 {
1327     bswap32s(&sym->st_name);
1328     bswaptls(&sym->st_value);
1329     bswaptls(&sym->st_size);
1330     bswap16s(&sym->st_shndx);
1331 }
1332 #else
1333 static inline void bswap_ehdr(struct elfhdr *ehdr) { }
1334 static inline void bswap_phdr(struct elf_phdr *phdr, int phnum) { }
1335 static inline void bswap_shdr(struct elf_shdr *shdr, int shnum) { }
1336 static inline void bswap_sym(struct elf_sym *sym) { }
1337 #endif
1338
1339 #ifdef USE_ELF_CORE_DUMP
1340 static int elf_core_dump(int, const CPUArchState *);
1341 #endif /* USE_ELF_CORE_DUMP */
1342 static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias);
1343
1344 /* Verify the portions of EHDR within E_IDENT for the target.
1345    This can be performed before bswapping the entire header.  */
1346 static bool elf_check_ident(struct elfhdr *ehdr)
1347 {
1348     return (ehdr->e_ident[EI_MAG0] == ELFMAG0
1349             && ehdr->e_ident[EI_MAG1] == ELFMAG1
1350             && ehdr->e_ident[EI_MAG2] == ELFMAG2
1351             && ehdr->e_ident[EI_MAG3] == ELFMAG3
1352             && ehdr->e_ident[EI_CLASS] == ELF_CLASS
1353             && ehdr->e_ident[EI_DATA] == ELF_DATA
1354             && ehdr->e_ident[EI_VERSION] == EV_CURRENT);
1355 }
1356
1357 /* Verify the portions of EHDR outside of E_IDENT for the target.
1358    This has to wait until after bswapping the header.  */
1359 static bool elf_check_ehdr(struct elfhdr *ehdr)
1360 {
1361     return (elf_check_arch(ehdr->e_machine)
1362             && ehdr->e_ehsize == sizeof(struct elfhdr)
1363             && ehdr->e_phentsize == sizeof(struct elf_phdr)
1364             && (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN));
1365 }
1366
1367 /*
1368  * 'copy_elf_strings()' copies argument/envelope strings from user
1369  * memory to free pages in kernel mem. These are in a format ready
1370  * to be put directly into the top of new user memory.
1371  *
1372  */
1373 static abi_ulong copy_elf_strings(int argc, char **argv, char *scratch,
1374                                   abi_ulong p, abi_ulong stack_limit)
1375 {
1376     char *tmp;
1377     int len, offset;
1378     abi_ulong top = p;
1379
1380     if (!p) {
1381         return 0;       /* bullet-proofing */
1382     }
1383
1384     offset = ((p - 1) % TARGET_PAGE_SIZE) + 1;
1385
1386     while (argc-- > 0) {
1387         tmp = argv[argc];
1388         if (!tmp) {
1389             fprintf(stderr, "VFS: argc is wrong");
1390             exit(-1);
1391         }
1392         len = strlen(tmp) + 1;
1393         tmp += len;
1394
1395         if (len > (p - stack_limit)) {
1396             return 0;
1397         }
1398         while (len) {
1399             int bytes_to_copy = (len > offset) ? offset : len;
1400             tmp -= bytes_to_copy;
1401             p -= bytes_to_copy;
1402             offset -= bytes_to_copy;
1403             len -= bytes_to_copy;
1404
1405             memcpy_fromfs(scratch + offset, tmp, bytes_to_copy);
1406
1407             if (offset == 0) {
1408                 memcpy_to_target(p, scratch, top - p);
1409                 top = p;
1410                 offset = TARGET_PAGE_SIZE;
1411             }
1412         }
1413     }
1414     if (offset) {
1415         memcpy_to_target(p, scratch + offset, top - p);
1416     }
1417
1418     return p;
1419 }
1420
1421 /* Older linux kernels provide up to MAX_ARG_PAGES (default: 32) of
1422  * argument/environment space. Newer kernels (>2.6.33) allow more,
1423  * dependent on stack size, but guarantee at least 32 pages for
1424  * backwards compatibility.
1425  */
1426 #define STACK_LOWER_LIMIT (32 * TARGET_PAGE_SIZE)
1427
1428 static abi_ulong setup_arg_pages(struct linux_binprm *bprm,
1429                                  struct image_info *info)
1430 {
1431     abi_ulong size, error, guard;
1432
1433     size = guest_stack_size;
1434     if (size < STACK_LOWER_LIMIT) {
1435         size = STACK_LOWER_LIMIT;
1436     }
1437     guard = TARGET_PAGE_SIZE;
1438     if (guard < qemu_real_host_page_size) {
1439         guard = qemu_real_host_page_size;
1440     }
1441
1442     error = target_mmap(0, size + guard, PROT_READ | PROT_WRITE,
1443                         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
1444     if (error == -1) {
1445         perror("mmap stack");
1446         exit(-1);
1447     }
1448
1449     /* We reserve one extra page at the top of the stack as guard.  */
1450     target_mprotect(error, guard, PROT_NONE);
1451
1452     info->stack_limit = error + guard;
1453
1454     return info->stack_limit + size - sizeof(void *);
1455 }
1456
1457 /* Map and zero the bss.  We need to explicitly zero any fractional pages
1458    after the data section (i.e. bss).  */
1459 static void zero_bss(abi_ulong elf_bss, abi_ulong last_bss, int prot)
1460 {
1461     uintptr_t host_start, host_map_start, host_end;
1462
1463     last_bss = TARGET_PAGE_ALIGN(last_bss);
1464
1465     /* ??? There is confusion between qemu_real_host_page_size and
1466        qemu_host_page_size here and elsewhere in target_mmap, which
1467        may lead to the end of the data section mapping from the file
1468        not being mapped.  At least there was an explicit test and
1469        comment for that here, suggesting that "the file size must
1470        be known".  The comment probably pre-dates the introduction
1471        of the fstat system call in target_mmap which does in fact
1472        find out the size.  What isn't clear is if the workaround
1473        here is still actually needed.  For now, continue with it,
1474        but merge it with the "normal" mmap that would allocate the bss.  */
1475
1476     host_start = (uintptr_t) g2h(elf_bss);
1477     host_end = (uintptr_t) g2h(last_bss);
1478     host_map_start = REAL_HOST_PAGE_ALIGN(host_start);
1479
1480     if (host_map_start < host_end) {
1481         void *p = mmap((void *)host_map_start, host_end - host_map_start,
1482                        prot, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
1483         if (p == MAP_FAILED) {
1484             perror("cannot mmap brk");
1485             exit(-1);
1486         }
1487     }
1488
1489     /* Ensure that the bss page(s) are valid */
1490     if ((page_get_flags(last_bss-1) & prot) != prot) {
1491         page_set_flags(elf_bss & TARGET_PAGE_MASK, last_bss, prot | PAGE_VALID);
1492     }
1493
1494     if (host_start < host_map_start) {
1495         memset((void *)host_start, 0, host_map_start - host_start);
1496     }
1497 }
1498
1499 #ifdef CONFIG_USE_FDPIC
1500 static abi_ulong loader_build_fdpic_loadmap(struct image_info *info, abi_ulong sp)
1501 {
1502     uint16_t n;
1503     struct elf32_fdpic_loadseg *loadsegs = info->loadsegs;
1504
1505     /* elf32_fdpic_loadseg */
1506     n = info->nsegs;
1507     while (n--) {
1508         sp -= 12;
1509         put_user_u32(loadsegs[n].addr, sp+0);
1510         put_user_u32(loadsegs[n].p_vaddr, sp+4);
1511         put_user_u32(loadsegs[n].p_memsz, sp+8);
1512     }
1513
1514     /* elf32_fdpic_loadmap */
1515     sp -= 4;
1516     put_user_u16(0, sp+0); /* version */
1517     put_user_u16(info->nsegs, sp+2); /* nsegs */
1518
1519     info->personality = PER_LINUX_FDPIC;
1520     info->loadmap_addr = sp;
1521
1522     return sp;
1523 }
1524 #endif
1525
1526 static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,
1527                                    struct elfhdr *exec,
1528                                    struct image_info *info,
1529                                    struct image_info *interp_info)
1530 {
1531     abi_ulong sp;
1532     abi_ulong sp_auxv;
1533     int size;
1534     int i;
1535     abi_ulong u_rand_bytes;
1536     uint8_t k_rand_bytes[16];
1537     abi_ulong u_platform;
1538     const char *k_platform;
1539     const int n = sizeof(elf_addr_t);
1540
1541     sp = p;
1542
1543 #ifdef CONFIG_USE_FDPIC
1544     /* Needs to be before we load the env/argc/... */
1545     if (elf_is_fdpic(exec)) {
1546         /* Need 4 byte alignment for these structs */
1547         sp &= ~3;
1548         sp = loader_build_fdpic_loadmap(info, sp);
1549         info->other_info = interp_info;
1550         if (interp_info) {
1551             interp_info->other_info = info;
1552             sp = loader_build_fdpic_loadmap(interp_info, sp);
1553         }
1554     }
1555 #endif
1556
1557     u_platform = 0;
1558     k_platform = ELF_PLATFORM;
1559     if (k_platform) {
1560         size_t len = strlen(k_platform) + 1;
1561         sp -= (len + n - 1) & ~(n - 1);
1562         u_platform = sp;
1563         /* FIXME - check return value of memcpy_to_target() for failure */
1564         memcpy_to_target(sp, k_platform, len);
1565     }
1566
1567     /*
1568      * Generate 16 random bytes for userspace PRNG seeding (not
1569      * cryptically secure but it's not the aim of QEMU).
1570      */
1571     for (i = 0; i < 16; i++) {
1572         k_rand_bytes[i] = rand();
1573     }
1574     sp -= 16;
1575     u_rand_bytes = sp;
1576     /* FIXME - check return value of memcpy_to_target() for failure */
1577     memcpy_to_target(sp, k_rand_bytes, 16);
1578
1579     /*
1580      * Force 16 byte _final_ alignment here for generality.
1581      */
1582     sp = sp &~ (abi_ulong)15;
1583     size = (DLINFO_ITEMS + 1) * 2;
1584     if (k_platform)
1585         size += 2;
1586 #ifdef DLINFO_ARCH_ITEMS
1587     size += DLINFO_ARCH_ITEMS * 2;
1588 #endif
1589 #ifdef ELF_HWCAP2
1590     size += 2;
1591 #endif
1592     size += envc + argc + 2;
1593     size += 1;  /* argc itself */
1594     size *= n;
1595     if (size & 15)
1596         sp -= 16 - (size & 15);
1597
1598     /* This is correct because Linux defines
1599      * elf_addr_t as Elf32_Off / Elf64_Off
1600      */
1601 #define NEW_AUX_ENT(id, val) do {               \
1602         sp -= n; put_user_ual(val, sp);         \
1603         sp -= n; put_user_ual(id, sp);          \
1604     } while(0)
1605
1606     sp_auxv = sp;
1607     NEW_AUX_ENT (AT_NULL, 0);
1608
1609     /* There must be exactly DLINFO_ITEMS entries here.  */
1610     NEW_AUX_ENT(AT_PHDR, (abi_ulong)(info->load_addr + exec->e_phoff));
1611     NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr)));
1612     NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));
1613     NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(MAX(TARGET_PAGE_SIZE, getpagesize())));
1614     NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_info ? interp_info->load_addr : 0));
1615     NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);
1616     NEW_AUX_ENT(AT_ENTRY, info->entry);
1617     NEW_AUX_ENT(AT_UID, (abi_ulong) getuid());
1618     NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid());
1619     NEW_AUX_ENT(AT_GID, (abi_ulong) getgid());
1620     NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid());
1621     NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP);
1622     NEW_AUX_ENT(AT_CLKTCK, (abi_ulong) sysconf(_SC_CLK_TCK));
1623     NEW_AUX_ENT(AT_RANDOM, (abi_ulong) u_rand_bytes);
1624
1625 #ifdef ELF_HWCAP2
1626     NEW_AUX_ENT(AT_HWCAP2, (abi_ulong) ELF_HWCAP2);
1627 #endif
1628
1629     if (k_platform)
1630         NEW_AUX_ENT(AT_PLATFORM, u_platform);
1631 #ifdef ARCH_DLINFO
1632     /*
1633      * ARCH_DLINFO must come last so platform specific code can enforce
1634      * special alignment requirements on the AUXV if necessary (eg. PPC).
1635      */
1636     ARCH_DLINFO;
1637 #endif
1638 #undef NEW_AUX_ENT
1639
1640     info->saved_auxv = sp;
1641     info->auxv_len = sp_auxv - sp;
1642
1643     sp = loader_build_argptr(envc, argc, sp, p, 0);
1644     /* Check the right amount of stack was allocated for auxvec, envp & argv. */
1645     assert(sp_auxv - sp == size);
1646     return sp;
1647 }
1648
1649 #ifndef TARGET_HAS_VALIDATE_GUEST_SPACE
1650 /* If the guest doesn't have a validation function just agree */
1651 static int validate_guest_space(unsigned long guest_base,
1652                                 unsigned long guest_size)
1653 {
1654     return 1;
1655 }
1656 #endif
1657
1658 unsigned long init_guest_space(unsigned long host_start,
1659                                unsigned long host_size,
1660                                unsigned long guest_start,
1661                                bool fixed)
1662 {
1663     unsigned long current_start, real_start;
1664     int flags;
1665
1666     assert(host_start || host_size);
1667
1668     /* If just a starting address is given, then just verify that
1669      * address.  */
1670     if (host_start && !host_size) {
1671         if (validate_guest_space(host_start, host_size) == 1) {
1672             return host_start;
1673         } else {
1674             return (unsigned long)-1;
1675         }
1676     }
1677
1678     /* Setup the initial flags and start address.  */
1679     current_start = host_start & qemu_host_page_mask;
1680     flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE;
1681     if (fixed) {
1682         flags |= MAP_FIXED;
1683     }
1684
1685     /* Otherwise, a non-zero size region of memory needs to be mapped
1686      * and validated.  */
1687     while (1) {
1688         unsigned long real_size = host_size;
1689
1690         /* Do not use mmap_find_vma here because that is limited to the
1691          * guest address space.  We are going to make the
1692          * guest address space fit whatever we're given.
1693          */
1694         real_start = (unsigned long)
1695             mmap((void *)current_start, host_size, PROT_NONE, flags, -1, 0);
1696         if (real_start == (unsigned long)-1) {
1697             return (unsigned long)-1;
1698         }
1699
1700         /* Ensure the address is properly aligned.  */
1701         if (real_start & ~qemu_host_page_mask) {
1702             munmap((void *)real_start, host_size);
1703             real_size = host_size + qemu_host_page_size;
1704             real_start = (unsigned long)
1705                 mmap((void *)real_start, real_size, PROT_NONE, flags, -1, 0);
1706             if (real_start == (unsigned long)-1) {
1707                 return (unsigned long)-1;
1708             }
1709             real_start = HOST_PAGE_ALIGN(real_start);
1710         }
1711
1712         /* Check to see if the address is valid.  */
1713         if (!host_start || real_start == current_start) {
1714             int valid = validate_guest_space(real_start - guest_start,
1715                                              real_size);
1716             if (valid == 1) {
1717                 break;
1718             } else if (valid == -1) {
1719                 return (unsigned long)-1;
1720             }
1721             /* valid == 0, so try again. */
1722         }
1723
1724         /* That address didn't work.  Unmap and try a different one.
1725          * The address the host picked because is typically right at
1726          * the top of the host address space and leaves the guest with
1727          * no usable address space.  Resort to a linear search.  We
1728          * already compensated for mmap_min_addr, so this should not
1729          * happen often.  Probably means we got unlucky and host
1730          * address space randomization put a shared library somewhere
1731          * inconvenient.
1732          */
1733         munmap((void *)real_start, host_size);
1734         current_start += qemu_host_page_size;
1735         if (host_start == current_start) {
1736             /* Theoretically possible if host doesn't have any suitably
1737              * aligned areas.  Normally the first mmap will fail.
1738              */
1739             return (unsigned long)-1;
1740         }
1741     }
1742
1743     qemu_log_mask(CPU_LOG_PAGE, "Reserved 0x%lx bytes of guest address space\n", host_size);
1744
1745     return real_start;
1746 }
1747
1748 static void probe_guest_base(const char *image_name,
1749                              abi_ulong loaddr, abi_ulong hiaddr)
1750 {
1751     /* Probe for a suitable guest base address, if the user has not set
1752      * it explicitly, and set guest_base appropriately.
1753      * In case of error we will print a suitable message and exit.
1754      */
1755     const char *errmsg;
1756     if (!have_guest_base && !reserved_va) {
1757         unsigned long host_start, real_start, host_size;
1758
1759         /* Round addresses to page boundaries.  */
1760         loaddr &= qemu_host_page_mask;
1761         hiaddr = HOST_PAGE_ALIGN(hiaddr);
1762
1763         if (loaddr < mmap_min_addr) {
1764             host_start = HOST_PAGE_ALIGN(mmap_min_addr);
1765         } else {
1766             host_start = loaddr;
1767             if (host_start != loaddr) {
1768                 errmsg = "Address overflow loading ELF binary";
1769                 goto exit_errmsg;
1770             }
1771         }
1772         host_size = hiaddr - loaddr;
1773
1774         /* Setup the initial guest memory space with ranges gleaned from
1775          * the ELF image that is being loaded.
1776          */
1777         real_start = init_guest_space(host_start, host_size, loaddr, false);
1778         if (real_start == (unsigned long)-1) {
1779             errmsg = "Unable to find space for application";
1780             goto exit_errmsg;
1781         }
1782         guest_base = real_start - loaddr;
1783
1784         qemu_log_mask(CPU_LOG_PAGE, "Relocating guest address space from 0x"
1785                       TARGET_ABI_FMT_lx " to 0x%lx\n",
1786                       loaddr, real_start);
1787     }
1788     return;
1789
1790 exit_errmsg:
1791     fprintf(stderr, "%s: %s\n", image_name, errmsg);
1792     exit(-1);
1793 }
1794
1795
1796 /* Load an ELF image into the address space.
1797
1798    IMAGE_NAME is the filename of the image, to use in error messages.
1799    IMAGE_FD is the open file descriptor for the image.
1800
1801    BPRM_BUF is a copy of the beginning of the file; this of course
1802    contains the elf file header at offset 0.  It is assumed that this
1803    buffer is sufficiently aligned to present no problems to the host
1804    in accessing data at aligned offsets within the buffer.
1805
1806    On return: INFO values will be filled in, as necessary or available.  */
1807
1808 static void load_elf_image(const char *image_name, int image_fd,
1809                            struct image_info *info, char **pinterp_name,
1810                            char bprm_buf[BPRM_BUF_SIZE])
1811 {
1812     struct elfhdr *ehdr = (struct elfhdr *)bprm_buf;
1813     struct elf_phdr *phdr;
1814     abi_ulong load_addr, load_bias, loaddr, hiaddr, error;
1815     int i, retval;
1816     const char *errmsg;
1817
1818     /* First of all, some simple consistency checks */
1819     errmsg = "Invalid ELF image for this architecture";
1820     if (!elf_check_ident(ehdr)) {
1821         goto exit_errmsg;
1822     }
1823     bswap_ehdr(ehdr);
1824     if (!elf_check_ehdr(ehdr)) {
1825         goto exit_errmsg;
1826     }
1827
1828     i = ehdr->e_phnum * sizeof(struct elf_phdr);
1829     if (ehdr->e_phoff + i <= BPRM_BUF_SIZE) {
1830         phdr = (struct elf_phdr *)(bprm_buf + ehdr->e_phoff);
1831     } else {
1832         phdr = (struct elf_phdr *) alloca(i);
1833         retval = pread(image_fd, phdr, i, ehdr->e_phoff);
1834         if (retval != i) {
1835             goto exit_read;
1836         }
1837     }
1838     bswap_phdr(phdr, ehdr->e_phnum);
1839
1840 #ifdef CONFIG_USE_FDPIC
1841     info->nsegs = 0;
1842     info->pt_dynamic_addr = 0;
1843 #endif
1844
1845     mmap_lock();
1846
1847     /* Find the maximum size of the image and allocate an appropriate
1848        amount of memory to handle that.  */
1849     loaddr = -1, hiaddr = 0;
1850     for (i = 0; i < ehdr->e_phnum; ++i) {
1851         if (phdr[i].p_type == PT_LOAD) {
1852             abi_ulong a = phdr[i].p_vaddr - phdr[i].p_offset;
1853             if (a < loaddr) {
1854                 loaddr = a;
1855             }
1856             a = phdr[i].p_vaddr + phdr[i].p_memsz;
1857             if (a > hiaddr) {
1858                 hiaddr = a;
1859             }
1860 #ifdef CONFIG_USE_FDPIC
1861             ++info->nsegs;
1862 #endif
1863         }
1864     }
1865
1866     load_addr = loaddr;
1867     if (ehdr->e_type == ET_DYN) {
1868         /* The image indicates that it can be loaded anywhere.  Find a
1869            location that can hold the memory space required.  If the
1870            image is pre-linked, LOADDR will be non-zero.  Since we do
1871            not supply MAP_FIXED here we'll use that address if and
1872            only if it remains available.  */
1873         load_addr = target_mmap(loaddr, hiaddr - loaddr, PROT_NONE,
1874                                 MAP_PRIVATE | MAP_ANON | MAP_NORESERVE,
1875                                 -1, 0);
1876         if (load_addr == -1) {
1877             goto exit_perror;
1878         }
1879     } else if (pinterp_name != NULL) {
1880         /* This is the main executable.  Make sure that the low
1881            address does not conflict with MMAP_MIN_ADDR or the
1882            QEMU application itself.  */
1883         probe_guest_base(image_name, loaddr, hiaddr);
1884     }
1885     load_bias = load_addr - loaddr;
1886
1887 #ifdef CONFIG_USE_FDPIC
1888     {
1889         struct elf32_fdpic_loadseg *loadsegs = info->loadsegs =
1890             g_malloc(sizeof(*loadsegs) * info->nsegs);
1891
1892         for (i = 0; i < ehdr->e_phnum; ++i) {
1893             switch (phdr[i].p_type) {
1894             case PT_DYNAMIC:
1895                 info->pt_dynamic_addr = phdr[i].p_vaddr + load_bias;
1896                 break;
1897             case PT_LOAD:
1898                 loadsegs->addr = phdr[i].p_vaddr + load_bias;
1899                 loadsegs->p_vaddr = phdr[i].p_vaddr;
1900                 loadsegs->p_memsz = phdr[i].p_memsz;
1901                 ++loadsegs;
1902                 break;
1903             }
1904         }
1905     }
1906 #endif
1907
1908     info->load_bias = load_bias;
1909     info->load_addr = load_addr;
1910     info->entry = ehdr->e_entry + load_bias;
1911     info->start_code = -1;
1912     info->end_code = 0;
1913     info->start_data = -1;
1914     info->end_data = 0;
1915     info->brk = 0;
1916     info->elf_flags = ehdr->e_flags;
1917
1918     for (i = 0; i < ehdr->e_phnum; i++) {
1919         struct elf_phdr *eppnt = phdr + i;
1920         if (eppnt->p_type == PT_LOAD) {
1921             abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em;
1922             int elf_prot = 0;
1923
1924             if (eppnt->p_flags & PF_R) elf_prot =  PROT_READ;
1925             if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
1926             if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
1927
1928             vaddr = load_bias + eppnt->p_vaddr;
1929             vaddr_po = TARGET_ELF_PAGEOFFSET(vaddr);
1930             vaddr_ps = TARGET_ELF_PAGESTART(vaddr);
1931
1932             error = target_mmap(vaddr_ps, eppnt->p_filesz + vaddr_po,
1933                                 elf_prot, MAP_PRIVATE | MAP_FIXED,
1934                                 image_fd, eppnt->p_offset - vaddr_po);
1935             if (error == -1) {
1936                 goto exit_perror;
1937             }
1938
1939             vaddr_ef = vaddr + eppnt->p_filesz;
1940             vaddr_em = vaddr + eppnt->p_memsz;
1941
1942             /* If the load segment requests extra zeros (e.g. bss), map it.  */
1943             if (vaddr_ef < vaddr_em) {
1944                 zero_bss(vaddr_ef, vaddr_em, elf_prot);
1945             }
1946
1947             /* Find the full program boundaries.  */
1948             if (elf_prot & PROT_EXEC) {
1949                 if (vaddr < info->start_code) {
1950                     info->start_code = vaddr;
1951                 }
1952                 if (vaddr_ef > info->end_code) {
1953                     info->end_code = vaddr_ef;
1954                 }
1955             }
1956             if (elf_prot & PROT_WRITE) {
1957                 if (vaddr < info->start_data) {
1958                     info->start_data = vaddr;
1959                 }
1960                 if (vaddr_ef > info->end_data) {
1961                     info->end_data = vaddr_ef;
1962                 }
1963                 if (vaddr_em > info->brk) {
1964                     info->brk = vaddr_em;
1965                 }
1966             }
1967         } else if (eppnt->p_type == PT_INTERP && pinterp_name) {
1968             char *interp_name;
1969
1970             if (*pinterp_name) {
1971                 errmsg = "Multiple PT_INTERP entries";
1972                 goto exit_errmsg;
1973             }
1974             interp_name = malloc(eppnt->p_filesz);
1975             if (!interp_name) {
1976                 goto exit_perror;
1977             }
1978
1979             if (eppnt->p_offset + eppnt->p_filesz <= BPRM_BUF_SIZE) {
1980                 memcpy(interp_name, bprm_buf + eppnt->p_offset,
1981                        eppnt->p_filesz);
1982             } else {
1983                 retval = pread(image_fd, interp_name, eppnt->p_filesz,
1984                                eppnt->p_offset);
1985                 if (retval != eppnt->p_filesz) {
1986                     goto exit_perror;
1987                 }
1988             }
1989             if (interp_name[eppnt->p_filesz - 1] != 0) {
1990                 errmsg = "Invalid PT_INTERP entry";
1991                 goto exit_errmsg;
1992             }
1993             *pinterp_name = interp_name;
1994         }
1995     }
1996
1997     if (info->end_data == 0) {
1998         info->start_data = info->end_code;
1999         info->end_data = info->end_code;
2000         info->brk = info->end_code;
2001     }
2002
2003     if (qemu_log_enabled()) {
2004         load_symbols(ehdr, image_fd, load_bias);
2005     }
2006
2007     mmap_unlock();
2008
2009     close(image_fd);
2010     return;
2011
2012  exit_read:
2013     if (retval >= 0) {
2014         errmsg = "Incomplete read of file header";
2015         goto exit_errmsg;
2016     }
2017  exit_perror:
2018     errmsg = strerror(errno);
2019  exit_errmsg:
2020     fprintf(stderr, "%s: %s\n", image_name, errmsg);
2021     exit(-1);
2022 }
2023
2024 static void load_elf_interp(const char *filename, struct image_info *info,
2025                             char bprm_buf[BPRM_BUF_SIZE])
2026 {
2027     int fd, retval;
2028
2029     fd = open(path(filename), O_RDONLY);
2030     if (fd < 0) {
2031         goto exit_perror;
2032     }
2033
2034     retval = read(fd, bprm_buf, BPRM_BUF_SIZE);
2035     if (retval < 0) {
2036         goto exit_perror;
2037     }
2038     if (retval < BPRM_BUF_SIZE) {
2039         memset(bprm_buf + retval, 0, BPRM_BUF_SIZE - retval);
2040     }
2041
2042     load_elf_image(filename, fd, info, NULL, bprm_buf);
2043     return;
2044
2045  exit_perror:
2046     fprintf(stderr, "%s: %s\n", filename, strerror(errno));
2047     exit(-1);
2048 }
2049
2050 static int symfind(const void *s0, const void *s1)
2051 {
2052     target_ulong addr = *(target_ulong *)s0;
2053     struct elf_sym *sym = (struct elf_sym *)s1;
2054     int result = 0;
2055     if (addr < sym->st_value) {
2056         result = -1;
2057     } else if (addr >= sym->st_value + sym->st_size) {
2058         result = 1;
2059     }
2060     return result;
2061 }
2062
2063 static const char *lookup_symbolxx(struct syminfo *s, target_ulong orig_addr)
2064 {
2065 #if ELF_CLASS == ELFCLASS32
2066     struct elf_sym *syms = s->disas_symtab.elf32;
2067 #else
2068     struct elf_sym *syms = s->disas_symtab.elf64;
2069 #endif
2070
2071     // binary search
2072     struct elf_sym *sym;
2073
2074     sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind);
2075     if (sym != NULL) {
2076         return s->disas_strtab + sym->st_name;
2077     }
2078
2079     return "";
2080 }
2081
2082 /* FIXME: This should use elf_ops.h  */
2083 static int symcmp(const void *s0, const void *s1)
2084 {
2085     struct elf_sym *sym0 = (struct elf_sym *)s0;
2086     struct elf_sym *sym1 = (struct elf_sym *)s1;
2087     return (sym0->st_value < sym1->st_value)
2088         ? -1
2089         : ((sym0->st_value > sym1->st_value) ? 1 : 0);
2090 }
2091
2092 /* Best attempt to load symbols from this ELF object. */
2093 static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias)
2094 {
2095     int i, shnum, nsyms, sym_idx = 0, str_idx = 0;
2096     struct elf_shdr *shdr;
2097     char *strings = NULL;
2098     struct syminfo *s = NULL;
2099     struct elf_sym *new_syms, *syms = NULL;
2100
2101     shnum = hdr->e_shnum;
2102     i = shnum * sizeof(struct elf_shdr);
2103     shdr = (struct elf_shdr *)alloca(i);
2104     if (pread(fd, shdr, i, hdr->e_shoff) != i) {
2105         return;
2106     }
2107
2108     bswap_shdr(shdr, shnum);
2109     for (i = 0; i < shnum; ++i) {
2110         if (shdr[i].sh_type == SHT_SYMTAB) {
2111             sym_idx = i;
2112             str_idx = shdr[i].sh_link;
2113             goto found;
2114         }
2115     }
2116
2117     /* There will be no symbol table if the file was stripped.  */
2118     return;
2119
2120  found:
2121     /* Now know where the strtab and symtab are.  Snarf them.  */
2122     s = g_try_new(struct syminfo, 1);
2123     if (!s) {
2124         goto give_up;
2125     }
2126
2127     i = shdr[str_idx].sh_size;
2128     s->disas_strtab = strings = g_try_malloc(i);
2129     if (!strings || pread(fd, strings, i, shdr[str_idx].sh_offset) != i) {
2130         goto give_up;
2131     }
2132
2133     i = shdr[sym_idx].sh_size;
2134     syms = g_try_malloc(i);
2135     if (!syms || pread(fd, syms, i, shdr[sym_idx].sh_offset) != i) {
2136         goto give_up;
2137     }
2138
2139     nsyms = i / sizeof(struct elf_sym);
2140     for (i = 0; i < nsyms; ) {
2141         bswap_sym(syms + i);
2142         /* Throw away entries which we do not need.  */
2143         if (syms[i].st_shndx == SHN_UNDEF
2144             || syms[i].st_shndx >= SHN_LORESERVE
2145             || ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) {
2146             if (i < --nsyms) {
2147                 syms[i] = syms[nsyms];
2148             }
2149         } else {
2150 #if defined(TARGET_ARM) || defined (TARGET_MIPS)
2151             /* The bottom address bit marks a Thumb or MIPS16 symbol.  */
2152             syms[i].st_value &= ~(target_ulong)1;
2153 #endif
2154             syms[i].st_value += load_bias;
2155             i++;
2156         }
2157     }
2158
2159     /* No "useful" symbol.  */
2160     if (nsyms == 0) {
2161         goto give_up;
2162     }
2163
2164     /* Attempt to free the storage associated with the local symbols
2165        that we threw away.  Whether or not this has any effect on the
2166        memory allocation depends on the malloc implementation and how
2167        many symbols we managed to discard.  */
2168     new_syms = g_try_renew(struct elf_sym, syms, nsyms);
2169     if (new_syms == NULL) {
2170         goto give_up;
2171     }
2172     syms = new_syms;
2173
2174     qsort(syms, nsyms, sizeof(*syms), symcmp);
2175
2176     s->disas_num_syms = nsyms;
2177 #if ELF_CLASS == ELFCLASS32
2178     s->disas_symtab.elf32 = syms;
2179 #else
2180     s->disas_symtab.elf64 = syms;
2181 #endif
2182     s->lookup_symbol = lookup_symbolxx;
2183     s->next = syminfos;
2184     syminfos = s;
2185
2186     return;
2187
2188 give_up:
2189     g_free(s);
2190     g_free(strings);
2191     g_free(syms);
2192 }
2193
2194 int load_elf_binary(struct linux_binprm *bprm, struct image_info *info)
2195 {
2196     struct image_info interp_info;
2197     struct elfhdr elf_ex;
2198     char *elf_interpreter = NULL;
2199     char *scratch;
2200
2201     info->start_mmap = (abi_ulong)ELF_START_MMAP;
2202
2203     load_elf_image(bprm->filename, bprm->fd, info,
2204                    &elf_interpreter, bprm->buf);
2205
2206     /* ??? We need a copy of the elf header for passing to create_elf_tables.
2207        If we do nothing, we'll have overwritten this when we re-use bprm->buf
2208        when we load the interpreter.  */
2209     elf_ex = *(struct elfhdr *)bprm->buf;
2210
2211     /* Do this so that we can load the interpreter, if need be.  We will
2212        change some of these later */
2213     bprm->p = setup_arg_pages(bprm, info);
2214
2215     scratch = g_new0(char, TARGET_PAGE_SIZE);
2216     bprm->p = copy_elf_strings(1, &bprm->filename, scratch,
2217                                bprm->p, info->stack_limit);
2218     bprm->p = copy_elf_strings(bprm->envc, bprm->envp, scratch,
2219                                bprm->p, info->stack_limit);
2220     bprm->p = copy_elf_strings(bprm->argc, bprm->argv, scratch,
2221                                bprm->p, info->stack_limit);
2222     g_free(scratch);
2223
2224     if (!bprm->p) {
2225         fprintf(stderr, "%s: %s\n", bprm->filename, strerror(E2BIG));
2226         exit(-1);
2227     }
2228
2229     if (elf_interpreter) {
2230         load_elf_interp(elf_interpreter, &interp_info, bprm->buf);
2231
2232         /* If the program interpreter is one of these two, then assume
2233            an iBCS2 image.  Otherwise assume a native linux image.  */
2234
2235         if (strcmp(elf_interpreter, "/usr/lib/libc.so.1") == 0
2236             || strcmp(elf_interpreter, "/usr/lib/ld.so.1") == 0) {
2237             info->personality = PER_SVR4;
2238
2239             /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
2240                and some applications "depend" upon this behavior.  Since
2241                we do not have the power to recompile these, we emulate
2242                the SVr4 behavior.  Sigh.  */
2243             target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
2244                         MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
2245         }
2246     }
2247
2248     bprm->p = create_elf_tables(bprm->p, bprm->argc, bprm->envc, &elf_ex,
2249                                 info, (elf_interpreter ? &interp_info : NULL));
2250     info->start_stack = bprm->p;
2251
2252     /* If we have an interpreter, set that as the program's entry point.
2253        Copy the load_bias as well, to help PPC64 interpret the entry
2254        point as a function descriptor.  Do this after creating elf tables
2255        so that we copy the original program entry point into the AUXV.  */
2256     if (elf_interpreter) {
2257         info->load_bias = interp_info.load_bias;
2258         info->entry = interp_info.entry;
2259         free(elf_interpreter);
2260     }
2261
2262 #ifdef USE_ELF_CORE_DUMP
2263     bprm->core_dump = &elf_core_dump;
2264 #endif
2265
2266     return 0;
2267 }
2268
2269 #ifdef USE_ELF_CORE_DUMP
2270 /*
2271  * Definitions to generate Intel SVR4-like core files.
2272  * These mostly have the same names as the SVR4 types with "target_elf_"
2273  * tacked on the front to prevent clashes with linux definitions,
2274  * and the typedef forms have been avoided.  This is mostly like
2275  * the SVR4 structure, but more Linuxy, with things that Linux does
2276  * not support and which gdb doesn't really use excluded.
2277  *
2278  * Fields we don't dump (their contents is zero) in linux-user qemu
2279  * are marked with XXX.
2280  *
2281  * Core dump code is copied from linux kernel (fs/binfmt_elf.c).
2282  *
2283  * Porting ELF coredump for target is (quite) simple process.  First you
2284  * define USE_ELF_CORE_DUMP in target ELF code (where init_thread() for
2285  * the target resides):
2286  *
2287  * #define USE_ELF_CORE_DUMP
2288  *
2289  * Next you define type of register set used for dumping.  ELF specification
2290  * says that it needs to be array of elf_greg_t that has size of ELF_NREG.
2291  *
2292  * typedef <target_regtype> target_elf_greg_t;
2293  * #define ELF_NREG <number of registers>
2294  * typedef taret_elf_greg_t target_elf_gregset_t[ELF_NREG];
2295  *
2296  * Last step is to implement target specific function that copies registers
2297  * from given cpu into just specified register set.  Prototype is:
2298  *
2299  * static void elf_core_copy_regs(taret_elf_gregset_t *regs,
2300  *                                const CPUArchState *env);
2301  *
2302  * Parameters:
2303  *     regs - copy register values into here (allocated and zeroed by caller)
2304  *     env - copy registers from here
2305  *
2306  * Example for ARM target is provided in this file.
2307  */
2308
2309 /* An ELF note in memory */
2310 struct memelfnote {
2311     const char *name;
2312     size_t     namesz;
2313     size_t     namesz_rounded;
2314     int        type;
2315     size_t     datasz;
2316     size_t     datasz_rounded;
2317     void       *data;
2318     size_t     notesz;
2319 };
2320
2321 struct target_elf_siginfo {
2322     abi_int    si_signo; /* signal number */
2323     abi_int    si_code;  /* extra code */
2324     abi_int    si_errno; /* errno */
2325 };
2326
2327 struct target_elf_prstatus {
2328     struct target_elf_siginfo pr_info;      /* Info associated with signal */
2329     abi_short          pr_cursig;    /* Current signal */
2330     abi_ulong          pr_sigpend;   /* XXX */
2331     abi_ulong          pr_sighold;   /* XXX */
2332     target_pid_t       pr_pid;
2333     target_pid_t       pr_ppid;
2334     target_pid_t       pr_pgrp;
2335     target_pid_t       pr_sid;
2336     struct target_timeval pr_utime;  /* XXX User time */
2337     struct target_timeval pr_stime;  /* XXX System time */
2338     struct target_timeval pr_cutime; /* XXX Cumulative user time */
2339     struct target_timeval pr_cstime; /* XXX Cumulative system time */
2340     target_elf_gregset_t      pr_reg;       /* GP registers */
2341     abi_int            pr_fpvalid;   /* XXX */
2342 };
2343
2344 #define ELF_PRARGSZ     (80) /* Number of chars for args */
2345
2346 struct target_elf_prpsinfo {
2347     char         pr_state;       /* numeric process state */
2348     char         pr_sname;       /* char for pr_state */
2349     char         pr_zomb;        /* zombie */
2350     char         pr_nice;        /* nice val */
2351     abi_ulong    pr_flag;        /* flags */
2352     target_uid_t pr_uid;
2353     target_gid_t pr_gid;
2354     target_pid_t pr_pid, pr_ppid, pr_pgrp, pr_sid;
2355     /* Lots missing */
2356     char    pr_fname[16];           /* filename of executable */
2357     char    pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
2358 };
2359
2360 /* Here is the structure in which status of each thread is captured. */
2361 struct elf_thread_status {
2362     QTAILQ_ENTRY(elf_thread_status)  ets_link;
2363     struct target_elf_prstatus prstatus;   /* NT_PRSTATUS */
2364 #if 0
2365     elf_fpregset_t fpu;             /* NT_PRFPREG */
2366     struct task_struct *thread;
2367     elf_fpxregset_t xfpu;           /* ELF_CORE_XFPREG_TYPE */
2368 #endif
2369     struct memelfnote notes[1];
2370     int num_notes;
2371 };
2372
2373 struct elf_note_info {
2374     struct memelfnote   *notes;
2375     struct target_elf_prstatus *prstatus;  /* NT_PRSTATUS */
2376     struct target_elf_prpsinfo *psinfo;    /* NT_PRPSINFO */
2377
2378     QTAILQ_HEAD(thread_list_head, elf_thread_status) thread_list;
2379 #if 0
2380     /*
2381      * Current version of ELF coredump doesn't support
2382      * dumping fp regs etc.
2383      */
2384     elf_fpregset_t *fpu;
2385     elf_fpxregset_t *xfpu;
2386     int thread_status_size;
2387 #endif
2388     int notes_size;
2389     int numnote;
2390 };
2391
2392 struct vm_area_struct {
2393     target_ulong   vma_start;  /* start vaddr of memory region */
2394     target_ulong   vma_end;    /* end vaddr of memory region */
2395     abi_ulong      vma_flags;  /* protection etc. flags for the region */
2396     QTAILQ_ENTRY(vm_area_struct) vma_link;
2397 };
2398
2399 struct mm_struct {
2400     QTAILQ_HEAD(, vm_area_struct) mm_mmap;
2401     int mm_count;           /* number of mappings */
2402 };
2403
2404 static struct mm_struct *vma_init(void);
2405 static void vma_delete(struct mm_struct *);
2406 static int vma_add_mapping(struct mm_struct *, target_ulong,
2407                            target_ulong, abi_ulong);
2408 static int vma_get_mapping_count(const struct mm_struct *);
2409 static struct vm_area_struct *vma_first(const struct mm_struct *);
2410 static struct vm_area_struct *vma_next(struct vm_area_struct *);
2411 static abi_ulong vma_dump_size(const struct vm_area_struct *);
2412 static int vma_walker(void *priv, target_ulong start, target_ulong end,
2413                       unsigned long flags);
2414
2415 static void fill_elf_header(struct elfhdr *, int, uint16_t, uint32_t);
2416 static void fill_note(struct memelfnote *, const char *, int,
2417                       unsigned int, void *);
2418 static void fill_prstatus(struct target_elf_prstatus *, const TaskState *, int);
2419 static int fill_psinfo(struct target_elf_prpsinfo *, const TaskState *);
2420 static void fill_auxv_note(struct memelfnote *, const TaskState *);
2421 static void fill_elf_note_phdr(struct elf_phdr *, int, off_t);
2422 static size_t note_size(const struct memelfnote *);
2423 static void free_note_info(struct elf_note_info *);
2424 static int fill_note_info(struct elf_note_info *, long, const CPUArchState *);
2425 static void fill_thread_info(struct elf_note_info *, const CPUArchState *);
2426 static int core_dump_filename(const TaskState *, char *, size_t);
2427
2428 static int dump_write(int, const void *, size_t);
2429 static int write_note(struct memelfnote *, int);
2430 static int write_note_info(struct elf_note_info *, int);
2431
2432 #ifdef BSWAP_NEEDED
2433 static void bswap_prstatus(struct target_elf_prstatus *prstatus)
2434 {
2435     prstatus->pr_info.si_signo = tswap32(prstatus->pr_info.si_signo);
2436     prstatus->pr_info.si_code = tswap32(prstatus->pr_info.si_code);
2437     prstatus->pr_info.si_errno = tswap32(prstatus->pr_info.si_errno);
2438     prstatus->pr_cursig = tswap16(prstatus->pr_cursig);
2439     prstatus->pr_sigpend = tswapal(prstatus->pr_sigpend);
2440     prstatus->pr_sighold = tswapal(prstatus->pr_sighold);
2441     prstatus->pr_pid = tswap32(prstatus->pr_pid);
2442     prstatus->pr_ppid = tswap32(prstatus->pr_ppid);
2443     prstatus->pr_pgrp = tswap32(prstatus->pr_pgrp);
2444     prstatus->pr_sid = tswap32(prstatus->pr_sid);
2445     /* cpu times are not filled, so we skip them */
2446     /* regs should be in correct format already */
2447     prstatus->pr_fpvalid = tswap32(prstatus->pr_fpvalid);
2448 }
2449
2450 static void bswap_psinfo(struct target_elf_prpsinfo *psinfo)
2451 {
2452     psinfo->pr_flag = tswapal(psinfo->pr_flag);
2453     psinfo->pr_uid = tswap16(psinfo->pr_uid);
2454     psinfo->pr_gid = tswap16(psinfo->pr_gid);
2455     psinfo->pr_pid = tswap32(psinfo->pr_pid);
2456     psinfo->pr_ppid = tswap32(psinfo->pr_ppid);
2457     psinfo->pr_pgrp = tswap32(psinfo->pr_pgrp);
2458     psinfo->pr_sid = tswap32(psinfo->pr_sid);
2459 }
2460
2461 static void bswap_note(struct elf_note *en)
2462 {
2463     bswap32s(&en->n_namesz);
2464     bswap32s(&en->n_descsz);
2465     bswap32s(&en->n_type);
2466 }
2467 #else
2468 static inline void bswap_prstatus(struct target_elf_prstatus *p) { }
2469 static inline void bswap_psinfo(struct target_elf_prpsinfo *p) {}
2470 static inline void bswap_note(struct elf_note *en) { }
2471 #endif /* BSWAP_NEEDED */
2472
2473 /*
2474  * Minimal support for linux memory regions.  These are needed
2475  * when we are finding out what memory exactly belongs to
2476  * emulated process.  No locks needed here, as long as
2477  * thread that received the signal is stopped.
2478  */
2479
2480 static struct mm_struct *vma_init(void)
2481 {
2482     struct mm_struct *mm;
2483
2484     if ((mm = g_malloc(sizeof (*mm))) == NULL)
2485         return (NULL);
2486
2487     mm->mm_count = 0;
2488     QTAILQ_INIT(&mm->mm_mmap);
2489
2490     return (mm);
2491 }
2492
2493 static void vma_delete(struct mm_struct *mm)
2494 {
2495     struct vm_area_struct *vma;
2496
2497     while ((vma = vma_first(mm)) != NULL) {
2498         QTAILQ_REMOVE(&mm->mm_mmap, vma, vma_link);
2499         g_free(vma);
2500     }
2501     g_free(mm);
2502 }
2503
2504 static int vma_add_mapping(struct mm_struct *mm, target_ulong start,
2505                            target_ulong end, abi_ulong flags)
2506 {
2507     struct vm_area_struct *vma;
2508
2509     if ((vma = g_malloc0(sizeof (*vma))) == NULL)
2510         return (-1);
2511
2512     vma->vma_start = start;
2513     vma->vma_end = end;
2514     vma->vma_flags = flags;
2515
2516     QTAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link);
2517     mm->mm_count++;
2518
2519     return (0);
2520 }
2521
2522 static struct vm_area_struct *vma_first(const struct mm_struct *mm)
2523 {
2524     return (QTAILQ_FIRST(&mm->mm_mmap));
2525 }
2526
2527 static struct vm_area_struct *vma_next(struct vm_area_struct *vma)
2528 {
2529     return (QTAILQ_NEXT(vma, vma_link));
2530 }
2531
2532 static int vma_get_mapping_count(const struct mm_struct *mm)
2533 {
2534     return (mm->mm_count);
2535 }
2536
2537 /*
2538  * Calculate file (dump) size of given memory region.
2539  */
2540 static abi_ulong vma_dump_size(const struct vm_area_struct *vma)
2541 {
2542     /* if we cannot even read the first page, skip it */
2543     if (!access_ok(VERIFY_READ, vma->vma_start, TARGET_PAGE_SIZE))
2544         return (0);
2545
2546     /*
2547      * Usually we don't dump executable pages as they contain
2548      * non-writable code that debugger can read directly from
2549      * target library etc.  However, thread stacks are marked
2550      * also executable so we read in first page of given region
2551      * and check whether it contains elf header.  If there is
2552      * no elf header, we dump it.
2553      */
2554     if (vma->vma_flags & PROT_EXEC) {
2555         char page[TARGET_PAGE_SIZE];
2556
2557         copy_from_user(page, vma->vma_start, sizeof (page));
2558         if ((page[EI_MAG0] == ELFMAG0) &&
2559             (page[EI_MAG1] == ELFMAG1) &&
2560             (page[EI_MAG2] == ELFMAG2) &&
2561             (page[EI_MAG3] == ELFMAG3)) {
2562             /*
2563              * Mappings are possibly from ELF binary.  Don't dump
2564              * them.
2565              */
2566             return (0);
2567         }
2568     }
2569
2570     return (vma->vma_end - vma->vma_start);
2571 }
2572
2573 static int vma_walker(void *priv, target_ulong start, target_ulong end,
2574                       unsigned long flags)
2575 {
2576     struct mm_struct *mm = (struct mm_struct *)priv;
2577
2578     vma_add_mapping(mm, start, end, flags);
2579     return (0);
2580 }
2581
2582 static void fill_note(struct memelfnote *note, const char *name, int type,
2583                       unsigned int sz, void *data)
2584 {
2585     unsigned int namesz;
2586
2587     namesz = strlen(name) + 1;
2588     note->name = name;
2589     note->namesz = namesz;
2590     note->namesz_rounded = roundup(namesz, sizeof (int32_t));
2591     note->type = type;
2592     note->datasz = sz;
2593     note->datasz_rounded = roundup(sz, sizeof (int32_t));
2594
2595     note->data = data;
2596
2597     /*
2598      * We calculate rounded up note size here as specified by
2599      * ELF document.
2600      */
2601     note->notesz = sizeof (struct elf_note) +
2602         note->namesz_rounded + note->datasz_rounded;
2603 }
2604
2605 static void fill_elf_header(struct elfhdr *elf, int segs, uint16_t machine,
2606                             uint32_t flags)
2607 {
2608     (void) memset(elf, 0, sizeof(*elf));
2609
2610     (void) memcpy(elf->e_ident, ELFMAG, SELFMAG);
2611     elf->e_ident[EI_CLASS] = ELF_CLASS;
2612     elf->e_ident[EI_DATA] = ELF_DATA;
2613     elf->e_ident[EI_VERSION] = EV_CURRENT;
2614     elf->e_ident[EI_OSABI] = ELF_OSABI;
2615
2616     elf->e_type = ET_CORE;
2617     elf->e_machine = machine;
2618     elf->e_version = EV_CURRENT;
2619     elf->e_phoff = sizeof(struct elfhdr);
2620     elf->e_flags = flags;
2621     elf->e_ehsize = sizeof(struct elfhdr);
2622     elf->e_phentsize = sizeof(struct elf_phdr);
2623     elf->e_phnum = segs;
2624
2625     bswap_ehdr(elf);
2626 }
2627
2628 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
2629 {
2630     phdr->p_type = PT_NOTE;
2631     phdr->p_offset = offset;
2632     phdr->p_vaddr = 0;
2633     phdr->p_paddr = 0;
2634     phdr->p_filesz = sz;
2635     phdr->p_memsz = 0;
2636     phdr->p_flags = 0;
2637     phdr->p_align = 0;
2638
2639     bswap_phdr(phdr, 1);
2640 }
2641
2642 static size_t note_size(const struct memelfnote *note)
2643 {
2644     return (note->notesz);
2645 }
2646
2647 static void fill_prstatus(struct target_elf_prstatus *prstatus,
2648                           const TaskState *ts, int signr)
2649 {
2650     (void) memset(prstatus, 0, sizeof (*prstatus));
2651     prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
2652     prstatus->pr_pid = ts->ts_tid;
2653     prstatus->pr_ppid = getppid();
2654     prstatus->pr_pgrp = getpgrp();
2655     prstatus->pr_sid = getsid(0);
2656
2657     bswap_prstatus(prstatus);
2658 }
2659
2660 static int fill_psinfo(struct target_elf_prpsinfo *psinfo, const TaskState *ts)
2661 {
2662     char *base_filename;
2663     unsigned int i, len;
2664
2665     (void) memset(psinfo, 0, sizeof (*psinfo));
2666
2667     len = ts->info->arg_end - ts->info->arg_start;
2668     if (len >= ELF_PRARGSZ)
2669         len = ELF_PRARGSZ - 1;
2670     if (copy_from_user(&psinfo->pr_psargs, ts->info->arg_start, len))
2671         return -EFAULT;
2672     for (i = 0; i < len; i++)
2673         if (psinfo->pr_psargs[i] == 0)
2674             psinfo->pr_psargs[i] = ' ';
2675     psinfo->pr_psargs[len] = 0;
2676
2677     psinfo->pr_pid = getpid();
2678     psinfo->pr_ppid = getppid();
2679     psinfo->pr_pgrp = getpgrp();
2680     psinfo->pr_sid = getsid(0);
2681     psinfo->pr_uid = getuid();
2682     psinfo->pr_gid = getgid();
2683
2684     base_filename = g_path_get_basename(ts->bprm->filename);
2685     /*
2686      * Using strncpy here is fine: at max-length,
2687      * this field is not NUL-terminated.
2688      */
2689     (void) strncpy(psinfo->pr_fname, base_filename,
2690                    sizeof(psinfo->pr_fname));
2691
2692     g_free(base_filename);
2693     bswap_psinfo(psinfo);
2694     return (0);
2695 }
2696
2697 static void fill_auxv_note(struct memelfnote *note, const TaskState *ts)
2698 {
2699     elf_addr_t auxv = (elf_addr_t)ts->info->saved_auxv;
2700     elf_addr_t orig_auxv = auxv;
2701     void *ptr;
2702     int len = ts->info->auxv_len;
2703
2704     /*
2705      * Auxiliary vector is stored in target process stack.  It contains
2706      * {type, value} pairs that we need to dump into note.  This is not
2707      * strictly necessary but we do it here for sake of completeness.
2708      */
2709
2710     /* read in whole auxv vector and copy it to memelfnote */
2711     ptr = lock_user(VERIFY_READ, orig_auxv, len, 0);
2712     if (ptr != NULL) {
2713         fill_note(note, "CORE", NT_AUXV, len, ptr);
2714         unlock_user(ptr, auxv, len);
2715     }
2716 }
2717
2718 /*
2719  * Constructs name of coredump file.  We have following convention
2720  * for the name:
2721  *     qemu_<basename-of-target-binary>_<date>-<time>_<pid>.core
2722  *
2723  * Returns 0 in case of success, -1 otherwise (errno is set).
2724  */
2725 static int core_dump_filename(const TaskState *ts, char *buf,
2726                               size_t bufsize)
2727 {
2728     char timestamp[64];
2729     char *base_filename = NULL;
2730     struct timeval tv;
2731     struct tm tm;
2732
2733     assert(bufsize >= PATH_MAX);
2734
2735     if (gettimeofday(&tv, NULL) < 0) {
2736         (void) fprintf(stderr, "unable to get current timestamp: %s",
2737                        strerror(errno));
2738         return (-1);
2739     }
2740
2741     base_filename = g_path_get_basename(ts->bprm->filename);
2742     (void) strftime(timestamp, sizeof (timestamp), "%Y%m%d-%H%M%S",
2743                     localtime_r(&tv.tv_sec, &tm));
2744     (void) snprintf(buf, bufsize, "qemu_%s_%s_%d.core",
2745                     base_filename, timestamp, (int)getpid());
2746     g_free(base_filename);
2747
2748     return (0);
2749 }
2750
2751 static int dump_write(int fd, const void *ptr, size_t size)
2752 {
2753     const char *bufp = (const char *)ptr;
2754     ssize_t bytes_written, bytes_left;
2755     struct rlimit dumpsize;
2756     off_t pos;
2757
2758     bytes_written = 0;
2759     getrlimit(RLIMIT_CORE, &dumpsize);
2760     if ((pos = lseek(fd, 0, SEEK_CUR))==-1) {
2761         if (errno == ESPIPE) { /* not a seekable stream */
2762             bytes_left = size;
2763         } else {
2764             return pos;
2765         }
2766     } else {
2767         if (dumpsize.rlim_cur <= pos) {
2768             return -1;
2769         } else if (dumpsize.rlim_cur == RLIM_INFINITY) {
2770             bytes_left = size;
2771         } else {
2772             size_t limit_left=dumpsize.rlim_cur - pos;
2773             bytes_left = limit_left >= size ? size : limit_left ;
2774         }
2775     }
2776
2777     /*
2778      * In normal conditions, single write(2) should do but
2779      * in case of socket etc. this mechanism is more portable.
2780      */
2781     do {
2782         bytes_written = write(fd, bufp, bytes_left);
2783         if (bytes_written < 0) {
2784             if (errno == EINTR)
2785                 continue;
2786             return (-1);
2787         } else if (bytes_written == 0) { /* eof */
2788             return (-1);
2789         }
2790         bufp += bytes_written;
2791         bytes_left -= bytes_written;
2792     } while (bytes_left > 0);
2793
2794     return (0);
2795 }
2796
2797 static int write_note(struct memelfnote *men, int fd)
2798 {
2799     struct elf_note en;
2800
2801     en.n_namesz = men->namesz;
2802     en.n_type = men->type;
2803     en.n_descsz = men->datasz;
2804
2805     bswap_note(&en);
2806
2807     if (dump_write(fd, &en, sizeof(en)) != 0)
2808         return (-1);
2809     if (dump_write(fd, men->name, men->namesz_rounded) != 0)
2810         return (-1);
2811     if (dump_write(fd, men->data, men->datasz_rounded) != 0)
2812         return (-1);
2813
2814     return (0);
2815 }
2816
2817 static void fill_thread_info(struct elf_note_info *info, const CPUArchState *env)
2818 {
2819     CPUState *cpu = ENV_GET_CPU((CPUArchState *)env);
2820     TaskState *ts = (TaskState *)cpu->opaque;
2821     struct elf_thread_status *ets;
2822
2823     ets = g_malloc0(sizeof (*ets));
2824     ets->num_notes = 1; /* only prstatus is dumped */
2825     fill_prstatus(&ets->prstatus, ts, 0);
2826     elf_core_copy_regs(&ets->prstatus.pr_reg, env);
2827     fill_note(&ets->notes[0], "CORE", NT_PRSTATUS, sizeof (ets->prstatus),
2828               &ets->prstatus);
2829
2830     QTAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link);
2831
2832     info->notes_size += note_size(&ets->notes[0]);
2833 }
2834
2835 static void init_note_info(struct elf_note_info *info)
2836 {
2837     /* Initialize the elf_note_info structure so that it is at
2838      * least safe to call free_note_info() on it. Must be
2839      * called before calling fill_note_info().
2840      */
2841     memset(info, 0, sizeof (*info));
2842     QTAILQ_INIT(&info->thread_list);
2843 }
2844
2845 static int fill_note_info(struct elf_note_info *info,
2846                           long signr, const CPUArchState *env)
2847 {
2848 #define NUMNOTES 3
2849     CPUState *cpu = ENV_GET_CPU((CPUArchState *)env);
2850     TaskState *ts = (TaskState *)cpu->opaque;
2851     int i;
2852
2853     info->notes = g_new0(struct memelfnote, NUMNOTES);
2854     if (info->notes == NULL)
2855         return (-ENOMEM);
2856     info->prstatus = g_malloc0(sizeof (*info->prstatus));
2857     if (info->prstatus == NULL)
2858         return (-ENOMEM);
2859     info->psinfo = g_malloc0(sizeof (*info->psinfo));
2860     if (info->prstatus == NULL)
2861         return (-ENOMEM);
2862
2863     /*
2864      * First fill in status (and registers) of current thread
2865      * including process info & aux vector.
2866      */
2867     fill_prstatus(info->prstatus, ts, signr);
2868     elf_core_copy_regs(&info->prstatus->pr_reg, env);
2869     fill_note(&info->notes[0], "CORE", NT_PRSTATUS,
2870               sizeof (*info->prstatus), info->prstatus);
2871     fill_psinfo(info->psinfo, ts);
2872     fill_note(&info->notes[1], "CORE", NT_PRPSINFO,
2873               sizeof (*info->psinfo), info->psinfo);
2874     fill_auxv_note(&info->notes[2], ts);
2875     info->numnote = 3;
2876
2877     info->notes_size = 0;
2878     for (i = 0; i < info->numnote; i++)
2879         info->notes_size += note_size(&info->notes[i]);
2880
2881     /* read and fill status of all threads */
2882     cpu_list_lock();
2883     CPU_FOREACH(cpu) {
2884         if (cpu == thread_cpu) {
2885             continue;
2886         }
2887         fill_thread_info(info, (CPUArchState *)cpu->env_ptr);
2888     }
2889     cpu_list_unlock();
2890
2891     return (0);
2892 }
2893
2894 static void free_note_info(struct elf_note_info *info)
2895 {
2896     struct elf_thread_status *ets;
2897
2898     while (!QTAILQ_EMPTY(&info->thread_list)) {
2899         ets = QTAILQ_FIRST(&info->thread_list);
2900         QTAILQ_REMOVE(&info->thread_list, ets, ets_link);
2901         g_free(ets);
2902     }
2903
2904     g_free(info->prstatus);
2905     g_free(info->psinfo);
2906     g_free(info->notes);
2907 }
2908
2909 static int write_note_info(struct elf_note_info *info, int fd)
2910 {
2911     struct elf_thread_status *ets;
2912     int i, error = 0;
2913
2914     /* write prstatus, psinfo and auxv for current thread */
2915     for (i = 0; i < info->numnote; i++)
2916         if ((error = write_note(&info->notes[i], fd)) != 0)
2917             return (error);
2918
2919     /* write prstatus for each thread */
2920     QTAILQ_FOREACH(ets, &info->thread_list, ets_link) {
2921         if ((error = write_note(&ets->notes[0], fd)) != 0)
2922             return (error);
2923     }
2924
2925     return (0);
2926 }
2927
2928 /*
2929  * Write out ELF coredump.
2930  *
2931  * See documentation of ELF object file format in:
2932  * http://www.caldera.com/developers/devspecs/gabi41.pdf
2933  *
2934  * Coredump format in linux is following:
2935  *
2936  * 0   +----------------------+         \
2937  *     | ELF header           | ET_CORE  |
2938  *     +----------------------+          |
2939  *     | ELF program headers  |          |--- headers
2940  *     | - NOTE section       |          |
2941  *     | - PT_LOAD sections   |          |
2942  *     +----------------------+         /
2943  *     | NOTEs:               |
2944  *     | - NT_PRSTATUS        |
2945  *     | - NT_PRSINFO         |
2946  *     | - NT_AUXV            |
2947  *     +----------------------+ <-- aligned to target page
2948  *     | Process memory dump  |
2949  *     :                      :
2950  *     .                      .
2951  *     :                      :
2952  *     |                      |
2953  *     +----------------------+
2954  *
2955  * NT_PRSTATUS -> struct elf_prstatus (per thread)
2956  * NT_PRSINFO  -> struct elf_prpsinfo
2957  * NT_AUXV is array of { type, value } pairs (see fill_auxv_note()).
2958  *
2959  * Format follows System V format as close as possible.  Current
2960  * version limitations are as follows:
2961  *     - no floating point registers are dumped
2962  *
2963  * Function returns 0 in case of success, negative errno otherwise.
2964  *
2965  * TODO: make this work also during runtime: it should be
2966  * possible to force coredump from running process and then
2967  * continue processing.  For example qemu could set up SIGUSR2
2968  * handler (provided that target process haven't registered
2969  * handler for that) that does the dump when signal is received.
2970  */
2971 static int elf_core_dump(int signr, const CPUArchState *env)
2972 {
2973     const CPUState *cpu = ENV_GET_CPU((CPUArchState *)env);
2974     const TaskState *ts = (const TaskState *)cpu->opaque;
2975     struct vm_area_struct *vma = NULL;
2976     char corefile[PATH_MAX];
2977     struct elf_note_info info;
2978     struct elfhdr elf;
2979     struct elf_phdr phdr;
2980     struct rlimit dumpsize;
2981     struct mm_struct *mm = NULL;
2982     off_t offset = 0, data_offset = 0;
2983     int segs = 0;
2984     int fd = -1;
2985
2986     init_note_info(&info);
2987
2988     errno = 0;
2989     getrlimit(RLIMIT_CORE, &dumpsize);
2990     if (dumpsize.rlim_cur == 0)
2991         return 0;
2992
2993     if (core_dump_filename(ts, corefile, sizeof (corefile)) < 0)
2994         return (-errno);
2995
2996     if ((fd = open(corefile, O_WRONLY | O_CREAT,
2997                    S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
2998         return (-errno);
2999
3000     /*
3001      * Walk through target process memory mappings and
3002      * set up structure containing this information.  After
3003      * this point vma_xxx functions can be used.
3004      */
3005     if ((mm = vma_init()) == NULL)
3006         goto out;
3007
3008     walk_memory_regions(mm, vma_walker);
3009     segs = vma_get_mapping_count(mm);
3010
3011     /*
3012      * Construct valid coredump ELF header.  We also
3013      * add one more segment for notes.
3014      */
3015     fill_elf_header(&elf, segs + 1, ELF_MACHINE, 0);
3016     if (dump_write(fd, &elf, sizeof (elf)) != 0)
3017         goto out;
3018
3019     /* fill in the in-memory version of notes */
3020     if (fill_note_info(&info, signr, env) < 0)
3021         goto out;
3022
3023     offset += sizeof (elf);                             /* elf header */
3024     offset += (segs + 1) * sizeof (struct elf_phdr);    /* program headers */
3025
3026     /* write out notes program header */
3027     fill_elf_note_phdr(&phdr, info.notes_size, offset);
3028
3029     offset += info.notes_size;
3030     if (dump_write(fd, &phdr, sizeof (phdr)) != 0)
3031         goto out;
3032
3033     /*
3034      * ELF specification wants data to start at page boundary so
3035      * we align it here.
3036      */
3037     data_offset = offset = roundup(offset, ELF_EXEC_PAGESIZE);
3038
3039     /*
3040      * Write program headers for memory regions mapped in
3041      * the target process.
3042      */
3043     for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
3044         (void) memset(&phdr, 0, sizeof (phdr));
3045
3046         phdr.p_type = PT_LOAD;
3047         phdr.p_offset = offset;
3048         phdr.p_vaddr = vma->vma_start;
3049         phdr.p_paddr = 0;
3050         phdr.p_filesz = vma_dump_size(vma);
3051         offset += phdr.p_filesz;
3052         phdr.p_memsz = vma->vma_end - vma->vma_start;
3053         phdr.p_flags = vma->vma_flags & PROT_READ ? PF_R : 0;
3054         if (vma->vma_flags & PROT_WRITE)
3055             phdr.p_flags |= PF_W;
3056         if (vma->vma_flags & PROT_EXEC)
3057             phdr.p_flags |= PF_X;
3058         phdr.p_align = ELF_EXEC_PAGESIZE;
3059
3060         bswap_phdr(&phdr, 1);
3061         if (dump_write(fd, &phdr, sizeof(phdr)) != 0) {
3062             goto out;
3063         }
3064     }
3065
3066     /*
3067      * Next we write notes just after program headers.  No
3068      * alignment needed here.
3069      */
3070     if (write_note_info(&info, fd) < 0)
3071         goto out;
3072
3073     /* align data to page boundary */
3074     if (lseek(fd, data_offset, SEEK_SET) != data_offset)
3075         goto out;
3076
3077     /*
3078      * Finally we can dump process memory into corefile as well.
3079      */
3080     for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
3081         abi_ulong addr;
3082         abi_ulong end;
3083
3084         end = vma->vma_start + vma_dump_size(vma);
3085
3086         for (addr = vma->vma_start; addr < end;
3087              addr += TARGET_PAGE_SIZE) {
3088             char page[TARGET_PAGE_SIZE];
3089             int error;
3090
3091             /*
3092              *  Read in page from target process memory and
3093              *  write it to coredump file.
3094              */
3095             error = copy_from_user(page, addr, sizeof (page));
3096             if (error != 0) {
3097                 (void) fprintf(stderr, "unable to dump " TARGET_ABI_FMT_lx "\n",
3098                                addr);
3099                 errno = -error;
3100                 goto out;
3101             }
3102             if (dump_write(fd, page, TARGET_PAGE_SIZE) < 0)
3103                 goto out;
3104         }
3105     }
3106
3107  out:
3108     free_note_info(&info);
3109     if (mm != NULL)
3110         vma_delete(mm);
3111     (void) close(fd);
3112
3113     if (errno != 0)
3114         return (-errno);
3115     return (0);
3116 }
3117 #endif /* USE_ELF_CORE_DUMP */
3118
3119 void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
3120 {
3121     init_thread(regs, infop);
3122 }