]> 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
Fix typo in comment (truely -> truly)
[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
80f5ce75
LV		 106typedef target_ushort target_uid_t;
107typedef target_ushort target_gid_t;
21e807fa 108#else
80f5ce75
LV		 109typedef target_uint target_uid_t;
110typedef target_uint target_gid_t;
21e807fa 111#endif
80f5ce75 112typedef target_int 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
d2fbca94
GX		 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
352static 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
368typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
369
370static 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
853d6f7a 416#ifdef TARGET_SPARC
a315a145 417#ifdef TARGET_SPARC64
853d6f7a
FB		 418
419#define ELF_START_MMAP 0x80000000
420
992f48a0 421#ifndef TARGET_ABI32
cb33da57 422#define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS )
992f48a0
BS		 423#else
424#define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC )
425#endif
853d6f7a 426
a315a145 427#define ELF_CLASS ELFCLASS64
5ef54116
FB		 428#define ELF_ARCH EM_SPARCV9
429
d97ef72e 430#define STACK_BIAS 2047
a315a145 431
d97ef72e
RH		 432static inline void init_thread(struct target_pt_regs *regs,
433 struct image_info *infop)
a315a145 434{
992f48a0 435#ifndef TARGET_ABI32
a315a145 436 regs->tstate = 0;
992f48a0 437#endif
a315a145
FB		 438 regs->pc = infop->entry;
439 regs->npc = regs->pc + 4;
440 regs->y = 0;
992f48a0
BS		 441#ifdef TARGET_ABI32
442 regs->u_regs[14] = infop->start_stack - 16 * 4;
443#else
cb33da57
BS		 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;
992f48a0 448#endif
a315a145
FB		 449}
450
451#else
452#define ELF_START_MMAP 0x80000000
453
454#define elf_check_arch(x) ( (x) == EM_SPARC )
455
853d6f7a 456#define ELF_CLASS ELFCLASS32
853d6f7a
FB		 457#define ELF_ARCH EM_SPARC
458
d97ef72e
RH		 459static inline void init_thread(struct target_pt_regs *regs,
460 struct image_info *infop)
853d6f7a 461{
f5155289
FB		 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;
853d6f7a
FB		 467}
468
a315a145 469#endif
853d6f7a
FB		 470#endif
471
67867308
FB		 472#ifdef TARGET_PPC
473
474#define ELF_START_MMAP 0x80000000
475
e85e7c6e 476#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
84409ddb
JM		 477
478#define elf_check_arch(x) ( (x) == EM_PPC64 )
479
d97ef72e 480#define ELF_CLASS ELFCLASS64
84409ddb
JM		 481
482#else
483
67867308
FB		 484#define elf_check_arch(x) ( (x) == EM_PPC )
485
d97ef72e 486#define ELF_CLASS ELFCLASS32
84409ddb
JM		 487
488#endif
489
d97ef72e 490#define ELF_ARCH EM_PPC
67867308 491
df84e4f3
NF		 492/* Feature masks for the Aux Vector Hardware Capabilities (AT_HWCAP).
493 See arch/powerpc/include/asm/cputable.h. */
494enum {
3efa9a67 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,
df84e4f3
NF		 524};
525
526#define ELF_HWCAP get_elf_hwcap()
527
528static 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. */
d97ef72e 535#define GET_FEATURE(flag, feature) \
df84e4f3 536 do {if (e->insns_flags & flag) features |= feature; } while(0)
3efa9a67 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);
df84e4f3
NF		 545#undef GET_FEATURE
546
547 return features;
548}
549
f5155289
FB		 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 */
0bccf03d 559#define DLINFO_ARCH_ITEMS 5
d97ef72e
RH		 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)
f5155289 571
67867308
FB		 572static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
573{
67867308 574 _regs->gpr[1] = infop->start_stack;
e85e7c6e 575#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
7983f435
RL		 576 _regs->gpr[2] = ldq_raw(infop->entry + 8) + infop->load_addr;
577 infop->entry = ldq_raw(infop->entry) + infop->load_addr;
84409ddb 578#endif
67867308
FB		 579 _regs->nip = infop->entry;
580}
581
e2f3e741
NF		 582/* See linux kernel: arch/powerpc/include/asm/elf.h. */
583#define ELF_NREG 48
584typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
585
586static 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
d97ef72e 608#define ELF_EXEC_PAGESIZE 4096
67867308
FB		 609
610#endif
611
048f6b4d
FB		 612#ifdef TARGET_MIPS
613
614#define ELF_START_MMAP 0x80000000
615
616#define elf_check_arch(x) ( (x) == EM_MIPS )
617
388bb21a
TS		 618#ifdef TARGET_MIPS64
619#define ELF_CLASS ELFCLASS64
620#else
048f6b4d 621#define ELF_CLASS ELFCLASS32
388bb21a 622#endif
048f6b4d
FB		 623#define ELF_ARCH EM_MIPS
624
d97ef72e
RH		 625static inline void init_thread(struct target_pt_regs *regs,
626 struct image_info *infop)
048f6b4d 627{
623a930e 628 regs->cp0_status = 2 << CP0St_KSU;
048f6b4d
FB		 629 regs->cp0_epc = infop->entry;
630 regs->regs[29] = infop->start_stack;
631}
632
51e52606
NF		 633/* See linux kernel: arch/mips/include/asm/elf.h. */
634#define ELF_NREG 45
635typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
636
637/* See linux kernel: arch/mips/include/asm/reg.h. */
638enum {
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. */
655static 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
388bb21a
TS		 679#define ELF_EXEC_PAGESIZE 4096
680
048f6b4d
FB		 681#endif /* TARGET_MIPS */
682
b779e29e
EI		 683#ifdef TARGET_MICROBLAZE
684
685#define ELF_START_MMAP 0x80000000
686
0d5d4699 687#define elf_check_arch(x) ( (x) == EM_MICROBLAZE || (x) == EM_MICROBLAZE_OLD)
b779e29e
EI		 688
689#define ELF_CLASS ELFCLASS32
0d5d4699 690#define ELF_ARCH EM_MICROBLAZE
b779e29e 691
d97ef72e
RH		 692static inline void init_thread(struct target_pt_regs *regs,
693 struct image_info *infop)
b779e29e
EI		 694{
695 regs->pc = infop->entry;
696 regs->r1 = infop->start_stack;
697
698}
699
b779e29e
EI		 700#define ELF_EXEC_PAGESIZE 4096
701
e4cbd44d
EI		 702#define USE_ELF_CORE_DUMP
703#define ELF_NREG 38
704typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
705
706/* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs. */
707static 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
b779e29e
EI		 720#endif /* TARGET_MICROBLAZE */
721
fdf9b3e8
FB		 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
fdf9b3e8
FB		 729#define ELF_ARCH EM_SH
730
d97ef72e
RH		 731static inline void init_thread(struct target_pt_regs *regs,
732 struct image_info *infop)
fdf9b3e8 733{
d97ef72e
RH		 734 /* Check other registers XXXXX */
735 regs->pc = infop->entry;
736 regs->regs[15] = infop->start_stack;
fdf9b3e8
FB		 737}
738
7631c97e
NF		 739/* See linux kernel: arch/sh/include/asm/elf.h. */
740#define ELF_NREG 23
741typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
742
743/* See linux kernel: arch/sh/include/asm/ptrace.h. */
744enum {
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
d97ef72e
RH		 754static inline void elf_core_copy_regs(target_elf_gregset_t *regs,
755 const CPUState *env)
7631c97e
NF		 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
fdf9b3e8
FB		 773#define ELF_EXEC_PAGESIZE 4096
774
775#endif
776
48733d19
TS		 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
48733d19
TS		 784#define ELF_ARCH EM_CRIS
785
d97ef72e
RH		 786static inline void init_thread(struct target_pt_regs *regs,
787 struct image_info *infop)
48733d19 788{
d97ef72e 789 regs->erp = infop->entry;
48733d19
TS		 790}
791
48733d19
TS		 792#define ELF_EXEC_PAGESIZE 8192
793
794#endif
795
e6e5906b
PB		 796#ifdef TARGET_M68K
797
798#define ELF_START_MMAP 0x80000000
799
800#define elf_check_arch(x) ( (x) == EM_68K )
801
d97ef72e 802#define ELF_CLASS ELFCLASS32
d97ef72e 803#define ELF_ARCH EM_68K
e6e5906b
PB		 804
805/* ??? Does this need to do anything?
d97ef72e 806 #define ELF_PLAT_INIT(_r) */
e6e5906b 807
d97ef72e
RH		 808static inline void init_thread(struct target_pt_regs *regs,
809 struct image_info *infop)
e6e5906b
PB		 810{
811 regs->usp = infop->start_stack;
812 regs->sr = 0;
813 regs->pc = infop->entry;
814}
815
7a93cc55
NF		 816/* See linux kernel: arch/m68k/include/asm/elf.h. */
817#define ELF_NREG 20
818typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
819
820static 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
d97ef72e 845#define ELF_EXEC_PAGESIZE 8192
e6e5906b
PB		 846
847#endif
848
7a3148a9
JM		 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
7a3148a9
JM		 856#define ELF_ARCH EM_ALPHA
857
d97ef72e
RH		 858static inline void init_thread(struct target_pt_regs *regs,
859 struct image_info *infop)
7a3148a9
JM		 860{
861 regs->pc = infop->entry;
862 regs->ps = 8;
863 regs->usp = infop->start_stack;
7a3148a9
JM		 864}
865
7a3148a9
JM		 866#define ELF_EXEC_PAGESIZE 8192
867
868#endif /* TARGET_ALPHA */
869
15338fd7
FB		 870#ifndef ELF_PLATFORM
871#define ELF_PLATFORM (NULL)
872#endif
873
874#ifndef ELF_HWCAP
875#define ELF_HWCAP 0
876#endif
877
992f48a0 878#ifdef TARGET_ABI32
cb33da57 879#undef ELF_CLASS
992f48a0 880#define ELF_CLASS ELFCLASS32
cb33da57
BS		 881#undef bswaptls
882#define bswaptls(ptr) bswap32s(ptr)
883#endif
884
31e31b8a 885#include "elf.h"
09bfb054 886
09bfb054
FB		 887struct exec
888{
d97ef72e
RH		 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 */
09bfb054
FB		 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
31e31b8a 906/* Necessary parameters */
54936004
FB		 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))
31e31b8a 910
15338fd7 911#define DLINFO_ITEMS 12
31e31b8a 912
09bfb054
FB		 913static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
914{
d97ef72e 915 memcpy(to, from, n);
09bfb054 916}
d691f669 917
31e31b8a 918#ifdef BSWAP_NEEDED
92a31b1f 919static void bswap_ehdr(struct elfhdr *ehdr)
31e31b8a 920{
d97ef72e
RH		 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 */
31e31b8a
FB		 934}
935
991f8f0c 936static void bswap_phdr(struct elf_phdr *phdr, int phnum)
31e31b8a 937{
991f8f0c
RH		 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 }
31e31b8a 949}
689f936f 950
991f8f0c 951static void bswap_shdr(struct elf_shdr *shdr, int shnum)
689f936f 952{
991f8f0c
RH		 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 }
689f936f
FB		 966}
967
7a3148a9 968static void bswap_sym(struct elf_sym *sym)
689f936f
FB		 969{
970 bswap32s(&sym->st_name);
7a3148a9
JM		 971 bswaptls(&sym->st_value);
972 bswaptls(&sym->st_size);
689f936f
FB		 973 bswap16s(&sym->st_shndx);
974}
991f8f0c
RH		 975#else
976static inline void bswap_ehdr(struct elfhdr *ehdr) { }
977static inline void bswap_phdr(struct elf_phdr *phdr, int phnum) { }
978static inline void bswap_shdr(struct elf_shdr *shdr, int shnum) { }
979static inline void bswap_sym(struct elf_sym *sym) { }
31e31b8a
FB		 980#endif
981
edf8e2af
MW		 982#ifdef USE_ELF_CORE_DUMP
983static int elf_core_dump(int, const CPUState *);
edf8e2af 984#endif /* USE_ELF_CORE_DUMP */
682674b8 985static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias);
edf8e2af 986
9058abdd
RH		 987/* Verify the portions of EHDR within E_IDENT for the target.
988 This can be performed before bswapping the entire header. */
989static 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. */
1002static 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
31e31b8a 1011/*
e5fe0c52 1012 * 'copy_elf_strings()' copies argument/envelope strings from user
31e31b8a
FB		 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 */
992f48a0
BS		 1017static abi_ulong copy_elf_strings(int argc,char ** argv, void **page,
1018 abi_ulong p)
31e31b8a
FB		 1019{
1020 char *tmp, *tmp1, *pag = NULL;
1021 int len, offset = 0;
1022
1023 if (!p) {
d97ef72e 1024 return 0; /* bullet-proofing */
31e31b8a
FB		 1025 }
1026 while (argc-- > 0) {
edf779ff
FB		 1027 tmp = argv[argc];
1028 if (!tmp) {
d97ef72e
RH		 1029 fprintf(stderr, "VFS: argc is wrong");
1030 exit(-1);
1031 }
edf779ff 1032 tmp1 = tmp;
d97ef72e
RH		 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;
53a5960a 1042 pag = (char *)page[p/TARGET_PAGE_SIZE];
44a91cae 1043 if (!pag) {
53a5960a 1044 pag = (char *)malloc(TARGET_PAGE_SIZE);
4118a970 1045 memset(pag, 0, TARGET_PAGE_SIZE);
53a5960a 1046 page[p/TARGET_PAGE_SIZE] = pag;
44a91cae
FB		 1047 if (!pag)
1048 return 0;
d97ef72e
RH		 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 }
31e31b8a
FB		 1063 }
1064 return p;
1065}
1066
992f48a0
BS		 1067static abi_ulong setup_arg_pages(abi_ulong p, struct linux_binprm *bprm,
1068 struct image_info *info)
53a5960a 1069{
60dcbcb5 1070 abi_ulong stack_base, size, error, guard;
31e31b8a 1071 int i;
31e31b8a 1072
09bfb054 1073 /* Create enough stack to hold everything. If we don't use
60dcbcb5 1074 it for args, we'll use it for something else. */
703e0e89 1075 size = guest_stack_size;
60dcbcb5 1076 if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE) {
54936004 1077 size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;
60dcbcb5
RH		 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);
09bfb054 1086 if (error == -1) {
60dcbcb5 1087 perror("mmap stack");
09bfb054
FB		 1088 exit(-1);
1089 }
31e31b8a 1090
60dcbcb5
RH		 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;
31e31b8a 1096 p += stack_base;
09bfb054 1097
31e31b8a 1098 for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
d97ef72e
RH		 1099 if (bprm->page[i]) {
1100 info->rss++;
579a97f7 1101 /* FIXME - check return value of memcpy_to_target() for failure */
d97ef72e
RH		 1102 memcpy_to_target(stack_base, bprm->page[i], TARGET_PAGE_SIZE);
1103 free(bprm->page[i]);
1104 }
53a5960a 1105 stack_base += TARGET_PAGE_SIZE;
31e31b8a
FB		 1106 }
1107 return p;
1108}
1109
cf129f3a
RH		 1110/* Map and zero the bss. We need to explicitly zero any fractional pages
1111 after the data section (i.e. bss). */
1112static void zero_bss(abi_ulong elf_bss, abi_ulong last_bss, int prot)
31e31b8a 1113{
cf129f3a
RH		 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);
853d6f7a
FB		 1140 }
1141
cf129f3a
RH		 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 }
31e31b8a 1146
cf129f3a
RH		 1147 if (host_start < host_map_start) {
1148 memset((void *)host_start, 0, host_map_start - host_start);
1149 }
1150}
53a5960a 1151
1af02e83
MF		 1152#ifdef CONFIG_USE_FDPIC
1153static 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
992f48a0 1179static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,
8e62a717
RH		 1180 struct elfhdr *exec,
1181 struct image_info *info,
1182 struct image_info *interp_info)
31e31b8a 1183{
d97ef72e
RH		 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;
1af02e83
MF		 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
d97ef72e
RH		 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;
f5155289 1222#ifdef DLINFO_ARCH_ITEMS
d97ef72e 1223 size += DLINFO_ARCH_ITEMS * 2;
f5155289 1224#endif
d97ef72e 1225 size += envc + argc + 2;
b9329d4b 1226 size += 1; /* argc itself */
d97ef72e
RH		 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. */
8e62a717 1242 NEW_AUX_ENT(AT_PHDR, (abi_ulong)(info->load_addr + exec->e_phoff));
d97ef72e
RH		 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));
8e62a717 1246 NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_info ? interp_info->load_addr : 0));
d97ef72e 1247 NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);
8e62a717 1248 NEW_AUX_ENT(AT_ENTRY, info->entry);
d97ef72e
RH		 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);
f5155289 1257#ifdef ARCH_DLINFO
d97ef72e
RH		 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;
f5155289
FB		 1263#endif
1264#undef NEW_AUX_ENT
1265
d97ef72e 1266 info->saved_auxv = sp;
edf8e2af 1267
b9329d4b 1268 sp = loader_build_argptr(envc, argc, sp, p, 0);
d97ef72e 1269 return sp;
31e31b8a
FB		 1270}
1271
8e62a717 1272/* Load an ELF image into the address space.
31e31b8a 1273
8e62a717
RH		 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
1284static void load_elf_image(const char *image_name, int image_fd,
bf858897 1285 struct image_info *info, char **pinterp_name,
8e62a717 1286 char bprm_buf[BPRM_BUF_SIZE])
31e31b8a 1287{
8e62a717
RH		 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;
5fafdf24 1293
8e62a717
RH		 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;
d97ef72e 1302 }
5fafdf24 1303
8e62a717
RH		 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);
9955ffac 1307 } else {
8e62a717
RH		 1308 phdr = (struct elf_phdr *) alloca(i);
1309 retval = pread(image_fd, phdr, i, ehdr->e_phoff);
9955ffac 1310 if (retval != i) {
8e62a717 1311 goto exit_read;
9955ffac 1312 }
d97ef72e 1313 }
8e62a717 1314 bswap_phdr(phdr, ehdr->e_phnum);
09bfb054 1315
1af02e83
MF		 1316#ifdef CONFIG_USE_FDPIC
1317 info->nsegs = 0;
1318 info->pt_dynamic_addr = 0;
1319#endif
1320
682674b8
RH		 1321 /* Find the maximum size of the image and allocate an appropriate
1322 amount of memory to handle that. */
1323 loaddr = -1, hiaddr = 0;
8e62a717
RH		 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;
682674b8
RH		 1327 if (a < loaddr) {
1328 loaddr = a;
1329 }
8e62a717 1330 a += phdr[i].p_memsz;
682674b8
RH		 1331 if (a > hiaddr) {
1332 hiaddr = a;
1333 }
1af02e83
MF		 1334#ifdef CONFIG_USE_FDPIC
1335 ++info->nsegs;
1336#endif
682674b8
RH		 1337 }
1338 }
1339
1340 load_addr = loaddr;
8e62a717 1341 if (ehdr->e_type == ET_DYN) {
682674b8
RH		 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) {
8e62a717 1351 goto exit_perror;
d97ef72e 1352 }
bf858897
RH		 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
d97ef72e 1414 }
682674b8 1415 load_bias = load_addr - loaddr;
d97ef72e 1416
1af02e83
MF		 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
8e62a717
RH		 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;
d97ef72e 1449 if (eppnt->p_type == PT_LOAD) {
682674b8 1450 abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em;
d97ef72e 1451 int elf_prot = 0;
d97ef72e
RH		 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;
d97ef72e 1456
682674b8
RH		 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,
8e62a717 1463 image_fd, eppnt->p_offset - vaddr_po);
09bfb054 1464 if (error == -1) {
8e62a717 1465 goto exit_perror;
09bfb054 1466 }
09bfb054 1467
682674b8
RH		 1468 vaddr_ef = vaddr + eppnt->p_filesz;
1469 vaddr_em = vaddr + eppnt->p_memsz;
31e31b8a 1470
cf129f3a 1471 /* If the load segment requests extra zeros (e.g. bss), map it. */
682674b8
RH		 1472 if (vaddr_ef < vaddr_em) {
1473 zero_bss(vaddr_ef, vaddr_em, elf_prot);
cf129f3a 1474 }
8e62a717
RH		 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 }
bf858897
RH		 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;
d97ef72e 1523 }
682674b8 1524 }
5fafdf24 1525
8e62a717
RH		 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
682674b8 1532 if (qemu_log_enabled()) {
8e62a717 1533 load_symbols(ehdr, image_fd, load_bias);
682674b8 1534 }
31e31b8a 1535
8e62a717
RH		 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
1551static 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 }
31e31b8a 1560
8e62a717
RH		 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
bf858897 1569 load_elf_image(filename, fd, info, NULL, bprm_buf);
8e62a717
RH		 1570 return;
1571
1572 exit_perror:
1573 fprintf(stderr, "%s: %s\n", filename, strerror(errno));
1574 exit(-1);
31e31b8a
FB		 1575}
1576
49918a75
PB		 1577static 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;
ec822001 1584 } else if (key->st_value >= sym->st_value + sym->st_size) {
49918a75
PB		 1585 result = 1;
1586 }
1587 return result;
1588}
1589
1590static 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);
7cba04f6 1605 if (sym != NULL) {
49918a75
PB		 1606 return s->disas_strtab + sym->st_name;
1607 }
1608
1609 return "";
1610}
1611
1612/* FIXME: This should use elf_ops.h */
1613static 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
689f936f 1622/* Best attempt to load symbols from this ELF object. */
682674b8 1623static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias)
689f936f 1624{
682674b8
RH		 1625 int i, shnum, nsyms, sym_idx = 0, str_idx = 0;
1626 struct elf_shdr *shdr;
689f936f 1627 char *strings;
e80cfcfc 1628 struct syminfo *s;
8d79de6e 1629 struct elf_sym *syms, *new_syms;
689f936f 1630
682674b8
RH		 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;
49918a75
PB		 1643 goto found;
1644 }
689f936f 1645 }
682674b8
RH		 1646
1647 /* There will be no symbol table if the file was stripped. */
1648 return;
689f936f
FB		 1649
1650 found:
682674b8 1651 /* Now know where the strtab and symtab are. Snarf them. */
e80cfcfc 1652 s = malloc(sizeof(*s));
682674b8 1653 if (!s) {
49918a75 1654 return;
682674b8 1655 }
5fafdf24 1656
682674b8
RH		 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);
49918a75 1662 return;
682674b8 1663 }
49918a75 1664
682674b8
RH		 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 }
31e31b8a 1673
682674b8
RH		 1674 nsyms = i / sizeof(struct elf_sym);
1675 for (i = 0; i < nsyms; ) {
49918a75 1676 bswap_sym(syms + i);
682674b8
RH		 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) {
49918a75
PB		 1682 syms[i] = syms[nsyms];
1683 }
682674b8 1684 } else {
49918a75 1685#if defined(TARGET_ARM) || defined (TARGET_MIPS)
682674b8
RH		 1686 /* The bottom address bit marks a Thumb or MIPS16 symbol. */
1687 syms[i].st_value &= ~(target_ulong)1;
0774bed1 1688#endif
682674b8
RH		 1689 syms[i].st_value += load_bias;
1690 i++;
1691 }
0774bed1 1692 }
49918a75 1693
5d5c9930
RH		 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. */
8d79de6e
SW		 1698 new_syms = realloc(syms, nsyms * sizeof(*syms));
1699 if (new_syms == NULL) {
5d5c9930 1700 free(s);
8d79de6e 1701 free(syms);
5d5c9930
RH		 1702 free(strings);
1703 return;
1704 }
8d79de6e 1705 syms = new_syms;
5d5c9930 1706
49918a75 1707 qsort(syms, nsyms, sizeof(*syms), symcmp);
689f936f 1708
49918a75
PB		 1709 s->disas_num_syms = nsyms;
1710#if ELF_CLASS == ELFCLASS32
1711 s->disas_symtab.elf32 = syms;
49918a75
PB		 1712#else
1713 s->disas_symtab.elf64 = syms;
49918a75 1714#endif
682674b8 1715 s->lookup_symbol = lookup_symbolxx;
e80cfcfc
FB		 1716 s->next = syminfos;
1717 syminfos = s;
689f936f 1718}
31e31b8a 1719
e5fe0c52
PB		 1720int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
1721 struct image_info * info)
31e31b8a 1722{
8e62a717 1723 struct image_info interp_info;
31e31b8a 1724 struct elfhdr elf_ex;
8e62a717 1725 char *elf_interpreter = NULL;
31e31b8a 1726
bf858897
RH		 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);
31e31b8a 1733
bf858897
RH		 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;
31e31b8a 1738
e5fe0c52
PB		 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) {
bf858897
RH		 1743 fprintf(stderr, "%s: %s\n", bprm->filename, strerror(E2BIG));
1744 exit(-1);
379f6698 1745 }
379f6698 1746
31e31b8a
FB		 1747 /* Do this so that we can load the interpreter, if need be. We will
1748 change some of these later */
31e31b8a 1749 bprm->p = setup_arg_pages(bprm->p, bprm, info);
31e31b8a 1750
8e62a717
RH		 1751 if (elf_interpreter) {
1752 load_elf_interp(elf_interpreter, &interp_info, bprm->buf);
31e31b8a 1753
8e62a717
RH		 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;
31e31b8a 1760
8e62a717
RH		 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 }
31e31b8a
FB		 1768 }
1769
8e62a717
RH		 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;
bf858897 1781 free(elf_interpreter);
8e62a717 1782 }
31e31b8a 1783
edf8e2af
MW		 1784#ifdef USE_ELF_CORE_DUMP
1785 bprm->core_dump = &elf_core_dump;
1786#endif
1787
31e31b8a
FB		 1788 return 0;
1789}
1790
edf8e2af 1791#ifdef USE_ELF_CORE_DUMP
edf8e2af
MW		 1792/*
1793 * Definitions to generate Intel SVR4-like core files.
a2547a13 1794 * These mostly have the same names as the SVR4 types with "target_elf_"
edf8e2af
MW		 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
dd0a3651 1806 * define USE_ELF_CORE_DUMP in target ELF code (where init_thread() for
edf8e2af
MW		 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 *
c227f099 1814 * typedef <target_regtype> target_elf_greg_t;
edf8e2af 1815 * #define ELF_NREG <number of registers>
c227f099 1816 * typedef taret_elf_greg_t target_elf_gregset_t[ELF_NREG];
edf8e2af 1817 *
edf8e2af
MW		 1818 * Last step is to implement target specific function that copies registers
1819 * from given cpu into just specified register set. Prototype is:
1820 *
c227f099 1821 * static void elf_core_copy_regs(taret_elf_gregset_t *regs,
a2547a13 1822 * const CPUState *env);
edf8e2af
MW		 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 */
1832struct memelfnote {
1833 const char *name;
1834 size_t namesz;
1835 size_t namesz_rounded;
1836 int type;
1837 size_t datasz;
80f5ce75 1838 size_t datasz_rounded;
edf8e2af
MW		 1839 void *data;
1840 size_t notesz;
1841};
1842
a2547a13 1843struct target_elf_siginfo {
80f5ce75
LV		 1844 target_int si_signo; /* signal number */
1845 target_int si_code; /* extra code */
1846 target_int si_errno; /* errno */
edf8e2af
MW		 1847};
1848
a2547a13
LD		 1849struct target_elf_prstatus {
1850 struct target_elf_siginfo pr_info; /* Info associated with signal */
80f5ce75 1851 target_short pr_cursig; /* Current signal */
edf8e2af
MW		 1852 target_ulong pr_sigpend; /* XXX */
1853 target_ulong pr_sighold; /* XXX */
c227f099
AL		 1854 target_pid_t pr_pid;
1855 target_pid_t pr_ppid;
1856 target_pid_t pr_pgrp;
1857 target_pid_t pr_sid;
edf8e2af
MW		 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 */
c227f099 1862 target_elf_gregset_t pr_reg; /* GP registers */
80f5ce75 1863 target_int pr_fpvalid; /* XXX */
edf8e2af
MW		 1864};
1865
1866#define ELF_PRARGSZ (80) /* Number of chars for args */
1867
a2547a13 1868struct target_elf_prpsinfo {
edf8e2af
MW		 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 */
c227f099
AL		 1874 target_uid_t pr_uid;
1875 target_gid_t pr_gid;
1876 target_pid_t pr_pid, pr_ppid, pr_pgrp, pr_sid;
edf8e2af
MW		 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. */
1883struct elf_thread_status {
72cf2d4f 1884 QTAILQ_ENTRY(elf_thread_status) ets_link;
a2547a13 1885 struct target_elf_prstatus prstatus; /* NT_PRSTATUS */
edf8e2af
MW		 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
1895struct elf_note_info {
1896 struct memelfnote *notes;
a2547a13
LD		 1897 struct target_elf_prstatus *prstatus; /* NT_PRSTATUS */
1898 struct target_elf_prpsinfo *psinfo; /* NT_PRPSINFO */
edf8e2af 1899
72cf2d4f 1900 QTAILQ_HEAD(thread_list_head, elf_thread_status) thread_list;
edf8e2af
MW		 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
1914struct 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 */
72cf2d4f 1918 QTAILQ_ENTRY(vm_area_struct) vma_link;
edf8e2af
MW		 1919};
1920
1921struct mm_struct {
72cf2d4f 1922 QTAILQ_HEAD(, vm_area_struct) mm_mmap;
edf8e2af
MW		 1923 int mm_count; /* number of mappings */
1924};
1925
1926static struct mm_struct *vma_init(void);
1927static void vma_delete(struct mm_struct *);
1928static int vma_add_mapping(struct mm_struct *, abi_ulong,
d97ef72e 1929 abi_ulong, abi_ulong);
edf8e2af
MW		 1930static int vma_get_mapping_count(const struct mm_struct *);
1931static struct vm_area_struct *vma_first(const struct mm_struct *);
1932static struct vm_area_struct *vma_next(struct vm_area_struct *);
1933static abi_ulong vma_dump_size(const struct vm_area_struct *);
b480d9b7 1934static int vma_walker(void *priv, abi_ulong start, abi_ulong end,
d97ef72e 1935 unsigned long flags);
edf8e2af
MW		 1936
1937static void fill_elf_header(struct elfhdr *, int, uint16_t, uint32_t);
1938static void fill_note(struct memelfnote *, const char *, int,
d97ef72e 1939 unsigned int, void *);
a2547a13
LD		 1940static void fill_prstatus(struct target_elf_prstatus *, const TaskState *, int);
1941static int fill_psinfo(struct target_elf_prpsinfo *, const TaskState *);
edf8e2af
MW		 1942static void fill_auxv_note(struct memelfnote *, const TaskState *);
1943static void fill_elf_note_phdr(struct elf_phdr *, int, off_t);
1944static size_t note_size(const struct memelfnote *);
1945static void free_note_info(struct elf_note_info *);
1946static int fill_note_info(struct elf_note_info *, long, const CPUState *);
1947static void fill_thread_info(struct elf_note_info *, const CPUState *);
1948static int core_dump_filename(const TaskState *, char *, size_t);
1949
1950static int dump_write(int, const void *, size_t);
1951static int write_note(struct memelfnote *, int);
1952static int write_note_info(struct elf_note_info *, int);
1953
1954#ifdef BSWAP_NEEDED
a2547a13 1955static void bswap_prstatus(struct target_elf_prstatus *prstatus)
edf8e2af
MW		 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
a2547a13 1972static void bswap_psinfo(struct target_elf_prpsinfo *psinfo)
edf8e2af
MW		 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}
991f8f0c
RH		 1982
1983static 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
1990static inline void bswap_prstatus(struct target_elf_prstatus *p) { }
1991static inline void bswap_psinfo(struct target_elf_prpsinfo *p) {}
1992static inline void bswap_note(struct elf_note *en) { }
edf8e2af
MW		 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
2002static 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;
72cf2d4f 2010 QTAILQ_INIT(&mm->mm_mmap);
edf8e2af
MW		 2011
2012 return (mm);
2013}
2014
2015static void vma_delete(struct mm_struct *mm)
2016{
2017 struct vm_area_struct *vma;
2018
2019 while ((vma = vma_first(mm)) != NULL) {
72cf2d4f 2020 QTAILQ_REMOVE(&mm->mm_mmap, vma, vma_link);
edf8e2af
MW		 2021 qemu_free(vma);
2022 }
2023 qemu_free(mm);
2024}
2025
2026static int vma_add_mapping(struct mm_struct *mm, abi_ulong start,
d97ef72e 2027 abi_ulong end, abi_ulong flags)
edf8e2af
MW		 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
72cf2d4f 2038 QTAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link);
edf8e2af
MW		 2039 mm->mm_count++;
2040
2041 return (0);
2042}
2043
2044static struct vm_area_struct *vma_first(const struct mm_struct *mm)
2045{
72cf2d4f 2046 return (QTAILQ_FIRST(&mm->mm_mmap));
edf8e2af
MW		 2047}
2048
2049static struct vm_area_struct *vma_next(struct vm_area_struct *vma)
2050{
72cf2d4f 2051 return (QTAILQ_NEXT(vma, vma_link));
edf8e2af
MW		 2052}
2053
2054static 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 */
2062static 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
b480d9b7 2095static int vma_walker(void *priv, abi_ulong start, abi_ulong end,
d97ef72e 2096 unsigned long flags)
edf8e2af
MW		 2097{
2098 struct mm_struct *mm = (struct mm_struct *)priv;
2099
edf8e2af
MW		 2100 vma_add_mapping(mm, start, end, flags);
2101 return (0);
2102}
2103
2104static void fill_note(struct memelfnote *note, const char *name, int type,
d97ef72e 2105 unsigned int sz, void *data)
edf8e2af
MW		 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;
80f5ce75
LV		 2114 note->datasz = sz;
2115 note->datasz_rounded = roundup(sz, sizeof (int32_t));
2116
edf8e2af
MW		 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) +
80f5ce75 2124 note->namesz_rounded + note->datasz_rounded;
edf8e2af
MW		 2125}
2126
2127static void fill_elf_header(struct elfhdr *elf, int segs, uint16_t machine,
d97ef72e 2128 uint32_t flags)
edf8e2af
MW		 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
edf8e2af 2147 bswap_ehdr(elf);
edf8e2af
MW		 2148}
2149
2150static 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
991f8f0c 2161 bswap_phdr(phdr, 1);
edf8e2af
MW		 2162}
2163
2164static size_t note_size(const struct memelfnote *note)
2165{
2166 return (note->notesz);
2167}
2168
a2547a13 2169static void fill_prstatus(struct target_elf_prstatus *prstatus,
d97ef72e 2170 const TaskState *ts, int signr)
edf8e2af
MW		 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
edf8e2af 2179 bswap_prstatus(prstatus);
edf8e2af
MW		 2180}
2181
a2547a13 2182static int fill_psinfo(struct target_elf_prpsinfo *psinfo, const TaskState *ts)
edf8e2af
MW		 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,
d97ef72e 2209 sizeof(psinfo->pr_fname));
edf8e2af
MW		 2210 free(base_filename);
2211 free(filename);
2212
edf8e2af 2213 bswap_psinfo(psinfo);
edf8e2af
MW		 2214 return (0);
2215}
2216
2217static 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 */
2255static int core_dump_filename(const TaskState *ts, char *buf,
d97ef72e 2256 size_t bufsize)
edf8e2af
MW		 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",
d97ef72e 2268 strerror(errno));
edf8e2af
MW		 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",
d97ef72e 2275 localtime_r(&tv.tv_sec, &tm));
edf8e2af 2276 (void) snprintf(buf, bufsize, "qemu_%s_%s_%d.core",
d97ef72e 2277 base_filename, timestamp, (int)getpid());
edf8e2af
MW		 2278 free(base_filename);
2279 free(filename);
2280
2281 return (0);
2282}
2283
2284static 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
2330static 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
edf8e2af 2338 bswap_note(&en);
edf8e2af
MW		 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);
80f5ce75 2344 if (dump_write(fd, men->data, men->datasz_rounded) != 0)
edf8e2af
MW		 2345 return (-1);
2346
2347 return (0);
2348}
2349
2350static 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),
d97ef72e 2360 &ets->prstatus);
edf8e2af 2361
72cf2d4f 2362 QTAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link);
edf8e2af
MW		 2363
2364 info->notes_size += note_size(&ets->notes[0]);
2365}
2366
2367static int fill_note_info(struct elf_note_info *info,
d97ef72e 2368 long signr, const CPUState *env)
edf8e2af
MW		 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
72cf2d4f 2377 QTAILQ_INIT(&info->thread_list);
edf8e2af
MW		 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,
d97ef72e 2396 sizeof (*info->prstatus), info->prstatus);
edf8e2af
MW		 2397 fill_psinfo(info->psinfo, ts);
2398 fill_note(&info->notes[1], "CORE", NT_PRPSINFO,
d97ef72e 2399 sizeof (*info->psinfo), info->psinfo);
edf8e2af
MW		 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
2419static void free_note_info(struct elf_note_info *info)
2420{
2421 struct elf_thread_status *ets;
2422
72cf2d4f
BS		 2423 while (!QTAILQ_EMPTY(&info->thread_list)) {
2424 ets = QTAILQ_FIRST(&info->thread_list);
2425 QTAILQ_REMOVE(&info->thread_list, ets, ets_link);
edf8e2af
MW		 2426 qemu_free(ets);
2427 }
2428
2429 qemu_free(info->prstatus);
2430 qemu_free(info->psinfo);
2431 qemu_free(info->notes);
2432}
2433
2434static 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;
d97ef72e 2446 ets = ets->ets_link.tqe_next) {
edf8e2af
MW		 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 */
2497static 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)
d97ef72e 2514 return 0;
edf8e2af
MW		 2515
2516 if (core_dump_filename(ts, corefile, sizeof (corefile)) < 0)
2517 return (-errno);
2518
2519 if ((fd = open(corefile, O_WRONLY | O_CREAT,
d97ef72e 2520 S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
edf8e2af
MW		 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 */
80f5ce75 2560 data_offset = offset = roundup(offset, ELF_EXEC_PAGESIZE);
edf8e2af
MW		 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
80f5ce75 2583 bswap_phdr(&phdr, 1);
edf8e2af
MW		 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 */
edf8e2af
MW		 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;
d97ef72e 2608 addr += TARGET_PAGE_SIZE) {
edf8e2af
MW		 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) {
49995e17 2618 (void) fprintf(stderr, "unable to dump " TARGET_ABI_FMT_lx "\n",
d97ef72e 2619 addr);
edf8e2af
MW		 2620 errno = -error;
2621 goto out;
2622 }
2623 if (dump_write(fd, page, TARGET_PAGE_SIZE) < 0)
2624 goto out;
2625 }
2626 }
2627
d97ef72e 2628 out:
edf8e2af
MW		 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}
edf8e2af
MW		 2638#endif /* USE_ELF_CORE_DUMP */
2639
e5fe0c52
PB		 2640void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
2641{
2642 init_thread(regs, infop);
2643}
Qemu copy for testing