linux-user/elfload.c

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