blob: 6b622d4ff95741d72f628009980421f4d74d023c [file] [log] [blame]
bellard31e31b82003-02-18 22:55:36 +00001/* This is the Linux kernel elf-loading code, ported into user space */
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002#include <sys/time.h>
3#include <sys/param.h>
bellard31e31b82003-02-18 22:55:36 +00004
5#include <stdio.h>
6#include <sys/types.h>
7#include <fcntl.h>
bellard31e31b82003-02-18 22:55:36 +00008#include <errno.h>
9#include <unistd.h>
10#include <sys/mman.h>
Mika Westerbergedf8e2a2009-04-07 09:57:11 +030011#include <sys/resource.h>
bellard31e31b82003-02-18 22:55:36 +000012#include <stdlib.h>
13#include <string.h>
Mika Westerbergedf8e2a2009-04-07 09:57:11 +030014#include <time.h>
bellard31e31b82003-02-18 22:55:36 +000015
bellard3ef693a2003-03-23 20:17:16 +000016#include "qemu.h"
bellard689f9362003-04-29 20:40:07 +000017#include "disas.h"
bellard31e31b82003-02-18 22:55:36 +000018
malce58ffeb2009-01-14 18:39:49 +000019#ifdef _ARCH_PPC64
malca6cc84f2008-08-20 22:39:28 +000020#undef ARCH_DLINFO
21#undef ELF_PLATFORM
22#undef ELF_HWCAP
23#undef ELF_CLASS
24#undef ELF_DATA
25#undef ELF_ARCH
26#endif
27
Mika Westerbergedf8e2a2009-04-07 09:57:11 +030028#define ELF_OSABI ELFOSABI_SYSV
29
blueswir1cb33da52007-10-09 16:34:29 +000030/* from personality.h */
31
32/*
33 * Flags for bug emulation.
34 *
35 * These occupy the top three bytes.
36 */
37enum {
Richard Hendersond97ef722010-07-27 10:25:29 -070038 ADDR_NO_RANDOMIZE = 0x0040000, /* disable randomization of VA space */
39 FDPIC_FUNCPTRS = 0x0080000, /* userspace function ptrs point to
40 descriptors (signal handling) */
41 MMAP_PAGE_ZERO = 0x0100000,
42 ADDR_COMPAT_LAYOUT = 0x0200000,
43 READ_IMPLIES_EXEC = 0x0400000,
44 ADDR_LIMIT_32BIT = 0x0800000,
45 SHORT_INODE = 0x1000000,
46 WHOLE_SECONDS = 0x2000000,
47 STICKY_TIMEOUTS = 0x4000000,
48 ADDR_LIMIT_3GB = 0x8000000,
blueswir1cb33da52007-10-09 16:34:29 +000049};
50
51/*
52 * Personality types.
53 *
54 * These go in the low byte. Avoid using the top bit, it will
55 * conflict with error returns.
56 */
57enum {
Richard Hendersond97ef722010-07-27 10:25:29 -070058 PER_LINUX = 0x0000,
59 PER_LINUX_32BIT = 0x0000 | ADDR_LIMIT_32BIT,
60 PER_LINUX_FDPIC = 0x0000 | FDPIC_FUNCPTRS,
61 PER_SVR4 = 0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
62 PER_SVR3 = 0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
63 PER_SCOSVR3 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS | SHORT_INODE,
64 PER_OSR5 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
65 PER_WYSEV386 = 0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
66 PER_ISCR4 = 0x0005 | STICKY_TIMEOUTS,
67 PER_BSD = 0x0006,
68 PER_SUNOS = 0x0006 | STICKY_TIMEOUTS,
69 PER_XENIX = 0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
70 PER_LINUX32 = 0x0008,
71 PER_LINUX32_3GB = 0x0008 | ADDR_LIMIT_3GB,
72 PER_IRIX32 = 0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */
73 PER_IRIXN32 = 0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */
74 PER_IRIX64 = 0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */
75 PER_RISCOS = 0x000c,
76 PER_SOLARIS = 0x000d | STICKY_TIMEOUTS,
77 PER_UW7 = 0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
78 PER_OSF4 = 0x000f, /* OSF/1 v4 */
79 PER_HPUX = 0x0010,
80 PER_MASK = 0x00ff,
blueswir1cb33da52007-10-09 16:34:29 +000081};
82
83/*
84 * Return the base personality without flags.
85 */
Richard Hendersond97ef722010-07-27 10:25:29 -070086#define personality(pers) (pers & PER_MASK)
blueswir1cb33da52007-10-09 16:34:29 +000087
bellard83fb7ad2004-07-05 21:25:26 +000088/* this flag is uneffective under linux too, should be deleted */
89#ifndef MAP_DENYWRITE
90#define MAP_DENYWRITE 0
91#endif
92
93/* should probably go in elf.h */
94#ifndef ELIBBAD
95#define ELIBBAD 80
96#endif
97
Richard Henderson28490232010-07-27 10:25:31 -070098#ifdef TARGET_WORDS_BIGENDIAN
99#define ELF_DATA ELFDATA2MSB
100#else
101#define ELF_DATA ELFDATA2LSB
102#endif
103
Richard Hendersond97ef722010-07-27 10:25:29 -0700104typedef target_ulong target_elf_greg_t;
Nathan Froyd21e807f2009-12-11 09:04:46 -0800105#ifdef USE_UID16
Laurent Vivier80f5ce72011-02-13 23:37:35 +0100106typedef target_ushort target_uid_t;
107typedef target_ushort target_gid_t;
Nathan Froyd21e807f2009-12-11 09:04:46 -0800108#else
Laurent Vivier80f5ce72011-02-13 23:37:35 +0100109typedef target_uint target_uid_t;
110typedef target_uint target_gid_t;
Nathan Froyd21e807f2009-12-11 09:04:46 -0800111#endif
Laurent Vivier80f5ce72011-02-13 23:37:35 +0100112typedef target_int target_pid_t;
Nathan Froyd21e807f2009-12-11 09:04:46 -0800113
bellard30ac07d2003-04-07 21:33:03 +0000114#ifdef TARGET_I386
115
bellard15338fd2005-11-26 11:41:16 +0000116#define ELF_PLATFORM get_elf_platform()
117
118static const char *get_elf_platform(void)
119{
120 static char elf_platform[] = "i386";
pbrookd5975362008-06-07 20:50:51 +0000121 int family = (thread_env->cpuid_version >> 8) & 0xff;
bellard15338fd2005-11-26 11:41:16 +0000122 if (family > 6)
123 family = 6;
124 if (family >= 3)
125 elf_platform[1] = '0' + family;
126 return elf_platform;
127}
128
129#define ELF_HWCAP get_elf_hwcap()
130
131static uint32_t get_elf_hwcap(void)
132{
Richard Hendersond97ef722010-07-27 10:25:29 -0700133 return thread_env->cpuid_features;
bellard15338fd2005-11-26 11:41:16 +0000134}
135
j_mayer84409dd2007-04-06 08:56:50 +0000136#ifdef TARGET_X86_64
137#define ELF_START_MMAP 0x2aaaaab000ULL
138#define elf_check_arch(x) ( ((x) == ELF_ARCH) )
139
140#define ELF_CLASS ELFCLASS64
j_mayer84409dd2007-04-06 08:56:50 +0000141#define ELF_ARCH EM_X86_64
142
143static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
144{
145 regs->rax = 0;
146 regs->rsp = infop->start_stack;
147 regs->rip = infop->entry;
148}
149
Mika Westerberg9edc5d72009-04-07 09:57:59 +0300150#define ELF_NREG 27
Anthony Liguoric227f092009-10-01 16:12:16 -0500151typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
Mika Westerberg9edc5d72009-04-07 09:57:59 +0300152
153/*
154 * Note that ELF_NREG should be 29 as there should be place for
155 * TRAPNO and ERR "registers" as well but linux doesn't dump
156 * those.
157 *
158 * See linux kernel: arch/x86/include/asm/elf.h
159 */
Andreas Färber05390242012-02-25 03:37:53 +0100160static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
Mika Westerberg9edc5d72009-04-07 09:57:59 +0300161{
162 (*regs)[0] = env->regs[15];
163 (*regs)[1] = env->regs[14];
164 (*regs)[2] = env->regs[13];
165 (*regs)[3] = env->regs[12];
166 (*regs)[4] = env->regs[R_EBP];
167 (*regs)[5] = env->regs[R_EBX];
168 (*regs)[6] = env->regs[11];
169 (*regs)[7] = env->regs[10];
170 (*regs)[8] = env->regs[9];
171 (*regs)[9] = env->regs[8];
172 (*regs)[10] = env->regs[R_EAX];
173 (*regs)[11] = env->regs[R_ECX];
174 (*regs)[12] = env->regs[R_EDX];
175 (*regs)[13] = env->regs[R_ESI];
176 (*regs)[14] = env->regs[R_EDI];
177 (*regs)[15] = env->regs[R_EAX]; /* XXX */
178 (*regs)[16] = env->eip;
179 (*regs)[17] = env->segs[R_CS].selector & 0xffff;
180 (*regs)[18] = env->eflags;
181 (*regs)[19] = env->regs[R_ESP];
182 (*regs)[20] = env->segs[R_SS].selector & 0xffff;
183 (*regs)[21] = env->segs[R_FS].selector & 0xffff;
184 (*regs)[22] = env->segs[R_GS].selector & 0xffff;
185 (*regs)[23] = env->segs[R_DS].selector & 0xffff;
186 (*regs)[24] = env->segs[R_ES].selector & 0xffff;
187 (*regs)[25] = env->segs[R_FS].selector & 0xffff;
188 (*regs)[26] = env->segs[R_GS].selector & 0xffff;
189}
190
j_mayer84409dd2007-04-06 08:56:50 +0000191#else
192
bellard30ac07d2003-04-07 21:33:03 +0000193#define ELF_START_MMAP 0x80000000
194
bellard30ac07d2003-04-07 21:33:03 +0000195/*
196 * This is used to ensure we don't load something for the wrong architecture.
197 */
198#define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
199
200/*
201 * These are used to set parameters in the core dumps.
202 */
Richard Hendersond97ef722010-07-27 10:25:29 -0700203#define ELF_CLASS ELFCLASS32
Richard Hendersond97ef722010-07-27 10:25:29 -0700204#define ELF_ARCH EM_386
bellard30ac07d2003-04-07 21:33:03 +0000205
Richard Hendersond97ef722010-07-27 10:25:29 -0700206static inline void init_thread(struct target_pt_regs *regs,
207 struct image_info *infop)
bellardb346ff42003-06-15 20:05:50 +0000208{
209 regs->esp = infop->start_stack;
210 regs->eip = infop->entry;
pbrooke5fe0c52006-06-11 13:32:59 +0000211
212 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
213 starts %edx contains a pointer to a function which might be
214 registered using `atexit'. This provides a mean for the
215 dynamic linker to call DT_FINI functions for shared libraries
216 that have been loaded before the code runs.
217
218 A value of 0 tells we have no such handler. */
219 regs->edx = 0;
bellardb346ff42003-06-15 20:05:50 +0000220}
Mika Westerberg9edc5d72009-04-07 09:57:59 +0300221
Mika Westerberg9edc5d72009-04-07 09:57:59 +0300222#define ELF_NREG 17
Anthony Liguoric227f092009-10-01 16:12:16 -0500223typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
Mika Westerberg9edc5d72009-04-07 09:57:59 +0300224
225/*
226 * Note that ELF_NREG should be 19 as there should be place for
227 * TRAPNO and ERR "registers" as well but linux doesn't dump
228 * those.
229 *
230 * See linux kernel: arch/x86/include/asm/elf.h
231 */
Andreas Färber05390242012-02-25 03:37:53 +0100232static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
Mika Westerberg9edc5d72009-04-07 09:57:59 +0300233{
234 (*regs)[0] = env->regs[R_EBX];
235 (*regs)[1] = env->regs[R_ECX];
236 (*regs)[2] = env->regs[R_EDX];
237 (*regs)[3] = env->regs[R_ESI];
238 (*regs)[4] = env->regs[R_EDI];
239 (*regs)[5] = env->regs[R_EBP];
240 (*regs)[6] = env->regs[R_EAX];
241 (*regs)[7] = env->segs[R_DS].selector & 0xffff;
242 (*regs)[8] = env->segs[R_ES].selector & 0xffff;
243 (*regs)[9] = env->segs[R_FS].selector & 0xffff;
244 (*regs)[10] = env->segs[R_GS].selector & 0xffff;
245 (*regs)[11] = env->regs[R_EAX]; /* XXX */
246 (*regs)[12] = env->eip;
247 (*regs)[13] = env->segs[R_CS].selector & 0xffff;
248 (*regs)[14] = env->eflags;
249 (*regs)[15] = env->regs[R_ESP];
250 (*regs)[16] = env->segs[R_SS].selector & 0xffff;
251}
j_mayer84409dd2007-04-06 08:56:50 +0000252#endif
bellardb346ff42003-06-15 20:05:50 +0000253
Mika Westerberg9edc5d72009-04-07 09:57:59 +0300254#define USE_ELF_CORE_DUMP
Richard Hendersond97ef722010-07-27 10:25:29 -0700255#define ELF_EXEC_PAGESIZE 4096
bellardb346ff42003-06-15 20:05:50 +0000256
257#endif
258
259#ifdef TARGET_ARM
260
261#define ELF_START_MMAP 0x80000000
262
263#define elf_check_arch(x) ( (x) == EM_ARM )
264
Richard Hendersond97ef722010-07-27 10:25:29 -0700265#define ELF_CLASS ELFCLASS32
Richard Hendersond97ef722010-07-27 10:25:29 -0700266#define ELF_ARCH EM_ARM
bellardb346ff42003-06-15 20:05:50 +0000267
Richard Hendersond97ef722010-07-27 10:25:29 -0700268static inline void init_thread(struct target_pt_regs *regs,
269 struct image_info *infop)
bellardb346ff42003-06-15 20:05:50 +0000270{
blueswir1992f48a2007-10-14 16:27:31 +0000271 abi_long stack = infop->start_stack;
bellardb346ff42003-06-15 20:05:50 +0000272 memset(regs, 0, sizeof(*regs));
273 regs->ARM_cpsr = 0x10;
pbrook0240ded2006-02-04 19:30:51 +0000274 if (infop->entry & 1)
Richard Hendersond97ef722010-07-27 10:25:29 -0700275 regs->ARM_cpsr |= CPSR_T;
pbrook0240ded2006-02-04 19:30:51 +0000276 regs->ARM_pc = infop->entry & 0xfffffffe;
bellardb346ff42003-06-15 20:05:50 +0000277 regs->ARM_sp = infop->start_stack;
bellard2f619692007-11-16 10:46:05 +0000278 /* FIXME - what to for failure of get_user()? */
279 get_user_ual(regs->ARM_r2, stack + 8); /* envp */
280 get_user_ual(regs->ARM_r1, stack + 4); /* envp */
bellarda1516e92003-07-09 17:13:37 +0000281 /* XXX: it seems that r0 is zeroed after ! */
pbrooke5fe0c52006-06-11 13:32:59 +0000282 regs->ARM_r0 = 0;
283 /* For uClinux PIC binaries. */
j_mayer863cf0b2007-10-07 15:59:45 +0000284 /* XXX: Linux does this only on ARM with no MMU (do we care ?) */
pbrooke5fe0c52006-06-11 13:32:59 +0000285 regs->ARM_r10 = infop->start_data;
bellardb346ff42003-06-15 20:05:50 +0000286}
287
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300288#define ELF_NREG 18
Anthony Liguoric227f092009-10-01 16:12:16 -0500289typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300290
Andreas Färber05390242012-02-25 03:37:53 +0100291static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUARMState *env)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300292{
Nathan Froydd049e622009-12-11 09:04:47 -0800293 (*regs)[0] = tswapl(env->regs[0]);
294 (*regs)[1] = tswapl(env->regs[1]);
295 (*regs)[2] = tswapl(env->regs[2]);
296 (*regs)[3] = tswapl(env->regs[3]);
297 (*regs)[4] = tswapl(env->regs[4]);
298 (*regs)[5] = tswapl(env->regs[5]);
299 (*regs)[6] = tswapl(env->regs[6]);
300 (*regs)[7] = tswapl(env->regs[7]);
301 (*regs)[8] = tswapl(env->regs[8]);
302 (*regs)[9] = tswapl(env->regs[9]);
303 (*regs)[10] = tswapl(env->regs[10]);
304 (*regs)[11] = tswapl(env->regs[11]);
305 (*regs)[12] = tswapl(env->regs[12]);
306 (*regs)[13] = tswapl(env->regs[13]);
307 (*regs)[14] = tswapl(env->regs[14]);
308 (*regs)[15] = tswapl(env->regs[15]);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300309
Andreas Färber05390242012-02-25 03:37:53 +0100310 (*regs)[16] = tswapl(cpsr_read((CPUARMState *)env));
Nathan Froydd049e622009-12-11 09:04:47 -0800311 (*regs)[17] = tswapl(env->regs[0]); /* XXX */
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300312}
313
bellard30ac07d2003-04-07 21:33:03 +0000314#define USE_ELF_CORE_DUMP
Richard Hendersond97ef722010-07-27 10:25:29 -0700315#define ELF_EXEC_PAGESIZE 4096
bellard30ac07d2003-04-07 21:33:03 +0000316
bellardafce2922005-10-30 20:58:30 +0000317enum
318{
Richard Hendersond97ef722010-07-27 10:25:29 -0700319 ARM_HWCAP_ARM_SWP = 1 << 0,
320 ARM_HWCAP_ARM_HALF = 1 << 1,
321 ARM_HWCAP_ARM_THUMB = 1 << 2,
322 ARM_HWCAP_ARM_26BIT = 1 << 3,
323 ARM_HWCAP_ARM_FAST_MULT = 1 << 4,
324 ARM_HWCAP_ARM_FPA = 1 << 5,
325 ARM_HWCAP_ARM_VFP = 1 << 6,
326 ARM_HWCAP_ARM_EDSP = 1 << 7,
327 ARM_HWCAP_ARM_JAVA = 1 << 8,
328 ARM_HWCAP_ARM_IWMMXT = 1 << 9,
329 ARM_HWCAP_ARM_THUMBEE = 1 << 10,
330 ARM_HWCAP_ARM_NEON = 1 << 11,
331 ARM_HWCAP_ARM_VFPv3 = 1 << 12,
332 ARM_HWCAP_ARM_VFPv3D16 = 1 << 13,
bellardafce2922005-10-30 20:58:30 +0000333};
334
Dr. David Alan Gilbert97cc7562011-08-31 17:24:34 +0100335#define TARGET_HAS_GUEST_VALIDATE_BASE
336/* We want the opportunity to check the suggested base */
337bool guest_validate_base(unsigned long guest_base)
338{
339 unsigned long real_start, test_page_addr;
340
341 /* We need to check that we can force a fault on access to the
342 * commpage at 0xffff0fxx
343 */
344 test_page_addr = guest_base + (0xffff0f00 & qemu_host_page_mask);
345 /* Note it needs to be writeable to let us initialise it */
346 real_start = (unsigned long)
347 mmap((void *)test_page_addr, qemu_host_page_size,
348 PROT_READ | PROT_WRITE,
349 MAP_ANONYMOUS | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
350
351 /* If we can't map it then try another address */
352 if (real_start == -1ul) {
353 return 0;
354 }
355
356 if (real_start != test_page_addr) {
357 /* OS didn't put the page where we asked - unmap and reject */
358 munmap((void *)real_start, qemu_host_page_size);
359 return 0;
360 }
361
362 /* Leave the page mapped
363 * Populate it (mmap should have left it all 0'd)
364 */
365
366 /* Kernel helper versions */
367 __put_user(5, (uint32_t *)g2h(0xffff0ffcul));
368
369 /* Now it's populated make it RO */
370 if (mprotect((void *)test_page_addr, qemu_host_page_size, PROT_READ)) {
371 perror("Protecting guest commpage");
372 exit(-1);
373 }
374
375 return 1; /* All good */
376}
377
Benoit Canetadf050b2011-11-09 03:37:23 +0000378
379#define ELF_HWCAP get_elf_hwcap()
380
381static uint32_t get_elf_hwcap(void)
382{
383 CPUARMState *e = thread_env;
384 uint32_t hwcaps = 0;
385
386 hwcaps |= ARM_HWCAP_ARM_SWP;
387 hwcaps |= ARM_HWCAP_ARM_HALF;
388 hwcaps |= ARM_HWCAP_ARM_THUMB;
389 hwcaps |= ARM_HWCAP_ARM_FAST_MULT;
390 hwcaps |= ARM_HWCAP_ARM_FPA;
391
392 /* probe for the extra features */
393#define GET_FEATURE(feat, hwcap) \
394 do {if (arm_feature(e, feat)) { hwcaps |= hwcap; } } while (0)
395 GET_FEATURE(ARM_FEATURE_VFP, ARM_HWCAP_ARM_VFP);
396 GET_FEATURE(ARM_FEATURE_IWMMXT, ARM_HWCAP_ARM_IWMMXT);
397 GET_FEATURE(ARM_FEATURE_THUMB2EE, ARM_HWCAP_ARM_THUMBEE);
398 GET_FEATURE(ARM_FEATURE_NEON, ARM_HWCAP_ARM_NEON);
399 GET_FEATURE(ARM_FEATURE_VFP3, ARM_HWCAP_ARM_VFPv3);
400 GET_FEATURE(ARM_FEATURE_VFP_FP16, ARM_HWCAP_ARM_VFPv3D16);
401#undef GET_FEATURE
402
403 return hwcaps;
404}
bellardafce2922005-10-30 20:58:30 +0000405
bellard30ac07d2003-04-07 21:33:03 +0000406#endif
407
Guan Xuetaod2fbca92011-04-12 16:27:03 +0800408#ifdef TARGET_UNICORE32
409
410#define ELF_START_MMAP 0x80000000
411
412#define elf_check_arch(x) ((x) == EM_UNICORE32)
413
414#define ELF_CLASS ELFCLASS32
415#define ELF_DATA ELFDATA2LSB
416#define ELF_ARCH EM_UNICORE32
417
418static inline void init_thread(struct target_pt_regs *regs,
419 struct image_info *infop)
420{
421 abi_long stack = infop->start_stack;
422 memset(regs, 0, sizeof(*regs));
423 regs->UC32_REG_asr = 0x10;
424 regs->UC32_REG_pc = infop->entry & 0xfffffffe;
425 regs->UC32_REG_sp = infop->start_stack;
426 /* FIXME - what to for failure of get_user()? */
427 get_user_ual(regs->UC32_REG_02, stack + 8); /* envp */
428 get_user_ual(regs->UC32_REG_01, stack + 4); /* envp */
429 /* XXX: it seems that r0 is zeroed after ! */
430 regs->UC32_REG_00 = 0;
431}
432
433#define ELF_NREG 34
434typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
435
Andreas Färber05390242012-02-25 03:37:53 +0100436static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUUniCore32State *env)
Guan Xuetaod2fbca92011-04-12 16:27:03 +0800437{
438 (*regs)[0] = env->regs[0];
439 (*regs)[1] = env->regs[1];
440 (*regs)[2] = env->regs[2];
441 (*regs)[3] = env->regs[3];
442 (*regs)[4] = env->regs[4];
443 (*regs)[5] = env->regs[5];
444 (*regs)[6] = env->regs[6];
445 (*regs)[7] = env->regs[7];
446 (*regs)[8] = env->regs[8];
447 (*regs)[9] = env->regs[9];
448 (*regs)[10] = env->regs[10];
449 (*regs)[11] = env->regs[11];
450 (*regs)[12] = env->regs[12];
451 (*regs)[13] = env->regs[13];
452 (*regs)[14] = env->regs[14];
453 (*regs)[15] = env->regs[15];
454 (*regs)[16] = env->regs[16];
455 (*regs)[17] = env->regs[17];
456 (*regs)[18] = env->regs[18];
457 (*regs)[19] = env->regs[19];
458 (*regs)[20] = env->regs[20];
459 (*regs)[21] = env->regs[21];
460 (*regs)[22] = env->regs[22];
461 (*regs)[23] = env->regs[23];
462 (*regs)[24] = env->regs[24];
463 (*regs)[25] = env->regs[25];
464 (*regs)[26] = env->regs[26];
465 (*regs)[27] = env->regs[27];
466 (*regs)[28] = env->regs[28];
467 (*regs)[29] = env->regs[29];
468 (*regs)[30] = env->regs[30];
469 (*regs)[31] = env->regs[31];
470
Andreas Färber05390242012-02-25 03:37:53 +0100471 (*regs)[32] = cpu_asr_read((CPUUniCore32State *)env);
Guan Xuetaod2fbca92011-04-12 16:27:03 +0800472 (*regs)[33] = env->regs[0]; /* XXX */
473}
474
475#define USE_ELF_CORE_DUMP
476#define ELF_EXEC_PAGESIZE 4096
477
478#define ELF_HWCAP (UC32_HWCAP_CMOV | UC32_HWCAP_UCF64)
479
480#endif
481
bellard853d6f72003-09-30 20:58:32 +0000482#ifdef TARGET_SPARC
bellarda315a142005-01-30 22:59:18 +0000483#ifdef TARGET_SPARC64
bellard853d6f72003-09-30 20:58:32 +0000484
485#define ELF_START_MMAP 0x80000000
Artyom Tarasenkocf973e42011-07-14 19:37:06 +0200486#define ELF_HWCAP (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
487 | HWCAP_SPARC_MULDIV | HWCAP_SPARC_V9)
blueswir1992f48a2007-10-14 16:27:31 +0000488#ifndef TARGET_ABI32
blueswir1cb33da52007-10-09 16:34:29 +0000489#define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS )
blueswir1992f48a2007-10-14 16:27:31 +0000490#else
491#define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC )
492#endif
bellard853d6f72003-09-30 20:58:32 +0000493
bellarda315a142005-01-30 22:59:18 +0000494#define ELF_CLASS ELFCLASS64
bellard5ef54112006-07-18 21:14:09 +0000495#define ELF_ARCH EM_SPARCV9
496
Richard Hendersond97ef722010-07-27 10:25:29 -0700497#define STACK_BIAS 2047
bellarda315a142005-01-30 22:59:18 +0000498
Richard Hendersond97ef722010-07-27 10:25:29 -0700499static inline void init_thread(struct target_pt_regs *regs,
500 struct image_info *infop)
bellarda315a142005-01-30 22:59:18 +0000501{
blueswir1992f48a2007-10-14 16:27:31 +0000502#ifndef TARGET_ABI32
bellarda315a142005-01-30 22:59:18 +0000503 regs->tstate = 0;
blueswir1992f48a2007-10-14 16:27:31 +0000504#endif
bellarda315a142005-01-30 22:59:18 +0000505 regs->pc = infop->entry;
506 regs->npc = regs->pc + 4;
507 regs->y = 0;
blueswir1992f48a2007-10-14 16:27:31 +0000508#ifdef TARGET_ABI32
509 regs->u_regs[14] = infop->start_stack - 16 * 4;
510#else
blueswir1cb33da52007-10-09 16:34:29 +0000511 if (personality(infop->personality) == PER_LINUX32)
512 regs->u_regs[14] = infop->start_stack - 16 * 4;
513 else
514 regs->u_regs[14] = infop->start_stack - 16 * 8 - STACK_BIAS;
blueswir1992f48a2007-10-14 16:27:31 +0000515#endif
bellarda315a142005-01-30 22:59:18 +0000516}
517
518#else
519#define ELF_START_MMAP 0x80000000
Artyom Tarasenkocf973e42011-07-14 19:37:06 +0200520#define ELF_HWCAP (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
521 | HWCAP_SPARC_MULDIV)
bellarda315a142005-01-30 22:59:18 +0000522#define elf_check_arch(x) ( (x) == EM_SPARC )
523
bellard853d6f72003-09-30 20:58:32 +0000524#define ELF_CLASS ELFCLASS32
bellard853d6f72003-09-30 20:58:32 +0000525#define ELF_ARCH EM_SPARC
526
Richard Hendersond97ef722010-07-27 10:25:29 -0700527static inline void init_thread(struct target_pt_regs *regs,
528 struct image_info *infop)
bellard853d6f72003-09-30 20:58:32 +0000529{
bellardf5155282004-01-04 15:46:50 +0000530 regs->psr = 0;
531 regs->pc = infop->entry;
532 regs->npc = regs->pc + 4;
533 regs->y = 0;
534 regs->u_regs[14] = infop->start_stack - 16 * 4;
bellard853d6f72003-09-30 20:58:32 +0000535}
536
537#endif
bellarda315a142005-01-30 22:59:18 +0000538#endif
bellard853d6f72003-09-30 20:58:32 +0000539
bellard67867302003-11-23 17:05:30 +0000540#ifdef TARGET_PPC
541
542#define ELF_START_MMAP 0x80000000
543
j_mayere85e7c62007-10-18 19:59:49 +0000544#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
j_mayer84409dd2007-04-06 08:56:50 +0000545
546#define elf_check_arch(x) ( (x) == EM_PPC64 )
547
Richard Hendersond97ef722010-07-27 10:25:29 -0700548#define ELF_CLASS ELFCLASS64
j_mayer84409dd2007-04-06 08:56:50 +0000549
550#else
551
bellard67867302003-11-23 17:05:30 +0000552#define elf_check_arch(x) ( (x) == EM_PPC )
553
Richard Hendersond97ef722010-07-27 10:25:29 -0700554#define ELF_CLASS ELFCLASS32
j_mayer84409dd2007-04-06 08:56:50 +0000555
556#endif
557
Richard Hendersond97ef722010-07-27 10:25:29 -0700558#define ELF_ARCH EM_PPC
bellard67867302003-11-23 17:05:30 +0000559
Nathan Froyddf84e4f2009-05-12 12:26:59 -0700560/* Feature masks for the Aux Vector Hardware Capabilities (AT_HWCAP).
561 See arch/powerpc/include/asm/cputable.h. */
562enum {
malc3efa9a62009-07-18 13:10:12 +0400563 QEMU_PPC_FEATURE_32 = 0x80000000,
564 QEMU_PPC_FEATURE_64 = 0x40000000,
565 QEMU_PPC_FEATURE_601_INSTR = 0x20000000,
566 QEMU_PPC_FEATURE_HAS_ALTIVEC = 0x10000000,
567 QEMU_PPC_FEATURE_HAS_FPU = 0x08000000,
568 QEMU_PPC_FEATURE_HAS_MMU = 0x04000000,
569 QEMU_PPC_FEATURE_HAS_4xxMAC = 0x02000000,
570 QEMU_PPC_FEATURE_UNIFIED_CACHE = 0x01000000,
571 QEMU_PPC_FEATURE_HAS_SPE = 0x00800000,
572 QEMU_PPC_FEATURE_HAS_EFP_SINGLE = 0x00400000,
573 QEMU_PPC_FEATURE_HAS_EFP_DOUBLE = 0x00200000,
574 QEMU_PPC_FEATURE_NO_TB = 0x00100000,
575 QEMU_PPC_FEATURE_POWER4 = 0x00080000,
576 QEMU_PPC_FEATURE_POWER5 = 0x00040000,
577 QEMU_PPC_FEATURE_POWER5_PLUS = 0x00020000,
578 QEMU_PPC_FEATURE_CELL = 0x00010000,
579 QEMU_PPC_FEATURE_BOOKE = 0x00008000,
580 QEMU_PPC_FEATURE_SMT = 0x00004000,
581 QEMU_PPC_FEATURE_ICACHE_SNOOP = 0x00002000,
582 QEMU_PPC_FEATURE_ARCH_2_05 = 0x00001000,
583 QEMU_PPC_FEATURE_PA6T = 0x00000800,
584 QEMU_PPC_FEATURE_HAS_DFP = 0x00000400,
585 QEMU_PPC_FEATURE_POWER6_EXT = 0x00000200,
586 QEMU_PPC_FEATURE_ARCH_2_06 = 0x00000100,
587 QEMU_PPC_FEATURE_HAS_VSX = 0x00000080,
588 QEMU_PPC_FEATURE_PSERIES_PERFMON_COMPAT = 0x00000040,
Nathan Froyddf84e4f2009-05-12 12:26:59 -0700589
malc3efa9a62009-07-18 13:10:12 +0400590 QEMU_PPC_FEATURE_TRUE_LE = 0x00000002,
591 QEMU_PPC_FEATURE_PPC_LE = 0x00000001,
Nathan Froyddf84e4f2009-05-12 12:26:59 -0700592};
593
594#define ELF_HWCAP get_elf_hwcap()
595
596static uint32_t get_elf_hwcap(void)
597{
Andreas Färber05390242012-02-25 03:37:53 +0100598 CPUPPCState *e = thread_env;
Nathan Froyddf84e4f2009-05-12 12:26:59 -0700599 uint32_t features = 0;
600
601 /* We don't have to be terribly complete here; the high points are
602 Altivec/FP/SPE support. Anything else is just a bonus. */
Richard Hendersond97ef722010-07-27 10:25:29 -0700603#define GET_FEATURE(flag, feature) \
Nathan Froyddf84e4f2009-05-12 12:26:59 -0700604 do {if (e->insns_flags & flag) features |= feature; } while(0)
malc3efa9a62009-07-18 13:10:12 +0400605 GET_FEATURE(PPC_64B, QEMU_PPC_FEATURE_64);
606 GET_FEATURE(PPC_FLOAT, QEMU_PPC_FEATURE_HAS_FPU);
607 GET_FEATURE(PPC_ALTIVEC, QEMU_PPC_FEATURE_HAS_ALTIVEC);
608 GET_FEATURE(PPC_SPE, QEMU_PPC_FEATURE_HAS_SPE);
609 GET_FEATURE(PPC_SPE_SINGLE, QEMU_PPC_FEATURE_HAS_EFP_SINGLE);
610 GET_FEATURE(PPC_SPE_DOUBLE, QEMU_PPC_FEATURE_HAS_EFP_DOUBLE);
611 GET_FEATURE(PPC_BOOKE, QEMU_PPC_FEATURE_BOOKE);
612 GET_FEATURE(PPC_405_MAC, QEMU_PPC_FEATURE_HAS_4xxMAC);
Nathan Froyddf84e4f2009-05-12 12:26:59 -0700613#undef GET_FEATURE
614
615 return features;
616}
617
bellardf5155282004-01-04 15:46:50 +0000618/*
bellardf5155282004-01-04 15:46:50 +0000619 * The requirements here are:
620 * - keep the final alignment of sp (sp & 0xf)
621 * - make sure the 32-bit value at the first 16 byte aligned position of
622 * AUXV is greater than 16 for glibc compatibility.
623 * AT_IGNOREPPC is used for that.
624 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
625 * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
626 */
bellard0bccf032005-08-21 10:12:28 +0000627#define DLINFO_ARCH_ITEMS 5
Richard Hendersond97ef722010-07-27 10:25:29 -0700628#define ARCH_DLINFO \
629 do { \
630 NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20); \
631 NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20); \
632 NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \
633 /* \
634 * Now handle glibc compatibility. \
635 */ \
636 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
637 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
638 } while (0)
bellardf5155282004-01-04 15:46:50 +0000639
bellard67867302003-11-23 17:05:30 +0000640static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
641{
bellard67867302003-11-23 17:05:30 +0000642 _regs->gpr[1] = infop->start_stack;
j_mayere85e7c62007-10-18 19:59:49 +0000643#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
Richard Henderson8e780642011-10-26 09:59:17 -0700644 _regs->gpr[2] = ldq_raw(infop->entry + 8) + infop->load_bias;
645 infop->entry = ldq_raw(infop->entry) + infop->load_bias;
j_mayer84409dd2007-04-06 08:56:50 +0000646#endif
bellard67867302003-11-23 17:05:30 +0000647 _regs->nip = infop->entry;
648}
649
Nathan Froyde2f3e742009-12-11 09:04:48 -0800650/* See linux kernel: arch/powerpc/include/asm/elf.h. */
651#define ELF_NREG 48
652typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
653
Andreas Färber05390242012-02-25 03:37:53 +0100654static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUPPCState *env)
Nathan Froyde2f3e742009-12-11 09:04:48 -0800655{
656 int i;
657 target_ulong ccr = 0;
658
659 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
660 (*regs)[i] = tswapl(env->gpr[i]);
661 }
662
663 (*regs)[32] = tswapl(env->nip);
664 (*regs)[33] = tswapl(env->msr);
665 (*regs)[35] = tswapl(env->ctr);
666 (*regs)[36] = tswapl(env->lr);
667 (*regs)[37] = tswapl(env->xer);
668
669 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
670 ccr |= env->crf[i] << (32 - ((i + 1) * 4));
671 }
672 (*regs)[38] = tswapl(ccr);
673}
674
675#define USE_ELF_CORE_DUMP
Richard Hendersond97ef722010-07-27 10:25:29 -0700676#define ELF_EXEC_PAGESIZE 4096
bellard67867302003-11-23 17:05:30 +0000677
678#endif
679
bellard048f6b42005-11-26 18:47:20 +0000680#ifdef TARGET_MIPS
681
682#define ELF_START_MMAP 0x80000000
683
684#define elf_check_arch(x) ( (x) == EM_MIPS )
685
ths388bb212007-05-13 13:58:00 +0000686#ifdef TARGET_MIPS64
687#define ELF_CLASS ELFCLASS64
688#else
bellard048f6b42005-11-26 18:47:20 +0000689#define ELF_CLASS ELFCLASS32
ths388bb212007-05-13 13:58:00 +0000690#endif
bellard048f6b42005-11-26 18:47:20 +0000691#define ELF_ARCH EM_MIPS
692
Richard Hendersond97ef722010-07-27 10:25:29 -0700693static inline void init_thread(struct target_pt_regs *regs,
694 struct image_info *infop)
bellard048f6b42005-11-26 18:47:20 +0000695{
ths623a9302007-10-28 19:45:05 +0000696 regs->cp0_status = 2 << CP0St_KSU;
bellard048f6b42005-11-26 18:47:20 +0000697 regs->cp0_epc = infop->entry;
698 regs->regs[29] = infop->start_stack;
699}
700
Nathan Froyd51e52602009-12-11 09:04:49 -0800701/* See linux kernel: arch/mips/include/asm/elf.h. */
702#define ELF_NREG 45
703typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
704
705/* See linux kernel: arch/mips/include/asm/reg.h. */
706enum {
707#ifdef TARGET_MIPS64
708 TARGET_EF_R0 = 0,
709#else
710 TARGET_EF_R0 = 6,
711#endif
712 TARGET_EF_R26 = TARGET_EF_R0 + 26,
713 TARGET_EF_R27 = TARGET_EF_R0 + 27,
714 TARGET_EF_LO = TARGET_EF_R0 + 32,
715 TARGET_EF_HI = TARGET_EF_R0 + 33,
716 TARGET_EF_CP0_EPC = TARGET_EF_R0 + 34,
717 TARGET_EF_CP0_BADVADDR = TARGET_EF_R0 + 35,
718 TARGET_EF_CP0_STATUS = TARGET_EF_R0 + 36,
719 TARGET_EF_CP0_CAUSE = TARGET_EF_R0 + 37
720};
721
722/* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs. */
Andreas Färber05390242012-02-25 03:37:53 +0100723static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMIPSState *env)
Nathan Froyd51e52602009-12-11 09:04:49 -0800724{
725 int i;
726
727 for (i = 0; i < TARGET_EF_R0; i++) {
728 (*regs)[i] = 0;
729 }
730 (*regs)[TARGET_EF_R0] = 0;
731
732 for (i = 1; i < ARRAY_SIZE(env->active_tc.gpr); i++) {
733 (*regs)[TARGET_EF_R0 + i] = tswapl(env->active_tc.gpr[i]);
734 }
735
736 (*regs)[TARGET_EF_R26] = 0;
737 (*regs)[TARGET_EF_R27] = 0;
738 (*regs)[TARGET_EF_LO] = tswapl(env->active_tc.LO[0]);
739 (*regs)[TARGET_EF_HI] = tswapl(env->active_tc.HI[0]);
740 (*regs)[TARGET_EF_CP0_EPC] = tswapl(env->active_tc.PC);
741 (*regs)[TARGET_EF_CP0_BADVADDR] = tswapl(env->CP0_BadVAddr);
742 (*regs)[TARGET_EF_CP0_STATUS] = tswapl(env->CP0_Status);
743 (*regs)[TARGET_EF_CP0_CAUSE] = tswapl(env->CP0_Cause);
744}
745
746#define USE_ELF_CORE_DUMP
ths388bb212007-05-13 13:58:00 +0000747#define ELF_EXEC_PAGESIZE 4096
748
bellard048f6b42005-11-26 18:47:20 +0000749#endif /* TARGET_MIPS */
750
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +0200751#ifdef TARGET_MICROBLAZE
752
753#define ELF_START_MMAP 0x80000000
754
Edgar E. Iglesias0d5d4692010-05-19 15:24:17 +0200755#define elf_check_arch(x) ( (x) == EM_MICROBLAZE || (x) == EM_MICROBLAZE_OLD)
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +0200756
757#define ELF_CLASS ELFCLASS32
Edgar E. Iglesias0d5d4692010-05-19 15:24:17 +0200758#define ELF_ARCH EM_MICROBLAZE
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +0200759
Richard Hendersond97ef722010-07-27 10:25:29 -0700760static inline void init_thread(struct target_pt_regs *regs,
761 struct image_info *infop)
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +0200762{
763 regs->pc = infop->entry;
764 regs->r1 = infop->start_stack;
765
766}
767
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +0200768#define ELF_EXEC_PAGESIZE 4096
769
Edgar E. Iglesiase4cbd442010-05-19 15:09:28 +0200770#define USE_ELF_CORE_DUMP
771#define ELF_NREG 38
772typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
773
774/* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs. */
Andreas Färber05390242012-02-25 03:37:53 +0100775static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMBState *env)
Edgar E. Iglesiase4cbd442010-05-19 15:09:28 +0200776{
777 int i, pos = 0;
778
779 for (i = 0; i < 32; i++) {
780 (*regs)[pos++] = tswapl(env->regs[i]);
781 }
782
783 for (i = 0; i < 6; i++) {
784 (*regs)[pos++] = tswapl(env->sregs[i]);
785 }
786}
787
Edgar E. Iglesiasb779e292009-05-20 21:31:33 +0200788#endif /* TARGET_MICROBLAZE */
789
Jia Liud9627832012-07-20 15:50:52 +0800790#ifdef TARGET_OPENRISC
791
792#define ELF_START_MMAP 0x08000000
793
794#define elf_check_arch(x) ((x) == EM_OPENRISC)
795
796#define ELF_ARCH EM_OPENRISC
797#define ELF_CLASS ELFCLASS32
798#define ELF_DATA ELFDATA2MSB
799
800static inline void init_thread(struct target_pt_regs *regs,
801 struct image_info *infop)
802{
803 regs->pc = infop->entry;
804 regs->gpr[1] = infop->start_stack;
805}
806
807#define USE_ELF_CORE_DUMP
808#define ELF_EXEC_PAGESIZE 8192
809
810/* See linux kernel arch/openrisc/include/asm/elf.h. */
811#define ELF_NREG 34 /* gprs and pc, sr */
812typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
813
814static void elf_core_copy_regs(target_elf_gregset_t *regs,
815 const CPUOpenRISCState *env)
816{
817 int i;
818
819 for (i = 0; i < 32; i++) {
820 (*regs)[i] = tswapl(env->gpr[i]);
821 }
822
823 (*regs)[32] = tswapl(env->pc);
824 (*regs)[33] = tswapl(env->sr);
825}
826#define ELF_HWCAP 0
827#define ELF_PLATFORM NULL
828
829#endif /* TARGET_OPENRISC */
830
bellardfdf9b3e2006-04-27 21:07:38 +0000831#ifdef TARGET_SH4
832
833#define ELF_START_MMAP 0x80000000
834
835#define elf_check_arch(x) ( (x) == EM_SH )
836
837#define ELF_CLASS ELFCLASS32
bellardfdf9b3e2006-04-27 21:07:38 +0000838#define ELF_ARCH EM_SH
839
Richard Hendersond97ef722010-07-27 10:25:29 -0700840static inline void init_thread(struct target_pt_regs *regs,
841 struct image_info *infop)
bellardfdf9b3e2006-04-27 21:07:38 +0000842{
Richard Hendersond97ef722010-07-27 10:25:29 -0700843 /* Check other registers XXXXX */
844 regs->pc = infop->entry;
845 regs->regs[15] = infop->start_stack;
bellardfdf9b3e2006-04-27 21:07:38 +0000846}
847
Nathan Froyd7631c972009-12-11 09:04:51 -0800848/* See linux kernel: arch/sh/include/asm/elf.h. */
849#define ELF_NREG 23
850typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
851
852/* See linux kernel: arch/sh/include/asm/ptrace.h. */
853enum {
854 TARGET_REG_PC = 16,
855 TARGET_REG_PR = 17,
856 TARGET_REG_SR = 18,
857 TARGET_REG_GBR = 19,
858 TARGET_REG_MACH = 20,
859 TARGET_REG_MACL = 21,
860 TARGET_REG_SYSCALL = 22
861};
862
Richard Hendersond97ef722010-07-27 10:25:29 -0700863static inline void elf_core_copy_regs(target_elf_gregset_t *regs,
Andreas Färber05390242012-02-25 03:37:53 +0100864 const CPUSH4State *env)
Nathan Froyd7631c972009-12-11 09:04:51 -0800865{
866 int i;
867
868 for (i = 0; i < 16; i++) {
869 (*regs[i]) = tswapl(env->gregs[i]);
870 }
871
872 (*regs)[TARGET_REG_PC] = tswapl(env->pc);
873 (*regs)[TARGET_REG_PR] = tswapl(env->pr);
874 (*regs)[TARGET_REG_SR] = tswapl(env->sr);
875 (*regs)[TARGET_REG_GBR] = tswapl(env->gbr);
876 (*regs)[TARGET_REG_MACH] = tswapl(env->mach);
877 (*regs)[TARGET_REG_MACL] = tswapl(env->macl);
878 (*regs)[TARGET_REG_SYSCALL] = 0; /* FIXME */
879}
880
881#define USE_ELF_CORE_DUMP
bellardfdf9b3e2006-04-27 21:07:38 +0000882#define ELF_EXEC_PAGESIZE 4096
883
884#endif
885
ths48733d12007-10-08 13:36:46 +0000886#ifdef TARGET_CRIS
887
888#define ELF_START_MMAP 0x80000000
889
890#define elf_check_arch(x) ( (x) == EM_CRIS )
891
892#define ELF_CLASS ELFCLASS32
ths48733d12007-10-08 13:36:46 +0000893#define ELF_ARCH EM_CRIS
894
Richard Hendersond97ef722010-07-27 10:25:29 -0700895static inline void init_thread(struct target_pt_regs *regs,
896 struct image_info *infop)
ths48733d12007-10-08 13:36:46 +0000897{
Richard Hendersond97ef722010-07-27 10:25:29 -0700898 regs->erp = infop->entry;
ths48733d12007-10-08 13:36:46 +0000899}
900
ths48733d12007-10-08 13:36:46 +0000901#define ELF_EXEC_PAGESIZE 8192
902
903#endif
904
pbrooke6e59062006-10-22 00:18:54 +0000905#ifdef TARGET_M68K
906
907#define ELF_START_MMAP 0x80000000
908
909#define elf_check_arch(x) ( (x) == EM_68K )
910
Richard Hendersond97ef722010-07-27 10:25:29 -0700911#define ELF_CLASS ELFCLASS32
Richard Hendersond97ef722010-07-27 10:25:29 -0700912#define ELF_ARCH EM_68K
pbrooke6e59062006-10-22 00:18:54 +0000913
914/* ??? Does this need to do anything?
Richard Hendersond97ef722010-07-27 10:25:29 -0700915 #define ELF_PLAT_INIT(_r) */
pbrooke6e59062006-10-22 00:18:54 +0000916
Richard Hendersond97ef722010-07-27 10:25:29 -0700917static inline void init_thread(struct target_pt_regs *regs,
918 struct image_info *infop)
pbrooke6e59062006-10-22 00:18:54 +0000919{
920 regs->usp = infop->start_stack;
921 regs->sr = 0;
922 regs->pc = infop->entry;
923}
924
Nathan Froyd7a93cc52009-12-11 09:04:50 -0800925/* See linux kernel: arch/m68k/include/asm/elf.h. */
926#define ELF_NREG 20
927typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
928
Andreas Färber05390242012-02-25 03:37:53 +0100929static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUM68KState *env)
Nathan Froyd7a93cc52009-12-11 09:04:50 -0800930{
931 (*regs)[0] = tswapl(env->dregs[1]);
932 (*regs)[1] = tswapl(env->dregs[2]);
933 (*regs)[2] = tswapl(env->dregs[3]);
934 (*regs)[3] = tswapl(env->dregs[4]);
935 (*regs)[4] = tswapl(env->dregs[5]);
936 (*regs)[5] = tswapl(env->dregs[6]);
937 (*regs)[6] = tswapl(env->dregs[7]);
938 (*regs)[7] = tswapl(env->aregs[0]);
939 (*regs)[8] = tswapl(env->aregs[1]);
940 (*regs)[9] = tswapl(env->aregs[2]);
941 (*regs)[10] = tswapl(env->aregs[3]);
942 (*regs)[11] = tswapl(env->aregs[4]);
943 (*regs)[12] = tswapl(env->aregs[5]);
944 (*regs)[13] = tswapl(env->aregs[6]);
945 (*regs)[14] = tswapl(env->dregs[0]);
946 (*regs)[15] = tswapl(env->aregs[7]);
947 (*regs)[16] = tswapl(env->dregs[0]); /* FIXME: orig_d0 */
948 (*regs)[17] = tswapl(env->sr);
949 (*regs)[18] = tswapl(env->pc);
950 (*regs)[19] = 0; /* FIXME: regs->format | regs->vector */
951}
952
953#define USE_ELF_CORE_DUMP
Richard Hendersond97ef722010-07-27 10:25:29 -0700954#define ELF_EXEC_PAGESIZE 8192
pbrooke6e59062006-10-22 00:18:54 +0000955
956#endif
957
j_mayer7a3148a2007-04-05 07:13:51 +0000958#ifdef TARGET_ALPHA
959
960#define ELF_START_MMAP (0x30000000000ULL)
961
962#define elf_check_arch(x) ( (x) == ELF_ARCH )
963
964#define ELF_CLASS ELFCLASS64
j_mayer7a3148a2007-04-05 07:13:51 +0000965#define ELF_ARCH EM_ALPHA
966
Richard Hendersond97ef722010-07-27 10:25:29 -0700967static inline void init_thread(struct target_pt_regs *regs,
968 struct image_info *infop)
j_mayer7a3148a2007-04-05 07:13:51 +0000969{
970 regs->pc = infop->entry;
971 regs->ps = 8;
972 regs->usp = infop->start_stack;
j_mayer7a3148a2007-04-05 07:13:51 +0000973}
974
j_mayer7a3148a2007-04-05 07:13:51 +0000975#define ELF_EXEC_PAGESIZE 8192
976
977#endif /* TARGET_ALPHA */
978
Ulrich Hechta4c075f2009-07-24 16:57:31 +0200979#ifdef TARGET_S390X
980
981#define ELF_START_MMAP (0x20000000000ULL)
982
983#define elf_check_arch(x) ( (x) == ELF_ARCH )
984
985#define ELF_CLASS ELFCLASS64
986#define ELF_DATA ELFDATA2MSB
987#define ELF_ARCH EM_S390
988
989static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
990{
991 regs->psw.addr = infop->entry;
992 regs->psw.mask = PSW_MASK_64 | PSW_MASK_32;
993 regs->gprs[15] = infop->start_stack;
994}
995
996#endif /* TARGET_S390X */
997
bellard15338fd2005-11-26 11:41:16 +0000998#ifndef ELF_PLATFORM
999#define ELF_PLATFORM (NULL)
1000#endif
1001
1002#ifndef ELF_HWCAP
1003#define ELF_HWCAP 0
1004#endif
1005
blueswir1992f48a2007-10-14 16:27:31 +00001006#ifdef TARGET_ABI32
blueswir1cb33da52007-10-09 16:34:29 +00001007#undef ELF_CLASS
blueswir1992f48a2007-10-14 16:27:31 +00001008#define ELF_CLASS ELFCLASS32
blueswir1cb33da52007-10-09 16:34:29 +00001009#undef bswaptls
1010#define bswaptls(ptr) bswap32s(ptr)
1011#endif
1012
bellard31e31b82003-02-18 22:55:36 +00001013#include "elf.h"
bellard09bfb052003-04-10 00:03:40 +00001014
bellard09bfb052003-04-10 00:03:40 +00001015struct exec
1016{
Richard Hendersond97ef722010-07-27 10:25:29 -07001017 unsigned int a_info; /* Use macros N_MAGIC, etc for access */
1018 unsigned int a_text; /* length of text, in bytes */
1019 unsigned int a_data; /* length of data, in bytes */
1020 unsigned int a_bss; /* length of uninitialized data area, in bytes */
1021 unsigned int a_syms; /* length of symbol table data in file, in bytes */
1022 unsigned int a_entry; /* start address */
1023 unsigned int a_trsize; /* length of relocation info for text, in bytes */
1024 unsigned int a_drsize; /* length of relocation info for data, in bytes */
bellard09bfb052003-04-10 00:03:40 +00001025};
1026
1027
1028#define N_MAGIC(exec) ((exec).a_info & 0xffff)
1029#define OMAGIC 0407
1030#define NMAGIC 0410
1031#define ZMAGIC 0413
1032#define QMAGIC 0314
1033
bellard31e31b82003-02-18 22:55:36 +00001034/* Necessary parameters */
bellard54936002003-05-13 00:25:15 +00001035#define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
1036#define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
1037#define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
bellard31e31b82003-02-18 22:55:36 +00001038
Laurent ALFONSI14322ba2011-06-20 08:43:13 +02001039#define DLINFO_ITEMS 13
bellard31e31b82003-02-18 22:55:36 +00001040
bellard09bfb052003-04-10 00:03:40 +00001041static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
1042{
Richard Hendersond97ef722010-07-27 10:25:29 -07001043 memcpy(to, from, n);
bellard09bfb052003-04-10 00:03:40 +00001044}
1045
bellard31e31b82003-02-18 22:55:36 +00001046#ifdef BSWAP_NEEDED
bellard92a31b12005-02-10 22:00:52 +00001047static void bswap_ehdr(struct elfhdr *ehdr)
bellard31e31b82003-02-18 22:55:36 +00001048{
Richard Hendersond97ef722010-07-27 10:25:29 -07001049 bswap16s(&ehdr->e_type); /* Object file type */
1050 bswap16s(&ehdr->e_machine); /* Architecture */
1051 bswap32s(&ehdr->e_version); /* Object file version */
1052 bswaptls(&ehdr->e_entry); /* Entry point virtual address */
1053 bswaptls(&ehdr->e_phoff); /* Program header table file offset */
1054 bswaptls(&ehdr->e_shoff); /* Section header table file offset */
1055 bswap32s(&ehdr->e_flags); /* Processor-specific flags */
1056 bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
1057 bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
1058 bswap16s(&ehdr->e_phnum); /* Program header table entry count */
1059 bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
1060 bswap16s(&ehdr->e_shnum); /* Section header table entry count */
1061 bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
bellard31e31b82003-02-18 22:55:36 +00001062}
1063
Richard Henderson991f8f02010-07-27 10:25:32 -07001064static void bswap_phdr(struct elf_phdr *phdr, int phnum)
bellard31e31b82003-02-18 22:55:36 +00001065{
Richard Henderson991f8f02010-07-27 10:25:32 -07001066 int i;
1067 for (i = 0; i < phnum; ++i, ++phdr) {
1068 bswap32s(&phdr->p_type); /* Segment type */
1069 bswap32s(&phdr->p_flags); /* Segment flags */
1070 bswaptls(&phdr->p_offset); /* Segment file offset */
1071 bswaptls(&phdr->p_vaddr); /* Segment virtual address */
1072 bswaptls(&phdr->p_paddr); /* Segment physical address */
1073 bswaptls(&phdr->p_filesz); /* Segment size in file */
1074 bswaptls(&phdr->p_memsz); /* Segment size in memory */
1075 bswaptls(&phdr->p_align); /* Segment alignment */
1076 }
bellard31e31b82003-02-18 22:55:36 +00001077}
bellard689f9362003-04-29 20:40:07 +00001078
Richard Henderson991f8f02010-07-27 10:25:32 -07001079static void bswap_shdr(struct elf_shdr *shdr, int shnum)
bellard689f9362003-04-29 20:40:07 +00001080{
Richard Henderson991f8f02010-07-27 10:25:32 -07001081 int i;
1082 for (i = 0; i < shnum; ++i, ++shdr) {
1083 bswap32s(&shdr->sh_name);
1084 bswap32s(&shdr->sh_type);
1085 bswaptls(&shdr->sh_flags);
1086 bswaptls(&shdr->sh_addr);
1087 bswaptls(&shdr->sh_offset);
1088 bswaptls(&shdr->sh_size);
1089 bswap32s(&shdr->sh_link);
1090 bswap32s(&shdr->sh_info);
1091 bswaptls(&shdr->sh_addralign);
1092 bswaptls(&shdr->sh_entsize);
1093 }
bellard689f9362003-04-29 20:40:07 +00001094}
1095
j_mayer7a3148a2007-04-05 07:13:51 +00001096static void bswap_sym(struct elf_sym *sym)
bellard689f9362003-04-29 20:40:07 +00001097{
1098 bswap32s(&sym->st_name);
j_mayer7a3148a2007-04-05 07:13:51 +00001099 bswaptls(&sym->st_value);
1100 bswaptls(&sym->st_size);
bellard689f9362003-04-29 20:40:07 +00001101 bswap16s(&sym->st_shndx);
1102}
Richard Henderson991f8f02010-07-27 10:25:32 -07001103#else
1104static inline void bswap_ehdr(struct elfhdr *ehdr) { }
1105static inline void bswap_phdr(struct elf_phdr *phdr, int phnum) { }
1106static inline void bswap_shdr(struct elf_shdr *shdr, int shnum) { }
1107static inline void bswap_sym(struct elf_sym *sym) { }
bellard31e31b82003-02-18 22:55:36 +00001108#endif
1109
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001110#ifdef USE_ELF_CORE_DUMP
Andreas Färber9349b4f2012-03-14 01:38:32 +01001111static int elf_core_dump(int, const CPUArchState *);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001112#endif /* USE_ELF_CORE_DUMP */
Richard Henderson682674b2010-07-27 10:25:33 -07001113static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001114
Richard Henderson9058abd2010-07-27 10:25:34 -07001115/* Verify the portions of EHDR within E_IDENT for the target.
1116 This can be performed before bswapping the entire header. */
1117static bool elf_check_ident(struct elfhdr *ehdr)
1118{
1119 return (ehdr->e_ident[EI_MAG0] == ELFMAG0
1120 && ehdr->e_ident[EI_MAG1] == ELFMAG1
1121 && ehdr->e_ident[EI_MAG2] == ELFMAG2
1122 && ehdr->e_ident[EI_MAG3] == ELFMAG3
1123 && ehdr->e_ident[EI_CLASS] == ELF_CLASS
1124 && ehdr->e_ident[EI_DATA] == ELF_DATA
1125 && ehdr->e_ident[EI_VERSION] == EV_CURRENT);
1126}
1127
1128/* Verify the portions of EHDR outside of E_IDENT for the target.
1129 This has to wait until after bswapping the header. */
1130static bool elf_check_ehdr(struct elfhdr *ehdr)
1131{
1132 return (elf_check_arch(ehdr->e_machine)
1133 && ehdr->e_ehsize == sizeof(struct elfhdr)
1134 && ehdr->e_phentsize == sizeof(struct elf_phdr)
1135 && ehdr->e_shentsize == sizeof(struct elf_shdr)
1136 && (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN));
1137}
1138
bellard31e31b82003-02-18 22:55:36 +00001139/*
pbrooke5fe0c52006-06-11 13:32:59 +00001140 * 'copy_elf_strings()' copies argument/envelope strings from user
bellard31e31b82003-02-18 22:55:36 +00001141 * memory to free pages in kernel mem. These are in a format ready
1142 * to be put directly into the top of new user memory.
1143 *
1144 */
blueswir1992f48a2007-10-14 16:27:31 +00001145static abi_ulong copy_elf_strings(int argc,char ** argv, void **page,
1146 abi_ulong p)
bellard31e31b82003-02-18 22:55:36 +00001147{
1148 char *tmp, *tmp1, *pag = NULL;
1149 int len, offset = 0;
1150
1151 if (!p) {
Richard Hendersond97ef722010-07-27 10:25:29 -07001152 return 0; /* bullet-proofing */
bellard31e31b82003-02-18 22:55:36 +00001153 }
1154 while (argc-- > 0) {
bellardedf779f2004-02-22 13:40:13 +00001155 tmp = argv[argc];
1156 if (!tmp) {
Richard Hendersond97ef722010-07-27 10:25:29 -07001157 fprintf(stderr, "VFS: argc is wrong");
1158 exit(-1);
1159 }
bellardedf779f2004-02-22 13:40:13 +00001160 tmp1 = tmp;
Richard Hendersond97ef722010-07-27 10:25:29 -07001161 while (*tmp++);
1162 len = tmp - tmp1;
1163 if (p < len) { /* this shouldn't happen - 128kB */
1164 return 0;
1165 }
1166 while (len) {
1167 --p; --tmp; --len;
1168 if (--offset < 0) {
1169 offset = p % TARGET_PAGE_SIZE;
pbrook53a59602006-03-25 19:31:22 +00001170 pag = (char *)page[p/TARGET_PAGE_SIZE];
bellard44a91ca2004-01-18 22:05:44 +00001171 if (!pag) {
Peter Maydell7dd47662011-11-09 19:22:11 +00001172 pag = g_try_malloc0(TARGET_PAGE_SIZE);
pbrook53a59602006-03-25 19:31:22 +00001173 page[p/TARGET_PAGE_SIZE] = pag;
bellard44a91ca2004-01-18 22:05:44 +00001174 if (!pag)
1175 return 0;
Richard Hendersond97ef722010-07-27 10:25:29 -07001176 }
1177 }
1178 if (len == 0 || offset == 0) {
1179 *(pag + offset) = *tmp;
1180 }
1181 else {
1182 int bytes_to_copy = (len > offset) ? offset : len;
1183 tmp -= bytes_to_copy;
1184 p -= bytes_to_copy;
1185 offset -= bytes_to_copy;
1186 len -= bytes_to_copy;
1187 memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
1188 }
1189 }
bellard31e31b82003-02-18 22:55:36 +00001190 }
1191 return p;
1192}
1193
blueswir1992f48a2007-10-14 16:27:31 +00001194static abi_ulong setup_arg_pages(abi_ulong p, struct linux_binprm *bprm,
1195 struct image_info *info)
pbrook53a59602006-03-25 19:31:22 +00001196{
Richard Henderson60dcbcb2010-07-27 10:25:35 -07001197 abi_ulong stack_base, size, error, guard;
bellard31e31b82003-02-18 22:55:36 +00001198 int i;
bellard31e31b82003-02-18 22:55:36 +00001199
1200 /* Create enough stack to hold everything. If we don't use
Richard Henderson60dcbcb2010-07-27 10:25:35 -07001201 it for args, we'll use it for something else. */
Richard Henderson703e0e82010-03-19 14:21:13 -07001202 size = guest_stack_size;
Richard Henderson60dcbcb2010-07-27 10:25:35 -07001203 if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE) {
bellard54936002003-05-13 00:25:15 +00001204 size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;
Richard Henderson60dcbcb2010-07-27 10:25:35 -07001205 }
1206 guard = TARGET_PAGE_SIZE;
1207 if (guard < qemu_real_host_page_size) {
1208 guard = qemu_real_host_page_size;
1209 }
1210
1211 error = target_mmap(0, size + guard, PROT_READ | PROT_WRITE,
1212 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
bellard09bfb052003-04-10 00:03:40 +00001213 if (error == -1) {
Richard Henderson60dcbcb2010-07-27 10:25:35 -07001214 perror("mmap stack");
bellard09bfb052003-04-10 00:03:40 +00001215 exit(-1);
bellard31e31b82003-02-18 22:55:36 +00001216 }
bellard09bfb052003-04-10 00:03:40 +00001217
Richard Henderson60dcbcb2010-07-27 10:25:35 -07001218 /* We reserve one extra page at the top of the stack as guard. */
1219 target_mprotect(error, guard, PROT_NONE);
1220
1221 info->stack_limit = error + guard;
1222 stack_base = info->stack_limit + size - MAX_ARG_PAGES*TARGET_PAGE_SIZE;
bellard09bfb052003-04-10 00:03:40 +00001223 p += stack_base;
1224
bellard31e31b82003-02-18 22:55:36 +00001225 for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
Richard Hendersond97ef722010-07-27 10:25:29 -07001226 if (bprm->page[i]) {
1227 info->rss++;
bellard579a97f2007-11-11 14:26:47 +00001228 /* FIXME - check return value of memcpy_to_target() for failure */
Richard Hendersond97ef722010-07-27 10:25:29 -07001229 memcpy_to_target(stack_base, bprm->page[i], TARGET_PAGE_SIZE);
Peter Maydell7dd47662011-11-09 19:22:11 +00001230 g_free(bprm->page[i]);
Richard Hendersond97ef722010-07-27 10:25:29 -07001231 }
pbrook53a59602006-03-25 19:31:22 +00001232 stack_base += TARGET_PAGE_SIZE;
bellard31e31b82003-02-18 22:55:36 +00001233 }
1234 return p;
1235}
1236
Richard Hendersoncf129f32010-07-27 10:25:27 -07001237/* Map and zero the bss. We need to explicitly zero any fractional pages
1238 after the data section (i.e. bss). */
1239static void zero_bss(abi_ulong elf_bss, abi_ulong last_bss, int prot)
bellard31e31b82003-02-18 22:55:36 +00001240{
Richard Hendersoncf129f32010-07-27 10:25:27 -07001241 uintptr_t host_start, host_map_start, host_end;
bellard31e31b82003-02-18 22:55:36 +00001242
Richard Hendersoncf129f32010-07-27 10:25:27 -07001243 last_bss = TARGET_PAGE_ALIGN(last_bss);
bellard31e31b82003-02-18 22:55:36 +00001244
Richard Hendersoncf129f32010-07-27 10:25:27 -07001245 /* ??? There is confusion between qemu_real_host_page_size and
1246 qemu_host_page_size here and elsewhere in target_mmap, which
1247 may lead to the end of the data section mapping from the file
1248 not being mapped. At least there was an explicit test and
1249 comment for that here, suggesting that "the file size must
1250 be known". The comment probably pre-dates the introduction
1251 of the fstat system call in target_mmap which does in fact
1252 find out the size. What isn't clear is if the workaround
1253 here is still actually needed. For now, continue with it,
1254 but merge it with the "normal" mmap that would allocate the bss. */
bellard31e31b82003-02-18 22:55:36 +00001255
Richard Hendersoncf129f32010-07-27 10:25:27 -07001256 host_start = (uintptr_t) g2h(elf_bss);
1257 host_end = (uintptr_t) g2h(last_bss);
1258 host_map_start = (host_start + qemu_real_host_page_size - 1);
1259 host_map_start &= -qemu_real_host_page_size;
ths768a4a32006-12-14 13:32:11 +00001260
Richard Hendersoncf129f32010-07-27 10:25:27 -07001261 if (host_map_start < host_end) {
1262 void *p = mmap((void *)host_map_start, host_end - host_map_start,
1263 prot, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
1264 if (p == MAP_FAILED) {
1265 perror("cannot mmap brk");
1266 exit(-1);
bellard853d6f72003-09-30 20:58:32 +00001267 }
1268
Richard Hendersoncf129f32010-07-27 10:25:27 -07001269 /* Since we didn't use target_mmap, make sure to record
1270 the validity of the pages with qemu. */
1271 page_set_flags(elf_bss & TARGET_PAGE_MASK, last_bss, prot|PAGE_VALID);
1272 }
bellard31e31b82003-02-18 22:55:36 +00001273
Richard Hendersoncf129f32010-07-27 10:25:27 -07001274 if (host_start < host_map_start) {
1275 memset((void *)host_start, 0, host_map_start - host_start);
1276 }
1277}
bellardedf779f2004-02-22 13:40:13 +00001278
Mike Frysinger1af02e82011-02-07 01:05:50 -05001279#ifdef CONFIG_USE_FDPIC
1280static abi_ulong loader_build_fdpic_loadmap(struct image_info *info, abi_ulong sp)
1281{
1282 uint16_t n;
1283 struct elf32_fdpic_loadseg *loadsegs = info->loadsegs;
1284
1285 /* elf32_fdpic_loadseg */
1286 n = info->nsegs;
1287 while (n--) {
1288 sp -= 12;
1289 put_user_u32(loadsegs[n].addr, sp+0);
1290 put_user_u32(loadsegs[n].p_vaddr, sp+4);
1291 put_user_u32(loadsegs[n].p_memsz, sp+8);
1292 }
1293
1294 /* elf32_fdpic_loadmap */
1295 sp -= 4;
1296 put_user_u16(0, sp+0); /* version */
1297 put_user_u16(info->nsegs, sp+2); /* nsegs */
1298
1299 info->personality = PER_LINUX_FDPIC;
1300 info->loadmap_addr = sp;
1301
1302 return sp;
1303}
1304#endif
1305
blueswir1992f48a2007-10-14 16:27:31 +00001306static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,
Richard Henderson8e62a712010-07-27 10:25:37 -07001307 struct elfhdr *exec,
1308 struct image_info *info,
1309 struct image_info *interp_info)
pbrook53a59602006-03-25 19:31:22 +00001310{
Richard Hendersond97ef722010-07-27 10:25:29 -07001311 abi_ulong sp;
Alexander Graf125b0f52012-01-28 21:12:14 +02001312 abi_ulong sp_auxv;
Richard Hendersond97ef722010-07-27 10:25:29 -07001313 int size;
Laurent ALFONSI14322ba2011-06-20 08:43:13 +02001314 int i;
1315 abi_ulong u_rand_bytes;
1316 uint8_t k_rand_bytes[16];
Richard Hendersond97ef722010-07-27 10:25:29 -07001317 abi_ulong u_platform;
1318 const char *k_platform;
1319 const int n = sizeof(elf_addr_t);
pbrook53a59602006-03-25 19:31:22 +00001320
Richard Hendersond97ef722010-07-27 10:25:29 -07001321 sp = p;
Mike Frysinger1af02e82011-02-07 01:05:50 -05001322
1323#ifdef CONFIG_USE_FDPIC
1324 /* Needs to be before we load the env/argc/... */
1325 if (elf_is_fdpic(exec)) {
1326 /* Need 4 byte alignment for these structs */
1327 sp &= ~3;
1328 sp = loader_build_fdpic_loadmap(info, sp);
1329 info->other_info = interp_info;
1330 if (interp_info) {
1331 interp_info->other_info = info;
1332 sp = loader_build_fdpic_loadmap(interp_info, sp);
1333 }
1334 }
1335#endif
1336
Richard Hendersond97ef722010-07-27 10:25:29 -07001337 u_platform = 0;
1338 k_platform = ELF_PLATFORM;
1339 if (k_platform) {
1340 size_t len = strlen(k_platform) + 1;
1341 sp -= (len + n - 1) & ~(n - 1);
1342 u_platform = sp;
1343 /* FIXME - check return value of memcpy_to_target() for failure */
1344 memcpy_to_target(sp, k_platform, len);
1345 }
Laurent ALFONSI14322ba2011-06-20 08:43:13 +02001346
1347 /*
1348 * Generate 16 random bytes for userspace PRNG seeding (not
1349 * cryptically secure but it's not the aim of QEMU).
1350 */
1351 srand((unsigned int) time(NULL));
1352 for (i = 0; i < 16; i++) {
1353 k_rand_bytes[i] = rand();
1354 }
1355 sp -= 16;
1356 u_rand_bytes = sp;
1357 /* FIXME - check return value of memcpy_to_target() for failure */
1358 memcpy_to_target(sp, k_rand_bytes, 16);
1359
Richard Hendersond97ef722010-07-27 10:25:29 -07001360 /*
1361 * Force 16 byte _final_ alignment here for generality.
1362 */
1363 sp = sp &~ (abi_ulong)15;
1364 size = (DLINFO_ITEMS + 1) * 2;
1365 if (k_platform)
1366 size += 2;
bellardf5155282004-01-04 15:46:50 +00001367#ifdef DLINFO_ARCH_ITEMS
Richard Hendersond97ef722010-07-27 10:25:29 -07001368 size += DLINFO_ARCH_ITEMS * 2;
bellardf5155282004-01-04 15:46:50 +00001369#endif
Richard Hendersond97ef722010-07-27 10:25:29 -07001370 size += envc + argc + 2;
Richard Hendersonb9329d42010-07-27 10:25:36 -07001371 size += 1; /* argc itself */
Richard Hendersond97ef722010-07-27 10:25:29 -07001372 size *= n;
1373 if (size & 15)
1374 sp -= 16 - (size & 15);
ths3b46e622007-09-17 08:09:54 +00001375
Richard Hendersond97ef722010-07-27 10:25:29 -07001376 /* This is correct because Linux defines
1377 * elf_addr_t as Elf32_Off / Elf64_Off
1378 */
1379#define NEW_AUX_ENT(id, val) do { \
1380 sp -= n; put_user_ual(val, sp); \
1381 sp -= n; put_user_ual(id, sp); \
1382 } while(0)
bellard2f619692007-11-16 10:46:05 +00001383
Alexander Graf125b0f52012-01-28 21:12:14 +02001384 sp_auxv = sp;
Richard Hendersond97ef722010-07-27 10:25:29 -07001385 NEW_AUX_ENT (AT_NULL, 0);
bellardf5155282004-01-04 15:46:50 +00001386
Richard Hendersond97ef722010-07-27 10:25:29 -07001387 /* There must be exactly DLINFO_ITEMS entries here. */
Richard Henderson8e62a712010-07-27 10:25:37 -07001388 NEW_AUX_ENT(AT_PHDR, (abi_ulong)(info->load_addr + exec->e_phoff));
Richard Hendersond97ef722010-07-27 10:25:29 -07001389 NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr)));
1390 NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));
1391 NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(TARGET_PAGE_SIZE));
Richard Henderson8e62a712010-07-27 10:25:37 -07001392 NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_info ? interp_info->load_addr : 0));
Richard Hendersond97ef722010-07-27 10:25:29 -07001393 NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);
Richard Henderson8e62a712010-07-27 10:25:37 -07001394 NEW_AUX_ENT(AT_ENTRY, info->entry);
Richard Hendersond97ef722010-07-27 10:25:29 -07001395 NEW_AUX_ENT(AT_UID, (abi_ulong) getuid());
1396 NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid());
1397 NEW_AUX_ENT(AT_GID, (abi_ulong) getgid());
1398 NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid());
1399 NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP);
1400 NEW_AUX_ENT(AT_CLKTCK, (abi_ulong) sysconf(_SC_CLK_TCK));
Laurent ALFONSI14322ba2011-06-20 08:43:13 +02001401 NEW_AUX_ENT(AT_RANDOM, (abi_ulong) u_rand_bytes);
1402
Richard Hendersond97ef722010-07-27 10:25:29 -07001403 if (k_platform)
1404 NEW_AUX_ENT(AT_PLATFORM, u_platform);
bellardf5155282004-01-04 15:46:50 +00001405#ifdef ARCH_DLINFO
Richard Hendersond97ef722010-07-27 10:25:29 -07001406 /*
1407 * ARCH_DLINFO must come last so platform specific code can enforce
1408 * special alignment requirements on the AUXV if necessary (eg. PPC).
1409 */
1410 ARCH_DLINFO;
bellardf5155282004-01-04 15:46:50 +00001411#endif
1412#undef NEW_AUX_ENT
1413
Richard Hendersond97ef722010-07-27 10:25:29 -07001414 info->saved_auxv = sp;
Alexander Graf125b0f52012-01-28 21:12:14 +02001415 info->auxv_len = sp_auxv - sp;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001416
Richard Hendersonb9329d42010-07-27 10:25:36 -07001417 sp = loader_build_argptr(envc, argc, sp, p, 0);
Richard Hendersond97ef722010-07-27 10:25:29 -07001418 return sp;
bellard31e31b82003-02-18 22:55:36 +00001419}
1420
Dr. David Alan Gilbert97cc7562011-08-31 17:24:34 +01001421#ifndef TARGET_HAS_GUEST_VALIDATE_BASE
1422/* If the guest doesn't have a validation function just agree */
1423bool guest_validate_base(unsigned long guest_base)
1424{
1425 return 1;
1426}
1427#endif
1428
Peter Maydellf3ed1f52011-05-17 13:34:46 +01001429static void probe_guest_base(const char *image_name,
1430 abi_ulong loaddr, abi_ulong hiaddr)
1431{
1432 /* Probe for a suitable guest base address, if the user has not set
1433 * it explicitly, and set guest_base appropriately.
1434 * In case of error we will print a suitable message and exit.
1435 */
1436#if defined(CONFIG_USE_GUEST_BASE)
1437 const char *errmsg;
1438 if (!have_guest_base && !reserved_va) {
1439 unsigned long host_start, real_start, host_size;
1440
1441 /* Round addresses to page boundaries. */
1442 loaddr &= qemu_host_page_mask;
1443 hiaddr = HOST_PAGE_ALIGN(hiaddr);
1444
1445 if (loaddr < mmap_min_addr) {
1446 host_start = HOST_PAGE_ALIGN(mmap_min_addr);
1447 } else {
1448 host_start = loaddr;
1449 if (host_start != loaddr) {
1450 errmsg = "Address overflow loading ELF binary";
1451 goto exit_errmsg;
1452 }
1453 }
1454 host_size = hiaddr - loaddr;
1455 while (1) {
1456 /* Do not use mmap_find_vma here because that is limited to the
1457 guest address space. We are going to make the
1458 guest address space fit whatever we're given. */
1459 real_start = (unsigned long)
1460 mmap((void *)host_start, host_size, PROT_NONE,
1461 MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE, -1, 0);
1462 if (real_start == (unsigned long)-1) {
1463 goto exit_perror;
1464 }
Dr. David Alan Gilbert97cc7562011-08-31 17:24:34 +01001465 guest_base = real_start - loaddr;
1466 if ((real_start == host_start) &&
1467 guest_validate_base(guest_base)) {
Peter Maydellf3ed1f52011-05-17 13:34:46 +01001468 break;
1469 }
1470 /* That address didn't work. Unmap and try a different one.
1471 The address the host picked because is typically right at
1472 the top of the host address space and leaves the guest with
1473 no usable address space. Resort to a linear search. We
1474 already compensated for mmap_min_addr, so this should not
1475 happen often. Probably means we got unlucky and host
1476 address space randomization put a shared library somewhere
1477 inconvenient. */
1478 munmap((void *)real_start, host_size);
1479 host_start += qemu_host_page_size;
1480 if (host_start == loaddr) {
1481 /* Theoretically possible if host doesn't have any suitably
1482 aligned areas. Normally the first mmap will fail. */
1483 errmsg = "Unable to find space for application";
1484 goto exit_errmsg;
1485 }
1486 }
1487 qemu_log("Relocating guest address space from 0x"
1488 TARGET_ABI_FMT_lx " to 0x%lx\n",
1489 loaddr, real_start);
Peter Maydellf3ed1f52011-05-17 13:34:46 +01001490 }
1491 return;
1492
1493exit_perror:
1494 errmsg = strerror(errno);
1495exit_errmsg:
1496 fprintf(stderr, "%s: %s\n", image_name, errmsg);
1497 exit(-1);
1498#endif
1499}
1500
1501
Richard Henderson8e62a712010-07-27 10:25:37 -07001502/* Load an ELF image into the address space.
bellard31e31b82003-02-18 22:55:36 +00001503
Richard Henderson8e62a712010-07-27 10:25:37 -07001504 IMAGE_NAME is the filename of the image, to use in error messages.
1505 IMAGE_FD is the open file descriptor for the image.
1506
1507 BPRM_BUF is a copy of the beginning of the file; this of course
1508 contains the elf file header at offset 0. It is assumed that this
1509 buffer is sufficiently aligned to present no problems to the host
1510 in accessing data at aligned offsets within the buffer.
1511
1512 On return: INFO values will be filled in, as necessary or available. */
1513
1514static void load_elf_image(const char *image_name, int image_fd,
Richard Hendersonbf858892010-07-27 10:25:38 -07001515 struct image_info *info, char **pinterp_name,
Richard Henderson8e62a712010-07-27 10:25:37 -07001516 char bprm_buf[BPRM_BUF_SIZE])
bellard31e31b82003-02-18 22:55:36 +00001517{
Richard Henderson8e62a712010-07-27 10:25:37 -07001518 struct elfhdr *ehdr = (struct elfhdr *)bprm_buf;
1519 struct elf_phdr *phdr;
1520 abi_ulong load_addr, load_bias, loaddr, hiaddr, error;
1521 int i, retval;
1522 const char *errmsg;
ths5fafdf22007-09-16 21:08:06 +00001523
Richard Henderson8e62a712010-07-27 10:25:37 -07001524 /* First of all, some simple consistency checks */
1525 errmsg = "Invalid ELF image for this architecture";
1526 if (!elf_check_ident(ehdr)) {
1527 goto exit_errmsg;
1528 }
1529 bswap_ehdr(ehdr);
1530 if (!elf_check_ehdr(ehdr)) {
1531 goto exit_errmsg;
Richard Hendersond97ef722010-07-27 10:25:29 -07001532 }
ths5fafdf22007-09-16 21:08:06 +00001533
Richard Henderson8e62a712010-07-27 10:25:37 -07001534 i = ehdr->e_phnum * sizeof(struct elf_phdr);
1535 if (ehdr->e_phoff + i <= BPRM_BUF_SIZE) {
1536 phdr = (struct elf_phdr *)(bprm_buf + ehdr->e_phoff);
Richard Henderson9955ffa2010-07-27 10:25:30 -07001537 } else {
Richard Henderson8e62a712010-07-27 10:25:37 -07001538 phdr = (struct elf_phdr *) alloca(i);
1539 retval = pread(image_fd, phdr, i, ehdr->e_phoff);
Richard Henderson9955ffa2010-07-27 10:25:30 -07001540 if (retval != i) {
Richard Henderson8e62a712010-07-27 10:25:37 -07001541 goto exit_read;
Richard Henderson9955ffa2010-07-27 10:25:30 -07001542 }
Richard Hendersond97ef722010-07-27 10:25:29 -07001543 }
Richard Henderson8e62a712010-07-27 10:25:37 -07001544 bswap_phdr(phdr, ehdr->e_phnum);
bellard09bfb052003-04-10 00:03:40 +00001545
Mike Frysinger1af02e82011-02-07 01:05:50 -05001546#ifdef CONFIG_USE_FDPIC
1547 info->nsegs = 0;
1548 info->pt_dynamic_addr = 0;
1549#endif
1550
Richard Henderson682674b2010-07-27 10:25:33 -07001551 /* Find the maximum size of the image and allocate an appropriate
1552 amount of memory to handle that. */
1553 loaddr = -1, hiaddr = 0;
Richard Henderson8e62a712010-07-27 10:25:37 -07001554 for (i = 0; i < ehdr->e_phnum; ++i) {
1555 if (phdr[i].p_type == PT_LOAD) {
1556 abi_ulong a = phdr[i].p_vaddr;
Richard Henderson682674b2010-07-27 10:25:33 -07001557 if (a < loaddr) {
1558 loaddr = a;
1559 }
Richard Henderson8e62a712010-07-27 10:25:37 -07001560 a += phdr[i].p_memsz;
Richard Henderson682674b2010-07-27 10:25:33 -07001561 if (a > hiaddr) {
1562 hiaddr = a;
1563 }
Mike Frysinger1af02e82011-02-07 01:05:50 -05001564#ifdef CONFIG_USE_FDPIC
1565 ++info->nsegs;
1566#endif
Richard Henderson682674b2010-07-27 10:25:33 -07001567 }
1568 }
1569
1570 load_addr = loaddr;
Richard Henderson8e62a712010-07-27 10:25:37 -07001571 if (ehdr->e_type == ET_DYN) {
Richard Henderson682674b2010-07-27 10:25:33 -07001572 /* The image indicates that it can be loaded anywhere. Find a
1573 location that can hold the memory space required. If the
1574 image is pre-linked, LOADDR will be non-zero. Since we do
1575 not supply MAP_FIXED here we'll use that address if and
1576 only if it remains available. */
1577 load_addr = target_mmap(loaddr, hiaddr - loaddr, PROT_NONE,
1578 MAP_PRIVATE | MAP_ANON | MAP_NORESERVE,
1579 -1, 0);
1580 if (load_addr == -1) {
Richard Henderson8e62a712010-07-27 10:25:37 -07001581 goto exit_perror;
Richard Hendersond97ef722010-07-27 10:25:29 -07001582 }
Richard Hendersonbf858892010-07-27 10:25:38 -07001583 } else if (pinterp_name != NULL) {
1584 /* This is the main executable. Make sure that the low
1585 address does not conflict with MMAP_MIN_ADDR or the
1586 QEMU application itself. */
Peter Maydellf3ed1f52011-05-17 13:34:46 +01001587 probe_guest_base(image_name, loaddr, hiaddr);
Richard Hendersond97ef722010-07-27 10:25:29 -07001588 }
Richard Henderson682674b2010-07-27 10:25:33 -07001589 load_bias = load_addr - loaddr;
Richard Hendersond97ef722010-07-27 10:25:29 -07001590
Mike Frysinger1af02e82011-02-07 01:05:50 -05001591#ifdef CONFIG_USE_FDPIC
1592 {
1593 struct elf32_fdpic_loadseg *loadsegs = info->loadsegs =
Anthony Liguori7267c092011-08-20 22:09:37 -05001594 g_malloc(sizeof(*loadsegs) * info->nsegs);
Mike Frysinger1af02e82011-02-07 01:05:50 -05001595
1596 for (i = 0; i < ehdr->e_phnum; ++i) {
1597 switch (phdr[i].p_type) {
1598 case PT_DYNAMIC:
1599 info->pt_dynamic_addr = phdr[i].p_vaddr + load_bias;
1600 break;
1601 case PT_LOAD:
1602 loadsegs->addr = phdr[i].p_vaddr + load_bias;
1603 loadsegs->p_vaddr = phdr[i].p_vaddr;
1604 loadsegs->p_memsz = phdr[i].p_memsz;
1605 ++loadsegs;
1606 break;
1607 }
1608 }
1609 }
1610#endif
1611
Richard Henderson8e62a712010-07-27 10:25:37 -07001612 info->load_bias = load_bias;
1613 info->load_addr = load_addr;
1614 info->entry = ehdr->e_entry + load_bias;
1615 info->start_code = -1;
1616 info->end_code = 0;
1617 info->start_data = -1;
1618 info->end_data = 0;
1619 info->brk = 0;
Paul Brookd8fd2952012-03-30 18:02:50 +01001620 info->elf_flags = ehdr->e_flags;
Richard Henderson8e62a712010-07-27 10:25:37 -07001621
1622 for (i = 0; i < ehdr->e_phnum; i++) {
1623 struct elf_phdr *eppnt = phdr + i;
Richard Hendersond97ef722010-07-27 10:25:29 -07001624 if (eppnt->p_type == PT_LOAD) {
Richard Henderson682674b2010-07-27 10:25:33 -07001625 abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em;
Richard Hendersond97ef722010-07-27 10:25:29 -07001626 int elf_prot = 0;
Richard Hendersond97ef722010-07-27 10:25:29 -07001627
1628 if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
1629 if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
1630 if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
bellard09bfb052003-04-10 00:03:40 +00001631
Richard Henderson682674b2010-07-27 10:25:33 -07001632 vaddr = load_bias + eppnt->p_vaddr;
1633 vaddr_po = TARGET_ELF_PAGEOFFSET(vaddr);
1634 vaddr_ps = TARGET_ELF_PAGESTART(vaddr);
1635
1636 error = target_mmap(vaddr_ps, eppnt->p_filesz + vaddr_po,
1637 elf_prot, MAP_PRIVATE | MAP_FIXED,
Richard Henderson8e62a712010-07-27 10:25:37 -07001638 image_fd, eppnt->p_offset - vaddr_po);
Richard Hendersond97ef722010-07-27 10:25:29 -07001639 if (error == -1) {
Richard Henderson8e62a712010-07-27 10:25:37 -07001640 goto exit_perror;
Richard Hendersond97ef722010-07-27 10:25:29 -07001641 }
bellard31e31b82003-02-18 22:55:36 +00001642
Richard Henderson682674b2010-07-27 10:25:33 -07001643 vaddr_ef = vaddr + eppnt->p_filesz;
1644 vaddr_em = vaddr + eppnt->p_memsz;
bellard31e31b82003-02-18 22:55:36 +00001645
Richard Hendersoncf129f32010-07-27 10:25:27 -07001646 /* If the load segment requests extra zeros (e.g. bss), map it. */
Richard Henderson682674b2010-07-27 10:25:33 -07001647 if (vaddr_ef < vaddr_em) {
1648 zero_bss(vaddr_ef, vaddr_em, elf_prot);
Richard Hendersoncf129f32010-07-27 10:25:27 -07001649 }
Richard Henderson8e62a712010-07-27 10:25:37 -07001650
1651 /* Find the full program boundaries. */
1652 if (elf_prot & PROT_EXEC) {
1653 if (vaddr < info->start_code) {
1654 info->start_code = vaddr;
1655 }
1656 if (vaddr_ef > info->end_code) {
1657 info->end_code = vaddr_ef;
1658 }
1659 }
1660 if (elf_prot & PROT_WRITE) {
1661 if (vaddr < info->start_data) {
1662 info->start_data = vaddr;
1663 }
1664 if (vaddr_ef > info->end_data) {
1665 info->end_data = vaddr_ef;
1666 }
1667 if (vaddr_em > info->brk) {
1668 info->brk = vaddr_em;
1669 }
1670 }
Richard Hendersonbf858892010-07-27 10:25:38 -07001671 } else if (eppnt->p_type == PT_INTERP && pinterp_name) {
1672 char *interp_name;
1673
1674 if (*pinterp_name) {
1675 errmsg = "Multiple PT_INTERP entries";
1676 goto exit_errmsg;
1677 }
1678 interp_name = malloc(eppnt->p_filesz);
1679 if (!interp_name) {
1680 goto exit_perror;
1681 }
1682
1683 if (eppnt->p_offset + eppnt->p_filesz <= BPRM_BUF_SIZE) {
1684 memcpy(interp_name, bprm_buf + eppnt->p_offset,
1685 eppnt->p_filesz);
1686 } else {
1687 retval = pread(image_fd, interp_name, eppnt->p_filesz,
1688 eppnt->p_offset);
1689 if (retval != eppnt->p_filesz) {
1690 goto exit_perror;
1691 }
1692 }
1693 if (interp_name[eppnt->p_filesz - 1] != 0) {
1694 errmsg = "Invalid PT_INTERP entry";
1695 goto exit_errmsg;
1696 }
1697 *pinterp_name = interp_name;
Richard Hendersond97ef722010-07-27 10:25:29 -07001698 }
Richard Henderson682674b2010-07-27 10:25:33 -07001699 }
ths5fafdf22007-09-16 21:08:06 +00001700
Richard Henderson8e62a712010-07-27 10:25:37 -07001701 if (info->end_data == 0) {
1702 info->start_data = info->end_code;
1703 info->end_data = info->end_code;
1704 info->brk = info->end_code;
Richard Henderson682674b2010-07-27 10:25:33 -07001705 }
bellard31e31b82003-02-18 22:55:36 +00001706
Richard Henderson8e62a712010-07-27 10:25:37 -07001707 if (qemu_log_enabled()) {
1708 load_symbols(ehdr, image_fd, load_bias);
1709 }
bellard31e31b82003-02-18 22:55:36 +00001710
Richard Henderson8e62a712010-07-27 10:25:37 -07001711 close(image_fd);
1712 return;
1713
1714 exit_read:
1715 if (retval >= 0) {
1716 errmsg = "Incomplete read of file header";
1717 goto exit_errmsg;
1718 }
1719 exit_perror:
1720 errmsg = strerror(errno);
1721 exit_errmsg:
1722 fprintf(stderr, "%s: %s\n", image_name, errmsg);
1723 exit(-1);
1724}
1725
1726static void load_elf_interp(const char *filename, struct image_info *info,
1727 char bprm_buf[BPRM_BUF_SIZE])
1728{
1729 int fd, retval;
1730
1731 fd = open(path(filename), O_RDONLY);
1732 if (fd < 0) {
1733 goto exit_perror;
1734 }
1735
1736 retval = read(fd, bprm_buf, BPRM_BUF_SIZE);
1737 if (retval < 0) {
1738 goto exit_perror;
1739 }
1740 if (retval < BPRM_BUF_SIZE) {
1741 memset(bprm_buf + retval, 0, BPRM_BUF_SIZE - retval);
1742 }
1743
Richard Hendersonbf858892010-07-27 10:25:38 -07001744 load_elf_image(filename, fd, info, NULL, bprm_buf);
Richard Henderson8e62a712010-07-27 10:25:37 -07001745 return;
1746
1747 exit_perror:
1748 fprintf(stderr, "%s: %s\n", filename, strerror(errno));
1749 exit(-1);
bellard31e31b82003-02-18 22:55:36 +00001750}
1751
pbrook49918a72008-10-22 15:11:31 +00001752static int symfind(const void *s0, const void *s1)
1753{
Stefan Weilc7c530c2012-01-05 15:39:39 +01001754 target_ulong addr = *(target_ulong *)s0;
pbrook49918a72008-10-22 15:11:31 +00001755 struct elf_sym *sym = (struct elf_sym *)s1;
1756 int result = 0;
Stefan Weilc7c530c2012-01-05 15:39:39 +01001757 if (addr < sym->st_value) {
pbrook49918a72008-10-22 15:11:31 +00001758 result = -1;
Stefan Weilc7c530c2012-01-05 15:39:39 +01001759 } else if (addr >= sym->st_value + sym->st_size) {
pbrook49918a72008-10-22 15:11:31 +00001760 result = 1;
1761 }
1762 return result;
1763}
1764
1765static const char *lookup_symbolxx(struct syminfo *s, target_ulong orig_addr)
1766{
1767#if ELF_CLASS == ELFCLASS32
1768 struct elf_sym *syms = s->disas_symtab.elf32;
1769#else
1770 struct elf_sym *syms = s->disas_symtab.elf64;
1771#endif
1772
1773 // binary search
pbrook49918a72008-10-22 15:11:31 +00001774 struct elf_sym *sym;
1775
Stefan Weilc7c530c2012-01-05 15:39:39 +01001776 sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind);
Blue Swirl7cba04f2009-08-01 10:13:20 +00001777 if (sym != NULL) {
pbrook49918a72008-10-22 15:11:31 +00001778 return s->disas_strtab + sym->st_name;
1779 }
1780
1781 return "";
1782}
1783
1784/* FIXME: This should use elf_ops.h */
1785static int symcmp(const void *s0, const void *s1)
1786{
1787 struct elf_sym *sym0 = (struct elf_sym *)s0;
1788 struct elf_sym *sym1 = (struct elf_sym *)s1;
1789 return (sym0->st_value < sym1->st_value)
1790 ? -1
1791 : ((sym0->st_value > sym1->st_value) ? 1 : 0);
1792}
1793
bellard689f9362003-04-29 20:40:07 +00001794/* Best attempt to load symbols from this ELF object. */
Richard Henderson682674b2010-07-27 10:25:33 -07001795static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias)
bellard689f9362003-04-29 20:40:07 +00001796{
Richard Henderson682674b2010-07-27 10:25:33 -07001797 int i, shnum, nsyms, sym_idx = 0, str_idx = 0;
1798 struct elf_shdr *shdr;
Cédric VINCENTb9475272011-06-01 14:36:38 +02001799 char *strings = NULL;
1800 struct syminfo *s = NULL;
1801 struct elf_sym *new_syms, *syms = NULL;
bellard31e31b82003-02-18 22:55:36 +00001802
Richard Henderson682674b2010-07-27 10:25:33 -07001803 shnum = hdr->e_shnum;
1804 i = shnum * sizeof(struct elf_shdr);
1805 shdr = (struct elf_shdr *)alloca(i);
1806 if (pread(fd, shdr, i, hdr->e_shoff) != i) {
1807 return;
1808 }
1809
1810 bswap_shdr(shdr, shnum);
1811 for (i = 0; i < shnum; ++i) {
1812 if (shdr[i].sh_type == SHT_SYMTAB) {
1813 sym_idx = i;
1814 str_idx = shdr[i].sh_link;
pbrook49918a72008-10-22 15:11:31 +00001815 goto found;
1816 }
bellard689f9362003-04-29 20:40:07 +00001817 }
Richard Henderson682674b2010-07-27 10:25:33 -07001818
1819 /* There will be no symbol table if the file was stripped. */
1820 return;
bellard689f9362003-04-29 20:40:07 +00001821
1822 found:
Richard Henderson682674b2010-07-27 10:25:33 -07001823 /* Now know where the strtab and symtab are. Snarf them. */
bellarde80cfcf2004-12-19 23:18:01 +00001824 s = malloc(sizeof(*s));
Richard Henderson682674b2010-07-27 10:25:33 -07001825 if (!s) {
Cédric VINCENTb9475272011-06-01 14:36:38 +02001826 goto give_up;
Richard Henderson682674b2010-07-27 10:25:33 -07001827 }
1828
1829 i = shdr[str_idx].sh_size;
1830 s->disas_strtab = strings = malloc(i);
1831 if (!strings || pread(fd, strings, i, shdr[str_idx].sh_offset) != i) {
Cédric VINCENTb9475272011-06-01 14:36:38 +02001832 goto give_up;
Richard Henderson682674b2010-07-27 10:25:33 -07001833 }
ths5fafdf22007-09-16 21:08:06 +00001834
Richard Henderson682674b2010-07-27 10:25:33 -07001835 i = shdr[sym_idx].sh_size;
1836 syms = malloc(i);
1837 if (!syms || pread(fd, syms, i, shdr[sym_idx].sh_offset) != i) {
Cédric VINCENTb9475272011-06-01 14:36:38 +02001838 goto give_up;
Richard Henderson682674b2010-07-27 10:25:33 -07001839 }
bellard689f9362003-04-29 20:40:07 +00001840
Richard Henderson682674b2010-07-27 10:25:33 -07001841 nsyms = i / sizeof(struct elf_sym);
1842 for (i = 0; i < nsyms; ) {
pbrook49918a72008-10-22 15:11:31 +00001843 bswap_sym(syms + i);
Richard Henderson682674b2010-07-27 10:25:33 -07001844 /* Throw away entries which we do not need. */
1845 if (syms[i].st_shndx == SHN_UNDEF
1846 || syms[i].st_shndx >= SHN_LORESERVE
1847 || ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) {
1848 if (i < --nsyms) {
pbrook49918a72008-10-22 15:11:31 +00001849 syms[i] = syms[nsyms];
1850 }
Richard Henderson682674b2010-07-27 10:25:33 -07001851 } else {
pbrook49918a72008-10-22 15:11:31 +00001852#if defined(TARGET_ARM) || defined (TARGET_MIPS)
Richard Henderson682674b2010-07-27 10:25:33 -07001853 /* The bottom address bit marks a Thumb or MIPS16 symbol. */
1854 syms[i].st_value &= ~(target_ulong)1;
blueswir10774bed2007-07-05 13:23:29 +00001855#endif
Richard Henderson682674b2010-07-27 10:25:33 -07001856 syms[i].st_value += load_bias;
1857 i++;
1858 }
blueswir10774bed2007-07-05 13:23:29 +00001859 }
bellard689f9362003-04-29 20:40:07 +00001860
Cédric VINCENTb9475272011-06-01 14:36:38 +02001861 /* No "useful" symbol. */
1862 if (nsyms == 0) {
1863 goto give_up;
1864 }
1865
Richard Henderson5d5c9932010-07-29 09:37:01 -07001866 /* Attempt to free the storage associated with the local symbols
1867 that we threw away. Whether or not this has any effect on the
1868 memory allocation depends on the malloc implementation and how
1869 many symbols we managed to discard. */
Stefan Weil8d79de62011-01-17 21:36:06 +01001870 new_syms = realloc(syms, nsyms * sizeof(*syms));
1871 if (new_syms == NULL) {
Cédric VINCENTb9475272011-06-01 14:36:38 +02001872 goto give_up;
Richard Henderson5d5c9932010-07-29 09:37:01 -07001873 }
Stefan Weil8d79de62011-01-17 21:36:06 +01001874 syms = new_syms;
Richard Henderson5d5c9932010-07-29 09:37:01 -07001875
pbrook49918a72008-10-22 15:11:31 +00001876 qsort(syms, nsyms, sizeof(*syms), symcmp);
1877
pbrook49918a72008-10-22 15:11:31 +00001878 s->disas_num_syms = nsyms;
1879#if ELF_CLASS == ELFCLASS32
1880 s->disas_symtab.elf32 = syms;
pbrook49918a72008-10-22 15:11:31 +00001881#else
1882 s->disas_symtab.elf64 = syms;
pbrook49918a72008-10-22 15:11:31 +00001883#endif
Richard Henderson682674b2010-07-27 10:25:33 -07001884 s->lookup_symbol = lookup_symbolxx;
bellarde80cfcf2004-12-19 23:18:01 +00001885 s->next = syminfos;
1886 syminfos = s;
Cédric VINCENTb9475272011-06-01 14:36:38 +02001887
1888 return;
1889
1890give_up:
1891 free(s);
1892 free(strings);
1893 free(syms);
bellard689f9362003-04-29 20:40:07 +00001894}
bellard31e31b82003-02-18 22:55:36 +00001895
pbrooke5fe0c52006-06-11 13:32:59 +00001896int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
1897 struct image_info * info)
bellard31e31b82003-02-18 22:55:36 +00001898{
Richard Henderson8e62a712010-07-27 10:25:37 -07001899 struct image_info interp_info;
bellard31e31b82003-02-18 22:55:36 +00001900 struct elfhdr elf_ex;
Richard Henderson8e62a712010-07-27 10:25:37 -07001901 char *elf_interpreter = NULL;
bellard31e31b82003-02-18 22:55:36 +00001902
Richard Hendersonbf858892010-07-27 10:25:38 -07001903 info->start_mmap = (abi_ulong)ELF_START_MMAP;
1904 info->mmap = 0;
1905 info->rss = 0;
bellard31e31b82003-02-18 22:55:36 +00001906
Richard Hendersonbf858892010-07-27 10:25:38 -07001907 load_elf_image(bprm->filename, bprm->fd, info,
1908 &elf_interpreter, bprm->buf);
1909
1910 /* ??? We need a copy of the elf header for passing to create_elf_tables.
1911 If we do nothing, we'll have overwritten this when we re-use bprm->buf
1912 when we load the interpreter. */
1913 elf_ex = *(struct elfhdr *)bprm->buf;
bellard31e31b82003-02-18 22:55:36 +00001914
pbrooke5fe0c52006-06-11 13:32:59 +00001915 bprm->p = copy_elf_strings(1, &bprm->filename, bprm->page, bprm->p);
1916 bprm->p = copy_elf_strings(bprm->envc,bprm->envp,bprm->page,bprm->p);
1917 bprm->p = copy_elf_strings(bprm->argc,bprm->argv,bprm->page,bprm->p);
1918 if (!bprm->p) {
Richard Hendersonbf858892010-07-27 10:25:38 -07001919 fprintf(stderr, "%s: %s\n", bprm->filename, strerror(E2BIG));
1920 exit(-1);
pbrooke5fe0c52006-06-11 13:32:59 +00001921 }
1922
bellard31e31b82003-02-18 22:55:36 +00001923 /* Do this so that we can load the interpreter, if need be. We will
1924 change some of these later */
bellard31e31b82003-02-18 22:55:36 +00001925 bprm->p = setup_arg_pages(bprm->p, bprm, info);
bellard31e31b82003-02-18 22:55:36 +00001926
Richard Henderson8e62a712010-07-27 10:25:37 -07001927 if (elf_interpreter) {
1928 load_elf_interp(elf_interpreter, &interp_info, bprm->buf);
bellard31e31b82003-02-18 22:55:36 +00001929
Richard Henderson8e62a712010-07-27 10:25:37 -07001930 /* If the program interpreter is one of these two, then assume
1931 an iBCS2 image. Otherwise assume a native linux image. */
bellard31e31b82003-02-18 22:55:36 +00001932
Richard Henderson8e62a712010-07-27 10:25:37 -07001933 if (strcmp(elf_interpreter, "/usr/lib/libc.so.1") == 0
1934 || strcmp(elf_interpreter, "/usr/lib/ld.so.1") == 0) {
1935 info->personality = PER_SVR4;
1936
1937 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1938 and some applications "depend" upon this behavior. Since
1939 we do not have the power to recompile these, we emulate
1940 the SVr4 behavior. Sigh. */
1941 target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
1942 MAP_FIXED | MAP_PRIVATE, -1, 0);
1943 }
bellard31e31b82003-02-18 22:55:36 +00001944 }
1945
Richard Henderson8e62a712010-07-27 10:25:37 -07001946 bprm->p = create_elf_tables(bprm->p, bprm->argc, bprm->envc, &elf_ex,
1947 info, (elf_interpreter ? &interp_info : NULL));
1948 info->start_stack = bprm->p;
1949
1950 /* If we have an interpreter, set that as the program's entry point.
Richard Henderson8e780642011-10-26 09:59:17 -07001951 Copy the load_bias as well, to help PPC64 interpret the entry
Richard Henderson8e62a712010-07-27 10:25:37 -07001952 point as a function descriptor. Do this after creating elf tables
1953 so that we copy the original program entry point into the AUXV. */
1954 if (elf_interpreter) {
Richard Henderson8e780642011-10-26 09:59:17 -07001955 info->load_bias = interp_info.load_bias;
Richard Henderson8e62a712010-07-27 10:25:37 -07001956 info->entry = interp_info.entry;
Richard Hendersonbf858892010-07-27 10:25:38 -07001957 free(elf_interpreter);
Richard Henderson8e62a712010-07-27 10:25:37 -07001958 }
bellard31e31b82003-02-18 22:55:36 +00001959
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001960#ifdef USE_ELF_CORE_DUMP
1961 bprm->core_dump = &elf_core_dump;
1962#endif
1963
bellard31e31b82003-02-18 22:55:36 +00001964 return 0;
1965}
1966
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001967#ifdef USE_ELF_CORE_DUMP
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001968/*
1969 * Definitions to generate Intel SVR4-like core files.
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01001970 * These mostly have the same names as the SVR4 types with "target_elf_"
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001971 * tacked on the front to prevent clashes with linux definitions,
1972 * and the typedef forms have been avoided. This is mostly like
1973 * the SVR4 structure, but more Linuxy, with things that Linux does
1974 * not support and which gdb doesn't really use excluded.
1975 *
1976 * Fields we don't dump (their contents is zero) in linux-user qemu
1977 * are marked with XXX.
1978 *
1979 * Core dump code is copied from linux kernel (fs/binfmt_elf.c).
1980 *
1981 * Porting ELF coredump for target is (quite) simple process. First you
Nathan Froyddd0a3652009-12-11 09:04:45 -08001982 * define USE_ELF_CORE_DUMP in target ELF code (where init_thread() for
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001983 * the target resides):
1984 *
1985 * #define USE_ELF_CORE_DUMP
1986 *
1987 * Next you define type of register set used for dumping. ELF specification
1988 * says that it needs to be array of elf_greg_t that has size of ELF_NREG.
1989 *
Anthony Liguoric227f092009-10-01 16:12:16 -05001990 * typedef <target_regtype> target_elf_greg_t;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001991 * #define ELF_NREG <number of registers>
Anthony Liguoric227f092009-10-01 16:12:16 -05001992 * typedef taret_elf_greg_t target_elf_gregset_t[ELF_NREG];
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001993 *
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001994 * Last step is to implement target specific function that copies registers
1995 * from given cpu into just specified register set. Prototype is:
1996 *
Anthony Liguoric227f092009-10-01 16:12:16 -05001997 * static void elf_core_copy_regs(taret_elf_gregset_t *regs,
Andreas Färber9349b4f2012-03-14 01:38:32 +01001998 * const CPUArchState *env);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03001999 *
2000 * Parameters:
2001 * regs - copy register values into here (allocated and zeroed by caller)
2002 * env - copy registers from here
2003 *
2004 * Example for ARM target is provided in this file.
2005 */
2006
2007/* An ELF note in memory */
2008struct memelfnote {
2009 const char *name;
2010 size_t namesz;
2011 size_t namesz_rounded;
2012 int type;
2013 size_t datasz;
Laurent Vivier80f5ce72011-02-13 23:37:35 +01002014 size_t datasz_rounded;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002015 void *data;
2016 size_t notesz;
2017};
2018
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002019struct target_elf_siginfo {
Laurent Vivier80f5ce72011-02-13 23:37:35 +01002020 target_int si_signo; /* signal number */
2021 target_int si_code; /* extra code */
2022 target_int si_errno; /* errno */
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002023};
2024
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002025struct target_elf_prstatus {
2026 struct target_elf_siginfo pr_info; /* Info associated with signal */
Laurent Vivier80f5ce72011-02-13 23:37:35 +01002027 target_short pr_cursig; /* Current signal */
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002028 target_ulong pr_sigpend; /* XXX */
2029 target_ulong pr_sighold; /* XXX */
Anthony Liguoric227f092009-10-01 16:12:16 -05002030 target_pid_t pr_pid;
2031 target_pid_t pr_ppid;
2032 target_pid_t pr_pgrp;
2033 target_pid_t pr_sid;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002034 struct target_timeval pr_utime; /* XXX User time */
2035 struct target_timeval pr_stime; /* XXX System time */
2036 struct target_timeval pr_cutime; /* XXX Cumulative user time */
2037 struct target_timeval pr_cstime; /* XXX Cumulative system time */
Anthony Liguoric227f092009-10-01 16:12:16 -05002038 target_elf_gregset_t pr_reg; /* GP registers */
Laurent Vivier80f5ce72011-02-13 23:37:35 +01002039 target_int pr_fpvalid; /* XXX */
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002040};
2041
2042#define ELF_PRARGSZ (80) /* Number of chars for args */
2043
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002044struct target_elf_prpsinfo {
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002045 char pr_state; /* numeric process state */
2046 char pr_sname; /* char for pr_state */
2047 char pr_zomb; /* zombie */
2048 char pr_nice; /* nice val */
2049 target_ulong pr_flag; /* flags */
Anthony Liguoric227f092009-10-01 16:12:16 -05002050 target_uid_t pr_uid;
2051 target_gid_t pr_gid;
2052 target_pid_t pr_pid, pr_ppid, pr_pgrp, pr_sid;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002053 /* Lots missing */
2054 char pr_fname[16]; /* filename of executable */
2055 char pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
2056};
2057
2058/* Here is the structure in which status of each thread is captured. */
2059struct elf_thread_status {
Blue Swirl72cf2d42009-09-12 07:36:22 +00002060 QTAILQ_ENTRY(elf_thread_status) ets_link;
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002061 struct target_elf_prstatus prstatus; /* NT_PRSTATUS */
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002062#if 0
2063 elf_fpregset_t fpu; /* NT_PRFPREG */
2064 struct task_struct *thread;
2065 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
2066#endif
2067 struct memelfnote notes[1];
2068 int num_notes;
2069};
2070
2071struct elf_note_info {
2072 struct memelfnote *notes;
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002073 struct target_elf_prstatus *prstatus; /* NT_PRSTATUS */
2074 struct target_elf_prpsinfo *psinfo; /* NT_PRPSINFO */
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002075
Blue Swirl72cf2d42009-09-12 07:36:22 +00002076 QTAILQ_HEAD(thread_list_head, elf_thread_status) thread_list;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002077#if 0
2078 /*
2079 * Current version of ELF coredump doesn't support
2080 * dumping fp regs etc.
2081 */
2082 elf_fpregset_t *fpu;
2083 elf_fpxregset_t *xfpu;
2084 int thread_status_size;
2085#endif
2086 int notes_size;
2087 int numnote;
2088};
2089
2090struct vm_area_struct {
2091 abi_ulong vma_start; /* start vaddr of memory region */
2092 abi_ulong vma_end; /* end vaddr of memory region */
2093 abi_ulong vma_flags; /* protection etc. flags for the region */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002094 QTAILQ_ENTRY(vm_area_struct) vma_link;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002095};
2096
2097struct mm_struct {
Blue Swirl72cf2d42009-09-12 07:36:22 +00002098 QTAILQ_HEAD(, vm_area_struct) mm_mmap;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002099 int mm_count; /* number of mappings */
2100};
2101
2102static struct mm_struct *vma_init(void);
2103static void vma_delete(struct mm_struct *);
2104static int vma_add_mapping(struct mm_struct *, abi_ulong,
Richard Hendersond97ef722010-07-27 10:25:29 -07002105 abi_ulong, abi_ulong);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002106static int vma_get_mapping_count(const struct mm_struct *);
2107static struct vm_area_struct *vma_first(const struct mm_struct *);
2108static struct vm_area_struct *vma_next(struct vm_area_struct *);
2109static abi_ulong vma_dump_size(const struct vm_area_struct *);
Paul Brookb480d9b2010-03-12 23:23:29 +00002110static int vma_walker(void *priv, abi_ulong start, abi_ulong end,
Richard Hendersond97ef722010-07-27 10:25:29 -07002111 unsigned long flags);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002112
2113static void fill_elf_header(struct elfhdr *, int, uint16_t, uint32_t);
2114static void fill_note(struct memelfnote *, const char *, int,
Richard Hendersond97ef722010-07-27 10:25:29 -07002115 unsigned int, void *);
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002116static void fill_prstatus(struct target_elf_prstatus *, const TaskState *, int);
2117static int fill_psinfo(struct target_elf_prpsinfo *, const TaskState *);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002118static void fill_auxv_note(struct memelfnote *, const TaskState *);
2119static void fill_elf_note_phdr(struct elf_phdr *, int, off_t);
2120static size_t note_size(const struct memelfnote *);
2121static void free_note_info(struct elf_note_info *);
Andreas Färber9349b4f2012-03-14 01:38:32 +01002122static int fill_note_info(struct elf_note_info *, long, const CPUArchState *);
2123static void fill_thread_info(struct elf_note_info *, const CPUArchState *);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002124static int core_dump_filename(const TaskState *, char *, size_t);
2125
2126static int dump_write(int, const void *, size_t);
2127static int write_note(struct memelfnote *, int);
2128static int write_note_info(struct elf_note_info *, int);
2129
2130#ifdef BSWAP_NEEDED
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002131static void bswap_prstatus(struct target_elf_prstatus *prstatus)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002132{
2133 prstatus->pr_info.si_signo = tswapl(prstatus->pr_info.si_signo);
2134 prstatus->pr_info.si_code = tswapl(prstatus->pr_info.si_code);
2135 prstatus->pr_info.si_errno = tswapl(prstatus->pr_info.si_errno);
2136 prstatus->pr_cursig = tswap16(prstatus->pr_cursig);
2137 prstatus->pr_sigpend = tswapl(prstatus->pr_sigpend);
2138 prstatus->pr_sighold = tswapl(prstatus->pr_sighold);
2139 prstatus->pr_pid = tswap32(prstatus->pr_pid);
2140 prstatus->pr_ppid = tswap32(prstatus->pr_ppid);
2141 prstatus->pr_pgrp = tswap32(prstatus->pr_pgrp);
2142 prstatus->pr_sid = tswap32(prstatus->pr_sid);
2143 /* cpu times are not filled, so we skip them */
2144 /* regs should be in correct format already */
2145 prstatus->pr_fpvalid = tswap32(prstatus->pr_fpvalid);
2146}
2147
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002148static void bswap_psinfo(struct target_elf_prpsinfo *psinfo)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002149{
2150 psinfo->pr_flag = tswapl(psinfo->pr_flag);
2151 psinfo->pr_uid = tswap16(psinfo->pr_uid);
2152 psinfo->pr_gid = tswap16(psinfo->pr_gid);
2153 psinfo->pr_pid = tswap32(psinfo->pr_pid);
2154 psinfo->pr_ppid = tswap32(psinfo->pr_ppid);
2155 psinfo->pr_pgrp = tswap32(psinfo->pr_pgrp);
2156 psinfo->pr_sid = tswap32(psinfo->pr_sid);
2157}
Richard Henderson991f8f02010-07-27 10:25:32 -07002158
2159static void bswap_note(struct elf_note *en)
2160{
2161 bswap32s(&en->n_namesz);
2162 bswap32s(&en->n_descsz);
2163 bswap32s(&en->n_type);
2164}
2165#else
2166static inline void bswap_prstatus(struct target_elf_prstatus *p) { }
2167static inline void bswap_psinfo(struct target_elf_prpsinfo *p) {}
2168static inline void bswap_note(struct elf_note *en) { }
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002169#endif /* BSWAP_NEEDED */
2170
2171/*
2172 * Minimal support for linux memory regions. These are needed
2173 * when we are finding out what memory exactly belongs to
2174 * emulated process. No locks needed here, as long as
2175 * thread that received the signal is stopped.
2176 */
2177
2178static struct mm_struct *vma_init(void)
2179{
2180 struct mm_struct *mm;
2181
Anthony Liguori7267c092011-08-20 22:09:37 -05002182 if ((mm = g_malloc(sizeof (*mm))) == NULL)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002183 return (NULL);
2184
2185 mm->mm_count = 0;
Blue Swirl72cf2d42009-09-12 07:36:22 +00002186 QTAILQ_INIT(&mm->mm_mmap);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002187
2188 return (mm);
2189}
2190
2191static void vma_delete(struct mm_struct *mm)
2192{
2193 struct vm_area_struct *vma;
2194
2195 while ((vma = vma_first(mm)) != NULL) {
Blue Swirl72cf2d42009-09-12 07:36:22 +00002196 QTAILQ_REMOVE(&mm->mm_mmap, vma, vma_link);
Anthony Liguori7267c092011-08-20 22:09:37 -05002197 g_free(vma);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002198 }
Anthony Liguori7267c092011-08-20 22:09:37 -05002199 g_free(mm);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002200}
2201
2202static int vma_add_mapping(struct mm_struct *mm, abi_ulong start,
Richard Hendersond97ef722010-07-27 10:25:29 -07002203 abi_ulong end, abi_ulong flags)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002204{
2205 struct vm_area_struct *vma;
2206
Anthony Liguori7267c092011-08-20 22:09:37 -05002207 if ((vma = g_malloc0(sizeof (*vma))) == NULL)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002208 return (-1);
2209
2210 vma->vma_start = start;
2211 vma->vma_end = end;
2212 vma->vma_flags = flags;
2213
Blue Swirl72cf2d42009-09-12 07:36:22 +00002214 QTAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002215 mm->mm_count++;
2216
2217 return (0);
2218}
2219
2220static struct vm_area_struct *vma_first(const struct mm_struct *mm)
2221{
Blue Swirl72cf2d42009-09-12 07:36:22 +00002222 return (QTAILQ_FIRST(&mm->mm_mmap));
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002223}
2224
2225static struct vm_area_struct *vma_next(struct vm_area_struct *vma)
2226{
Blue Swirl72cf2d42009-09-12 07:36:22 +00002227 return (QTAILQ_NEXT(vma, vma_link));
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002228}
2229
2230static int vma_get_mapping_count(const struct mm_struct *mm)
2231{
2232 return (mm->mm_count);
2233}
2234
2235/*
2236 * Calculate file (dump) size of given memory region.
2237 */
2238static abi_ulong vma_dump_size(const struct vm_area_struct *vma)
2239{
2240 /* if we cannot even read the first page, skip it */
2241 if (!access_ok(VERIFY_READ, vma->vma_start, TARGET_PAGE_SIZE))
2242 return (0);
2243
2244 /*
2245 * Usually we don't dump executable pages as they contain
2246 * non-writable code that debugger can read directly from
2247 * target library etc. However, thread stacks are marked
2248 * also executable so we read in first page of given region
2249 * and check whether it contains elf header. If there is
2250 * no elf header, we dump it.
2251 */
2252 if (vma->vma_flags & PROT_EXEC) {
2253 char page[TARGET_PAGE_SIZE];
2254
2255 copy_from_user(page, vma->vma_start, sizeof (page));
2256 if ((page[EI_MAG0] == ELFMAG0) &&
2257 (page[EI_MAG1] == ELFMAG1) &&
2258 (page[EI_MAG2] == ELFMAG2) &&
2259 (page[EI_MAG3] == ELFMAG3)) {
2260 /*
2261 * Mappings are possibly from ELF binary. Don't dump
2262 * them.
2263 */
2264 return (0);
2265 }
2266 }
2267
2268 return (vma->vma_end - vma->vma_start);
2269}
2270
Paul Brookb480d9b2010-03-12 23:23:29 +00002271static int vma_walker(void *priv, abi_ulong start, abi_ulong end,
Richard Hendersond97ef722010-07-27 10:25:29 -07002272 unsigned long flags)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002273{
2274 struct mm_struct *mm = (struct mm_struct *)priv;
2275
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002276 vma_add_mapping(mm, start, end, flags);
2277 return (0);
2278}
2279
2280static void fill_note(struct memelfnote *note, const char *name, int type,
Richard Hendersond97ef722010-07-27 10:25:29 -07002281 unsigned int sz, void *data)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002282{
2283 unsigned int namesz;
2284
2285 namesz = strlen(name) + 1;
2286 note->name = name;
2287 note->namesz = namesz;
2288 note->namesz_rounded = roundup(namesz, sizeof (int32_t));
2289 note->type = type;
Laurent Vivier80f5ce72011-02-13 23:37:35 +01002290 note->datasz = sz;
2291 note->datasz_rounded = roundup(sz, sizeof (int32_t));
2292
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002293 note->data = data;
2294
2295 /*
2296 * We calculate rounded up note size here as specified by
2297 * ELF document.
2298 */
2299 note->notesz = sizeof (struct elf_note) +
Laurent Vivier80f5ce72011-02-13 23:37:35 +01002300 note->namesz_rounded + note->datasz_rounded;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002301}
2302
2303static void fill_elf_header(struct elfhdr *elf, int segs, uint16_t machine,
Richard Hendersond97ef722010-07-27 10:25:29 -07002304 uint32_t flags)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002305{
2306 (void) memset(elf, 0, sizeof(*elf));
2307
2308 (void) memcpy(elf->e_ident, ELFMAG, SELFMAG);
2309 elf->e_ident[EI_CLASS] = ELF_CLASS;
2310 elf->e_ident[EI_DATA] = ELF_DATA;
2311 elf->e_ident[EI_VERSION] = EV_CURRENT;
2312 elf->e_ident[EI_OSABI] = ELF_OSABI;
2313
2314 elf->e_type = ET_CORE;
2315 elf->e_machine = machine;
2316 elf->e_version = EV_CURRENT;
2317 elf->e_phoff = sizeof(struct elfhdr);
2318 elf->e_flags = flags;
2319 elf->e_ehsize = sizeof(struct elfhdr);
2320 elf->e_phentsize = sizeof(struct elf_phdr);
2321 elf->e_phnum = segs;
2322
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002323 bswap_ehdr(elf);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002324}
2325
2326static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
2327{
2328 phdr->p_type = PT_NOTE;
2329 phdr->p_offset = offset;
2330 phdr->p_vaddr = 0;
2331 phdr->p_paddr = 0;
2332 phdr->p_filesz = sz;
2333 phdr->p_memsz = 0;
2334 phdr->p_flags = 0;
2335 phdr->p_align = 0;
2336
Richard Henderson991f8f02010-07-27 10:25:32 -07002337 bswap_phdr(phdr, 1);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002338}
2339
2340static size_t note_size(const struct memelfnote *note)
2341{
2342 return (note->notesz);
2343}
2344
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002345static void fill_prstatus(struct target_elf_prstatus *prstatus,
Richard Hendersond97ef722010-07-27 10:25:29 -07002346 const TaskState *ts, int signr)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002347{
2348 (void) memset(prstatus, 0, sizeof (*prstatus));
2349 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
2350 prstatus->pr_pid = ts->ts_tid;
2351 prstatus->pr_ppid = getppid();
2352 prstatus->pr_pgrp = getpgrp();
2353 prstatus->pr_sid = getsid(0);
2354
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002355 bswap_prstatus(prstatus);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002356}
2357
Laurent Desnoguesa2547a12009-07-17 13:33:41 +01002358static int fill_psinfo(struct target_elf_prpsinfo *psinfo, const TaskState *ts)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002359{
2360 char *filename, *base_filename;
2361 unsigned int i, len;
2362
2363 (void) memset(psinfo, 0, sizeof (*psinfo));
2364
2365 len = ts->info->arg_end - ts->info->arg_start;
2366 if (len >= ELF_PRARGSZ)
2367 len = ELF_PRARGSZ - 1;
2368 if (copy_from_user(&psinfo->pr_psargs, ts->info->arg_start, len))
2369 return -EFAULT;
2370 for (i = 0; i < len; i++)
2371 if (psinfo->pr_psargs[i] == 0)
2372 psinfo->pr_psargs[i] = ' ';
2373 psinfo->pr_psargs[len] = 0;
2374
2375 psinfo->pr_pid = getpid();
2376 psinfo->pr_ppid = getppid();
2377 psinfo->pr_pgrp = getpgrp();
2378 psinfo->pr_sid = getsid(0);
2379 psinfo->pr_uid = getuid();
2380 psinfo->pr_gid = getgid();
2381
2382 filename = strdup(ts->bprm->filename);
2383 base_filename = strdup(basename(filename));
2384 (void) strncpy(psinfo->pr_fname, base_filename,
Richard Hendersond97ef722010-07-27 10:25:29 -07002385 sizeof(psinfo->pr_fname));
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002386 free(base_filename);
2387 free(filename);
2388
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002389 bswap_psinfo(psinfo);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002390 return (0);
2391}
2392
2393static void fill_auxv_note(struct memelfnote *note, const TaskState *ts)
2394{
2395 elf_addr_t auxv = (elf_addr_t)ts->info->saved_auxv;
2396 elf_addr_t orig_auxv = auxv;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002397 void *ptr;
Alexander Graf125b0f52012-01-28 21:12:14 +02002398 int len = ts->info->auxv_len;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002399
2400 /*
2401 * Auxiliary vector is stored in target process stack. It contains
2402 * {type, value} pairs that we need to dump into note. This is not
2403 * strictly necessary but we do it here for sake of completeness.
2404 */
2405
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002406 /* read in whole auxv vector and copy it to memelfnote */
2407 ptr = lock_user(VERIFY_READ, orig_auxv, len, 0);
2408 if (ptr != NULL) {
2409 fill_note(note, "CORE", NT_AUXV, len, ptr);
2410 unlock_user(ptr, auxv, len);
2411 }
2412}
2413
2414/*
2415 * Constructs name of coredump file. We have following convention
2416 * for the name:
2417 * qemu_<basename-of-target-binary>_<date>-<time>_<pid>.core
2418 *
2419 * Returns 0 in case of success, -1 otherwise (errno is set).
2420 */
2421static int core_dump_filename(const TaskState *ts, char *buf,
Richard Hendersond97ef722010-07-27 10:25:29 -07002422 size_t bufsize)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002423{
2424 char timestamp[64];
2425 char *filename = NULL;
2426 char *base_filename = NULL;
2427 struct timeval tv;
2428 struct tm tm;
2429
2430 assert(bufsize >= PATH_MAX);
2431
2432 if (gettimeofday(&tv, NULL) < 0) {
2433 (void) fprintf(stderr, "unable to get current timestamp: %s",
Richard Hendersond97ef722010-07-27 10:25:29 -07002434 strerror(errno));
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002435 return (-1);
2436 }
2437
2438 filename = strdup(ts->bprm->filename);
2439 base_filename = strdup(basename(filename));
2440 (void) strftime(timestamp, sizeof (timestamp), "%Y%m%d-%H%M%S",
Richard Hendersond97ef722010-07-27 10:25:29 -07002441 localtime_r(&tv.tv_sec, &tm));
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002442 (void) snprintf(buf, bufsize, "qemu_%s_%s_%d.core",
Richard Hendersond97ef722010-07-27 10:25:29 -07002443 base_filename, timestamp, (int)getpid());
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002444 free(base_filename);
2445 free(filename);
2446
2447 return (0);
2448}
2449
2450static int dump_write(int fd, const void *ptr, size_t size)
2451{
2452 const char *bufp = (const char *)ptr;
2453 ssize_t bytes_written, bytes_left;
2454 struct rlimit dumpsize;
2455 off_t pos;
2456
2457 bytes_written = 0;
2458 getrlimit(RLIMIT_CORE, &dumpsize);
2459 if ((pos = lseek(fd, 0, SEEK_CUR))==-1) {
2460 if (errno == ESPIPE) { /* not a seekable stream */
2461 bytes_left = size;
2462 } else {
2463 return pos;
2464 }
2465 } else {
2466 if (dumpsize.rlim_cur <= pos) {
2467 return -1;
2468 } else if (dumpsize.rlim_cur == RLIM_INFINITY) {
2469 bytes_left = size;
2470 } else {
2471 size_t limit_left=dumpsize.rlim_cur - pos;
2472 bytes_left = limit_left >= size ? size : limit_left ;
2473 }
2474 }
2475
2476 /*
2477 * In normal conditions, single write(2) should do but
2478 * in case of socket etc. this mechanism is more portable.
2479 */
2480 do {
2481 bytes_written = write(fd, bufp, bytes_left);
2482 if (bytes_written < 0) {
2483 if (errno == EINTR)
2484 continue;
2485 return (-1);
2486 } else if (bytes_written == 0) { /* eof */
2487 return (-1);
2488 }
2489 bufp += bytes_written;
2490 bytes_left -= bytes_written;
2491 } while (bytes_left > 0);
2492
2493 return (0);
2494}
2495
2496static int write_note(struct memelfnote *men, int fd)
2497{
2498 struct elf_note en;
2499
2500 en.n_namesz = men->namesz;
2501 en.n_type = men->type;
2502 en.n_descsz = men->datasz;
2503
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002504 bswap_note(&en);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002505
2506 if (dump_write(fd, &en, sizeof(en)) != 0)
2507 return (-1);
2508 if (dump_write(fd, men->name, men->namesz_rounded) != 0)
2509 return (-1);
Laurent Vivier80f5ce72011-02-13 23:37:35 +01002510 if (dump_write(fd, men->data, men->datasz_rounded) != 0)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002511 return (-1);
2512
2513 return (0);
2514}
2515
Andreas Färber9349b4f2012-03-14 01:38:32 +01002516static void fill_thread_info(struct elf_note_info *info, const CPUArchState *env)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002517{
2518 TaskState *ts = (TaskState *)env->opaque;
2519 struct elf_thread_status *ets;
2520
Anthony Liguori7267c092011-08-20 22:09:37 -05002521 ets = g_malloc0(sizeof (*ets));
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002522 ets->num_notes = 1; /* only prstatus is dumped */
2523 fill_prstatus(&ets->prstatus, ts, 0);
2524 elf_core_copy_regs(&ets->prstatus.pr_reg, env);
2525 fill_note(&ets->notes[0], "CORE", NT_PRSTATUS, sizeof (ets->prstatus),
Richard Hendersond97ef722010-07-27 10:25:29 -07002526 &ets->prstatus);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002527
Blue Swirl72cf2d42009-09-12 07:36:22 +00002528 QTAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002529
2530 info->notes_size += note_size(&ets->notes[0]);
2531}
2532
2533static int fill_note_info(struct elf_note_info *info,
Andreas Färber9349b4f2012-03-14 01:38:32 +01002534 long signr, const CPUArchState *env)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002535{
2536#define NUMNOTES 3
Andreas Färber9349b4f2012-03-14 01:38:32 +01002537 CPUArchState *cpu = NULL;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002538 TaskState *ts = (TaskState *)env->opaque;
2539 int i;
2540
2541 (void) memset(info, 0, sizeof (*info));
2542
Blue Swirl72cf2d42009-09-12 07:36:22 +00002543 QTAILQ_INIT(&info->thread_list);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002544
Anthony Liguori7267c092011-08-20 22:09:37 -05002545 info->notes = g_malloc0(NUMNOTES * sizeof (struct memelfnote));
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002546 if (info->notes == NULL)
2547 return (-ENOMEM);
Anthony Liguori7267c092011-08-20 22:09:37 -05002548 info->prstatus = g_malloc0(sizeof (*info->prstatus));
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002549 if (info->prstatus == NULL)
2550 return (-ENOMEM);
Anthony Liguori7267c092011-08-20 22:09:37 -05002551 info->psinfo = g_malloc0(sizeof (*info->psinfo));
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002552 if (info->prstatus == NULL)
2553 return (-ENOMEM);
2554
2555 /*
2556 * First fill in status (and registers) of current thread
2557 * including process info & aux vector.
2558 */
2559 fill_prstatus(info->prstatus, ts, signr);
2560 elf_core_copy_regs(&info->prstatus->pr_reg, env);
2561 fill_note(&info->notes[0], "CORE", NT_PRSTATUS,
Richard Hendersond97ef722010-07-27 10:25:29 -07002562 sizeof (*info->prstatus), info->prstatus);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002563 fill_psinfo(info->psinfo, ts);
2564 fill_note(&info->notes[1], "CORE", NT_PRPSINFO,
Richard Hendersond97ef722010-07-27 10:25:29 -07002565 sizeof (*info->psinfo), info->psinfo);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002566 fill_auxv_note(&info->notes[2], ts);
2567 info->numnote = 3;
2568
2569 info->notes_size = 0;
2570 for (i = 0; i < info->numnote; i++)
2571 info->notes_size += note_size(&info->notes[i]);
2572
2573 /* read and fill status of all threads */
2574 cpu_list_lock();
2575 for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {
2576 if (cpu == thread_env)
2577 continue;
2578 fill_thread_info(info, cpu);
2579 }
2580 cpu_list_unlock();
2581
2582 return (0);
2583}
2584
2585static void free_note_info(struct elf_note_info *info)
2586{
2587 struct elf_thread_status *ets;
2588
Blue Swirl72cf2d42009-09-12 07:36:22 +00002589 while (!QTAILQ_EMPTY(&info->thread_list)) {
2590 ets = QTAILQ_FIRST(&info->thread_list);
2591 QTAILQ_REMOVE(&info->thread_list, ets, ets_link);
Anthony Liguori7267c092011-08-20 22:09:37 -05002592 g_free(ets);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002593 }
2594
Anthony Liguori7267c092011-08-20 22:09:37 -05002595 g_free(info->prstatus);
2596 g_free(info->psinfo);
2597 g_free(info->notes);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002598}
2599
2600static int write_note_info(struct elf_note_info *info, int fd)
2601{
2602 struct elf_thread_status *ets;
2603 int i, error = 0;
2604
2605 /* write prstatus, psinfo and auxv for current thread */
2606 for (i = 0; i < info->numnote; i++)
2607 if ((error = write_note(&info->notes[i], fd)) != 0)
2608 return (error);
2609
2610 /* write prstatus for each thread */
2611 for (ets = info->thread_list.tqh_first; ets != NULL;
Richard Hendersond97ef722010-07-27 10:25:29 -07002612 ets = ets->ets_link.tqe_next) {
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002613 if ((error = write_note(&ets->notes[0], fd)) != 0)
2614 return (error);
2615 }
2616
2617 return (0);
2618}
2619
2620/*
2621 * Write out ELF coredump.
2622 *
2623 * See documentation of ELF object file format in:
2624 * http://www.caldera.com/developers/devspecs/gabi41.pdf
2625 *
2626 * Coredump format in linux is following:
2627 *
2628 * 0 +----------------------+ \
2629 * | ELF header | ET_CORE |
2630 * +----------------------+ |
2631 * | ELF program headers | |--- headers
2632 * | - NOTE section | |
2633 * | - PT_LOAD sections | |
2634 * +----------------------+ /
2635 * | NOTEs: |
2636 * | - NT_PRSTATUS |
2637 * | - NT_PRSINFO |
2638 * | - NT_AUXV |
2639 * +----------------------+ <-- aligned to target page
2640 * | Process memory dump |
2641 * : :
2642 * . .
2643 * : :
2644 * | |
2645 * +----------------------+
2646 *
2647 * NT_PRSTATUS -> struct elf_prstatus (per thread)
2648 * NT_PRSINFO -> struct elf_prpsinfo
2649 * NT_AUXV is array of { type, value } pairs (see fill_auxv_note()).
2650 *
2651 * Format follows System V format as close as possible. Current
2652 * version limitations are as follows:
2653 * - no floating point registers are dumped
2654 *
2655 * Function returns 0 in case of success, negative errno otherwise.
2656 *
2657 * TODO: make this work also during runtime: it should be
2658 * possible to force coredump from running process and then
2659 * continue processing. For example qemu could set up SIGUSR2
2660 * handler (provided that target process haven't registered
2661 * handler for that) that does the dump when signal is received.
2662 */
Andreas Färber9349b4f2012-03-14 01:38:32 +01002663static int elf_core_dump(int signr, const CPUArchState *env)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002664{
2665 const TaskState *ts = (const TaskState *)env->opaque;
2666 struct vm_area_struct *vma = NULL;
2667 char corefile[PATH_MAX];
2668 struct elf_note_info info;
2669 struct elfhdr elf;
2670 struct elf_phdr phdr;
2671 struct rlimit dumpsize;
2672 struct mm_struct *mm = NULL;
2673 off_t offset = 0, data_offset = 0;
2674 int segs = 0;
2675 int fd = -1;
2676
2677 errno = 0;
2678 getrlimit(RLIMIT_CORE, &dumpsize);
2679 if (dumpsize.rlim_cur == 0)
Richard Hendersond97ef722010-07-27 10:25:29 -07002680 return 0;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002681
2682 if (core_dump_filename(ts, corefile, sizeof (corefile)) < 0)
2683 return (-errno);
2684
2685 if ((fd = open(corefile, O_WRONLY | O_CREAT,
Richard Hendersond97ef722010-07-27 10:25:29 -07002686 S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002687 return (-errno);
2688
2689 /*
2690 * Walk through target process memory mappings and
2691 * set up structure containing this information. After
2692 * this point vma_xxx functions can be used.
2693 */
2694 if ((mm = vma_init()) == NULL)
2695 goto out;
2696
2697 walk_memory_regions(mm, vma_walker);
2698 segs = vma_get_mapping_count(mm);
2699
2700 /*
2701 * Construct valid coredump ELF header. We also
2702 * add one more segment for notes.
2703 */
2704 fill_elf_header(&elf, segs + 1, ELF_MACHINE, 0);
2705 if (dump_write(fd, &elf, sizeof (elf)) != 0)
2706 goto out;
2707
2708 /* fill in in-memory version of notes */
2709 if (fill_note_info(&info, signr, env) < 0)
2710 goto out;
2711
2712 offset += sizeof (elf); /* elf header */
2713 offset += (segs + 1) * sizeof (struct elf_phdr); /* program headers */
2714
2715 /* write out notes program header */
2716 fill_elf_note_phdr(&phdr, info.notes_size, offset);
2717
2718 offset += info.notes_size;
2719 if (dump_write(fd, &phdr, sizeof (phdr)) != 0)
2720 goto out;
2721
2722 /*
2723 * ELF specification wants data to start at page boundary so
2724 * we align it here.
2725 */
Laurent Vivier80f5ce72011-02-13 23:37:35 +01002726 data_offset = offset = roundup(offset, ELF_EXEC_PAGESIZE);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002727
2728 /*
2729 * Write program headers for memory regions mapped in
2730 * the target process.
2731 */
2732 for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
2733 (void) memset(&phdr, 0, sizeof (phdr));
2734
2735 phdr.p_type = PT_LOAD;
2736 phdr.p_offset = offset;
2737 phdr.p_vaddr = vma->vma_start;
2738 phdr.p_paddr = 0;
2739 phdr.p_filesz = vma_dump_size(vma);
2740 offset += phdr.p_filesz;
2741 phdr.p_memsz = vma->vma_end - vma->vma_start;
2742 phdr.p_flags = vma->vma_flags & PROT_READ ? PF_R : 0;
2743 if (vma->vma_flags & PROT_WRITE)
2744 phdr.p_flags |= PF_W;
2745 if (vma->vma_flags & PROT_EXEC)
2746 phdr.p_flags |= PF_X;
2747 phdr.p_align = ELF_EXEC_PAGESIZE;
2748
Laurent Vivier80f5ce72011-02-13 23:37:35 +01002749 bswap_phdr(&phdr, 1);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002750 dump_write(fd, &phdr, sizeof (phdr));
2751 }
2752
2753 /*
2754 * Next we write notes just after program headers. No
2755 * alignment needed here.
2756 */
2757 if (write_note_info(&info, fd) < 0)
2758 goto out;
2759
2760 /* align data to page boundary */
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002761 if (lseek(fd, data_offset, SEEK_SET) != data_offset)
2762 goto out;
2763
2764 /*
2765 * Finally we can dump process memory into corefile as well.
2766 */
2767 for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
2768 abi_ulong addr;
2769 abi_ulong end;
2770
2771 end = vma->vma_start + vma_dump_size(vma);
2772
2773 for (addr = vma->vma_start; addr < end;
Richard Hendersond97ef722010-07-27 10:25:29 -07002774 addr += TARGET_PAGE_SIZE) {
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002775 char page[TARGET_PAGE_SIZE];
2776 int error;
2777
2778 /*
2779 * Read in page from target process memory and
2780 * write it to coredump file.
2781 */
2782 error = copy_from_user(page, addr, sizeof (page));
2783 if (error != 0) {
Aurelien Jarno49995e12009-12-19 20:28:23 +01002784 (void) fprintf(stderr, "unable to dump " TARGET_ABI_FMT_lx "\n",
Richard Hendersond97ef722010-07-27 10:25:29 -07002785 addr);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002786 errno = -error;
2787 goto out;
2788 }
2789 if (dump_write(fd, page, TARGET_PAGE_SIZE) < 0)
2790 goto out;
2791 }
2792 }
2793
Richard Hendersond97ef722010-07-27 10:25:29 -07002794 out:
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002795 free_note_info(&info);
2796 if (mm != NULL)
2797 vma_delete(mm);
2798 (void) close(fd);
2799
2800 if (errno != 0)
2801 return (-errno);
2802 return (0);
2803}
Mika Westerbergedf8e2a2009-04-07 09:57:11 +03002804#endif /* USE_ELF_CORE_DUMP */
2805
pbrooke5fe0c52006-06-11 13:32:59 +00002806void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
2807{
2808 init_thread(regs, infop);
2809}