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