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