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