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