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 #define ELF_EXEC_PAGESIZE 4096
599 #endif /* TARGET_MIPS */
601 #ifdef TARGET_MICROBLAZE
603 #define ELF_START_MMAP 0x80000000
605 #define elf_check_arch(x) ( (x) == EM_XILINX_MICROBLAZE )
607 #define ELF_CLASS ELFCLASS32
608 #define ELF_DATA ELFDATA2MSB
609 #define ELF_ARCH EM_MIPS
611 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
613 regs
->pc
= infop
->entry
;
614 regs
->r1
= infop
->start_stack
;
618 #define ELF_EXEC_PAGESIZE 4096
620 #endif /* TARGET_MICROBLAZE */
624 #define ELF_START_MMAP 0x80000000
626 #define elf_check_arch(x) ( (x) == EM_SH )
628 #define ELF_CLASS ELFCLASS32
629 #define ELF_DATA ELFDATA2LSB
630 #define ELF_ARCH EM_SH
632 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
634 /* Check other registers XXXXX */
635 regs
->pc
= infop
->entry
;
636 regs
->regs
[15] = infop
->start_stack
;
639 #define ELF_EXEC_PAGESIZE 4096
645 #define ELF_START_MMAP 0x80000000
647 #define elf_check_arch(x) ( (x) == EM_CRIS )
649 #define ELF_CLASS ELFCLASS32
650 #define ELF_DATA ELFDATA2LSB
651 #define ELF_ARCH EM_CRIS
653 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
655 regs
->erp
= infop
->entry
;
658 #define ELF_EXEC_PAGESIZE 8192
664 #define ELF_START_MMAP 0x80000000
666 #define elf_check_arch(x) ( (x) == EM_68K )
668 #define ELF_CLASS ELFCLASS32
669 #define ELF_DATA ELFDATA2MSB
670 #define ELF_ARCH EM_68K
672 /* ??? Does this need to do anything?
673 #define ELF_PLAT_INIT(_r) */
675 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
677 regs
->usp
= infop
->start_stack
;
679 regs
->pc
= infop
->entry
;
682 #define ELF_EXEC_PAGESIZE 8192
688 #define ELF_START_MMAP (0x30000000000ULL)
690 #define elf_check_arch(x) ( (x) == ELF_ARCH )
692 #define ELF_CLASS ELFCLASS64
693 #define ELF_DATA ELFDATA2MSB
694 #define ELF_ARCH EM_ALPHA
696 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
698 regs
->pc
= infop
->entry
;
700 regs
->usp
= infop
->start_stack
;
703 #define ELF_EXEC_PAGESIZE 8192
705 #endif /* TARGET_ALPHA */
708 #define ELF_PLATFORM (NULL)
717 #define ELF_CLASS ELFCLASS32
719 #define bswaptls(ptr) bswap32s(ptr)
726 unsigned int a_info
; /* Use macros N_MAGIC, etc for access */
727 unsigned int a_text
; /* length of text, in bytes */
728 unsigned int a_data
; /* length of data, in bytes */
729 unsigned int a_bss
; /* length of uninitialized data area, in bytes */
730 unsigned int a_syms
; /* length of symbol table data in file, in bytes */
731 unsigned int a_entry
; /* start address */
732 unsigned int a_trsize
; /* length of relocation info for text, in bytes */
733 unsigned int a_drsize
; /* length of relocation info for data, in bytes */
737 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
743 /* max code+data+bss space allocated to elf interpreter */
744 #define INTERP_MAP_SIZE (32 * 1024 * 1024)
746 /* max code+data+bss+brk space allocated to ET_DYN executables */
747 #define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
749 /* Necessary parameters */
750 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
751 #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
752 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
754 #define INTERPRETER_NONE 0
755 #define INTERPRETER_AOUT 1
756 #define INTERPRETER_ELF 2
758 #define DLINFO_ITEMS 12
760 static inline void memcpy_fromfs(void * to
, const void * from
, unsigned long n
)
765 static int load_aout_interp(void * exptr
, int interp_fd
);
768 static void bswap_ehdr(struct elfhdr
*ehdr
)
770 bswap16s(&ehdr
->e_type
); /* Object file type */
771 bswap16s(&ehdr
->e_machine
); /* Architecture */
772 bswap32s(&ehdr
->e_version
); /* Object file version */
773 bswaptls(&ehdr
->e_entry
); /* Entry point virtual address */
774 bswaptls(&ehdr
->e_phoff
); /* Program header table file offset */
775 bswaptls(&ehdr
->e_shoff
); /* Section header table file offset */
776 bswap32s(&ehdr
->e_flags
); /* Processor-specific flags */
777 bswap16s(&ehdr
->e_ehsize
); /* ELF header size in bytes */
778 bswap16s(&ehdr
->e_phentsize
); /* Program header table entry size */
779 bswap16s(&ehdr
->e_phnum
); /* Program header table entry count */
780 bswap16s(&ehdr
->e_shentsize
); /* Section header table entry size */
781 bswap16s(&ehdr
->e_shnum
); /* Section header table entry count */
782 bswap16s(&ehdr
->e_shstrndx
); /* Section header string table index */
785 static void bswap_phdr(struct elf_phdr
*phdr
)
787 bswap32s(&phdr
->p_type
); /* Segment type */
788 bswaptls(&phdr
->p_offset
); /* Segment file offset */
789 bswaptls(&phdr
->p_vaddr
); /* Segment virtual address */
790 bswaptls(&phdr
->p_paddr
); /* Segment physical address */
791 bswaptls(&phdr
->p_filesz
); /* Segment size in file */
792 bswaptls(&phdr
->p_memsz
); /* Segment size in memory */
793 bswap32s(&phdr
->p_flags
); /* Segment flags */
794 bswaptls(&phdr
->p_align
); /* Segment alignment */
797 static void bswap_shdr(struct elf_shdr
*shdr
)
799 bswap32s(&shdr
->sh_name
);
800 bswap32s(&shdr
->sh_type
);
801 bswaptls(&shdr
->sh_flags
);
802 bswaptls(&shdr
->sh_addr
);
803 bswaptls(&shdr
->sh_offset
);
804 bswaptls(&shdr
->sh_size
);
805 bswap32s(&shdr
->sh_link
);
806 bswap32s(&shdr
->sh_info
);
807 bswaptls(&shdr
->sh_addralign
);
808 bswaptls(&shdr
->sh_entsize
);
811 static void bswap_sym(struct elf_sym
*sym
)
813 bswap32s(&sym
->st_name
);
814 bswaptls(&sym
->st_value
);
815 bswaptls(&sym
->st_size
);
816 bswap16s(&sym
->st_shndx
);
820 #ifdef USE_ELF_CORE_DUMP
821 static int elf_core_dump(int, const CPUState
*);
824 static void bswap_note(struct elf_note
*en
)
826 bswap32s(&en
->n_namesz
);
827 bswap32s(&en
->n_descsz
);
828 bswap32s(&en
->n_type
);
830 #endif /* BSWAP_NEEDED */
832 #endif /* USE_ELF_CORE_DUMP */
835 * 'copy_elf_strings()' copies argument/envelope strings from user
836 * memory to free pages in kernel mem. These are in a format ready
837 * to be put directly into the top of new user memory.
840 static abi_ulong
copy_elf_strings(int argc
,char ** argv
, void **page
,
843 char *tmp
, *tmp1
, *pag
= NULL
;
847 return 0; /* bullet-proofing */
852 fprintf(stderr
, "VFS: argc is wrong");
858 if (p
< len
) { /* this shouldn't happen - 128kB */
864 offset
= p
% TARGET_PAGE_SIZE
;
865 pag
= (char *)page
[p
/TARGET_PAGE_SIZE
];
867 pag
= (char *)malloc(TARGET_PAGE_SIZE
);
868 memset(pag
, 0, TARGET_PAGE_SIZE
);
869 page
[p
/TARGET_PAGE_SIZE
] = pag
;
874 if (len
== 0 || offset
== 0) {
875 *(pag
+ offset
) = *tmp
;
878 int bytes_to_copy
= (len
> offset
) ? offset
: len
;
879 tmp
-= bytes_to_copy
;
881 offset
-= bytes_to_copy
;
882 len
-= bytes_to_copy
;
883 memcpy_fromfs(pag
+ offset
, tmp
, bytes_to_copy
+ 1);
890 static abi_ulong
setup_arg_pages(abi_ulong p
, struct linux_binprm
*bprm
,
891 struct image_info
*info
)
893 abi_ulong stack_base
, size
, error
;
896 /* Create enough stack to hold everything. If we don't use
897 * it for args, we'll use it for something else...
899 size
= x86_stack_size
;
900 if (size
< MAX_ARG_PAGES
*TARGET_PAGE_SIZE
)
901 size
= MAX_ARG_PAGES
*TARGET_PAGE_SIZE
;
902 error
= target_mmap(0,
903 size
+ qemu_host_page_size
,
904 PROT_READ
| PROT_WRITE
,
905 MAP_PRIVATE
| MAP_ANONYMOUS
,
911 /* we reserve one extra page at the top of the stack as guard */
912 target_mprotect(error
+ size
, qemu_host_page_size
, PROT_NONE
);
914 stack_base
= error
+ size
- MAX_ARG_PAGES
*TARGET_PAGE_SIZE
;
917 for (i
= 0 ; i
< MAX_ARG_PAGES
; i
++) {
920 /* FIXME - check return value of memcpy_to_target() for failure */
921 memcpy_to_target(stack_base
, bprm
->page
[i
], TARGET_PAGE_SIZE
);
924 stack_base
+= TARGET_PAGE_SIZE
;
929 static void set_brk(abi_ulong start
, abi_ulong end
)
931 /* page-align the start and end addresses... */
932 start
= HOST_PAGE_ALIGN(start
);
933 end
= HOST_PAGE_ALIGN(end
);
936 if(target_mmap(start
, end
- start
,
937 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
938 MAP_FIXED
| MAP_PRIVATE
| MAP_ANONYMOUS
, -1, 0) == -1) {
939 perror("cannot mmap brk");
945 /* We need to explicitly zero any fractional pages after the data
946 section (i.e. bss). This would contain the junk from the file that
947 should not be in memory. */
948 static void padzero(abi_ulong elf_bss
, abi_ulong last_bss
)
952 if (elf_bss
>= last_bss
)
955 /* XXX: this is really a hack : if the real host page size is
956 smaller than the target page size, some pages after the end
957 of the file may not be mapped. A better fix would be to
958 patch target_mmap(), but it is more complicated as the file
959 size must be known */
960 if (qemu_real_host_page_size
< qemu_host_page_size
) {
961 abi_ulong end_addr
, end_addr1
;
962 end_addr1
= (elf_bss
+ qemu_real_host_page_size
- 1) &
963 ~(qemu_real_host_page_size
- 1);
964 end_addr
= HOST_PAGE_ALIGN(elf_bss
);
965 if (end_addr1
< end_addr
) {
966 mmap((void *)g2h(end_addr1
), end_addr
- end_addr1
,
967 PROT_READ
|PROT_WRITE
|PROT_EXEC
,
968 MAP_FIXED
|MAP_PRIVATE
|MAP_ANONYMOUS
, -1, 0);
972 nbyte
= elf_bss
& (qemu_host_page_size
-1);
974 nbyte
= qemu_host_page_size
- nbyte
;
976 /* FIXME - what to do if put_user() fails? */
977 put_user_u8(0, elf_bss
);
984 static abi_ulong
create_elf_tables(abi_ulong p
, int argc
, int envc
,
985 struct elfhdr
* exec
,
988 abi_ulong interp_load_addr
, int ibcs
,
989 struct image_info
*info
)
993 abi_ulong u_platform
;
994 const char *k_platform
;
995 const int n
= sizeof(elf_addr_t
);
999 k_platform
= ELF_PLATFORM
;
1001 size_t len
= strlen(k_platform
) + 1;
1002 sp
-= (len
+ n
- 1) & ~(n
- 1);
1004 /* FIXME - check return value of memcpy_to_target() for failure */
1005 memcpy_to_target(sp
, k_platform
, len
);
1008 * Force 16 byte _final_ alignment here for generality.
1010 sp
= sp
&~ (abi_ulong
)15;
1011 size
= (DLINFO_ITEMS
+ 1) * 2;
1014 #ifdef DLINFO_ARCH_ITEMS
1015 size
+= DLINFO_ARCH_ITEMS
* 2;
1017 size
+= envc
+ argc
+ 2;
1018 size
+= (!ibcs
? 3 : 1); /* argc itself */
1021 sp
-= 16 - (size
& 15);
1023 /* This is correct because Linux defines
1024 * elf_addr_t as Elf32_Off / Elf64_Off
1026 #define NEW_AUX_ENT(id, val) do { \
1027 sp -= n; put_user_ual(val, sp); \
1028 sp -= n; put_user_ual(id, sp); \
1031 NEW_AUX_ENT (AT_NULL
, 0);
1033 /* There must be exactly DLINFO_ITEMS entries here. */
1034 NEW_AUX_ENT(AT_PHDR
, (abi_ulong
)(load_addr
+ exec
->e_phoff
));
1035 NEW_AUX_ENT(AT_PHENT
, (abi_ulong
)(sizeof (struct elf_phdr
)));
1036 NEW_AUX_ENT(AT_PHNUM
, (abi_ulong
)(exec
->e_phnum
));
1037 NEW_AUX_ENT(AT_PAGESZ
, (abi_ulong
)(TARGET_PAGE_SIZE
));
1038 NEW_AUX_ENT(AT_BASE
, (abi_ulong
)(interp_load_addr
));
1039 NEW_AUX_ENT(AT_FLAGS
, (abi_ulong
)0);
1040 NEW_AUX_ENT(AT_ENTRY
, load_bias
+ exec
->e_entry
);
1041 NEW_AUX_ENT(AT_UID
, (abi_ulong
) getuid());
1042 NEW_AUX_ENT(AT_EUID
, (abi_ulong
) geteuid());
1043 NEW_AUX_ENT(AT_GID
, (abi_ulong
) getgid());
1044 NEW_AUX_ENT(AT_EGID
, (abi_ulong
) getegid());
1045 NEW_AUX_ENT(AT_HWCAP
, (abi_ulong
) ELF_HWCAP
);
1046 NEW_AUX_ENT(AT_CLKTCK
, (abi_ulong
) sysconf(_SC_CLK_TCK
));
1048 NEW_AUX_ENT(AT_PLATFORM
, u_platform
);
1051 * ARCH_DLINFO must come last so platform specific code can enforce
1052 * special alignment requirements on the AUXV if necessary (eg. PPC).
1058 info
->saved_auxv
= sp
;
1060 sp
= loader_build_argptr(envc
, argc
, sp
, p
, !ibcs
);
1065 static abi_ulong
load_elf_interp(struct elfhdr
* interp_elf_ex
,
1067 abi_ulong
*interp_load_addr
)
1069 struct elf_phdr
*elf_phdata
= NULL
;
1070 struct elf_phdr
*eppnt
;
1071 abi_ulong load_addr
= 0;
1072 int load_addr_set
= 0;
1074 abi_ulong last_bss
, elf_bss
;
1083 bswap_ehdr(interp_elf_ex
);
1085 /* First of all, some simple consistency checks */
1086 if ((interp_elf_ex
->e_type
!= ET_EXEC
&&
1087 interp_elf_ex
->e_type
!= ET_DYN
) ||
1088 !elf_check_arch(interp_elf_ex
->e_machine
)) {
1089 return ~((abi_ulong
)0UL);
1093 /* Now read in all of the header information */
1095 if (sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
> TARGET_PAGE_SIZE
)
1096 return ~(abi_ulong
)0UL;
1098 elf_phdata
= (struct elf_phdr
*)
1099 malloc(sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
);
1102 return ~((abi_ulong
)0UL);
1105 * If the size of this structure has changed, then punt, since
1106 * we will be doing the wrong thing.
1108 if (interp_elf_ex
->e_phentsize
!= sizeof(struct elf_phdr
)) {
1110 return ~((abi_ulong
)0UL);
1113 retval
= lseek(interpreter_fd
, interp_elf_ex
->e_phoff
, SEEK_SET
);
1115 retval
= read(interpreter_fd
,
1116 (char *) elf_phdata
,
1117 sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
);
1120 perror("load_elf_interp");
1127 for (i
=0; i
<interp_elf_ex
->e_phnum
; i
++, eppnt
++) {
1132 if (interp_elf_ex
->e_type
== ET_DYN
) {
1133 /* in order to avoid hardcoding the interpreter load
1134 address in qemu, we allocate a big enough memory zone */
1135 error
= target_mmap(0, INTERP_MAP_SIZE
,
1136 PROT_NONE
, MAP_PRIVATE
| MAP_ANON
,
1147 for(i
=0; i
<interp_elf_ex
->e_phnum
; i
++, eppnt
++)
1148 if (eppnt
->p_type
== PT_LOAD
) {
1149 int elf_type
= MAP_PRIVATE
| MAP_DENYWRITE
;
1151 abi_ulong vaddr
= 0;
1154 if (eppnt
->p_flags
& PF_R
) elf_prot
= PROT_READ
;
1155 if (eppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
1156 if (eppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
1157 if (interp_elf_ex
->e_type
== ET_EXEC
|| load_addr_set
) {
1158 elf_type
|= MAP_FIXED
;
1159 vaddr
= eppnt
->p_vaddr
;
1161 error
= target_mmap(load_addr
+TARGET_ELF_PAGESTART(vaddr
),
1162 eppnt
->p_filesz
+ TARGET_ELF_PAGEOFFSET(eppnt
->p_vaddr
),
1166 eppnt
->p_offset
- TARGET_ELF_PAGEOFFSET(eppnt
->p_vaddr
));
1170 close(interpreter_fd
);
1172 return ~((abi_ulong
)0UL);
1175 if (!load_addr_set
&& interp_elf_ex
->e_type
== ET_DYN
) {
1181 * Find the end of the file mapping for this phdr, and keep
1182 * track of the largest address we see for this.
1184 k
= load_addr
+ eppnt
->p_vaddr
+ eppnt
->p_filesz
;
1185 if (k
> elf_bss
) elf_bss
= k
;
1188 * Do the same thing for the memory mapping - between
1189 * elf_bss and last_bss is the bss section.
1191 k
= load_addr
+ eppnt
->p_memsz
+ eppnt
->p_vaddr
;
1192 if (k
> last_bss
) last_bss
= k
;
1195 /* Now use mmap to map the library into memory. */
1197 close(interpreter_fd
);
1200 * Now fill out the bss section. First pad the last page up
1201 * to the page boundary, and then perform a mmap to make sure
1202 * that there are zeromapped pages up to and including the last
1205 padzero(elf_bss
, last_bss
);
1206 elf_bss
= TARGET_ELF_PAGESTART(elf_bss
+ qemu_host_page_size
- 1); /* What we have mapped so far */
1208 /* Map the last of the bss segment */
1209 if (last_bss
> elf_bss
) {
1210 target_mmap(elf_bss
, last_bss
-elf_bss
,
1211 PROT_READ
|PROT_WRITE
|PROT_EXEC
,
1212 MAP_FIXED
|MAP_PRIVATE
|MAP_ANONYMOUS
, -1, 0);
1216 *interp_load_addr
= load_addr
;
1217 return ((abi_ulong
) interp_elf_ex
->e_entry
) + load_addr
;
1220 static int symfind(const void *s0
, const void *s1
)
1222 struct elf_sym
*key
= (struct elf_sym
*)s0
;
1223 struct elf_sym
*sym
= (struct elf_sym
*)s1
;
1225 if (key
->st_value
< sym
->st_value
) {
1227 } else if (key
->st_value
>= sym
->st_value
+ sym
->st_size
) {
1233 static const char *lookup_symbolxx(struct syminfo
*s
, target_ulong orig_addr
)
1235 #if ELF_CLASS == ELFCLASS32
1236 struct elf_sym
*syms
= s
->disas_symtab
.elf32
;
1238 struct elf_sym
*syms
= s
->disas_symtab
.elf64
;
1243 struct elf_sym
*sym
;
1245 key
.st_value
= orig_addr
;
1247 sym
= bsearch(&key
, syms
, s
->disas_num_syms
, sizeof(*syms
), symfind
);
1249 return s
->disas_strtab
+ sym
->st_name
;
1255 /* FIXME: This should use elf_ops.h */
1256 static int symcmp(const void *s0
, const void *s1
)
1258 struct elf_sym
*sym0
= (struct elf_sym
*)s0
;
1259 struct elf_sym
*sym1
= (struct elf_sym
*)s1
;
1260 return (sym0
->st_value
< sym1
->st_value
)
1262 : ((sym0
->st_value
> sym1
->st_value
) ? 1 : 0);
1265 /* Best attempt to load symbols from this ELF object. */
1266 static void load_symbols(struct elfhdr
*hdr
, int fd
)
1268 unsigned int i
, nsyms
;
1269 struct elf_shdr sechdr
, symtab
, strtab
;
1272 struct elf_sym
*syms
;
1274 lseek(fd
, hdr
->e_shoff
, SEEK_SET
);
1275 for (i
= 0; i
< hdr
->e_shnum
; i
++) {
1276 if (read(fd
, &sechdr
, sizeof(sechdr
)) != sizeof(sechdr
))
1279 bswap_shdr(&sechdr
);
1281 if (sechdr
.sh_type
== SHT_SYMTAB
) {
1283 lseek(fd
, hdr
->e_shoff
1284 + sizeof(sechdr
) * sechdr
.sh_link
, SEEK_SET
);
1285 if (read(fd
, &strtab
, sizeof(strtab
))
1289 bswap_shdr(&strtab
);
1294 return; /* Shouldn't happen... */
1297 /* Now know where the strtab and symtab are. Snarf them. */
1298 s
= malloc(sizeof(*s
));
1299 syms
= malloc(symtab
.sh_size
);
1302 s
->disas_strtab
= strings
= malloc(strtab
.sh_size
);
1303 if (!s
->disas_strtab
)
1306 lseek(fd
, symtab
.sh_offset
, SEEK_SET
);
1307 if (read(fd
, syms
, symtab
.sh_size
) != symtab
.sh_size
)
1310 nsyms
= symtab
.sh_size
/ sizeof(struct elf_sym
);
1315 bswap_sym(syms
+ i
);
1317 // Throw away entries which we do not need.
1318 if (syms
[i
].st_shndx
== SHN_UNDEF
||
1319 syms
[i
].st_shndx
>= SHN_LORESERVE
||
1320 ELF_ST_TYPE(syms
[i
].st_info
) != STT_FUNC
) {
1323 syms
[i
] = syms
[nsyms
];
1327 #if defined(TARGET_ARM) || defined (TARGET_MIPS)
1328 /* The bottom address bit marks a Thumb or MIPS16 symbol. */
1329 syms
[i
].st_value
&= ~(target_ulong
)1;
1333 syms
= realloc(syms
, nsyms
* sizeof(*syms
));
1335 qsort(syms
, nsyms
, sizeof(*syms
), symcmp
);
1337 lseek(fd
, strtab
.sh_offset
, SEEK_SET
);
1338 if (read(fd
, strings
, strtab
.sh_size
) != strtab
.sh_size
)
1340 s
->disas_num_syms
= nsyms
;
1341 #if ELF_CLASS == ELFCLASS32
1342 s
->disas_symtab
.elf32
= syms
;
1343 s
->lookup_symbol
= (lookup_symbol_t
)lookup_symbolxx
;
1345 s
->disas_symtab
.elf64
= syms
;
1346 s
->lookup_symbol
= (lookup_symbol_t
)lookup_symbolxx
;
1352 int load_elf_binary(struct linux_binprm
* bprm
, struct target_pt_regs
* regs
,
1353 struct image_info
* info
)
1355 struct elfhdr elf_ex
;
1356 struct elfhdr interp_elf_ex
;
1357 struct exec interp_ex
;
1358 int interpreter_fd
= -1; /* avoid warning */
1359 abi_ulong load_addr
, load_bias
;
1360 int load_addr_set
= 0;
1361 unsigned int interpreter_type
= INTERPRETER_NONE
;
1362 unsigned char ibcs2_interpreter
;
1364 abi_ulong mapped_addr
;
1365 struct elf_phdr
* elf_ppnt
;
1366 struct elf_phdr
*elf_phdata
;
1367 abi_ulong elf_bss
, k
, elf_brk
;
1369 char * elf_interpreter
;
1370 abi_ulong elf_entry
, interp_load_addr
= 0;
1372 abi_ulong start_code
, end_code
, start_data
, end_data
;
1373 abi_ulong reloc_func_desc
= 0;
1374 abi_ulong elf_stack
;
1375 char passed_fileno
[6];
1377 ibcs2_interpreter
= 0;
1381 elf_ex
= *((struct elfhdr
*) bprm
->buf
); /* exec-header */
1383 bswap_ehdr(&elf_ex
);
1386 /* First of all, some simple consistency checks */
1387 if ((elf_ex
.e_type
!= ET_EXEC
&& elf_ex
.e_type
!= ET_DYN
) ||
1388 (! elf_check_arch(elf_ex
.e_machine
))) {
1392 bprm
->p
= copy_elf_strings(1, &bprm
->filename
, bprm
->page
, bprm
->p
);
1393 bprm
->p
= copy_elf_strings(bprm
->envc
,bprm
->envp
,bprm
->page
,bprm
->p
);
1394 bprm
->p
= copy_elf_strings(bprm
->argc
,bprm
->argv
,bprm
->page
,bprm
->p
);
1399 /* Now read in all of the header information */
1400 elf_phdata
= (struct elf_phdr
*)malloc(elf_ex
.e_phentsize
*elf_ex
.e_phnum
);
1401 if (elf_phdata
== NULL
) {
1405 retval
= lseek(bprm
->fd
, elf_ex
.e_phoff
, SEEK_SET
);
1407 retval
= read(bprm
->fd
, (char *) elf_phdata
,
1408 elf_ex
.e_phentsize
* elf_ex
.e_phnum
);
1412 perror("load_elf_binary");
1419 elf_ppnt
= elf_phdata
;
1420 for (i
=0; i
<elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
1421 bswap_phdr(elf_ppnt
);
1424 elf_ppnt
= elf_phdata
;
1430 elf_stack
= ~((abi_ulong
)0UL);
1431 elf_interpreter
= NULL
;
1432 start_code
= ~((abi_ulong
)0UL);
1436 interp_ex
.a_info
= 0;
1438 for(i
=0;i
< elf_ex
.e_phnum
; i
++) {
1439 if (elf_ppnt
->p_type
== PT_INTERP
) {
1440 if ( elf_interpreter
!= NULL
)
1443 free(elf_interpreter
);
1448 /* This is the program interpreter used for
1449 * shared libraries - for now assume that this
1450 * is an a.out format binary
1453 elf_interpreter
= (char *)malloc(elf_ppnt
->p_filesz
);
1455 if (elf_interpreter
== NULL
) {
1461 retval
= lseek(bprm
->fd
, elf_ppnt
->p_offset
, SEEK_SET
);
1463 retval
= read(bprm
->fd
, elf_interpreter
, elf_ppnt
->p_filesz
);
1466 perror("load_elf_binary2");
1470 /* If the program interpreter is one of these two,
1471 then assume an iBCS2 image. Otherwise assume
1472 a native linux image. */
1474 /* JRP - Need to add X86 lib dir stuff here... */
1476 if (strcmp(elf_interpreter
,"/usr/lib/libc.so.1") == 0 ||
1477 strcmp(elf_interpreter
,"/usr/lib/ld.so.1") == 0) {
1478 ibcs2_interpreter
= 1;
1482 printf("Using ELF interpreter %s\n", path(elf_interpreter
));
1485 retval
= open(path(elf_interpreter
), O_RDONLY
);
1487 interpreter_fd
= retval
;
1490 perror(elf_interpreter
);
1492 /* retval = -errno; */
1497 retval
= lseek(interpreter_fd
, 0, SEEK_SET
);
1499 retval
= read(interpreter_fd
,bprm
->buf
,128);
1503 interp_ex
= *((struct exec
*) bprm
->buf
); /* aout exec-header */
1504 interp_elf_ex
= *((struct elfhdr
*) bprm
->buf
); /* elf exec-header */
1507 perror("load_elf_binary3");
1510 free(elf_interpreter
);
1518 /* Some simple consistency checks for the interpreter */
1519 if (elf_interpreter
){
1520 interpreter_type
= INTERPRETER_ELF
| INTERPRETER_AOUT
;
1522 /* Now figure out which format our binary is */
1523 if ((N_MAGIC(interp_ex
) != OMAGIC
) && (N_MAGIC(interp_ex
) != ZMAGIC
) &&
1524 (N_MAGIC(interp_ex
) != QMAGIC
)) {
1525 interpreter_type
= INTERPRETER_ELF
;
1528 if (interp_elf_ex
.e_ident
[0] != 0x7f ||
1529 strncmp((char *)&interp_elf_ex
.e_ident
[1], "ELF",3) != 0) {
1530 interpreter_type
&= ~INTERPRETER_ELF
;
1533 if (!interpreter_type
) {
1534 free(elf_interpreter
);
1541 /* OK, we are done with that, now set up the arg stuff,
1542 and then start this sucker up */
1547 if (interpreter_type
== INTERPRETER_AOUT
) {
1548 snprintf(passed_fileno
, sizeof(passed_fileno
), "%d", bprm
->fd
);
1549 passed_p
= passed_fileno
;
1551 if (elf_interpreter
) {
1552 bprm
->p
= copy_elf_strings(1,&passed_p
,bprm
->page
,bprm
->p
);
1557 if (elf_interpreter
) {
1558 free(elf_interpreter
);
1566 /* OK, This is the point of no return */
1569 info
->start_mmap
= (abi_ulong
)ELF_START_MMAP
;
1571 elf_entry
= (abi_ulong
) elf_ex
.e_entry
;
1573 #if defined(CONFIG_USE_GUEST_BASE)
1575 * In case where user has not explicitly set the guest_base, we
1576 * probe here that should we set it automatically.
1578 if (!have_guest_base
) {
1580 * Go through ELF program header table and find out whether
1581 * any of the segments drop below our current mmap_min_addr and
1582 * in that case set guest_base to corresponding address.
1584 for (i
= 0, elf_ppnt
= elf_phdata
; i
< elf_ex
.e_phnum
;
1586 if (elf_ppnt
->p_type
!= PT_LOAD
)
1588 if (HOST_PAGE_ALIGN(elf_ppnt
->p_vaddr
) < mmap_min_addr
) {
1589 guest_base
= HOST_PAGE_ALIGN(mmap_min_addr
);
1594 #endif /* CONFIG_USE_GUEST_BASE */
1596 /* Do this so that we can load the interpreter, if need be. We will
1597 change some of these later */
1599 bprm
->p
= setup_arg_pages(bprm
->p
, bprm
, info
);
1600 info
->start_stack
= bprm
->p
;
1602 /* Now we do a little grungy work by mmaping the ELF image into
1603 * the correct location in memory. At this point, we assume that
1604 * the image should be loaded at fixed address, not at a variable
1608 for(i
= 0, elf_ppnt
= elf_phdata
; i
< elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
1613 if (elf_ppnt
->p_type
!= PT_LOAD
)
1616 if (elf_ppnt
->p_flags
& PF_R
) elf_prot
|= PROT_READ
;
1617 if (elf_ppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
1618 if (elf_ppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
1619 elf_flags
= MAP_PRIVATE
| MAP_DENYWRITE
;
1620 if (elf_ex
.e_type
== ET_EXEC
|| load_addr_set
) {
1621 elf_flags
|= MAP_FIXED
;
1622 } else if (elf_ex
.e_type
== ET_DYN
) {
1623 /* Try and get dynamic programs out of the way of the default mmap
1624 base, as well as whatever program they might try to exec. This
1625 is because the brk will follow the loader, and is not movable. */
1626 /* NOTE: for qemu, we do a big mmap to get enough space
1627 without hardcoding any address */
1628 error
= target_mmap(0, ET_DYN_MAP_SIZE
,
1629 PROT_NONE
, MAP_PRIVATE
| MAP_ANON
,
1635 load_bias
= TARGET_ELF_PAGESTART(error
- elf_ppnt
->p_vaddr
);
1638 error
= target_mmap(TARGET_ELF_PAGESTART(load_bias
+ elf_ppnt
->p_vaddr
),
1639 (elf_ppnt
->p_filesz
+
1640 TARGET_ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)),
1642 (MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
),
1644 (elf_ppnt
->p_offset
-
1645 TARGET_ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)));
1651 #ifdef LOW_ELF_STACK
1652 if (TARGET_ELF_PAGESTART(elf_ppnt
->p_vaddr
) < elf_stack
)
1653 elf_stack
= TARGET_ELF_PAGESTART(elf_ppnt
->p_vaddr
);
1656 if (!load_addr_set
) {
1658 load_addr
= elf_ppnt
->p_vaddr
- elf_ppnt
->p_offset
;
1659 if (elf_ex
.e_type
== ET_DYN
) {
1660 load_bias
+= error
-
1661 TARGET_ELF_PAGESTART(load_bias
+ elf_ppnt
->p_vaddr
);
1662 load_addr
+= load_bias
;
1663 reloc_func_desc
= load_bias
;
1666 k
= elf_ppnt
->p_vaddr
;
1671 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_filesz
;
1674 if ((elf_ppnt
->p_flags
& PF_X
) && end_code
< k
)
1678 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_memsz
;
1679 if (k
> elf_brk
) elf_brk
= k
;
1682 elf_entry
+= load_bias
;
1683 elf_bss
+= load_bias
;
1684 elf_brk
+= load_bias
;
1685 start_code
+= load_bias
;
1686 end_code
+= load_bias
;
1687 start_data
+= load_bias
;
1688 end_data
+= load_bias
;
1690 if (elf_interpreter
) {
1691 if (interpreter_type
& 1) {
1692 elf_entry
= load_aout_interp(&interp_ex
, interpreter_fd
);
1694 else if (interpreter_type
& 2) {
1695 elf_entry
= load_elf_interp(&interp_elf_ex
, interpreter_fd
,
1698 reloc_func_desc
= interp_load_addr
;
1700 close(interpreter_fd
);
1701 free(elf_interpreter
);
1703 if (elf_entry
== ~((abi_ulong
)0UL)) {
1704 printf("Unable to load interpreter\n");
1713 if (qemu_log_enabled())
1714 load_symbols(&elf_ex
, bprm
->fd
);
1716 if (interpreter_type
!= INTERPRETER_AOUT
) close(bprm
->fd
);
1717 info
->personality
= (ibcs2_interpreter
? PER_SVR4
: PER_LINUX
);
1719 #ifdef LOW_ELF_STACK
1720 info
->start_stack
= bprm
->p
= elf_stack
- 4;
1722 bprm
->p
= create_elf_tables(bprm
->p
,
1726 load_addr
, load_bias
,
1728 (interpreter_type
== INTERPRETER_AOUT
? 0 : 1),
1730 info
->load_addr
= reloc_func_desc
;
1731 info
->start_brk
= info
->brk
= elf_brk
;
1732 info
->end_code
= end_code
;
1733 info
->start_code
= start_code
;
1734 info
->start_data
= start_data
;
1735 info
->end_data
= end_data
;
1736 info
->start_stack
= bprm
->p
;
1738 /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1740 set_brk(elf_bss
, elf_brk
);
1742 padzero(elf_bss
, elf_brk
);
1745 printf("(start_brk) %x\n" , info
->start_brk
);
1746 printf("(end_code) %x\n" , info
->end_code
);
1747 printf("(start_code) %x\n" , info
->start_code
);
1748 printf("(end_data) %x\n" , info
->end_data
);
1749 printf("(start_stack) %x\n" , info
->start_stack
);
1750 printf("(brk) %x\n" , info
->brk
);
1753 if ( info
->personality
== PER_SVR4
)
1755 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1756 and some applications "depend" upon this behavior.
1757 Since we do not have the power to recompile these, we
1758 emulate the SVr4 behavior. Sigh. */
1759 mapped_addr
= target_mmap(0, qemu_host_page_size
, PROT_READ
| PROT_EXEC
,
1760 MAP_FIXED
| MAP_PRIVATE
, -1, 0);
1763 info
->entry
= elf_entry
;
1765 #ifdef USE_ELF_CORE_DUMP
1766 bprm
->core_dump
= &elf_core_dump
;
1772 #ifdef USE_ELF_CORE_DUMP
1775 * Definitions to generate Intel SVR4-like core files.
1776 * These mostly have the same names as the SVR4 types with "target_elf_"
1777 * tacked on the front to prevent clashes with linux definitions,
1778 * and the typedef forms have been avoided. This is mostly like
1779 * the SVR4 structure, but more Linuxy, with things that Linux does
1780 * not support and which gdb doesn't really use excluded.
1782 * Fields we don't dump (their contents is zero) in linux-user qemu
1783 * are marked with XXX.
1785 * Core dump code is copied from linux kernel (fs/binfmt_elf.c).
1787 * Porting ELF coredump for target is (quite) simple process. First you
1788 * define USE_ELF_CORE_DUMP in target ELF code (where init_thread() for
1789 * the target resides):
1791 * #define USE_ELF_CORE_DUMP
1793 * Next you define type of register set used for dumping. ELF specification
1794 * says that it needs to be array of elf_greg_t that has size of ELF_NREG.
1796 * typedef <target_regtype> target_elf_greg_t;
1797 * #define ELF_NREG <number of registers>
1798 * typedef taret_elf_greg_t target_elf_gregset_t[ELF_NREG];
1800 * Last step is to implement target specific function that copies registers
1801 * from given cpu into just specified register set. Prototype is:
1803 * static void elf_core_copy_regs(taret_elf_gregset_t *regs,
1804 * const CPUState *env);
1807 * regs - copy register values into here (allocated and zeroed by caller)
1808 * env - copy registers from here
1810 * Example for ARM target is provided in this file.
1813 /* An ELF note in memory */
1817 size_t namesz_rounded
;
1824 struct target_elf_siginfo
{
1825 int si_signo
; /* signal number */
1826 int si_code
; /* extra code */
1827 int si_errno
; /* errno */
1830 struct target_elf_prstatus
{
1831 struct target_elf_siginfo pr_info
; /* Info associated with signal */
1832 short pr_cursig
; /* Current signal */
1833 target_ulong pr_sigpend
; /* XXX */
1834 target_ulong pr_sighold
; /* XXX */
1835 target_pid_t pr_pid
;
1836 target_pid_t pr_ppid
;
1837 target_pid_t pr_pgrp
;
1838 target_pid_t pr_sid
;
1839 struct target_timeval pr_utime
; /* XXX User time */
1840 struct target_timeval pr_stime
; /* XXX System time */
1841 struct target_timeval pr_cutime
; /* XXX Cumulative user time */
1842 struct target_timeval pr_cstime
; /* XXX Cumulative system time */
1843 target_elf_gregset_t pr_reg
; /* GP registers */
1844 int pr_fpvalid
; /* XXX */
1847 #define ELF_PRARGSZ (80) /* Number of chars for args */
1849 struct target_elf_prpsinfo
{
1850 char pr_state
; /* numeric process state */
1851 char pr_sname
; /* char for pr_state */
1852 char pr_zomb
; /* zombie */
1853 char pr_nice
; /* nice val */
1854 target_ulong pr_flag
; /* flags */
1855 target_uid_t pr_uid
;
1856 target_gid_t pr_gid
;
1857 target_pid_t pr_pid
, pr_ppid
, pr_pgrp
, pr_sid
;
1859 char pr_fname
[16]; /* filename of executable */
1860 char pr_psargs
[ELF_PRARGSZ
]; /* initial part of arg list */
1863 /* Here is the structure in which status of each thread is captured. */
1864 struct elf_thread_status
{
1865 QTAILQ_ENTRY(elf_thread_status
) ets_link
;
1866 struct target_elf_prstatus prstatus
; /* NT_PRSTATUS */
1868 elf_fpregset_t fpu
; /* NT_PRFPREG */
1869 struct task_struct
*thread
;
1870 elf_fpxregset_t xfpu
; /* ELF_CORE_XFPREG_TYPE */
1872 struct memelfnote notes
[1];
1876 struct elf_note_info
{
1877 struct memelfnote
*notes
;
1878 struct target_elf_prstatus
*prstatus
; /* NT_PRSTATUS */
1879 struct target_elf_prpsinfo
*psinfo
; /* NT_PRPSINFO */
1881 QTAILQ_HEAD(thread_list_head
, elf_thread_status
) thread_list
;
1884 * Current version of ELF coredump doesn't support
1885 * dumping fp regs etc.
1887 elf_fpregset_t
*fpu
;
1888 elf_fpxregset_t
*xfpu
;
1889 int thread_status_size
;
1895 struct vm_area_struct
{
1896 abi_ulong vma_start
; /* start vaddr of memory region */
1897 abi_ulong vma_end
; /* end vaddr of memory region */
1898 abi_ulong vma_flags
; /* protection etc. flags for the region */
1899 QTAILQ_ENTRY(vm_area_struct
) vma_link
;
1903 QTAILQ_HEAD(, vm_area_struct
) mm_mmap
;
1904 int mm_count
; /* number of mappings */
1907 static struct mm_struct
*vma_init(void);
1908 static void vma_delete(struct mm_struct
*);
1909 static int vma_add_mapping(struct mm_struct
*, abi_ulong
,
1910 abi_ulong
, abi_ulong
);
1911 static int vma_get_mapping_count(const struct mm_struct
*);
1912 static struct vm_area_struct
*vma_first(const struct mm_struct
*);
1913 static struct vm_area_struct
*vma_next(struct vm_area_struct
*);
1914 static abi_ulong
vma_dump_size(const struct vm_area_struct
*);
1915 static int vma_walker(void *priv
, unsigned long start
, unsigned long end
,
1916 unsigned long flags
);
1918 static void fill_elf_header(struct elfhdr
*, int, uint16_t, uint32_t);
1919 static void fill_note(struct memelfnote
*, const char *, int,
1920 unsigned int, void *);
1921 static void fill_prstatus(struct target_elf_prstatus
*, const TaskState
*, int);
1922 static int fill_psinfo(struct target_elf_prpsinfo
*, const TaskState
*);
1923 static void fill_auxv_note(struct memelfnote
*, const TaskState
*);
1924 static void fill_elf_note_phdr(struct elf_phdr
*, int, off_t
);
1925 static size_t note_size(const struct memelfnote
*);
1926 static void free_note_info(struct elf_note_info
*);
1927 static int fill_note_info(struct elf_note_info
*, long, const CPUState
*);
1928 static void fill_thread_info(struct elf_note_info
*, const CPUState
*);
1929 static int core_dump_filename(const TaskState
*, char *, size_t);
1931 static int dump_write(int, const void *, size_t);
1932 static int write_note(struct memelfnote
*, int);
1933 static int write_note_info(struct elf_note_info
*, int);
1936 static void bswap_prstatus(struct target_elf_prstatus
*);
1937 static void bswap_psinfo(struct target_elf_prpsinfo
*);
1939 static void bswap_prstatus(struct target_elf_prstatus
*prstatus
)
1941 prstatus
->pr_info
.si_signo
= tswapl(prstatus
->pr_info
.si_signo
);
1942 prstatus
->pr_info
.si_code
= tswapl(prstatus
->pr_info
.si_code
);
1943 prstatus
->pr_info
.si_errno
= tswapl(prstatus
->pr_info
.si_errno
);
1944 prstatus
->pr_cursig
= tswap16(prstatus
->pr_cursig
);
1945 prstatus
->pr_sigpend
= tswapl(prstatus
->pr_sigpend
);
1946 prstatus
->pr_sighold
= tswapl(prstatus
->pr_sighold
);
1947 prstatus
->pr_pid
= tswap32(prstatus
->pr_pid
);
1948 prstatus
->pr_ppid
= tswap32(prstatus
->pr_ppid
);
1949 prstatus
->pr_pgrp
= tswap32(prstatus
->pr_pgrp
);
1950 prstatus
->pr_sid
= tswap32(prstatus
->pr_sid
);
1951 /* cpu times are not filled, so we skip them */
1952 /* regs should be in correct format already */
1953 prstatus
->pr_fpvalid
= tswap32(prstatus
->pr_fpvalid
);
1956 static void bswap_psinfo(struct target_elf_prpsinfo
*psinfo
)
1958 psinfo
->pr_flag
= tswapl(psinfo
->pr_flag
);
1959 psinfo
->pr_uid
= tswap16(psinfo
->pr_uid
);
1960 psinfo
->pr_gid
= tswap16(psinfo
->pr_gid
);
1961 psinfo
->pr_pid
= tswap32(psinfo
->pr_pid
);
1962 psinfo
->pr_ppid
= tswap32(psinfo
->pr_ppid
);
1963 psinfo
->pr_pgrp
= tswap32(psinfo
->pr_pgrp
);
1964 psinfo
->pr_sid
= tswap32(psinfo
->pr_sid
);
1966 #endif /* BSWAP_NEEDED */
1969 * Minimal support for linux memory regions. These are needed
1970 * when we are finding out what memory exactly belongs to
1971 * emulated process. No locks needed here, as long as
1972 * thread that received the signal is stopped.
1975 static struct mm_struct
*vma_init(void)
1977 struct mm_struct
*mm
;
1979 if ((mm
= qemu_malloc(sizeof (*mm
))) == NULL
)
1983 QTAILQ_INIT(&mm
->mm_mmap
);
1988 static void vma_delete(struct mm_struct
*mm
)
1990 struct vm_area_struct
*vma
;
1992 while ((vma
= vma_first(mm
)) != NULL
) {
1993 QTAILQ_REMOVE(&mm
->mm_mmap
, vma
, vma_link
);
1999 static int vma_add_mapping(struct mm_struct
*mm
, abi_ulong start
,
2000 abi_ulong end
, abi_ulong flags
)
2002 struct vm_area_struct
*vma
;
2004 if ((vma
= qemu_mallocz(sizeof (*vma
))) == NULL
)
2007 vma
->vma_start
= start
;
2009 vma
->vma_flags
= flags
;
2011 QTAILQ_INSERT_TAIL(&mm
->mm_mmap
, vma
, vma_link
);
2017 static struct vm_area_struct
*vma_first(const struct mm_struct
*mm
)
2019 return (QTAILQ_FIRST(&mm
->mm_mmap
));
2022 static struct vm_area_struct
*vma_next(struct vm_area_struct
*vma
)
2024 return (QTAILQ_NEXT(vma
, vma_link
));
2027 static int vma_get_mapping_count(const struct mm_struct
*mm
)
2029 return (mm
->mm_count
);
2033 * Calculate file (dump) size of given memory region.
2035 static abi_ulong
vma_dump_size(const struct vm_area_struct
*vma
)
2037 /* if we cannot even read the first page, skip it */
2038 if (!access_ok(VERIFY_READ
, vma
->vma_start
, TARGET_PAGE_SIZE
))
2042 * Usually we don't dump executable pages as they contain
2043 * non-writable code that debugger can read directly from
2044 * target library etc. However, thread stacks are marked
2045 * also executable so we read in first page of given region
2046 * and check whether it contains elf header. If there is
2047 * no elf header, we dump it.
2049 if (vma
->vma_flags
& PROT_EXEC
) {
2050 char page
[TARGET_PAGE_SIZE
];
2052 copy_from_user(page
, vma
->vma_start
, sizeof (page
));
2053 if ((page
[EI_MAG0
] == ELFMAG0
) &&
2054 (page
[EI_MAG1
] == ELFMAG1
) &&
2055 (page
[EI_MAG2
] == ELFMAG2
) &&
2056 (page
[EI_MAG3
] == ELFMAG3
)) {
2058 * Mappings are possibly from ELF binary. Don't dump
2065 return (vma
->vma_end
- vma
->vma_start
);
2068 static int vma_walker(void *priv
, unsigned long start
, unsigned long end
,
2069 unsigned long flags
)
2071 struct mm_struct
*mm
= (struct mm_struct
*)priv
;
2074 * Don't dump anything that qemu has reserved for internal use.
2076 if (flags
& PAGE_RESERVED
)
2079 vma_add_mapping(mm
, start
, end
, flags
);
2083 static void fill_note(struct memelfnote
*note
, const char *name
, int type
,
2084 unsigned int sz
, void *data
)
2086 unsigned int namesz
;
2088 namesz
= strlen(name
) + 1;
2090 note
->namesz
= namesz
;
2091 note
->namesz_rounded
= roundup(namesz
, sizeof (int32_t));
2093 note
->datasz
= roundup(sz
, sizeof (int32_t));;
2097 * We calculate rounded up note size here as specified by
2100 note
->notesz
= sizeof (struct elf_note
) +
2101 note
->namesz_rounded
+ note
->datasz
;
2104 static void fill_elf_header(struct elfhdr
*elf
, int segs
, uint16_t machine
,
2107 (void) memset(elf
, 0, sizeof(*elf
));
2109 (void) memcpy(elf
->e_ident
, ELFMAG
, SELFMAG
);
2110 elf
->e_ident
[EI_CLASS
] = ELF_CLASS
;
2111 elf
->e_ident
[EI_DATA
] = ELF_DATA
;
2112 elf
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2113 elf
->e_ident
[EI_OSABI
] = ELF_OSABI
;
2115 elf
->e_type
= ET_CORE
;
2116 elf
->e_machine
= machine
;
2117 elf
->e_version
= EV_CURRENT
;
2118 elf
->e_phoff
= sizeof(struct elfhdr
);
2119 elf
->e_flags
= flags
;
2120 elf
->e_ehsize
= sizeof(struct elfhdr
);
2121 elf
->e_phentsize
= sizeof(struct elf_phdr
);
2122 elf
->e_phnum
= segs
;
2129 static void fill_elf_note_phdr(struct elf_phdr
*phdr
, int sz
, off_t offset
)
2131 phdr
->p_type
= PT_NOTE
;
2132 phdr
->p_offset
= offset
;
2135 phdr
->p_filesz
= sz
;
2145 static size_t note_size(const struct memelfnote
*note
)
2147 return (note
->notesz
);
2150 static void fill_prstatus(struct target_elf_prstatus
*prstatus
,
2151 const TaskState
*ts
, int signr
)
2153 (void) memset(prstatus
, 0, sizeof (*prstatus
));
2154 prstatus
->pr_info
.si_signo
= prstatus
->pr_cursig
= signr
;
2155 prstatus
->pr_pid
= ts
->ts_tid
;
2156 prstatus
->pr_ppid
= getppid();
2157 prstatus
->pr_pgrp
= getpgrp();
2158 prstatus
->pr_sid
= getsid(0);
2161 bswap_prstatus(prstatus
);
2165 static int fill_psinfo(struct target_elf_prpsinfo
*psinfo
, const TaskState
*ts
)
2167 char *filename
, *base_filename
;
2168 unsigned int i
, len
;
2170 (void) memset(psinfo
, 0, sizeof (*psinfo
));
2172 len
= ts
->info
->arg_end
- ts
->info
->arg_start
;
2173 if (len
>= ELF_PRARGSZ
)
2174 len
= ELF_PRARGSZ
- 1;
2175 if (copy_from_user(&psinfo
->pr_psargs
, ts
->info
->arg_start
, len
))
2177 for (i
= 0; i
< len
; i
++)
2178 if (psinfo
->pr_psargs
[i
] == 0)
2179 psinfo
->pr_psargs
[i
] = ' ';
2180 psinfo
->pr_psargs
[len
] = 0;
2182 psinfo
->pr_pid
= getpid();
2183 psinfo
->pr_ppid
= getppid();
2184 psinfo
->pr_pgrp
= getpgrp();
2185 psinfo
->pr_sid
= getsid(0);
2186 psinfo
->pr_uid
= getuid();
2187 psinfo
->pr_gid
= getgid();
2189 filename
= strdup(ts
->bprm
->filename
);
2190 base_filename
= strdup(basename(filename
));
2191 (void) strncpy(psinfo
->pr_fname
, base_filename
,
2192 sizeof(psinfo
->pr_fname
));
2193 free(base_filename
);
2197 bswap_psinfo(psinfo
);
2202 static void fill_auxv_note(struct memelfnote
*note
, const TaskState
*ts
)
2204 elf_addr_t auxv
= (elf_addr_t
)ts
->info
->saved_auxv
;
2205 elf_addr_t orig_auxv
= auxv
;
2211 * Auxiliary vector is stored in target process stack. It contains
2212 * {type, value} pairs that we need to dump into note. This is not
2213 * strictly necessary but we do it here for sake of completeness.
2216 /* find out lenght of the vector, AT_NULL is terminator */
2219 get_user_ual(val
, auxv
);
2221 auxv
+= 2 * sizeof (elf_addr_t
);
2222 } while (val
!= AT_NULL
);
2223 len
= i
* sizeof (elf_addr_t
);
2225 /* read in whole auxv vector and copy it to memelfnote */
2226 ptr
= lock_user(VERIFY_READ
, orig_auxv
, len
, 0);
2228 fill_note(note
, "CORE", NT_AUXV
, len
, ptr
);
2229 unlock_user(ptr
, auxv
, len
);
2234 * Constructs name of coredump file. We have following convention
2236 * qemu_<basename-of-target-binary>_<date>-<time>_<pid>.core
2238 * Returns 0 in case of success, -1 otherwise (errno is set).
2240 static int core_dump_filename(const TaskState
*ts
, char *buf
,
2244 char *filename
= NULL
;
2245 char *base_filename
= NULL
;
2249 assert(bufsize
>= PATH_MAX
);
2251 if (gettimeofday(&tv
, NULL
) < 0) {
2252 (void) fprintf(stderr
, "unable to get current timestamp: %s",
2257 filename
= strdup(ts
->bprm
->filename
);
2258 base_filename
= strdup(basename(filename
));
2259 (void) strftime(timestamp
, sizeof (timestamp
), "%Y%m%d-%H%M%S",
2260 localtime_r(&tv
.tv_sec
, &tm
));
2261 (void) snprintf(buf
, bufsize
, "qemu_%s_%s_%d.core",
2262 base_filename
, timestamp
, (int)getpid());
2263 free(base_filename
);
2269 static int dump_write(int fd
, const void *ptr
, size_t size
)
2271 const char *bufp
= (const char *)ptr
;
2272 ssize_t bytes_written
, bytes_left
;
2273 struct rlimit dumpsize
;
2277 getrlimit(RLIMIT_CORE
, &dumpsize
);
2278 if ((pos
= lseek(fd
, 0, SEEK_CUR
))==-1) {
2279 if (errno
== ESPIPE
) { /* not a seekable stream */
2285 if (dumpsize
.rlim_cur
<= pos
) {
2287 } else if (dumpsize
.rlim_cur
== RLIM_INFINITY
) {
2290 size_t limit_left
=dumpsize
.rlim_cur
- pos
;
2291 bytes_left
= limit_left
>= size
? size
: limit_left
;
2296 * In normal conditions, single write(2) should do but
2297 * in case of socket etc. this mechanism is more portable.
2300 bytes_written
= write(fd
, bufp
, bytes_left
);
2301 if (bytes_written
< 0) {
2305 } else if (bytes_written
== 0) { /* eof */
2308 bufp
+= bytes_written
;
2309 bytes_left
-= bytes_written
;
2310 } while (bytes_left
> 0);
2315 static int write_note(struct memelfnote
*men
, int fd
)
2319 en
.n_namesz
= men
->namesz
;
2320 en
.n_type
= men
->type
;
2321 en
.n_descsz
= men
->datasz
;
2327 if (dump_write(fd
, &en
, sizeof(en
)) != 0)
2329 if (dump_write(fd
, men
->name
, men
->namesz_rounded
) != 0)
2331 if (dump_write(fd
, men
->data
, men
->datasz
) != 0)
2337 static void fill_thread_info(struct elf_note_info
*info
, const CPUState
*env
)
2339 TaskState
*ts
= (TaskState
*)env
->opaque
;
2340 struct elf_thread_status
*ets
;
2342 ets
= qemu_mallocz(sizeof (*ets
));
2343 ets
->num_notes
= 1; /* only prstatus is dumped */
2344 fill_prstatus(&ets
->prstatus
, ts
, 0);
2345 elf_core_copy_regs(&ets
->prstatus
.pr_reg
, env
);
2346 fill_note(&ets
->notes
[0], "CORE", NT_PRSTATUS
, sizeof (ets
->prstatus
),
2349 QTAILQ_INSERT_TAIL(&info
->thread_list
, ets
, ets_link
);
2351 info
->notes_size
+= note_size(&ets
->notes
[0]);
2354 static int fill_note_info(struct elf_note_info
*info
,
2355 long signr
, const CPUState
*env
)
2358 CPUState
*cpu
= NULL
;
2359 TaskState
*ts
= (TaskState
*)env
->opaque
;
2362 (void) memset(info
, 0, sizeof (*info
));
2364 QTAILQ_INIT(&info
->thread_list
);
2366 info
->notes
= qemu_mallocz(NUMNOTES
* sizeof (struct memelfnote
));
2367 if (info
->notes
== NULL
)
2369 info
->prstatus
= qemu_mallocz(sizeof (*info
->prstatus
));
2370 if (info
->prstatus
== NULL
)
2372 info
->psinfo
= qemu_mallocz(sizeof (*info
->psinfo
));
2373 if (info
->prstatus
== NULL
)
2377 * First fill in status (and registers) of current thread
2378 * including process info & aux vector.
2380 fill_prstatus(info
->prstatus
, ts
, signr
);
2381 elf_core_copy_regs(&info
->prstatus
->pr_reg
, env
);
2382 fill_note(&info
->notes
[0], "CORE", NT_PRSTATUS
,
2383 sizeof (*info
->prstatus
), info
->prstatus
);
2384 fill_psinfo(info
->psinfo
, ts
);
2385 fill_note(&info
->notes
[1], "CORE", NT_PRPSINFO
,
2386 sizeof (*info
->psinfo
), info
->psinfo
);
2387 fill_auxv_note(&info
->notes
[2], ts
);
2390 info
->notes_size
= 0;
2391 for (i
= 0; i
< info
->numnote
; i
++)
2392 info
->notes_size
+= note_size(&info
->notes
[i
]);
2394 /* read and fill status of all threads */
2396 for (cpu
= first_cpu
; cpu
!= NULL
; cpu
= cpu
->next_cpu
) {
2397 if (cpu
== thread_env
)
2399 fill_thread_info(info
, cpu
);
2406 static void free_note_info(struct elf_note_info
*info
)
2408 struct elf_thread_status
*ets
;
2410 while (!QTAILQ_EMPTY(&info
->thread_list
)) {
2411 ets
= QTAILQ_FIRST(&info
->thread_list
);
2412 QTAILQ_REMOVE(&info
->thread_list
, ets
, ets_link
);
2416 qemu_free(info
->prstatus
);
2417 qemu_free(info
->psinfo
);
2418 qemu_free(info
->notes
);
2421 static int write_note_info(struct elf_note_info
*info
, int fd
)
2423 struct elf_thread_status
*ets
;
2426 /* write prstatus, psinfo and auxv for current thread */
2427 for (i
= 0; i
< info
->numnote
; i
++)
2428 if ((error
= write_note(&info
->notes
[i
], fd
)) != 0)
2431 /* write prstatus for each thread */
2432 for (ets
= info
->thread_list
.tqh_first
; ets
!= NULL
;
2433 ets
= ets
->ets_link
.tqe_next
) {
2434 if ((error
= write_note(&ets
->notes
[0], fd
)) != 0)
2442 * Write out ELF coredump.
2444 * See documentation of ELF object file format in:
2445 * http://www.caldera.com/developers/devspecs/gabi41.pdf
2447 * Coredump format in linux is following:
2449 * 0 +----------------------+ \
2450 * | ELF header | ET_CORE |
2451 * +----------------------+ |
2452 * | ELF program headers | |--- headers
2453 * | - NOTE section | |
2454 * | - PT_LOAD sections | |
2455 * +----------------------+ /
2460 * +----------------------+ <-- aligned to target page
2461 * | Process memory dump |
2466 * +----------------------+
2468 * NT_PRSTATUS -> struct elf_prstatus (per thread)
2469 * NT_PRSINFO -> struct elf_prpsinfo
2470 * NT_AUXV is array of { type, value } pairs (see fill_auxv_note()).
2472 * Format follows System V format as close as possible. Current
2473 * version limitations are as follows:
2474 * - no floating point registers are dumped
2476 * Function returns 0 in case of success, negative errno otherwise.
2478 * TODO: make this work also during runtime: it should be
2479 * possible to force coredump from running process and then
2480 * continue processing. For example qemu could set up SIGUSR2
2481 * handler (provided that target process haven't registered
2482 * handler for that) that does the dump when signal is received.
2484 static int elf_core_dump(int signr
, const CPUState
*env
)
2486 const TaskState
*ts
= (const TaskState
*)env
->opaque
;
2487 struct vm_area_struct
*vma
= NULL
;
2488 char corefile
[PATH_MAX
];
2489 struct elf_note_info info
;
2491 struct elf_phdr phdr
;
2492 struct rlimit dumpsize
;
2493 struct mm_struct
*mm
= NULL
;
2494 off_t offset
= 0, data_offset
= 0;
2499 getrlimit(RLIMIT_CORE
, &dumpsize
);
2500 if (dumpsize
.rlim_cur
== 0)
2503 if (core_dump_filename(ts
, corefile
, sizeof (corefile
)) < 0)
2506 if ((fd
= open(corefile
, O_WRONLY
| O_CREAT
,
2507 S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
)) < 0)
2511 * Walk through target process memory mappings and
2512 * set up structure containing this information. After
2513 * this point vma_xxx functions can be used.
2515 if ((mm
= vma_init()) == NULL
)
2518 walk_memory_regions(mm
, vma_walker
);
2519 segs
= vma_get_mapping_count(mm
);
2522 * Construct valid coredump ELF header. We also
2523 * add one more segment for notes.
2525 fill_elf_header(&elf
, segs
+ 1, ELF_MACHINE
, 0);
2526 if (dump_write(fd
, &elf
, sizeof (elf
)) != 0)
2529 /* fill in in-memory version of notes */
2530 if (fill_note_info(&info
, signr
, env
) < 0)
2533 offset
+= sizeof (elf
); /* elf header */
2534 offset
+= (segs
+ 1) * sizeof (struct elf_phdr
); /* program headers */
2536 /* write out notes program header */
2537 fill_elf_note_phdr(&phdr
, info
.notes_size
, offset
);
2539 offset
+= info
.notes_size
;
2540 if (dump_write(fd
, &phdr
, sizeof (phdr
)) != 0)
2544 * ELF specification wants data to start at page boundary so
2547 offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
2550 * Write program headers for memory regions mapped in
2551 * the target process.
2553 for (vma
= vma_first(mm
); vma
!= NULL
; vma
= vma_next(vma
)) {
2554 (void) memset(&phdr
, 0, sizeof (phdr
));
2556 phdr
.p_type
= PT_LOAD
;
2557 phdr
.p_offset
= offset
;
2558 phdr
.p_vaddr
= vma
->vma_start
;
2560 phdr
.p_filesz
= vma_dump_size(vma
);
2561 offset
+= phdr
.p_filesz
;
2562 phdr
.p_memsz
= vma
->vma_end
- vma
->vma_start
;
2563 phdr
.p_flags
= vma
->vma_flags
& PROT_READ
? PF_R
: 0;
2564 if (vma
->vma_flags
& PROT_WRITE
)
2565 phdr
.p_flags
|= PF_W
;
2566 if (vma
->vma_flags
& PROT_EXEC
)
2567 phdr
.p_flags
|= PF_X
;
2568 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
2570 dump_write(fd
, &phdr
, sizeof (phdr
));
2574 * Next we write notes just after program headers. No
2575 * alignment needed here.
2577 if (write_note_info(&info
, fd
) < 0)
2580 /* align data to page boundary */
2581 data_offset
= lseek(fd
, 0, SEEK_CUR
);
2582 data_offset
= TARGET_PAGE_ALIGN(data_offset
);
2583 if (lseek(fd
, data_offset
, SEEK_SET
) != data_offset
)
2587 * Finally we can dump process memory into corefile as well.
2589 for (vma
= vma_first(mm
); vma
!= NULL
; vma
= vma_next(vma
)) {
2593 end
= vma
->vma_start
+ vma_dump_size(vma
);
2595 for (addr
= vma
->vma_start
; addr
< end
;
2596 addr
+= TARGET_PAGE_SIZE
) {
2597 char page
[TARGET_PAGE_SIZE
];
2601 * Read in page from target process memory and
2602 * write it to coredump file.
2604 error
= copy_from_user(page
, addr
, sizeof (page
));
2606 (void) fprintf(stderr
, "unable to dump " TARGET_ABI_FMT_lx
"\n",
2611 if (dump_write(fd
, page
, TARGET_PAGE_SIZE
) < 0)
2617 free_note_info(&info
);
2627 #endif /* USE_ELF_CORE_DUMP */
2629 static int load_aout_interp(void * exptr
, int interp_fd
)
2631 printf("a.out interpreter not yet supported\n");
2635 void do_init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
2637 init_thread(regs
, infop
);