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