1 /* This is the Linux kernel elf-loading code, ported into user space */
11 #include <sys/resource.h>
28 #define ELF_OSABI ELFOSABI_SYSV
30 /* from personality.h */
33 * Flags for bug emulation.
35 * These occupy the top three bytes.
38 ADDR_NO_RANDOMIZE
= 0x0040000, /* disable randomization of VA space */
39 FDPIC_FUNCPTRS
= 0x0080000, /* userspace function ptrs point to descriptors
42 MMAP_PAGE_ZERO
= 0x0100000,
43 ADDR_COMPAT_LAYOUT
= 0x0200000,
44 READ_IMPLIES_EXEC
= 0x0400000,
45 ADDR_LIMIT_32BIT
= 0x0800000,
46 SHORT_INODE
= 0x1000000,
47 WHOLE_SECONDS
= 0x2000000,
48 STICKY_TIMEOUTS
= 0x4000000,
49 ADDR_LIMIT_3GB
= 0x8000000,
55 * These go in the low byte. Avoid using the top bit, it will
56 * conflict with error returns.
60 PER_LINUX_32BIT
= 0x0000 | ADDR_LIMIT_32BIT
,
61 PER_LINUX_FDPIC
= 0x0000 | FDPIC_FUNCPTRS
,
62 PER_SVR4
= 0x0001 | STICKY_TIMEOUTS
| MMAP_PAGE_ZERO
,
63 PER_SVR3
= 0x0002 | STICKY_TIMEOUTS
| SHORT_INODE
,
64 PER_SCOSVR3
= 0x0003 | STICKY_TIMEOUTS
|
65 WHOLE_SECONDS
| SHORT_INODE
,
66 PER_OSR5
= 0x0003 | STICKY_TIMEOUTS
| WHOLE_SECONDS
,
67 PER_WYSEV386
= 0x0004 | STICKY_TIMEOUTS
| SHORT_INODE
,
68 PER_ISCR4
= 0x0005 | STICKY_TIMEOUTS
,
70 PER_SUNOS
= 0x0006 | STICKY_TIMEOUTS
,
71 PER_XENIX
= 0x0007 | STICKY_TIMEOUTS
| SHORT_INODE
,
73 PER_LINUX32_3GB
= 0x0008 | ADDR_LIMIT_3GB
,
74 PER_IRIX32
= 0x0009 | STICKY_TIMEOUTS
,/* IRIX5 32-bit */
75 PER_IRIXN32
= 0x000a | STICKY_TIMEOUTS
,/* IRIX6 new 32-bit */
76 PER_IRIX64
= 0x000b | STICKY_TIMEOUTS
,/* IRIX6 64-bit */
78 PER_SOLARIS
= 0x000d | STICKY_TIMEOUTS
,
79 PER_UW7
= 0x000e | STICKY_TIMEOUTS
| MMAP_PAGE_ZERO
,
80 PER_OSF4
= 0x000f, /* OSF/1 v4 */
86 * Return the base personality without flags.
88 #define personality(pers) (pers & PER_MASK)
90 /* this flag is uneffective under linux too, should be deleted */
92 #define MAP_DENYWRITE 0
95 /* should probably go in elf.h */
100 typedef target_ulong target_elf_greg_t
;
102 typedef uint16_t target_uid_t
;
103 typedef uint16_t target_gid_t
;
105 typedef uint32_t target_uid_t
;
106 typedef uint32_t target_gid_t
;
108 typedef int32_t target_pid_t
;
112 #define ELF_PLATFORM get_elf_platform()
114 static const char *get_elf_platform(void)
116 static char elf_platform
[] = "i386";
117 int family
= (thread_env
->cpuid_version
>> 8) & 0xff;
121 elf_platform
[1] = '0' + family
;
125 #define ELF_HWCAP get_elf_hwcap()
127 static uint32_t get_elf_hwcap(void)
129 return thread_env
->cpuid_features
;
133 #define ELF_START_MMAP 0x2aaaaab000ULL
134 #define elf_check_arch(x) ( ((x) == ELF_ARCH) )
136 #define ELF_CLASS ELFCLASS64
137 #define ELF_DATA ELFDATA2LSB
138 #define ELF_ARCH EM_X86_64
140 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
143 regs
->rsp
= infop
->start_stack
;
144 regs
->rip
= infop
->entry
;
148 typedef target_elf_greg_t target_elf_gregset_t
[ELF_NREG
];
151 * Note that ELF_NREG should be 29 as there should be place for
152 * TRAPNO and ERR "registers" as well but linux doesn't dump
155 * See linux kernel: arch/x86/include/asm/elf.h
157 static void elf_core_copy_regs(target_elf_gregset_t
*regs
, const CPUState
*env
)
159 (*regs
)[0] = env
->regs
[15];
160 (*regs
)[1] = env
->regs
[14];
161 (*regs
)[2] = env
->regs
[13];
162 (*regs
)[3] = env
->regs
[12];
163 (*regs
)[4] = env
->regs
[R_EBP
];
164 (*regs
)[5] = env
->regs
[R_EBX
];
165 (*regs
)[6] = env
->regs
[11];
166 (*regs
)[7] = env
->regs
[10];
167 (*regs
)[8] = env
->regs
[9];
168 (*regs
)[9] = env
->regs
[8];
169 (*regs
)[10] = env
->regs
[R_EAX
];
170 (*regs
)[11] = env
->regs
[R_ECX
];
171 (*regs
)[12] = env
->regs
[R_EDX
];
172 (*regs
)[13] = env
->regs
[R_ESI
];
173 (*regs
)[14] = env
->regs
[R_EDI
];
174 (*regs
)[15] = env
->regs
[R_EAX
]; /* XXX */
175 (*regs
)[16] = env
->eip
;
176 (*regs
)[17] = env
->segs
[R_CS
].selector
& 0xffff;
177 (*regs
)[18] = env
->eflags
;
178 (*regs
)[19] = env
->regs
[R_ESP
];
179 (*regs
)[20] = env
->segs
[R_SS
].selector
& 0xffff;
180 (*regs
)[21] = env
->segs
[R_FS
].selector
& 0xffff;
181 (*regs
)[22] = env
->segs
[R_GS
].selector
& 0xffff;
182 (*regs
)[23] = env
->segs
[R_DS
].selector
& 0xffff;
183 (*regs
)[24] = env
->segs
[R_ES
].selector
& 0xffff;
184 (*regs
)[25] = env
->segs
[R_FS
].selector
& 0xffff;
185 (*regs
)[26] = env
->segs
[R_GS
].selector
& 0xffff;
190 #define ELF_START_MMAP 0x80000000
193 * This is used to ensure we don't load something for the wrong architecture.
195 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
198 * These are used to set parameters in the core dumps.
200 #define ELF_CLASS ELFCLASS32
201 #define ELF_DATA ELFDATA2LSB
202 #define ELF_ARCH EM_386
204 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
206 regs
->esp
= infop
->start_stack
;
207 regs
->eip
= infop
->entry
;
209 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
210 starts %edx contains a pointer to a function which might be
211 registered using `atexit'. This provides a mean for the
212 dynamic linker to call DT_FINI functions for shared libraries
213 that have been loaded before the code runs.
215 A value of 0 tells we have no such handler. */
220 typedef target_elf_greg_t target_elf_gregset_t
[ELF_NREG
];
223 * Note that ELF_NREG should be 19 as there should be place for
224 * TRAPNO and ERR "registers" as well but linux doesn't dump
227 * See linux kernel: arch/x86/include/asm/elf.h
229 static void elf_core_copy_regs(target_elf_gregset_t
*regs
, const CPUState
*env
)
231 (*regs
)[0] = env
->regs
[R_EBX
];
232 (*regs
)[1] = env
->regs
[R_ECX
];
233 (*regs
)[2] = env
->regs
[R_EDX
];
234 (*regs
)[3] = env
->regs
[R_ESI
];
235 (*regs
)[4] = env
->regs
[R_EDI
];
236 (*regs
)[5] = env
->regs
[R_EBP
];
237 (*regs
)[6] = env
->regs
[R_EAX
];
238 (*regs
)[7] = env
->segs
[R_DS
].selector
& 0xffff;
239 (*regs
)[8] = env
->segs
[R_ES
].selector
& 0xffff;
240 (*regs
)[9] = env
->segs
[R_FS
].selector
& 0xffff;
241 (*regs
)[10] = env
->segs
[R_GS
].selector
& 0xffff;
242 (*regs
)[11] = env
->regs
[R_EAX
]; /* XXX */
243 (*regs
)[12] = env
->eip
;
244 (*regs
)[13] = env
->segs
[R_CS
].selector
& 0xffff;
245 (*regs
)[14] = env
->eflags
;
246 (*regs
)[15] = env
->regs
[R_ESP
];
247 (*regs
)[16] = env
->segs
[R_SS
].selector
& 0xffff;
251 #define USE_ELF_CORE_DUMP
252 #define ELF_EXEC_PAGESIZE 4096
258 #define ELF_START_MMAP 0x80000000
260 #define elf_check_arch(x) ( (x) == EM_ARM )
262 #define ELF_CLASS ELFCLASS32
263 #ifdef TARGET_WORDS_BIGENDIAN
264 #define ELF_DATA ELFDATA2MSB
266 #define ELF_DATA ELFDATA2LSB
268 #define ELF_ARCH EM_ARM
270 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
272 abi_long stack
= infop
->start_stack
;
273 memset(regs
, 0, sizeof(*regs
));
274 regs
->ARM_cpsr
= 0x10;
275 if (infop
->entry
& 1)
276 regs
->ARM_cpsr
|= CPSR_T
;
277 regs
->ARM_pc
= infop
->entry
& 0xfffffffe;
278 regs
->ARM_sp
= infop
->start_stack
;
279 /* FIXME - what to for failure of get_user()? */
280 get_user_ual(regs
->ARM_r2
, stack
+ 8); /* envp */
281 get_user_ual(regs
->ARM_r1
, stack
+ 4); /* envp */
282 /* XXX: it seems that r0 is zeroed after ! */
284 /* For uClinux PIC binaries. */
285 /* XXX: Linux does this only on ARM with no MMU (do we care ?) */
286 regs
->ARM_r10
= infop
->start_data
;
290 typedef target_elf_greg_t target_elf_gregset_t
[ELF_NREG
];
292 static void elf_core_copy_regs(target_elf_gregset_t
*regs
, const CPUState
*env
)
294 (*regs
)[0] = tswapl(env
->regs
[0]);
295 (*regs
)[1] = tswapl(env
->regs
[1]);
296 (*regs
)[2] = tswapl(env
->regs
[2]);
297 (*regs
)[3] = tswapl(env
->regs
[3]);
298 (*regs
)[4] = tswapl(env
->regs
[4]);
299 (*regs
)[5] = tswapl(env
->regs
[5]);
300 (*regs
)[6] = tswapl(env
->regs
[6]);
301 (*regs
)[7] = tswapl(env
->regs
[7]);
302 (*regs
)[8] = tswapl(env
->regs
[8]);
303 (*regs
)[9] = tswapl(env
->regs
[9]);
304 (*regs
)[10] = tswapl(env
->regs
[10]);
305 (*regs
)[11] = tswapl(env
->regs
[11]);
306 (*regs
)[12] = tswapl(env
->regs
[12]);
307 (*regs
)[13] = tswapl(env
->regs
[13]);
308 (*regs
)[14] = tswapl(env
->regs
[14]);
309 (*regs
)[15] = tswapl(env
->regs
[15]);
311 (*regs
)[16] = tswapl(cpsr_read((CPUState
*)env
));
312 (*regs
)[17] = tswapl(env
->regs
[0]); /* XXX */
315 #define USE_ELF_CORE_DUMP
316 #define ELF_EXEC_PAGESIZE 4096
320 ARM_HWCAP_ARM_SWP
= 1 << 0,
321 ARM_HWCAP_ARM_HALF
= 1 << 1,
322 ARM_HWCAP_ARM_THUMB
= 1 << 2,
323 ARM_HWCAP_ARM_26BIT
= 1 << 3,
324 ARM_HWCAP_ARM_FAST_MULT
= 1 << 4,
325 ARM_HWCAP_ARM_FPA
= 1 << 5,
326 ARM_HWCAP_ARM_VFP
= 1 << 6,
327 ARM_HWCAP_ARM_EDSP
= 1 << 7,
328 ARM_HWCAP_ARM_JAVA
= 1 << 8,
329 ARM_HWCAP_ARM_IWMMXT
= 1 << 9,
330 ARM_HWCAP_ARM_THUMBEE
= 1 << 10,
331 ARM_HWCAP_ARM_NEON
= 1 << 11,
332 ARM_HWCAP_ARM_VFPv3
= 1 << 12,
333 ARM_HWCAP_ARM_VFPv3D16
= 1 << 13,
336 #define ELF_HWCAP (ARM_HWCAP_ARM_SWP | ARM_HWCAP_ARM_HALF \
337 | ARM_HWCAP_ARM_THUMB | ARM_HWCAP_ARM_FAST_MULT \
338 | ARM_HWCAP_ARM_FPA | ARM_HWCAP_ARM_VFP \
339 | ARM_HWCAP_ARM_NEON | ARM_HWCAP_ARM_VFPv3 )
344 #ifdef TARGET_SPARC64
346 #define ELF_START_MMAP 0x80000000
349 #define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS )
351 #define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC )
354 #define ELF_CLASS ELFCLASS64
355 #define ELF_DATA ELFDATA2MSB
356 #define ELF_ARCH EM_SPARCV9
358 #define STACK_BIAS 2047
360 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
365 regs
->pc
= infop
->entry
;
366 regs
->npc
= regs
->pc
+ 4;
369 regs
->u_regs
[14] = infop
->start_stack
- 16 * 4;
371 if (personality(infop
->personality
) == PER_LINUX32
)
372 regs
->u_regs
[14] = infop
->start_stack
- 16 * 4;
374 regs
->u_regs
[14] = infop
->start_stack
- 16 * 8 - STACK_BIAS
;
379 #define ELF_START_MMAP 0x80000000
381 #define elf_check_arch(x) ( (x) == EM_SPARC )
383 #define ELF_CLASS ELFCLASS32
384 #define ELF_DATA ELFDATA2MSB
385 #define ELF_ARCH EM_SPARC
387 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
390 regs
->pc
= infop
->entry
;
391 regs
->npc
= regs
->pc
+ 4;
393 regs
->u_regs
[14] = infop
->start_stack
- 16 * 4;
401 #define ELF_START_MMAP 0x80000000
403 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
405 #define elf_check_arch(x) ( (x) == EM_PPC64 )
407 #define ELF_CLASS ELFCLASS64
411 #define elf_check_arch(x) ( (x) == EM_PPC )
413 #define ELF_CLASS ELFCLASS32
417 #ifdef TARGET_WORDS_BIGENDIAN
418 #define ELF_DATA ELFDATA2MSB
420 #define ELF_DATA ELFDATA2LSB
422 #define ELF_ARCH EM_PPC
424 /* Feature masks for the Aux Vector Hardware Capabilities (AT_HWCAP).
425 See arch/powerpc/include/asm/cputable.h. */
427 QEMU_PPC_FEATURE_32
= 0x80000000,
428 QEMU_PPC_FEATURE_64
= 0x40000000,
429 QEMU_PPC_FEATURE_601_INSTR
= 0x20000000,
430 QEMU_PPC_FEATURE_HAS_ALTIVEC
= 0x10000000,
431 QEMU_PPC_FEATURE_HAS_FPU
= 0x08000000,
432 QEMU_PPC_FEATURE_HAS_MMU
= 0x04000000,
433 QEMU_PPC_FEATURE_HAS_4xxMAC
= 0x02000000,
434 QEMU_PPC_FEATURE_UNIFIED_CACHE
= 0x01000000,
435 QEMU_PPC_FEATURE_HAS_SPE
= 0x00800000,
436 QEMU_PPC_FEATURE_HAS_EFP_SINGLE
= 0x00400000,
437 QEMU_PPC_FEATURE_HAS_EFP_DOUBLE
= 0x00200000,
438 QEMU_PPC_FEATURE_NO_TB
= 0x00100000,
439 QEMU_PPC_FEATURE_POWER4
= 0x00080000,
440 QEMU_PPC_FEATURE_POWER5
= 0x00040000,
441 QEMU_PPC_FEATURE_POWER5_PLUS
= 0x00020000,
442 QEMU_PPC_FEATURE_CELL
= 0x00010000,
443 QEMU_PPC_FEATURE_BOOKE
= 0x00008000,
444 QEMU_PPC_FEATURE_SMT
= 0x00004000,
445 QEMU_PPC_FEATURE_ICACHE_SNOOP
= 0x00002000,
446 QEMU_PPC_FEATURE_ARCH_2_05
= 0x00001000,
447 QEMU_PPC_FEATURE_PA6T
= 0x00000800,
448 QEMU_PPC_FEATURE_HAS_DFP
= 0x00000400,
449 QEMU_PPC_FEATURE_POWER6_EXT
= 0x00000200,
450 QEMU_PPC_FEATURE_ARCH_2_06
= 0x00000100,
451 QEMU_PPC_FEATURE_HAS_VSX
= 0x00000080,
452 QEMU_PPC_FEATURE_PSERIES_PERFMON_COMPAT
= 0x00000040,
454 QEMU_PPC_FEATURE_TRUE_LE
= 0x00000002,
455 QEMU_PPC_FEATURE_PPC_LE
= 0x00000001,
458 #define ELF_HWCAP get_elf_hwcap()
460 static uint32_t get_elf_hwcap(void)
462 CPUState
*e
= thread_env
;
463 uint32_t features
= 0;
465 /* We don't have to be terribly complete here; the high points are
466 Altivec/FP/SPE support. Anything else is just a bonus. */
467 #define GET_FEATURE(flag, feature) \
468 do {if (e->insns_flags & flag) features |= feature; } while(0)
469 GET_FEATURE(PPC_64B
, QEMU_PPC_FEATURE_64
);
470 GET_FEATURE(PPC_FLOAT
, QEMU_PPC_FEATURE_HAS_FPU
);
471 GET_FEATURE(PPC_ALTIVEC
, QEMU_PPC_FEATURE_HAS_ALTIVEC
);
472 GET_FEATURE(PPC_SPE
, QEMU_PPC_FEATURE_HAS_SPE
);
473 GET_FEATURE(PPC_SPE_SINGLE
, QEMU_PPC_FEATURE_HAS_EFP_SINGLE
);
474 GET_FEATURE(PPC_SPE_DOUBLE
, QEMU_PPC_FEATURE_HAS_EFP_DOUBLE
);
475 GET_FEATURE(PPC_BOOKE
, QEMU_PPC_FEATURE_BOOKE
);
476 GET_FEATURE(PPC_405_MAC
, QEMU_PPC_FEATURE_HAS_4xxMAC
);
483 * We need to put in some extra aux table entries to tell glibc what
484 * the cache block size is, so it can use the dcbz instruction safely.
486 #define AT_DCACHEBSIZE 19
487 #define AT_ICACHEBSIZE 20
488 #define AT_UCACHEBSIZE 21
489 /* A special ignored type value for PPC, for glibc compatibility. */
490 #define AT_IGNOREPPC 22
492 * The requirements here are:
493 * - keep the final alignment of sp (sp & 0xf)
494 * - make sure the 32-bit value at the first 16 byte aligned position of
495 * AUXV is greater than 16 for glibc compatibility.
496 * AT_IGNOREPPC is used for that.
497 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
498 * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
500 #define DLINFO_ARCH_ITEMS 5
501 #define ARCH_DLINFO \
503 NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20); \
504 NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20); \
505 NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \
507 * Now handle glibc compatibility. \
509 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
510 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
513 static inline void init_thread(struct target_pt_regs
*_regs
, struct image_info
*infop
)
515 abi_ulong pos
= infop
->start_stack
;
517 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
518 abi_ulong entry
, toc
;
521 _regs
->gpr
[1] = infop
->start_stack
;
522 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
523 entry
= ldq_raw(infop
->entry
) + infop
->load_addr
;
524 toc
= ldq_raw(infop
->entry
+ 8) + infop
->load_addr
;
526 infop
->entry
= entry
;
528 _regs
->nip
= infop
->entry
;
529 /* Note that isn't exactly what regular kernel does
530 * but this is what the ABI wants and is needed to allow
531 * execution of PPC BSD programs.
533 /* FIXME - what to for failure of get_user()? */
534 get_user_ual(_regs
->gpr
[3], pos
);
535 pos
+= sizeof(abi_ulong
);
537 for (tmp
= 1; tmp
!= 0; pos
+= sizeof(abi_ulong
))
542 /* See linux kernel: arch/powerpc/include/asm/elf.h. */
544 typedef target_elf_greg_t target_elf_gregset_t
[ELF_NREG
];
546 static void elf_core_copy_regs(target_elf_gregset_t
*regs
, const CPUState
*env
)
549 target_ulong ccr
= 0;
551 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
552 (*regs
)[i
] = tswapl(env
->gpr
[i
]);
555 (*regs
)[32] = tswapl(env
->nip
);
556 (*regs
)[33] = tswapl(env
->msr
);
557 (*regs
)[35] = tswapl(env
->ctr
);
558 (*regs
)[36] = tswapl(env
->lr
);
559 (*regs
)[37] = tswapl(env
->xer
);
561 for (i
= 0; i
< ARRAY_SIZE(env
->crf
); i
++) {
562 ccr
|= env
->crf
[i
] << (32 - ((i
+ 1) * 4));
564 (*regs
)[38] = tswapl(ccr
);
567 #define USE_ELF_CORE_DUMP
568 #define ELF_EXEC_PAGESIZE 4096
574 #define ELF_START_MMAP 0x80000000
576 #define elf_check_arch(x) ( (x) == EM_MIPS )
579 #define ELF_CLASS ELFCLASS64
581 #define ELF_CLASS ELFCLASS32
583 #ifdef TARGET_WORDS_BIGENDIAN
584 #define ELF_DATA ELFDATA2MSB
586 #define ELF_DATA ELFDATA2LSB
588 #define ELF_ARCH EM_MIPS
590 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
592 regs
->cp0_status
= 2 << CP0St_KSU
;
593 regs
->cp0_epc
= infop
->entry
;
594 regs
->regs
[29] = infop
->start_stack
;
597 /* See linux kernel: arch/mips/include/asm/elf.h. */
599 typedef target_elf_greg_t target_elf_gregset_t
[ELF_NREG
];
601 /* See linux kernel: arch/mips/include/asm/reg.h. */
608 TARGET_EF_R26
= TARGET_EF_R0
+ 26,
609 TARGET_EF_R27
= TARGET_EF_R0
+ 27,
610 TARGET_EF_LO
= TARGET_EF_R0
+ 32,
611 TARGET_EF_HI
= TARGET_EF_R0
+ 33,
612 TARGET_EF_CP0_EPC
= TARGET_EF_R0
+ 34,
613 TARGET_EF_CP0_BADVADDR
= TARGET_EF_R0
+ 35,
614 TARGET_EF_CP0_STATUS
= TARGET_EF_R0
+ 36,
615 TARGET_EF_CP0_CAUSE
= TARGET_EF_R0
+ 37
618 /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs. */
619 static void elf_core_copy_regs(target_elf_gregset_t
*regs
, const CPUState
*env
)
623 for (i
= 0; i
< TARGET_EF_R0
; i
++) {
626 (*regs
)[TARGET_EF_R0
] = 0;
628 for (i
= 1; i
< ARRAY_SIZE(env
->active_tc
.gpr
); i
++) {
629 (*regs
)[TARGET_EF_R0
+ i
] = tswapl(env
->active_tc
.gpr
[i
]);
632 (*regs
)[TARGET_EF_R26
] = 0;
633 (*regs
)[TARGET_EF_R27
] = 0;
634 (*regs
)[TARGET_EF_LO
] = tswapl(env
->active_tc
.LO
[0]);
635 (*regs
)[TARGET_EF_HI
] = tswapl(env
->active_tc
.HI
[0]);
636 (*regs
)[TARGET_EF_CP0_EPC
] = tswapl(env
->active_tc
.PC
);
637 (*regs
)[TARGET_EF_CP0_BADVADDR
] = tswapl(env
->CP0_BadVAddr
);
638 (*regs
)[TARGET_EF_CP0_STATUS
] = tswapl(env
->CP0_Status
);
639 (*regs
)[TARGET_EF_CP0_CAUSE
] = tswapl(env
->CP0_Cause
);
642 #define USE_ELF_CORE_DUMP
643 #define ELF_EXEC_PAGESIZE 4096
645 #endif /* TARGET_MIPS */
647 #ifdef TARGET_MICROBLAZE
649 #define ELF_START_MMAP 0x80000000
651 #define elf_check_arch(x) ( (x) == EM_XILINX_MICROBLAZE )
653 #define ELF_CLASS ELFCLASS32
654 #define ELF_DATA ELFDATA2MSB
655 #define ELF_ARCH EM_MIPS
657 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
659 regs
->pc
= infop
->entry
;
660 regs
->r1
= infop
->start_stack
;
664 #define ELF_EXEC_PAGESIZE 4096
666 #endif /* TARGET_MICROBLAZE */
670 #define ELF_START_MMAP 0x80000000
672 #define elf_check_arch(x) ( (x) == EM_SH )
674 #define ELF_CLASS ELFCLASS32
675 #define ELF_DATA ELFDATA2LSB
676 #define ELF_ARCH EM_SH
678 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
680 /* Check other registers XXXXX */
681 regs
->pc
= infop
->entry
;
682 regs
->regs
[15] = infop
->start_stack
;
685 #define ELF_EXEC_PAGESIZE 4096
691 #define ELF_START_MMAP 0x80000000
693 #define elf_check_arch(x) ( (x) == EM_CRIS )
695 #define ELF_CLASS ELFCLASS32
696 #define ELF_DATA ELFDATA2LSB
697 #define ELF_ARCH EM_CRIS
699 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
701 regs
->erp
= infop
->entry
;
704 #define ELF_EXEC_PAGESIZE 8192
710 #define ELF_START_MMAP 0x80000000
712 #define elf_check_arch(x) ( (x) == EM_68K )
714 #define ELF_CLASS ELFCLASS32
715 #define ELF_DATA ELFDATA2MSB
716 #define ELF_ARCH EM_68K
718 /* ??? Does this need to do anything?
719 #define ELF_PLAT_INIT(_r) */
721 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
723 regs
->usp
= infop
->start_stack
;
725 regs
->pc
= infop
->entry
;
728 #define ELF_EXEC_PAGESIZE 8192
734 #define ELF_START_MMAP (0x30000000000ULL)
736 #define elf_check_arch(x) ( (x) == ELF_ARCH )
738 #define ELF_CLASS ELFCLASS64
739 #define ELF_DATA ELFDATA2MSB
740 #define ELF_ARCH EM_ALPHA
742 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
744 regs
->pc
= infop
->entry
;
746 regs
->usp
= infop
->start_stack
;
749 #define ELF_EXEC_PAGESIZE 8192
751 #endif /* TARGET_ALPHA */
754 #define ELF_PLATFORM (NULL)
763 #define ELF_CLASS ELFCLASS32
765 #define bswaptls(ptr) bswap32s(ptr)
772 unsigned int a_info
; /* Use macros N_MAGIC, etc for access */
773 unsigned int a_text
; /* length of text, in bytes */
774 unsigned int a_data
; /* length of data, in bytes */
775 unsigned int a_bss
; /* length of uninitialized data area, in bytes */
776 unsigned int a_syms
; /* length of symbol table data in file, in bytes */
777 unsigned int a_entry
; /* start address */
778 unsigned int a_trsize
; /* length of relocation info for text, in bytes */
779 unsigned int a_drsize
; /* length of relocation info for data, in bytes */
783 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
789 /* max code+data+bss space allocated to elf interpreter */
790 #define INTERP_MAP_SIZE (32 * 1024 * 1024)
792 /* max code+data+bss+brk space allocated to ET_DYN executables */
793 #define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
795 /* Necessary parameters */
796 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
797 #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
798 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
800 #define INTERPRETER_NONE 0
801 #define INTERPRETER_AOUT 1
802 #define INTERPRETER_ELF 2
804 #define DLINFO_ITEMS 12
806 static inline void memcpy_fromfs(void * to
, const void * from
, unsigned long n
)
811 static int load_aout_interp(void * exptr
, int interp_fd
);
814 static void bswap_ehdr(struct elfhdr
*ehdr
)
816 bswap16s(&ehdr
->e_type
); /* Object file type */
817 bswap16s(&ehdr
->e_machine
); /* Architecture */
818 bswap32s(&ehdr
->e_version
); /* Object file version */
819 bswaptls(&ehdr
->e_entry
); /* Entry point virtual address */
820 bswaptls(&ehdr
->e_phoff
); /* Program header table file offset */
821 bswaptls(&ehdr
->e_shoff
); /* Section header table file offset */
822 bswap32s(&ehdr
->e_flags
); /* Processor-specific flags */
823 bswap16s(&ehdr
->e_ehsize
); /* ELF header size in bytes */
824 bswap16s(&ehdr
->e_phentsize
); /* Program header table entry size */
825 bswap16s(&ehdr
->e_phnum
); /* Program header table entry count */
826 bswap16s(&ehdr
->e_shentsize
); /* Section header table entry size */
827 bswap16s(&ehdr
->e_shnum
); /* Section header table entry count */
828 bswap16s(&ehdr
->e_shstrndx
); /* Section header string table index */
831 static void bswap_phdr(struct elf_phdr
*phdr
)
833 bswap32s(&phdr
->p_type
); /* Segment type */
834 bswaptls(&phdr
->p_offset
); /* Segment file offset */
835 bswaptls(&phdr
->p_vaddr
); /* Segment virtual address */
836 bswaptls(&phdr
->p_paddr
); /* Segment physical address */
837 bswaptls(&phdr
->p_filesz
); /* Segment size in file */
838 bswaptls(&phdr
->p_memsz
); /* Segment size in memory */
839 bswap32s(&phdr
->p_flags
); /* Segment flags */
840 bswaptls(&phdr
->p_align
); /* Segment alignment */
843 static void bswap_shdr(struct elf_shdr
*shdr
)
845 bswap32s(&shdr
->sh_name
);
846 bswap32s(&shdr
->sh_type
);
847 bswaptls(&shdr
->sh_flags
);
848 bswaptls(&shdr
->sh_addr
);
849 bswaptls(&shdr
->sh_offset
);
850 bswaptls(&shdr
->sh_size
);
851 bswap32s(&shdr
->sh_link
);
852 bswap32s(&shdr
->sh_info
);
853 bswaptls(&shdr
->sh_addralign
);
854 bswaptls(&shdr
->sh_entsize
);
857 static void bswap_sym(struct elf_sym
*sym
)
859 bswap32s(&sym
->st_name
);
860 bswaptls(&sym
->st_value
);
861 bswaptls(&sym
->st_size
);
862 bswap16s(&sym
->st_shndx
);
866 #ifdef USE_ELF_CORE_DUMP
867 static int elf_core_dump(int, const CPUState
*);
870 static void bswap_note(struct elf_note
*en
)
872 bswap32s(&en
->n_namesz
);
873 bswap32s(&en
->n_descsz
);
874 bswap32s(&en
->n_type
);
876 #endif /* BSWAP_NEEDED */
878 #endif /* USE_ELF_CORE_DUMP */
881 * 'copy_elf_strings()' copies argument/envelope strings from user
882 * memory to free pages in kernel mem. These are in a format ready
883 * to be put directly into the top of new user memory.
886 static abi_ulong
copy_elf_strings(int argc
,char ** argv
, void **page
,
889 char *tmp
, *tmp1
, *pag
= NULL
;
893 return 0; /* bullet-proofing */
898 fprintf(stderr
, "VFS: argc is wrong");
904 if (p
< len
) { /* this shouldn't happen - 128kB */
910 offset
= p
% TARGET_PAGE_SIZE
;
911 pag
= (char *)page
[p
/TARGET_PAGE_SIZE
];
913 pag
= (char *)malloc(TARGET_PAGE_SIZE
);
914 memset(pag
, 0, TARGET_PAGE_SIZE
);
915 page
[p
/TARGET_PAGE_SIZE
] = pag
;
920 if (len
== 0 || offset
== 0) {
921 *(pag
+ offset
) = *tmp
;
924 int bytes_to_copy
= (len
> offset
) ? offset
: len
;
925 tmp
-= bytes_to_copy
;
927 offset
-= bytes_to_copy
;
928 len
-= bytes_to_copy
;
929 memcpy_fromfs(pag
+ offset
, tmp
, bytes_to_copy
+ 1);
936 static abi_ulong
setup_arg_pages(abi_ulong p
, struct linux_binprm
*bprm
,
937 struct image_info
*info
)
939 abi_ulong stack_base
, size
, error
;
942 /* Create enough stack to hold everything. If we don't use
943 * it for args, we'll use it for something else...
945 size
= x86_stack_size
;
946 if (size
< MAX_ARG_PAGES
*TARGET_PAGE_SIZE
)
947 size
= MAX_ARG_PAGES
*TARGET_PAGE_SIZE
;
948 error
= target_mmap(0,
949 size
+ qemu_host_page_size
,
950 PROT_READ
| PROT_WRITE
,
951 MAP_PRIVATE
| MAP_ANONYMOUS
,
957 /* we reserve one extra page at the top of the stack as guard */
958 target_mprotect(error
+ size
, qemu_host_page_size
, PROT_NONE
);
960 stack_base
= error
+ size
- MAX_ARG_PAGES
*TARGET_PAGE_SIZE
;
963 for (i
= 0 ; i
< MAX_ARG_PAGES
; i
++) {
966 /* FIXME - check return value of memcpy_to_target() for failure */
967 memcpy_to_target(stack_base
, bprm
->page
[i
], TARGET_PAGE_SIZE
);
970 stack_base
+= TARGET_PAGE_SIZE
;
975 static void set_brk(abi_ulong start
, abi_ulong end
)
977 /* page-align the start and end addresses... */
978 start
= HOST_PAGE_ALIGN(start
);
979 end
= HOST_PAGE_ALIGN(end
);
982 if(target_mmap(start
, end
- start
,
983 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
984 MAP_FIXED
| MAP_PRIVATE
| MAP_ANONYMOUS
, -1, 0) == -1) {
985 perror("cannot mmap brk");
991 /* We need to explicitly zero any fractional pages after the data
992 section (i.e. bss). This would contain the junk from the file that
993 should not be in memory. */
994 static void padzero(abi_ulong elf_bss
, abi_ulong last_bss
)
998 if (elf_bss
>= last_bss
)
1001 /* XXX: this is really a hack : if the real host page size is
1002 smaller than the target page size, some pages after the end
1003 of the file may not be mapped. A better fix would be to
1004 patch target_mmap(), but it is more complicated as the file
1005 size must be known */
1006 if (qemu_real_host_page_size
< qemu_host_page_size
) {
1007 abi_ulong end_addr
, end_addr1
;
1008 end_addr1
= (elf_bss
+ qemu_real_host_page_size
- 1) &
1009 ~(qemu_real_host_page_size
- 1);
1010 end_addr
= HOST_PAGE_ALIGN(elf_bss
);
1011 if (end_addr1
< end_addr
) {
1012 mmap((void *)g2h(end_addr1
), end_addr
- end_addr1
,
1013 PROT_READ
|PROT_WRITE
|PROT_EXEC
,
1014 MAP_FIXED
|MAP_PRIVATE
|MAP_ANONYMOUS
, -1, 0);
1018 nbyte
= elf_bss
& (qemu_host_page_size
-1);
1020 nbyte
= qemu_host_page_size
- nbyte
;
1022 /* FIXME - what to do if put_user() fails? */
1023 put_user_u8(0, elf_bss
);
1030 static abi_ulong
create_elf_tables(abi_ulong p
, int argc
, int envc
,
1031 struct elfhdr
* exec
,
1032 abi_ulong load_addr
,
1033 abi_ulong load_bias
,
1034 abi_ulong interp_load_addr
, int ibcs
,
1035 struct image_info
*info
)
1039 abi_ulong u_platform
;
1040 const char *k_platform
;
1041 const int n
= sizeof(elf_addr_t
);
1045 k_platform
= ELF_PLATFORM
;
1047 size_t len
= strlen(k_platform
) + 1;
1048 sp
-= (len
+ n
- 1) & ~(n
- 1);
1050 /* FIXME - check return value of memcpy_to_target() for failure */
1051 memcpy_to_target(sp
, k_platform
, len
);
1054 * Force 16 byte _final_ alignment here for generality.
1056 sp
= sp
&~ (abi_ulong
)15;
1057 size
= (DLINFO_ITEMS
+ 1) * 2;
1060 #ifdef DLINFO_ARCH_ITEMS
1061 size
+= DLINFO_ARCH_ITEMS
* 2;
1063 size
+= envc
+ argc
+ 2;
1064 size
+= (!ibcs
? 3 : 1); /* argc itself */
1067 sp
-= 16 - (size
& 15);
1069 /* This is correct because Linux defines
1070 * elf_addr_t as Elf32_Off / Elf64_Off
1072 #define NEW_AUX_ENT(id, val) do { \
1073 sp -= n; put_user_ual(val, sp); \
1074 sp -= n; put_user_ual(id, sp); \
1077 NEW_AUX_ENT (AT_NULL
, 0);
1079 /* There must be exactly DLINFO_ITEMS entries here. */
1080 NEW_AUX_ENT(AT_PHDR
, (abi_ulong
)(load_addr
+ exec
->e_phoff
));
1081 NEW_AUX_ENT(AT_PHENT
, (abi_ulong
)(sizeof (struct elf_phdr
)));
1082 NEW_AUX_ENT(AT_PHNUM
, (abi_ulong
)(exec
->e_phnum
));
1083 NEW_AUX_ENT(AT_PAGESZ
, (abi_ulong
)(TARGET_PAGE_SIZE
));
1084 NEW_AUX_ENT(AT_BASE
, (abi_ulong
)(interp_load_addr
));
1085 NEW_AUX_ENT(AT_FLAGS
, (abi_ulong
)0);
1086 NEW_AUX_ENT(AT_ENTRY
, load_bias
+ exec
->e_entry
);
1087 NEW_AUX_ENT(AT_UID
, (abi_ulong
) getuid());
1088 NEW_AUX_ENT(AT_EUID
, (abi_ulong
) geteuid());
1089 NEW_AUX_ENT(AT_GID
, (abi_ulong
) getgid());
1090 NEW_AUX_ENT(AT_EGID
, (abi_ulong
) getegid());
1091 NEW_AUX_ENT(AT_HWCAP
, (abi_ulong
) ELF_HWCAP
);
1092 NEW_AUX_ENT(AT_CLKTCK
, (abi_ulong
) sysconf(_SC_CLK_TCK
));
1094 NEW_AUX_ENT(AT_PLATFORM
, u_platform
);
1097 * ARCH_DLINFO must come last so platform specific code can enforce
1098 * special alignment requirements on the AUXV if necessary (eg. PPC).
1104 info
->saved_auxv
= sp
;
1106 sp
= loader_build_argptr(envc
, argc
, sp
, p
, !ibcs
);
1111 static abi_ulong
load_elf_interp(struct elfhdr
* interp_elf_ex
,
1113 abi_ulong
*interp_load_addr
)
1115 struct elf_phdr
*elf_phdata
= NULL
;
1116 struct elf_phdr
*eppnt
;
1117 abi_ulong load_addr
= 0;
1118 int load_addr_set
= 0;
1120 abi_ulong last_bss
, elf_bss
;
1129 bswap_ehdr(interp_elf_ex
);
1131 /* First of all, some simple consistency checks */
1132 if ((interp_elf_ex
->e_type
!= ET_EXEC
&&
1133 interp_elf_ex
->e_type
!= ET_DYN
) ||
1134 !elf_check_arch(interp_elf_ex
->e_machine
)) {
1135 return ~((abi_ulong
)0UL);
1139 /* Now read in all of the header information */
1141 if (sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
> TARGET_PAGE_SIZE
)
1142 return ~(abi_ulong
)0UL;
1144 elf_phdata
= (struct elf_phdr
*)
1145 malloc(sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
);
1148 return ~((abi_ulong
)0UL);
1151 * If the size of this structure has changed, then punt, since
1152 * we will be doing the wrong thing.
1154 if (interp_elf_ex
->e_phentsize
!= sizeof(struct elf_phdr
)) {
1156 return ~((abi_ulong
)0UL);
1159 retval
= lseek(interpreter_fd
, interp_elf_ex
->e_phoff
, SEEK_SET
);
1161 retval
= read(interpreter_fd
,
1162 (char *) elf_phdata
,
1163 sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
);
1166 perror("load_elf_interp");
1173 for (i
=0; i
<interp_elf_ex
->e_phnum
; i
++, eppnt
++) {
1178 if (interp_elf_ex
->e_type
== ET_DYN
) {
1179 /* in order to avoid hardcoding the interpreter load
1180 address in qemu, we allocate a big enough memory zone */
1181 error
= target_mmap(0, INTERP_MAP_SIZE
,
1182 PROT_NONE
, MAP_PRIVATE
| MAP_ANON
,
1193 for(i
=0; i
<interp_elf_ex
->e_phnum
; i
++, eppnt
++)
1194 if (eppnt
->p_type
== PT_LOAD
) {
1195 int elf_type
= MAP_PRIVATE
| MAP_DENYWRITE
;
1197 abi_ulong vaddr
= 0;
1200 if (eppnt
->p_flags
& PF_R
) elf_prot
= PROT_READ
;
1201 if (eppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
1202 if (eppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
1203 if (interp_elf_ex
->e_type
== ET_EXEC
|| load_addr_set
) {
1204 elf_type
|= MAP_FIXED
;
1205 vaddr
= eppnt
->p_vaddr
;
1207 error
= target_mmap(load_addr
+TARGET_ELF_PAGESTART(vaddr
),
1208 eppnt
->p_filesz
+ TARGET_ELF_PAGEOFFSET(eppnt
->p_vaddr
),
1212 eppnt
->p_offset
- TARGET_ELF_PAGEOFFSET(eppnt
->p_vaddr
));
1216 close(interpreter_fd
);
1218 return ~((abi_ulong
)0UL);
1221 if (!load_addr_set
&& interp_elf_ex
->e_type
== ET_DYN
) {
1227 * Find the end of the file mapping for this phdr, and keep
1228 * track of the largest address we see for this.
1230 k
= load_addr
+ eppnt
->p_vaddr
+ eppnt
->p_filesz
;
1231 if (k
> elf_bss
) elf_bss
= k
;
1234 * Do the same thing for the memory mapping - between
1235 * elf_bss and last_bss is the bss section.
1237 k
= load_addr
+ eppnt
->p_memsz
+ eppnt
->p_vaddr
;
1238 if (k
> last_bss
) last_bss
= k
;
1241 /* Now use mmap to map the library into memory. */
1243 close(interpreter_fd
);
1246 * Now fill out the bss section. First pad the last page up
1247 * to the page boundary, and then perform a mmap to make sure
1248 * that there are zeromapped pages up to and including the last
1251 padzero(elf_bss
, last_bss
);
1252 elf_bss
= TARGET_ELF_PAGESTART(elf_bss
+ qemu_host_page_size
- 1); /* What we have mapped so far */
1254 /* Map the last of the bss segment */
1255 if (last_bss
> elf_bss
) {
1256 target_mmap(elf_bss
, last_bss
-elf_bss
,
1257 PROT_READ
|PROT_WRITE
|PROT_EXEC
,
1258 MAP_FIXED
|MAP_PRIVATE
|MAP_ANONYMOUS
, -1, 0);
1262 *interp_load_addr
= load_addr
;
1263 return ((abi_ulong
) interp_elf_ex
->e_entry
) + load_addr
;
1266 static int symfind(const void *s0
, const void *s1
)
1268 struct elf_sym
*key
= (struct elf_sym
*)s0
;
1269 struct elf_sym
*sym
= (struct elf_sym
*)s1
;
1271 if (key
->st_value
< sym
->st_value
) {
1273 } else if (key
->st_value
>= sym
->st_value
+ sym
->st_size
) {
1279 static const char *lookup_symbolxx(struct syminfo
*s
, target_ulong orig_addr
)
1281 #if ELF_CLASS == ELFCLASS32
1282 struct elf_sym
*syms
= s
->disas_symtab
.elf32
;
1284 struct elf_sym
*syms
= s
->disas_symtab
.elf64
;
1289 struct elf_sym
*sym
;
1291 key
.st_value
= orig_addr
;
1293 sym
= bsearch(&key
, syms
, s
->disas_num_syms
, sizeof(*syms
), symfind
);
1295 return s
->disas_strtab
+ sym
->st_name
;
1301 /* FIXME: This should use elf_ops.h */
1302 static int symcmp(const void *s0
, const void *s1
)
1304 struct elf_sym
*sym0
= (struct elf_sym
*)s0
;
1305 struct elf_sym
*sym1
= (struct elf_sym
*)s1
;
1306 return (sym0
->st_value
< sym1
->st_value
)
1308 : ((sym0
->st_value
> sym1
->st_value
) ? 1 : 0);
1311 /* Best attempt to load symbols from this ELF object. */
1312 static void load_symbols(struct elfhdr
*hdr
, int fd
)
1314 unsigned int i
, nsyms
;
1315 struct elf_shdr sechdr
, symtab
, strtab
;
1318 struct elf_sym
*syms
;
1320 lseek(fd
, hdr
->e_shoff
, SEEK_SET
);
1321 for (i
= 0; i
< hdr
->e_shnum
; i
++) {
1322 if (read(fd
, &sechdr
, sizeof(sechdr
)) != sizeof(sechdr
))
1325 bswap_shdr(&sechdr
);
1327 if (sechdr
.sh_type
== SHT_SYMTAB
) {
1329 lseek(fd
, hdr
->e_shoff
1330 + sizeof(sechdr
) * sechdr
.sh_link
, SEEK_SET
);
1331 if (read(fd
, &strtab
, sizeof(strtab
))
1335 bswap_shdr(&strtab
);
1340 return; /* Shouldn't happen... */
1343 /* Now know where the strtab and symtab are. Snarf them. */
1344 s
= malloc(sizeof(*s
));
1345 syms
= malloc(symtab
.sh_size
);
1348 s
->disas_strtab
= strings
= malloc(strtab
.sh_size
);
1349 if (!s
->disas_strtab
)
1352 lseek(fd
, symtab
.sh_offset
, SEEK_SET
);
1353 if (read(fd
, syms
, symtab
.sh_size
) != symtab
.sh_size
)
1356 nsyms
= symtab
.sh_size
/ sizeof(struct elf_sym
);
1361 bswap_sym(syms
+ i
);
1363 // Throw away entries which we do not need.
1364 if (syms
[i
].st_shndx
== SHN_UNDEF
||
1365 syms
[i
].st_shndx
>= SHN_LORESERVE
||
1366 ELF_ST_TYPE(syms
[i
].st_info
) != STT_FUNC
) {
1369 syms
[i
] = syms
[nsyms
];
1373 #if defined(TARGET_ARM) || defined (TARGET_MIPS)
1374 /* The bottom address bit marks a Thumb or MIPS16 symbol. */
1375 syms
[i
].st_value
&= ~(target_ulong
)1;
1379 syms
= realloc(syms
, nsyms
* sizeof(*syms
));
1381 qsort(syms
, nsyms
, sizeof(*syms
), symcmp
);
1383 lseek(fd
, strtab
.sh_offset
, SEEK_SET
);
1384 if (read(fd
, strings
, strtab
.sh_size
) != strtab
.sh_size
)
1386 s
->disas_num_syms
= nsyms
;
1387 #if ELF_CLASS == ELFCLASS32
1388 s
->disas_symtab
.elf32
= syms
;
1389 s
->lookup_symbol
= (lookup_symbol_t
)lookup_symbolxx
;
1391 s
->disas_symtab
.elf64
= syms
;
1392 s
->lookup_symbol
= (lookup_symbol_t
)lookup_symbolxx
;
1398 int load_elf_binary(struct linux_binprm
* bprm
, struct target_pt_regs
* regs
,
1399 struct image_info
* info
)
1401 struct elfhdr elf_ex
;
1402 struct elfhdr interp_elf_ex
;
1403 struct exec interp_ex
;
1404 int interpreter_fd
= -1; /* avoid warning */
1405 abi_ulong load_addr
, load_bias
;
1406 int load_addr_set
= 0;
1407 unsigned int interpreter_type
= INTERPRETER_NONE
;
1408 unsigned char ibcs2_interpreter
;
1410 abi_ulong mapped_addr
;
1411 struct elf_phdr
* elf_ppnt
;
1412 struct elf_phdr
*elf_phdata
;
1413 abi_ulong elf_bss
, k
, elf_brk
;
1415 char * elf_interpreter
;
1416 abi_ulong elf_entry
, interp_load_addr
= 0;
1418 abi_ulong start_code
, end_code
, start_data
, end_data
;
1419 abi_ulong reloc_func_desc
= 0;
1420 abi_ulong elf_stack
;
1421 char passed_fileno
[6];
1423 ibcs2_interpreter
= 0;
1427 elf_ex
= *((struct elfhdr
*) bprm
->buf
); /* exec-header */
1429 bswap_ehdr(&elf_ex
);
1432 /* First of all, some simple consistency checks */
1433 if ((elf_ex
.e_type
!= ET_EXEC
&& elf_ex
.e_type
!= ET_DYN
) ||
1434 (! elf_check_arch(elf_ex
.e_machine
))) {
1438 bprm
->p
= copy_elf_strings(1, &bprm
->filename
, bprm
->page
, bprm
->p
);
1439 bprm
->p
= copy_elf_strings(bprm
->envc
,bprm
->envp
,bprm
->page
,bprm
->p
);
1440 bprm
->p
= copy_elf_strings(bprm
->argc
,bprm
->argv
,bprm
->page
,bprm
->p
);
1445 /* Now read in all of the header information */
1446 elf_phdata
= (struct elf_phdr
*)malloc(elf_ex
.e_phentsize
*elf_ex
.e_phnum
);
1447 if (elf_phdata
== NULL
) {
1451 retval
= lseek(bprm
->fd
, elf_ex
.e_phoff
, SEEK_SET
);
1453 retval
= read(bprm
->fd
, (char *) elf_phdata
,
1454 elf_ex
.e_phentsize
* elf_ex
.e_phnum
);
1458 perror("load_elf_binary");
1465 elf_ppnt
= elf_phdata
;
1466 for (i
=0; i
<elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
1467 bswap_phdr(elf_ppnt
);
1470 elf_ppnt
= elf_phdata
;
1476 elf_stack
= ~((abi_ulong
)0UL);
1477 elf_interpreter
= NULL
;
1478 start_code
= ~((abi_ulong
)0UL);
1482 interp_ex
.a_info
= 0;
1484 for(i
=0;i
< elf_ex
.e_phnum
; i
++) {
1485 if (elf_ppnt
->p_type
== PT_INTERP
) {
1486 if ( elf_interpreter
!= NULL
)
1489 free(elf_interpreter
);
1494 /* This is the program interpreter used for
1495 * shared libraries - for now assume that this
1496 * is an a.out format binary
1499 elf_interpreter
= (char *)malloc(elf_ppnt
->p_filesz
);
1501 if (elf_interpreter
== NULL
) {
1507 retval
= lseek(bprm
->fd
, elf_ppnt
->p_offset
, SEEK_SET
);
1509 retval
= read(bprm
->fd
, elf_interpreter
, elf_ppnt
->p_filesz
);
1512 perror("load_elf_binary2");
1516 /* If the program interpreter is one of these two,
1517 then assume an iBCS2 image. Otherwise assume
1518 a native linux image. */
1520 /* JRP - Need to add X86 lib dir stuff here... */
1522 if (strcmp(elf_interpreter
,"/usr/lib/libc.so.1") == 0 ||
1523 strcmp(elf_interpreter
,"/usr/lib/ld.so.1") == 0) {
1524 ibcs2_interpreter
= 1;
1528 printf("Using ELF interpreter %s\n", path(elf_interpreter
));
1531 retval
= open(path(elf_interpreter
), O_RDONLY
);
1533 interpreter_fd
= retval
;
1536 perror(elf_interpreter
);
1538 /* retval = -errno; */
1543 retval
= lseek(interpreter_fd
, 0, SEEK_SET
);
1545 retval
= read(interpreter_fd
,bprm
->buf
,128);
1549 interp_ex
= *((struct exec
*) bprm
->buf
); /* aout exec-header */
1550 interp_elf_ex
= *((struct elfhdr
*) bprm
->buf
); /* elf exec-header */
1553 perror("load_elf_binary3");
1556 free(elf_interpreter
);
1564 /* Some simple consistency checks for the interpreter */
1565 if (elf_interpreter
){
1566 interpreter_type
= INTERPRETER_ELF
| INTERPRETER_AOUT
;
1568 /* Now figure out which format our binary is */
1569 if ((N_MAGIC(interp_ex
) != OMAGIC
) && (N_MAGIC(interp_ex
) != ZMAGIC
) &&
1570 (N_MAGIC(interp_ex
) != QMAGIC
)) {
1571 interpreter_type
= INTERPRETER_ELF
;
1574 if (interp_elf_ex
.e_ident
[0] != 0x7f ||
1575 strncmp((char *)&interp_elf_ex
.e_ident
[1], "ELF",3) != 0) {
1576 interpreter_type
&= ~INTERPRETER_ELF
;
1579 if (!interpreter_type
) {
1580 free(elf_interpreter
);
1587 /* OK, we are done with that, now set up the arg stuff,
1588 and then start this sucker up */
1593 if (interpreter_type
== INTERPRETER_AOUT
) {
1594 snprintf(passed_fileno
, sizeof(passed_fileno
), "%d", bprm
->fd
);
1595 passed_p
= passed_fileno
;
1597 if (elf_interpreter
) {
1598 bprm
->p
= copy_elf_strings(1,&passed_p
,bprm
->page
,bprm
->p
);
1603 if (elf_interpreter
) {
1604 free(elf_interpreter
);
1612 /* OK, This is the point of no return */
1615 info
->start_mmap
= (abi_ulong
)ELF_START_MMAP
;
1617 elf_entry
= (abi_ulong
) elf_ex
.e_entry
;
1619 #if defined(CONFIG_USE_GUEST_BASE)
1621 * In case where user has not explicitly set the guest_base, we
1622 * probe here that should we set it automatically.
1624 if (!have_guest_base
) {
1626 * Go through ELF program header table and find out whether
1627 * any of the segments drop below our current mmap_min_addr and
1628 * in that case set guest_base to corresponding address.
1630 for (i
= 0, elf_ppnt
= elf_phdata
; i
< elf_ex
.e_phnum
;
1632 if (elf_ppnt
->p_type
!= PT_LOAD
)
1634 if (HOST_PAGE_ALIGN(elf_ppnt
->p_vaddr
) < mmap_min_addr
) {
1635 guest_base
= HOST_PAGE_ALIGN(mmap_min_addr
);
1640 #endif /* CONFIG_USE_GUEST_BASE */
1642 /* Do this so that we can load the interpreter, if need be. We will
1643 change some of these later */
1645 bprm
->p
= setup_arg_pages(bprm
->p
, bprm
, info
);
1646 info
->start_stack
= bprm
->p
;
1648 /* Now we do a little grungy work by mmaping the ELF image into
1649 * the correct location in memory. At this point, we assume that
1650 * the image should be loaded at fixed address, not at a variable
1654 for(i
= 0, elf_ppnt
= elf_phdata
; i
< elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
1659 if (elf_ppnt
->p_type
!= PT_LOAD
)
1662 if (elf_ppnt
->p_flags
& PF_R
) elf_prot
|= PROT_READ
;
1663 if (elf_ppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
1664 if (elf_ppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
1665 elf_flags
= MAP_PRIVATE
| MAP_DENYWRITE
;
1666 if (elf_ex
.e_type
== ET_EXEC
|| load_addr_set
) {
1667 elf_flags
|= MAP_FIXED
;
1668 } else if (elf_ex
.e_type
== ET_DYN
) {
1669 /* Try and get dynamic programs out of the way of the default mmap
1670 base, as well as whatever program they might try to exec. This
1671 is because the brk will follow the loader, and is not movable. */
1672 /* NOTE: for qemu, we do a big mmap to get enough space
1673 without hardcoding any address */
1674 error
= target_mmap(0, ET_DYN_MAP_SIZE
,
1675 PROT_NONE
, MAP_PRIVATE
| MAP_ANON
,
1681 load_bias
= TARGET_ELF_PAGESTART(error
- elf_ppnt
->p_vaddr
);
1684 error
= target_mmap(TARGET_ELF_PAGESTART(load_bias
+ elf_ppnt
->p_vaddr
),
1685 (elf_ppnt
->p_filesz
+
1686 TARGET_ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)),
1688 (MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
),
1690 (elf_ppnt
->p_offset
-
1691 TARGET_ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)));
1697 #ifdef LOW_ELF_STACK
1698 if (TARGET_ELF_PAGESTART(elf_ppnt
->p_vaddr
) < elf_stack
)
1699 elf_stack
= TARGET_ELF_PAGESTART(elf_ppnt
->p_vaddr
);
1702 if (!load_addr_set
) {
1704 load_addr
= elf_ppnt
->p_vaddr
- elf_ppnt
->p_offset
;
1705 if (elf_ex
.e_type
== ET_DYN
) {
1706 load_bias
+= error
-
1707 TARGET_ELF_PAGESTART(load_bias
+ elf_ppnt
->p_vaddr
);
1708 load_addr
+= load_bias
;
1709 reloc_func_desc
= load_bias
;
1712 k
= elf_ppnt
->p_vaddr
;
1717 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_filesz
;
1720 if ((elf_ppnt
->p_flags
& PF_X
) && end_code
< k
)
1724 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_memsz
;
1725 if (k
> elf_brk
) elf_brk
= k
;
1728 elf_entry
+= load_bias
;
1729 elf_bss
+= load_bias
;
1730 elf_brk
+= load_bias
;
1731 start_code
+= load_bias
;
1732 end_code
+= load_bias
;
1733 start_data
+= load_bias
;
1734 end_data
+= load_bias
;
1736 if (elf_interpreter
) {
1737 if (interpreter_type
& 1) {
1738 elf_entry
= load_aout_interp(&interp_ex
, interpreter_fd
);
1740 else if (interpreter_type
& 2) {
1741 elf_entry
= load_elf_interp(&interp_elf_ex
, interpreter_fd
,
1744 reloc_func_desc
= interp_load_addr
;
1746 close(interpreter_fd
);
1747 free(elf_interpreter
);
1749 if (elf_entry
== ~((abi_ulong
)0UL)) {
1750 printf("Unable to load interpreter\n");
1759 if (qemu_log_enabled())
1760 load_symbols(&elf_ex
, bprm
->fd
);
1762 if (interpreter_type
!= INTERPRETER_AOUT
) close(bprm
->fd
);
1763 info
->personality
= (ibcs2_interpreter
? PER_SVR4
: PER_LINUX
);
1765 #ifdef LOW_ELF_STACK
1766 info
->start_stack
= bprm
->p
= elf_stack
- 4;
1768 bprm
->p
= create_elf_tables(bprm
->p
,
1772 load_addr
, load_bias
,
1774 (interpreter_type
== INTERPRETER_AOUT
? 0 : 1),
1776 info
->load_addr
= reloc_func_desc
;
1777 info
->start_brk
= info
->brk
= elf_brk
;
1778 info
->end_code
= end_code
;
1779 info
->start_code
= start_code
;
1780 info
->start_data
= start_data
;
1781 info
->end_data
= end_data
;
1782 info
->start_stack
= bprm
->p
;
1784 /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1786 set_brk(elf_bss
, elf_brk
);
1788 padzero(elf_bss
, elf_brk
);
1791 printf("(start_brk) %x\n" , info
->start_brk
);
1792 printf("(end_code) %x\n" , info
->end_code
);
1793 printf("(start_code) %x\n" , info
->start_code
);
1794 printf("(end_data) %x\n" , info
->end_data
);
1795 printf("(start_stack) %x\n" , info
->start_stack
);
1796 printf("(brk) %x\n" , info
->brk
);
1799 if ( info
->personality
== PER_SVR4
)
1801 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1802 and some applications "depend" upon this behavior.
1803 Since we do not have the power to recompile these, we
1804 emulate the SVr4 behavior. Sigh. */
1805 mapped_addr
= target_mmap(0, qemu_host_page_size
, PROT_READ
| PROT_EXEC
,
1806 MAP_FIXED
| MAP_PRIVATE
, -1, 0);
1809 info
->entry
= elf_entry
;
1811 #ifdef USE_ELF_CORE_DUMP
1812 bprm
->core_dump
= &elf_core_dump
;
1818 #ifdef USE_ELF_CORE_DUMP
1821 * Definitions to generate Intel SVR4-like core files.
1822 * These mostly have the same names as the SVR4 types with "target_elf_"
1823 * tacked on the front to prevent clashes with linux definitions,
1824 * and the typedef forms have been avoided. This is mostly like
1825 * the SVR4 structure, but more Linuxy, with things that Linux does
1826 * not support and which gdb doesn't really use excluded.
1828 * Fields we don't dump (their contents is zero) in linux-user qemu
1829 * are marked with XXX.
1831 * Core dump code is copied from linux kernel (fs/binfmt_elf.c).
1833 * Porting ELF coredump for target is (quite) simple process. First you
1834 * define USE_ELF_CORE_DUMP in target ELF code (where init_thread() for
1835 * the target resides):
1837 * #define USE_ELF_CORE_DUMP
1839 * Next you define type of register set used for dumping. ELF specification
1840 * says that it needs to be array of elf_greg_t that has size of ELF_NREG.
1842 * typedef <target_regtype> target_elf_greg_t;
1843 * #define ELF_NREG <number of registers>
1844 * typedef taret_elf_greg_t target_elf_gregset_t[ELF_NREG];
1846 * Last step is to implement target specific function that copies registers
1847 * from given cpu into just specified register set. Prototype is:
1849 * static void elf_core_copy_regs(taret_elf_gregset_t *regs,
1850 * const CPUState *env);
1853 * regs - copy register values into here (allocated and zeroed by caller)
1854 * env - copy registers from here
1856 * Example for ARM target is provided in this file.
1859 /* An ELF note in memory */
1863 size_t namesz_rounded
;
1870 struct target_elf_siginfo
{
1871 int si_signo
; /* signal number */
1872 int si_code
; /* extra code */
1873 int si_errno
; /* errno */
1876 struct target_elf_prstatus
{
1877 struct target_elf_siginfo pr_info
; /* Info associated with signal */
1878 short pr_cursig
; /* Current signal */
1879 target_ulong pr_sigpend
; /* XXX */
1880 target_ulong pr_sighold
; /* XXX */
1881 target_pid_t pr_pid
;
1882 target_pid_t pr_ppid
;
1883 target_pid_t pr_pgrp
;
1884 target_pid_t pr_sid
;
1885 struct target_timeval pr_utime
; /* XXX User time */
1886 struct target_timeval pr_stime
; /* XXX System time */
1887 struct target_timeval pr_cutime
; /* XXX Cumulative user time */
1888 struct target_timeval pr_cstime
; /* XXX Cumulative system time */
1889 target_elf_gregset_t pr_reg
; /* GP registers */
1890 int pr_fpvalid
; /* XXX */
1893 #define ELF_PRARGSZ (80) /* Number of chars for args */
1895 struct target_elf_prpsinfo
{
1896 char pr_state
; /* numeric process state */
1897 char pr_sname
; /* char for pr_state */
1898 char pr_zomb
; /* zombie */
1899 char pr_nice
; /* nice val */
1900 target_ulong pr_flag
; /* flags */
1901 target_uid_t pr_uid
;
1902 target_gid_t pr_gid
;
1903 target_pid_t pr_pid
, pr_ppid
, pr_pgrp
, pr_sid
;
1905 char pr_fname
[16]; /* filename of executable */
1906 char pr_psargs
[ELF_PRARGSZ
]; /* initial part of arg list */
1909 /* Here is the structure in which status of each thread is captured. */
1910 struct elf_thread_status
{
1911 QTAILQ_ENTRY(elf_thread_status
) ets_link
;
1912 struct target_elf_prstatus prstatus
; /* NT_PRSTATUS */
1914 elf_fpregset_t fpu
; /* NT_PRFPREG */
1915 struct task_struct
*thread
;
1916 elf_fpxregset_t xfpu
; /* ELF_CORE_XFPREG_TYPE */
1918 struct memelfnote notes
[1];
1922 struct elf_note_info
{
1923 struct memelfnote
*notes
;
1924 struct target_elf_prstatus
*prstatus
; /* NT_PRSTATUS */
1925 struct target_elf_prpsinfo
*psinfo
; /* NT_PRPSINFO */
1927 QTAILQ_HEAD(thread_list_head
, elf_thread_status
) thread_list
;
1930 * Current version of ELF coredump doesn't support
1931 * dumping fp regs etc.
1933 elf_fpregset_t
*fpu
;
1934 elf_fpxregset_t
*xfpu
;
1935 int thread_status_size
;
1941 struct vm_area_struct
{
1942 abi_ulong vma_start
; /* start vaddr of memory region */
1943 abi_ulong vma_end
; /* end vaddr of memory region */
1944 abi_ulong vma_flags
; /* protection etc. flags for the region */
1945 QTAILQ_ENTRY(vm_area_struct
) vma_link
;
1949 QTAILQ_HEAD(, vm_area_struct
) mm_mmap
;
1950 int mm_count
; /* number of mappings */
1953 static struct mm_struct
*vma_init(void);
1954 static void vma_delete(struct mm_struct
*);
1955 static int vma_add_mapping(struct mm_struct
*, abi_ulong
,
1956 abi_ulong
, abi_ulong
);
1957 static int vma_get_mapping_count(const struct mm_struct
*);
1958 static struct vm_area_struct
*vma_first(const struct mm_struct
*);
1959 static struct vm_area_struct
*vma_next(struct vm_area_struct
*);
1960 static abi_ulong
vma_dump_size(const struct vm_area_struct
*);
1961 static int vma_walker(void *priv
, unsigned long start
, unsigned long end
,
1962 unsigned long flags
);
1964 static void fill_elf_header(struct elfhdr
*, int, uint16_t, uint32_t);
1965 static void fill_note(struct memelfnote
*, const char *, int,
1966 unsigned int, void *);
1967 static void fill_prstatus(struct target_elf_prstatus
*, const TaskState
*, int);
1968 static int fill_psinfo(struct target_elf_prpsinfo
*, const TaskState
*);
1969 static void fill_auxv_note(struct memelfnote
*, const TaskState
*);
1970 static void fill_elf_note_phdr(struct elf_phdr
*, int, off_t
);
1971 static size_t note_size(const struct memelfnote
*);
1972 static void free_note_info(struct elf_note_info
*);
1973 static int fill_note_info(struct elf_note_info
*, long, const CPUState
*);
1974 static void fill_thread_info(struct elf_note_info
*, const CPUState
*);
1975 static int core_dump_filename(const TaskState
*, char *, size_t);
1977 static int dump_write(int, const void *, size_t);
1978 static int write_note(struct memelfnote
*, int);
1979 static int write_note_info(struct elf_note_info
*, int);
1982 static void bswap_prstatus(struct target_elf_prstatus
*);
1983 static void bswap_psinfo(struct target_elf_prpsinfo
*);
1985 static void bswap_prstatus(struct target_elf_prstatus
*prstatus
)
1987 prstatus
->pr_info
.si_signo
= tswapl(prstatus
->pr_info
.si_signo
);
1988 prstatus
->pr_info
.si_code
= tswapl(prstatus
->pr_info
.si_code
);
1989 prstatus
->pr_info
.si_errno
= tswapl(prstatus
->pr_info
.si_errno
);
1990 prstatus
->pr_cursig
= tswap16(prstatus
->pr_cursig
);
1991 prstatus
->pr_sigpend
= tswapl(prstatus
->pr_sigpend
);
1992 prstatus
->pr_sighold
= tswapl(prstatus
->pr_sighold
);
1993 prstatus
->pr_pid
= tswap32(prstatus
->pr_pid
);
1994 prstatus
->pr_ppid
= tswap32(prstatus
->pr_ppid
);
1995 prstatus
->pr_pgrp
= tswap32(prstatus
->pr_pgrp
);
1996 prstatus
->pr_sid
= tswap32(prstatus
->pr_sid
);
1997 /* cpu times are not filled, so we skip them */
1998 /* regs should be in correct format already */
1999 prstatus
->pr_fpvalid
= tswap32(prstatus
->pr_fpvalid
);
2002 static void bswap_psinfo(struct target_elf_prpsinfo
*psinfo
)
2004 psinfo
->pr_flag
= tswapl(psinfo
->pr_flag
);
2005 psinfo
->pr_uid
= tswap16(psinfo
->pr_uid
);
2006 psinfo
->pr_gid
= tswap16(psinfo
->pr_gid
);
2007 psinfo
->pr_pid
= tswap32(psinfo
->pr_pid
);
2008 psinfo
->pr_ppid
= tswap32(psinfo
->pr_ppid
);
2009 psinfo
->pr_pgrp
= tswap32(psinfo
->pr_pgrp
);
2010 psinfo
->pr_sid
= tswap32(psinfo
->pr_sid
);
2012 #endif /* BSWAP_NEEDED */
2015 * Minimal support for linux memory regions. These are needed
2016 * when we are finding out what memory exactly belongs to
2017 * emulated process. No locks needed here, as long as
2018 * thread that received the signal is stopped.
2021 static struct mm_struct
*vma_init(void)
2023 struct mm_struct
*mm
;
2025 if ((mm
= qemu_malloc(sizeof (*mm
))) == NULL
)
2029 QTAILQ_INIT(&mm
->mm_mmap
);
2034 static void vma_delete(struct mm_struct
*mm
)
2036 struct vm_area_struct
*vma
;
2038 while ((vma
= vma_first(mm
)) != NULL
) {
2039 QTAILQ_REMOVE(&mm
->mm_mmap
, vma
, vma_link
);
2045 static int vma_add_mapping(struct mm_struct
*mm
, abi_ulong start
,
2046 abi_ulong end
, abi_ulong flags
)
2048 struct vm_area_struct
*vma
;
2050 if ((vma
= qemu_mallocz(sizeof (*vma
))) == NULL
)
2053 vma
->vma_start
= start
;
2055 vma
->vma_flags
= flags
;
2057 QTAILQ_INSERT_TAIL(&mm
->mm_mmap
, vma
, vma_link
);
2063 static struct vm_area_struct
*vma_first(const struct mm_struct
*mm
)
2065 return (QTAILQ_FIRST(&mm
->mm_mmap
));
2068 static struct vm_area_struct
*vma_next(struct vm_area_struct
*vma
)
2070 return (QTAILQ_NEXT(vma
, vma_link
));
2073 static int vma_get_mapping_count(const struct mm_struct
*mm
)
2075 return (mm
->mm_count
);
2079 * Calculate file (dump) size of given memory region.
2081 static abi_ulong
vma_dump_size(const struct vm_area_struct
*vma
)
2083 /* if we cannot even read the first page, skip it */
2084 if (!access_ok(VERIFY_READ
, vma
->vma_start
, TARGET_PAGE_SIZE
))
2088 * Usually we don't dump executable pages as they contain
2089 * non-writable code that debugger can read directly from
2090 * target library etc. However, thread stacks are marked
2091 * also executable so we read in first page of given region
2092 * and check whether it contains elf header. If there is
2093 * no elf header, we dump it.
2095 if (vma
->vma_flags
& PROT_EXEC
) {
2096 char page
[TARGET_PAGE_SIZE
];
2098 copy_from_user(page
, vma
->vma_start
, sizeof (page
));
2099 if ((page
[EI_MAG0
] == ELFMAG0
) &&
2100 (page
[EI_MAG1
] == ELFMAG1
) &&
2101 (page
[EI_MAG2
] == ELFMAG2
) &&
2102 (page
[EI_MAG3
] == ELFMAG3
)) {
2104 * Mappings are possibly from ELF binary. Don't dump
2111 return (vma
->vma_end
- vma
->vma_start
);
2114 static int vma_walker(void *priv
, unsigned long start
, unsigned long end
,
2115 unsigned long flags
)
2117 struct mm_struct
*mm
= (struct mm_struct
*)priv
;
2120 * Don't dump anything that qemu has reserved for internal use.
2122 if (flags
& PAGE_RESERVED
)
2125 vma_add_mapping(mm
, start
, end
, flags
);
2129 static void fill_note(struct memelfnote
*note
, const char *name
, int type
,
2130 unsigned int sz
, void *data
)
2132 unsigned int namesz
;
2134 namesz
= strlen(name
) + 1;
2136 note
->namesz
= namesz
;
2137 note
->namesz_rounded
= roundup(namesz
, sizeof (int32_t));
2139 note
->datasz
= roundup(sz
, sizeof (int32_t));;
2143 * We calculate rounded up note size here as specified by
2146 note
->notesz
= sizeof (struct elf_note
) +
2147 note
->namesz_rounded
+ note
->datasz
;
2150 static void fill_elf_header(struct elfhdr
*elf
, int segs
, uint16_t machine
,
2153 (void) memset(elf
, 0, sizeof(*elf
));
2155 (void) memcpy(elf
->e_ident
, ELFMAG
, SELFMAG
);
2156 elf
->e_ident
[EI_CLASS
] = ELF_CLASS
;
2157 elf
->e_ident
[EI_DATA
] = ELF_DATA
;
2158 elf
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2159 elf
->e_ident
[EI_OSABI
] = ELF_OSABI
;
2161 elf
->e_type
= ET_CORE
;
2162 elf
->e_machine
= machine
;
2163 elf
->e_version
= EV_CURRENT
;
2164 elf
->e_phoff
= sizeof(struct elfhdr
);
2165 elf
->e_flags
= flags
;
2166 elf
->e_ehsize
= sizeof(struct elfhdr
);
2167 elf
->e_phentsize
= sizeof(struct elf_phdr
);
2168 elf
->e_phnum
= segs
;
2175 static void fill_elf_note_phdr(struct elf_phdr
*phdr
, int sz
, off_t offset
)
2177 phdr
->p_type
= PT_NOTE
;
2178 phdr
->p_offset
= offset
;
2181 phdr
->p_filesz
= sz
;
2191 static size_t note_size(const struct memelfnote
*note
)
2193 return (note
->notesz
);
2196 static void fill_prstatus(struct target_elf_prstatus
*prstatus
,
2197 const TaskState
*ts
, int signr
)
2199 (void) memset(prstatus
, 0, sizeof (*prstatus
));
2200 prstatus
->pr_info
.si_signo
= prstatus
->pr_cursig
= signr
;
2201 prstatus
->pr_pid
= ts
->ts_tid
;
2202 prstatus
->pr_ppid
= getppid();
2203 prstatus
->pr_pgrp
= getpgrp();
2204 prstatus
->pr_sid
= getsid(0);
2207 bswap_prstatus(prstatus
);
2211 static int fill_psinfo(struct target_elf_prpsinfo
*psinfo
, const TaskState
*ts
)
2213 char *filename
, *base_filename
;
2214 unsigned int i
, len
;
2216 (void) memset(psinfo
, 0, sizeof (*psinfo
));
2218 len
= ts
->info
->arg_end
- ts
->info
->arg_start
;
2219 if (len
>= ELF_PRARGSZ
)
2220 len
= ELF_PRARGSZ
- 1;
2221 if (copy_from_user(&psinfo
->pr_psargs
, ts
->info
->arg_start
, len
))
2223 for (i
= 0; i
< len
; i
++)
2224 if (psinfo
->pr_psargs
[i
] == 0)
2225 psinfo
->pr_psargs
[i
] = ' ';
2226 psinfo
->pr_psargs
[len
] = 0;
2228 psinfo
->pr_pid
= getpid();
2229 psinfo
->pr_ppid
= getppid();
2230 psinfo
->pr_pgrp
= getpgrp();
2231 psinfo
->pr_sid
= getsid(0);
2232 psinfo
->pr_uid
= getuid();
2233 psinfo
->pr_gid
= getgid();
2235 filename
= strdup(ts
->bprm
->filename
);
2236 base_filename
= strdup(basename(filename
));
2237 (void) strncpy(psinfo
->pr_fname
, base_filename
,
2238 sizeof(psinfo
->pr_fname
));
2239 free(base_filename
);
2243 bswap_psinfo(psinfo
);
2248 static void fill_auxv_note(struct memelfnote
*note
, const TaskState
*ts
)
2250 elf_addr_t auxv
= (elf_addr_t
)ts
->info
->saved_auxv
;
2251 elf_addr_t orig_auxv
= auxv
;
2257 * Auxiliary vector is stored in target process stack. It contains
2258 * {type, value} pairs that we need to dump into note. This is not
2259 * strictly necessary but we do it here for sake of completeness.
2262 /* find out lenght of the vector, AT_NULL is terminator */
2265 get_user_ual(val
, auxv
);
2267 auxv
+= 2 * sizeof (elf_addr_t
);
2268 } while (val
!= AT_NULL
);
2269 len
= i
* sizeof (elf_addr_t
);
2271 /* read in whole auxv vector and copy it to memelfnote */
2272 ptr
= lock_user(VERIFY_READ
, orig_auxv
, len
, 0);
2274 fill_note(note
, "CORE", NT_AUXV
, len
, ptr
);
2275 unlock_user(ptr
, auxv
, len
);
2280 * Constructs name of coredump file. We have following convention
2282 * qemu_<basename-of-target-binary>_<date>-<time>_<pid>.core
2284 * Returns 0 in case of success, -1 otherwise (errno is set).
2286 static int core_dump_filename(const TaskState
*ts
, char *buf
,
2290 char *filename
= NULL
;
2291 char *base_filename
= NULL
;
2295 assert(bufsize
>= PATH_MAX
);
2297 if (gettimeofday(&tv
, NULL
) < 0) {
2298 (void) fprintf(stderr
, "unable to get current timestamp: %s",
2303 filename
= strdup(ts
->bprm
->filename
);
2304 base_filename
= strdup(basename(filename
));
2305 (void) strftime(timestamp
, sizeof (timestamp
), "%Y%m%d-%H%M%S",
2306 localtime_r(&tv
.tv_sec
, &tm
));
2307 (void) snprintf(buf
, bufsize
, "qemu_%s_%s_%d.core",
2308 base_filename
, timestamp
, (int)getpid());
2309 free(base_filename
);
2315 static int dump_write(int fd
, const void *ptr
, size_t size
)
2317 const char *bufp
= (const char *)ptr
;
2318 ssize_t bytes_written
, bytes_left
;
2319 struct rlimit dumpsize
;
2323 getrlimit(RLIMIT_CORE
, &dumpsize
);
2324 if ((pos
= lseek(fd
, 0, SEEK_CUR
))==-1) {
2325 if (errno
== ESPIPE
) { /* not a seekable stream */
2331 if (dumpsize
.rlim_cur
<= pos
) {
2333 } else if (dumpsize
.rlim_cur
== RLIM_INFINITY
) {
2336 size_t limit_left
=dumpsize
.rlim_cur
- pos
;
2337 bytes_left
= limit_left
>= size
? size
: limit_left
;
2342 * In normal conditions, single write(2) should do but
2343 * in case of socket etc. this mechanism is more portable.
2346 bytes_written
= write(fd
, bufp
, bytes_left
);
2347 if (bytes_written
< 0) {
2351 } else if (bytes_written
== 0) { /* eof */
2354 bufp
+= bytes_written
;
2355 bytes_left
-= bytes_written
;
2356 } while (bytes_left
> 0);
2361 static int write_note(struct memelfnote
*men
, int fd
)
2365 en
.n_namesz
= men
->namesz
;
2366 en
.n_type
= men
->type
;
2367 en
.n_descsz
= men
->datasz
;
2373 if (dump_write(fd
, &en
, sizeof(en
)) != 0)
2375 if (dump_write(fd
, men
->name
, men
->namesz_rounded
) != 0)
2377 if (dump_write(fd
, men
->data
, men
->datasz
) != 0)
2383 static void fill_thread_info(struct elf_note_info
*info
, const CPUState
*env
)
2385 TaskState
*ts
= (TaskState
*)env
->opaque
;
2386 struct elf_thread_status
*ets
;
2388 ets
= qemu_mallocz(sizeof (*ets
));
2389 ets
->num_notes
= 1; /* only prstatus is dumped */
2390 fill_prstatus(&ets
->prstatus
, ts
, 0);
2391 elf_core_copy_regs(&ets
->prstatus
.pr_reg
, env
);
2392 fill_note(&ets
->notes
[0], "CORE", NT_PRSTATUS
, sizeof (ets
->prstatus
),
2395 QTAILQ_INSERT_TAIL(&info
->thread_list
, ets
, ets_link
);
2397 info
->notes_size
+= note_size(&ets
->notes
[0]);
2400 static int fill_note_info(struct elf_note_info
*info
,
2401 long signr
, const CPUState
*env
)
2404 CPUState
*cpu
= NULL
;
2405 TaskState
*ts
= (TaskState
*)env
->opaque
;
2408 (void) memset(info
, 0, sizeof (*info
));
2410 QTAILQ_INIT(&info
->thread_list
);
2412 info
->notes
= qemu_mallocz(NUMNOTES
* sizeof (struct memelfnote
));
2413 if (info
->notes
== NULL
)
2415 info
->prstatus
= qemu_mallocz(sizeof (*info
->prstatus
));
2416 if (info
->prstatus
== NULL
)
2418 info
->psinfo
= qemu_mallocz(sizeof (*info
->psinfo
));
2419 if (info
->prstatus
== NULL
)
2423 * First fill in status (and registers) of current thread
2424 * including process info & aux vector.
2426 fill_prstatus(info
->prstatus
, ts
, signr
);
2427 elf_core_copy_regs(&info
->prstatus
->pr_reg
, env
);
2428 fill_note(&info
->notes
[0], "CORE", NT_PRSTATUS
,
2429 sizeof (*info
->prstatus
), info
->prstatus
);
2430 fill_psinfo(info
->psinfo
, ts
);
2431 fill_note(&info
->notes
[1], "CORE", NT_PRPSINFO
,
2432 sizeof (*info
->psinfo
), info
->psinfo
);
2433 fill_auxv_note(&info
->notes
[2], ts
);
2436 info
->notes_size
= 0;
2437 for (i
= 0; i
< info
->numnote
; i
++)
2438 info
->notes_size
+= note_size(&info
->notes
[i
]);
2440 /* read and fill status of all threads */
2442 for (cpu
= first_cpu
; cpu
!= NULL
; cpu
= cpu
->next_cpu
) {
2443 if (cpu
== thread_env
)
2445 fill_thread_info(info
, cpu
);
2452 static void free_note_info(struct elf_note_info
*info
)
2454 struct elf_thread_status
*ets
;
2456 while (!QTAILQ_EMPTY(&info
->thread_list
)) {
2457 ets
= QTAILQ_FIRST(&info
->thread_list
);
2458 QTAILQ_REMOVE(&info
->thread_list
, ets
, ets_link
);
2462 qemu_free(info
->prstatus
);
2463 qemu_free(info
->psinfo
);
2464 qemu_free(info
->notes
);
2467 static int write_note_info(struct elf_note_info
*info
, int fd
)
2469 struct elf_thread_status
*ets
;
2472 /* write prstatus, psinfo and auxv for current thread */
2473 for (i
= 0; i
< info
->numnote
; i
++)
2474 if ((error
= write_note(&info
->notes
[i
], fd
)) != 0)
2477 /* write prstatus for each thread */
2478 for (ets
= info
->thread_list
.tqh_first
; ets
!= NULL
;
2479 ets
= ets
->ets_link
.tqe_next
) {
2480 if ((error
= write_note(&ets
->notes
[0], fd
)) != 0)
2488 * Write out ELF coredump.
2490 * See documentation of ELF object file format in:
2491 * http://www.caldera.com/developers/devspecs/gabi41.pdf
2493 * Coredump format in linux is following:
2495 * 0 +----------------------+ \
2496 * | ELF header | ET_CORE |
2497 * +----------------------+ |
2498 * | ELF program headers | |--- headers
2499 * | - NOTE section | |
2500 * | - PT_LOAD sections | |
2501 * +----------------------+ /
2506 * +----------------------+ <-- aligned to target page
2507 * | Process memory dump |
2512 * +----------------------+
2514 * NT_PRSTATUS -> struct elf_prstatus (per thread)
2515 * NT_PRSINFO -> struct elf_prpsinfo
2516 * NT_AUXV is array of { type, value } pairs (see fill_auxv_note()).
2518 * Format follows System V format as close as possible. Current
2519 * version limitations are as follows:
2520 * - no floating point registers are dumped
2522 * Function returns 0 in case of success, negative errno otherwise.
2524 * TODO: make this work also during runtime: it should be
2525 * possible to force coredump from running process and then
2526 * continue processing. For example qemu could set up SIGUSR2
2527 * handler (provided that target process haven't registered
2528 * handler for that) that does the dump when signal is received.
2530 static int elf_core_dump(int signr
, const CPUState
*env
)
2532 const TaskState
*ts
= (const TaskState
*)env
->opaque
;
2533 struct vm_area_struct
*vma
= NULL
;
2534 char corefile
[PATH_MAX
];
2535 struct elf_note_info info
;
2537 struct elf_phdr phdr
;
2538 struct rlimit dumpsize
;
2539 struct mm_struct
*mm
= NULL
;
2540 off_t offset
= 0, data_offset
= 0;
2545 getrlimit(RLIMIT_CORE
, &dumpsize
);
2546 if (dumpsize
.rlim_cur
== 0)
2549 if (core_dump_filename(ts
, corefile
, sizeof (corefile
)) < 0)
2552 if ((fd
= open(corefile
, O_WRONLY
| O_CREAT
,
2553 S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
)) < 0)
2557 * Walk through target process memory mappings and
2558 * set up structure containing this information. After
2559 * this point vma_xxx functions can be used.
2561 if ((mm
= vma_init()) == NULL
)
2564 walk_memory_regions(mm
, vma_walker
);
2565 segs
= vma_get_mapping_count(mm
);
2568 * Construct valid coredump ELF header. We also
2569 * add one more segment for notes.
2571 fill_elf_header(&elf
, segs
+ 1, ELF_MACHINE
, 0);
2572 if (dump_write(fd
, &elf
, sizeof (elf
)) != 0)
2575 /* fill in in-memory version of notes */
2576 if (fill_note_info(&info
, signr
, env
) < 0)
2579 offset
+= sizeof (elf
); /* elf header */
2580 offset
+= (segs
+ 1) * sizeof (struct elf_phdr
); /* program headers */
2582 /* write out notes program header */
2583 fill_elf_note_phdr(&phdr
, info
.notes_size
, offset
);
2585 offset
+= info
.notes_size
;
2586 if (dump_write(fd
, &phdr
, sizeof (phdr
)) != 0)
2590 * ELF specification wants data to start at page boundary so
2593 offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
2596 * Write program headers for memory regions mapped in
2597 * the target process.
2599 for (vma
= vma_first(mm
); vma
!= NULL
; vma
= vma_next(vma
)) {
2600 (void) memset(&phdr
, 0, sizeof (phdr
));
2602 phdr
.p_type
= PT_LOAD
;
2603 phdr
.p_offset
= offset
;
2604 phdr
.p_vaddr
= vma
->vma_start
;
2606 phdr
.p_filesz
= vma_dump_size(vma
);
2607 offset
+= phdr
.p_filesz
;
2608 phdr
.p_memsz
= vma
->vma_end
- vma
->vma_start
;
2609 phdr
.p_flags
= vma
->vma_flags
& PROT_READ
? PF_R
: 0;
2610 if (vma
->vma_flags
& PROT_WRITE
)
2611 phdr
.p_flags
|= PF_W
;
2612 if (vma
->vma_flags
& PROT_EXEC
)
2613 phdr
.p_flags
|= PF_X
;
2614 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
2616 dump_write(fd
, &phdr
, sizeof (phdr
));
2620 * Next we write notes just after program headers. No
2621 * alignment needed here.
2623 if (write_note_info(&info
, fd
) < 0)
2626 /* align data to page boundary */
2627 data_offset
= lseek(fd
, 0, SEEK_CUR
);
2628 data_offset
= TARGET_PAGE_ALIGN(data_offset
);
2629 if (lseek(fd
, data_offset
, SEEK_SET
) != data_offset
)
2633 * Finally we can dump process memory into corefile as well.
2635 for (vma
= vma_first(mm
); vma
!= NULL
; vma
= vma_next(vma
)) {
2639 end
= vma
->vma_start
+ vma_dump_size(vma
);
2641 for (addr
= vma
->vma_start
; addr
< end
;
2642 addr
+= TARGET_PAGE_SIZE
) {
2643 char page
[TARGET_PAGE_SIZE
];
2647 * Read in page from target process memory and
2648 * write it to coredump file.
2650 error
= copy_from_user(page
, addr
, sizeof (page
));
2652 (void) fprintf(stderr
, "unable to dump " TARGET_ABI_FMT_lx
"\n",
2657 if (dump_write(fd
, page
, TARGET_PAGE_SIZE
) < 0)
2663 free_note_info(&info
);
2673 #endif /* USE_ELF_CORE_DUMP */
2675 static int load_aout_interp(void * exptr
, int interp_fd
)
2677 printf("a.out interpreter not yet supported\n");
2681 void do_init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
2683 init_thread(regs
, infop
);