]> git.proxmox.com Git - mirror_qemu.git/blob - linux-user/elfload.c
projects / mirror_qemu.git / blob
? search:


2e3809f03c40240292277b9e905260d5ff84d18a
[mirror_qemu.git] / linux-user / elfload.c
1 /* This is the Linux kernel elf-loading code, ported into user space */
2 #include "qemu/osdep.h"
3 #include <sys/param.h>
4
5 #include <sys/resource.h>
6 #include <sys/shm.h>
7
8 #include "qemu.h"
9 #include "user-internals.h"
10 #include "signal-common.h"
11 #include "loader.h"
12 #include "user-mmap.h"
13 #include "disas/disas.h"
14 #include "qemu/bitops.h"
15 #include "qemu/path.h"
16 #include "qemu/queue.h"
17 #include "qemu/guest-random.h"
18 #include "qemu/units.h"
19 #include "qemu/selfmap.h"
20 #include "qemu/lockable.h"
21 #include "qapi/error.h"
22 #include "qemu/error-report.h"
23 #include "target_signal.h"
24 #include "accel/tcg/debuginfo.h"
25
26 #ifdef _ARCH_PPC64
27 #undef ARCH_DLINFO
28 #undef ELF_PLATFORM
29 #undef ELF_HWCAP
30 #undef ELF_HWCAP2
31 #undef ELF_CLASS
32 #undef ELF_DATA
33 #undef ELF_ARCH
34 #endif
35
36 #define ELF_OSABI ELFOSABI_SYSV
37
38 /* from personality.h */
39
40 /*
41 * Flags for bug emulation.
42 *
43 * These occupy the top three bytes.
44 */
45 enum {
46 ADDR_NO_RANDOMIZE = 0x0040000, /* disable randomization of VA space */
47 FDPIC_FUNCPTRS = 0x0080000, /* userspace function ptrs point to
48 descriptors (signal handling) */
49 MMAP_PAGE_ZERO = 0x0100000,
50 ADDR_COMPAT_LAYOUT = 0x0200000,
51 READ_IMPLIES_EXEC = 0x0400000,
52 ADDR_LIMIT_32BIT = 0x0800000,
53 SHORT_INODE = 0x1000000,
54 WHOLE_SECONDS = 0x2000000,
55 STICKY_TIMEOUTS = 0x4000000,
56 ADDR_LIMIT_3GB = 0x8000000,
57 };
58
59 /*
60 * Personality types.
61 *
62 * These go in the low byte. Avoid using the top bit, it will
63 * conflict with error returns.
64 */
65 enum {
66 PER_LINUX = 0x0000,
67 PER_LINUX_32BIT = 0x0000 | ADDR_LIMIT_32BIT,
68 PER_LINUX_FDPIC = 0x0000 | FDPIC_FUNCPTRS,
69 PER_SVR4 = 0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
70 PER_SVR3 = 0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
71 PER_SCOSVR3 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS | SHORT_INODE,
72 PER_OSR5 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
73 PER_WYSEV386 = 0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
74 PER_ISCR4 = 0x0005 | STICKY_TIMEOUTS,
75 PER_BSD = 0x0006,
76 PER_SUNOS = 0x0006 | STICKY_TIMEOUTS,
77 PER_XENIX = 0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
78 PER_LINUX32 = 0x0008,
79 PER_LINUX32_3GB = 0x0008 | ADDR_LIMIT_3GB,
80 PER_IRIX32 = 0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */
81 PER_IRIXN32 = 0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */
82 PER_IRIX64 = 0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */
83 PER_RISCOS = 0x000c,
84 PER_SOLARIS = 0x000d | STICKY_TIMEOUTS,
85 PER_UW7 = 0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
86 PER_OSF4 = 0x000f, /* OSF/1 v4 */
87 PER_HPUX = 0x0010,
88 PER_MASK = 0x00ff,
89 };
90
91 /*
92 * Return the base personality without flags.
93 */
94 #define personality(pers) (pers & PER_MASK)
95
96 int info_is_fdpic(struct image_info *info)
97 {
98 return info->personality == PER_LINUX_FDPIC;
99 }
100
101 /* this flag is uneffective under linux too, should be deleted */
102 #ifndef MAP_DENYWRITE
103 #define MAP_DENYWRITE 0
104 #endif
105
106 /* should probably go in elf.h */
107 #ifndef ELIBBAD
108 #define ELIBBAD 80
109 #endif
110
111 #if TARGET_BIG_ENDIAN
112 #define ELF_DATA ELFDATA2MSB
113 #else
114 #define ELF_DATA ELFDATA2LSB
115 #endif
116
117 #ifdef TARGET_ABI_MIPSN32
118 typedef abi_ullong target_elf_greg_t;
119 #define tswapreg(ptr) tswap64(ptr)
120 #else
121 typedef abi_ulong target_elf_greg_t;
122 #define tswapreg(ptr) tswapal(ptr)
123 #endif
124
125 #ifdef USE_UID16
126 typedef abi_ushort target_uid_t;
127 typedef abi_ushort target_gid_t;
128 #else
129 typedef abi_uint target_uid_t;
130 typedef abi_uint target_gid_t;
131 #endif
132 typedef abi_int target_pid_t;
133
134 #ifdef TARGET_I386
135
136 #define ELF_HWCAP get_elf_hwcap()
137
138 static uint32_t get_elf_hwcap(void)
139 {
140 X86CPU *cpu = X86_CPU(thread_cpu);
141
142 return cpu->env.features[FEAT_1_EDX];
143 }
144
145 #ifdef TARGET_X86_64
146 #define ELF_CLASS ELFCLASS64
147 #define ELF_ARCH EM_X86_64
148
149 #define ELF_PLATFORM "x86_64"
150
151 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
152 {
153 regs->rax = 0;
154 regs->rsp = infop->start_stack;
155 regs->rip = infop->entry;
156 }
157
158 #define ELF_NREG 27
159 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
160
161 /*
162 * Note that ELF_NREG should be 29 as there should be place for
163 * TRAPNO and ERR "registers" as well but linux doesn't dump
164 * those.
165 *
166 * See linux kernel: arch/x86/include/asm/elf.h
167 */
168 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
169 {
170 (*regs)[0] = tswapreg(env->regs[15]);
171 (*regs)[1] = tswapreg(env->regs[14]);
172 (*regs)[2] = tswapreg(env->regs[13]);
173 (*regs)[3] = tswapreg(env->regs[12]);
174 (*regs)[4] = tswapreg(env->regs[R_EBP]);
175 (*regs)[5] = tswapreg(env->regs[R_EBX]);
176 (*regs)[6] = tswapreg(env->regs[11]);
177 (*regs)[7] = tswapreg(env->regs[10]);
178 (*regs)[8] = tswapreg(env->regs[9]);
179 (*regs)[9] = tswapreg(env->regs[8]);
180 (*regs)[10] = tswapreg(env->regs[R_EAX]);
181 (*regs)[11] = tswapreg(env->regs[R_ECX]);
182 (*regs)[12] = tswapreg(env->regs[R_EDX]);
183 (*regs)[13] = tswapreg(env->regs[R_ESI]);
184 (*regs)[14] = tswapreg(env->regs[R_EDI]);
185 (*regs)[15] = tswapreg(env->regs[R_EAX]); /* XXX */
186 (*regs)[16] = tswapreg(env->eip);
187 (*regs)[17] = tswapreg(env->segs[R_CS].selector & 0xffff);
188 (*regs)[18] = tswapreg(env->eflags);
189 (*regs)[19] = tswapreg(env->regs[R_ESP]);
190 (*regs)[20] = tswapreg(env->segs[R_SS].selector & 0xffff);
191 (*regs)[21] = tswapreg(env->segs[R_FS].selector & 0xffff);
192 (*regs)[22] = tswapreg(env->segs[R_GS].selector & 0xffff);
193 (*regs)[23] = tswapreg(env->segs[R_DS].selector & 0xffff);
194 (*regs)[24] = tswapreg(env->segs[R_ES].selector & 0xffff);
195 (*regs)[25] = tswapreg(env->segs[R_FS].selector & 0xffff);
196 (*regs)[26] = tswapreg(env->segs[R_GS].selector & 0xffff);
197 }
198
199 #if ULONG_MAX > UINT32_MAX
200 #define INIT_GUEST_COMMPAGE
201 static bool init_guest_commpage(void)
202 {
203 /*
204 * The vsyscall page is at a high negative address aka kernel space,
205 * which means that we cannot actually allocate it with target_mmap.
206 * We still should be able to use page_set_flags, unless the user
207 * has specified -R reserved_va, which would trigger an assert().
208 */
209 if (reserved_va != 0 &&
210 TARGET_VSYSCALL_PAGE + TARGET_PAGE_SIZE - 1 > reserved_va) {
211 error_report("Cannot allocate vsyscall page");
212 exit(EXIT_FAILURE);
213 }
214 page_set_flags(TARGET_VSYSCALL_PAGE,
215 TARGET_VSYSCALL_PAGE | ~TARGET_PAGE_MASK,
216 PAGE_EXEC | PAGE_VALID);
217 return true;
218 }
219 #endif
220 #else
221
222 /*
223 * This is used to ensure we don't load something for the wrong architecture.
224 */
225 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
226
227 /*
228 * These are used to set parameters in the core dumps.
229 */
230 #define ELF_CLASS ELFCLASS32
231 #define ELF_ARCH EM_386
232
233 #define ELF_PLATFORM get_elf_platform()
234 #define EXSTACK_DEFAULT true
235
236 static const char *get_elf_platform(void)
237 {
238 static char elf_platform[] = "i386";
239 int family = object_property_get_int(OBJECT(thread_cpu), "family", NULL);
240 if (family > 6) {
241 family = 6;
242 }
243 if (family >= 3) {
244 elf_platform[1] = '0' + family;
245 }
246 return elf_platform;
247 }
248
249 static inline void init_thread(struct target_pt_regs *regs,
250 struct image_info *infop)
251 {
252 regs->esp = infop->start_stack;
253 regs->eip = infop->entry;
254
255 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
256 starts %edx contains a pointer to a function which might be
257 registered using `atexit'. This provides a mean for the
258 dynamic linker to call DT_FINI functions for shared libraries
259 that have been loaded before the code runs.
260
261 A value of 0 tells we have no such handler. */
262 regs->edx = 0;
263 }
264
265 #define ELF_NREG 17
266 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
267
268 /*
269 * Note that ELF_NREG should be 19 as there should be place for
270 * TRAPNO and ERR "registers" as well but linux doesn't dump
271 * those.
272 *
273 * See linux kernel: arch/x86/include/asm/elf.h
274 */
275 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
276 {
277 (*regs)[0] = tswapreg(env->regs[R_EBX]);
278 (*regs)[1] = tswapreg(env->regs[R_ECX]);
279 (*regs)[2] = tswapreg(env->regs[R_EDX]);
280 (*regs)[3] = tswapreg(env->regs[R_ESI]);
281 (*regs)[4] = tswapreg(env->regs[R_EDI]);
282 (*regs)[5] = tswapreg(env->regs[R_EBP]);
283 (*regs)[6] = tswapreg(env->regs[R_EAX]);
284 (*regs)[7] = tswapreg(env->segs[R_DS].selector & 0xffff);
285 (*regs)[8] = tswapreg(env->segs[R_ES].selector & 0xffff);
286 (*regs)[9] = tswapreg(env->segs[R_FS].selector & 0xffff);
287 (*regs)[10] = tswapreg(env->segs[R_GS].selector & 0xffff);
288 (*regs)[11] = tswapreg(env->regs[R_EAX]); /* XXX */
289 (*regs)[12] = tswapreg(env->eip);
290 (*regs)[13] = tswapreg(env->segs[R_CS].selector & 0xffff);
291 (*regs)[14] = tswapreg(env->eflags);
292 (*regs)[15] = tswapreg(env->regs[R_ESP]);
293 (*regs)[16] = tswapreg(env->segs[R_SS].selector & 0xffff);
294 }
295 #endif
296
297 #define USE_ELF_CORE_DUMP
298 #define ELF_EXEC_PAGESIZE 4096
299
300 #endif
301
302 #ifdef TARGET_ARM
303
304 #ifndef TARGET_AARCH64
305 /* 32 bit ARM definitions */
306
307 #define ELF_ARCH EM_ARM
308 #define ELF_CLASS ELFCLASS32
309 #define EXSTACK_DEFAULT true
310
311 static inline void init_thread(struct target_pt_regs *regs,
312 struct image_info *infop)
313 {
314 abi_long stack = infop->start_stack;
315 memset(regs, 0, sizeof(*regs));
316
317 regs->uregs[16] = ARM_CPU_MODE_USR;
318 if (infop->entry & 1) {
319 regs->uregs[16] |= CPSR_T;
320 }
321 regs->uregs[15] = infop->entry & 0xfffffffe;
322 regs->uregs[13] = infop->start_stack;
323 /* FIXME - what to for failure of get_user()? */
324 get_user_ual(regs->uregs[2], stack + 8); /* envp */
325 get_user_ual(regs->uregs[1], stack + 4); /* envp */
326 /* XXX: it seems that r0 is zeroed after ! */
327 regs->uregs[0] = 0;
328 /* For uClinux PIC binaries. */
329 /* XXX: Linux does this only on ARM with no MMU (do we care ?) */
330 regs->uregs[10] = infop->start_data;
331
332 /* Support ARM FDPIC. */
333 if (info_is_fdpic(infop)) {
334 /* As described in the ABI document, r7 points to the loadmap info
335 * prepared by the kernel. If an interpreter is needed, r8 points
336 * to the interpreter loadmap and r9 points to the interpreter
337 * PT_DYNAMIC info. If no interpreter is needed, r8 is zero, and
338 * r9 points to the main program PT_DYNAMIC info.
339 */
340 regs->uregs[7] = infop->loadmap_addr;
341 if (infop->interpreter_loadmap_addr) {
342 /* Executable is dynamically loaded. */
343 regs->uregs[8] = infop->interpreter_loadmap_addr;
344 regs->uregs[9] = infop->interpreter_pt_dynamic_addr;
345 } else {
346 regs->uregs[8] = 0;
347 regs->uregs[9] = infop->pt_dynamic_addr;
348 }
349 }
350 }
351
352 #define ELF_NREG 18
353 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
354
355 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUARMState *env)
356 {
357 (*regs)[0] = tswapreg(env->regs[0]);
358 (*regs)[1] = tswapreg(env->regs[1]);
359 (*regs)[2] = tswapreg(env->regs[2]);
360 (*regs)[3] = tswapreg(env->regs[3]);
361 (*regs)[4] = tswapreg(env->regs[4]);
362 (*regs)[5] = tswapreg(env->regs[5]);
363 (*regs)[6] = tswapreg(env->regs[6]);
364 (*regs)[7] = tswapreg(env->regs[7]);
365 (*regs)[8] = tswapreg(env->regs[8]);
366 (*regs)[9] = tswapreg(env->regs[9]);
367 (*regs)[10] = tswapreg(env->regs[10]);
368 (*regs)[11] = tswapreg(env->regs[11]);
369 (*regs)[12] = tswapreg(env->regs[12]);
370 (*regs)[13] = tswapreg(env->regs[13]);
371 (*regs)[14] = tswapreg(env->regs[14]);
372 (*regs)[15] = tswapreg(env->regs[15]);
373
374 (*regs)[16] = tswapreg(cpsr_read((CPUARMState *)env));
375 (*regs)[17] = tswapreg(env->regs[0]); /* XXX */
376 }
377
378 #define USE_ELF_CORE_DUMP
379 #define ELF_EXEC_PAGESIZE 4096
380
381 enum
382 {
383 ARM_HWCAP_ARM_SWP = 1 << 0,
384 ARM_HWCAP_ARM_HALF = 1 << 1,
385 ARM_HWCAP_ARM_THUMB = 1 << 2,
386 ARM_HWCAP_ARM_26BIT = 1 << 3,
387 ARM_HWCAP_ARM_FAST_MULT = 1 << 4,
388 ARM_HWCAP_ARM_FPA = 1 << 5,
389 ARM_HWCAP_ARM_VFP = 1 << 6,
390 ARM_HWCAP_ARM_EDSP = 1 << 7,
391 ARM_HWCAP_ARM_JAVA = 1 << 8,
392 ARM_HWCAP_ARM_IWMMXT = 1 << 9,
393 ARM_HWCAP_ARM_CRUNCH = 1 << 10,
394 ARM_HWCAP_ARM_THUMBEE = 1 << 11,
395 ARM_HWCAP_ARM_NEON = 1 << 12,
396 ARM_HWCAP_ARM_VFPv3 = 1 << 13,
397 ARM_HWCAP_ARM_VFPv3D16 = 1 << 14,
398 ARM_HWCAP_ARM_TLS = 1 << 15,
399 ARM_HWCAP_ARM_VFPv4 = 1 << 16,
400 ARM_HWCAP_ARM_IDIVA = 1 << 17,
401 ARM_HWCAP_ARM_IDIVT = 1 << 18,
402 ARM_HWCAP_ARM_VFPD32 = 1 << 19,
403 ARM_HWCAP_ARM_LPAE = 1 << 20,
404 ARM_HWCAP_ARM_EVTSTRM = 1 << 21,
405 ARM_HWCAP_ARM_FPHP = 1 << 22,
406 ARM_HWCAP_ARM_ASIMDHP = 1 << 23,
407 ARM_HWCAP_ARM_ASIMDDP = 1 << 24,
408 ARM_HWCAP_ARM_ASIMDFHM = 1 << 25,
409 ARM_HWCAP_ARM_ASIMDBF16 = 1 << 26,
410 ARM_HWCAP_ARM_I8MM = 1 << 27,
411 };
412
413 enum {
414 ARM_HWCAP2_ARM_AES = 1 << 0,
415 ARM_HWCAP2_ARM_PMULL = 1 << 1,
416 ARM_HWCAP2_ARM_SHA1 = 1 << 2,
417 ARM_HWCAP2_ARM_SHA2 = 1 << 3,
418 ARM_HWCAP2_ARM_CRC32 = 1 << 4,
419 ARM_HWCAP2_ARM_SB = 1 << 5,
420 ARM_HWCAP2_ARM_SSBS = 1 << 6,
421 };
422
423 /* The commpage only exists for 32 bit kernels */
424
425 #define HI_COMMPAGE (intptr_t)0xffff0f00u
426
427 static bool init_guest_commpage(void)
428 {
429 ARMCPU *cpu = ARM_CPU(thread_cpu);
430 abi_ptr commpage;
431 void *want;
432 void *addr;
433
434 /*
435 * M-profile allocates maximum of 2GB address space, so can never
436 * allocate the commpage. Skip it.
437 */
438 if (arm_feature(&cpu->env, ARM_FEATURE_M)) {
439 return true;
440 }
441
442 commpage = HI_COMMPAGE & -qemu_host_page_size;
443 want = g2h_untagged(commpage);
444 addr = mmap(want, qemu_host_page_size, PROT_READ | PROT_WRITE,
445 MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
446
447 if (addr == MAP_FAILED) {
448 perror("Allocating guest commpage");
449 exit(EXIT_FAILURE);
450 }
451 if (addr != want) {
452 return false;
453 }
454
455 /* Set kernel helper versions; rest of page is 0. */
456 __put_user(5, (uint32_t *)g2h_untagged(0xffff0ffcu));
457
458 if (mprotect(addr, qemu_host_page_size, PROT_READ)) {
459 perror("Protecting guest commpage");
460 exit(EXIT_FAILURE);
461 }
462
463 page_set_flags(commpage, commpage | ~qemu_host_page_mask,
464 PAGE_READ | PAGE_EXEC | PAGE_VALID);
465 return true;
466 }
467
468 #define ELF_HWCAP get_elf_hwcap()
469 #define ELF_HWCAP2 get_elf_hwcap2()
470
471 uint32_t get_elf_hwcap(void)
472 {
473 ARMCPU *cpu = ARM_CPU(thread_cpu);
474 uint32_t hwcaps = 0;
475
476 hwcaps |= ARM_HWCAP_ARM_SWP;
477 hwcaps |= ARM_HWCAP_ARM_HALF;
478 hwcaps |= ARM_HWCAP_ARM_THUMB;
479 hwcaps |= ARM_HWCAP_ARM_FAST_MULT;
480
481 /* probe for the extra features */
482 #define GET_FEATURE(feat, hwcap) \
483 do { if (arm_feature(&cpu->env, feat)) { hwcaps |= hwcap; } } while (0)
484
485 #define GET_FEATURE_ID(feat, hwcap) \
486 do { if (cpu_isar_feature(feat, cpu)) { hwcaps |= hwcap; } } while (0)
487
488 /* EDSP is in v5TE and above, but all our v5 CPUs are v5TE */
489 GET_FEATURE(ARM_FEATURE_V5, ARM_HWCAP_ARM_EDSP);
490 GET_FEATURE(ARM_FEATURE_IWMMXT, ARM_HWCAP_ARM_IWMMXT);
491 GET_FEATURE(ARM_FEATURE_THUMB2EE, ARM_HWCAP_ARM_THUMBEE);
492 GET_FEATURE(ARM_FEATURE_NEON, ARM_HWCAP_ARM_NEON);
493 GET_FEATURE(ARM_FEATURE_V6K, ARM_HWCAP_ARM_TLS);
494 GET_FEATURE(ARM_FEATURE_LPAE, ARM_HWCAP_ARM_LPAE);
495 GET_FEATURE_ID(aa32_arm_div, ARM_HWCAP_ARM_IDIVA);
496 GET_FEATURE_ID(aa32_thumb_div, ARM_HWCAP_ARM_IDIVT);
497 GET_FEATURE_ID(aa32_vfp, ARM_HWCAP_ARM_VFP);
498
499 if (cpu_isar_feature(aa32_fpsp_v3, cpu) ||
500 cpu_isar_feature(aa32_fpdp_v3, cpu)) {
501 hwcaps |= ARM_HWCAP_ARM_VFPv3;
502 if (cpu_isar_feature(aa32_simd_r32, cpu)) {
503 hwcaps |= ARM_HWCAP_ARM_VFPD32;
504 } else {
505 hwcaps |= ARM_HWCAP_ARM_VFPv3D16;
506 }
507 }
508 GET_FEATURE_ID(aa32_simdfmac, ARM_HWCAP_ARM_VFPv4);
509 /*
510 * MVFR1.FPHP and .SIMDHP must be in sync, and QEMU uses the same
511 * isar_feature function for both. The kernel reports them as two hwcaps.
512 */
513 GET_FEATURE_ID(aa32_fp16_arith, ARM_HWCAP_ARM_FPHP);
514 GET_FEATURE_ID(aa32_fp16_arith, ARM_HWCAP_ARM_ASIMDHP);
515 GET_FEATURE_ID(aa32_dp, ARM_HWCAP_ARM_ASIMDDP);
516 GET_FEATURE_ID(aa32_fhm, ARM_HWCAP_ARM_ASIMDFHM);
517 GET_FEATURE_ID(aa32_bf16, ARM_HWCAP_ARM_ASIMDBF16);
518 GET_FEATURE_ID(aa32_i8mm, ARM_HWCAP_ARM_I8MM);
519
520 return hwcaps;
521 }
522
523 uint32_t get_elf_hwcap2(void)
524 {
525 ARMCPU *cpu = ARM_CPU(thread_cpu);
526 uint32_t hwcaps = 0;
527
528 GET_FEATURE_ID(aa32_aes, ARM_HWCAP2_ARM_AES);
529 GET_FEATURE_ID(aa32_pmull, ARM_HWCAP2_ARM_PMULL);
530 GET_FEATURE_ID(aa32_sha1, ARM_HWCAP2_ARM_SHA1);
531 GET_FEATURE_ID(aa32_sha2, ARM_HWCAP2_ARM_SHA2);
532 GET_FEATURE_ID(aa32_crc32, ARM_HWCAP2_ARM_CRC32);
533 GET_FEATURE_ID(aa32_sb, ARM_HWCAP2_ARM_SB);
534 GET_FEATURE_ID(aa32_ssbs, ARM_HWCAP2_ARM_SSBS);
535 return hwcaps;
536 }
537
538 const char *elf_hwcap_str(uint32_t bit)
539 {
540 static const char *hwcap_str[] = {
541 [__builtin_ctz(ARM_HWCAP_ARM_SWP )] = "swp",
542 [__builtin_ctz(ARM_HWCAP_ARM_HALF )] = "half",
543 [__builtin_ctz(ARM_HWCAP_ARM_THUMB )] = "thumb",
544 [__builtin_ctz(ARM_HWCAP_ARM_26BIT )] = "26bit",
545 [__builtin_ctz(ARM_HWCAP_ARM_FAST_MULT)] = "fast_mult",
546 [__builtin_ctz(ARM_HWCAP_ARM_FPA )] = "fpa",
547 [__builtin_ctz(ARM_HWCAP_ARM_VFP )] = "vfp",
548 [__builtin_ctz(ARM_HWCAP_ARM_EDSP )] = "edsp",
549 [__builtin_ctz(ARM_HWCAP_ARM_JAVA )] = "java",
550 [__builtin_ctz(ARM_HWCAP_ARM_IWMMXT )] = "iwmmxt",
551 [__builtin_ctz(ARM_HWCAP_ARM_CRUNCH )] = "crunch",
552 [__builtin_ctz(ARM_HWCAP_ARM_THUMBEE )] = "thumbee",
553 [__builtin_ctz(ARM_HWCAP_ARM_NEON )] = "neon",
554 [__builtin_ctz(ARM_HWCAP_ARM_VFPv3 )] = "vfpv3",
555 [__builtin_ctz(ARM_HWCAP_ARM_VFPv3D16 )] = "vfpv3d16",
556 [__builtin_ctz(ARM_HWCAP_ARM_TLS )] = "tls",
557 [__builtin_ctz(ARM_HWCAP_ARM_VFPv4 )] = "vfpv4",
558 [__builtin_ctz(ARM_HWCAP_ARM_IDIVA )] = "idiva",
559 [__builtin_ctz(ARM_HWCAP_ARM_IDIVT )] = "idivt",
560 [__builtin_ctz(ARM_HWCAP_ARM_VFPD32 )] = "vfpd32",
561 [__builtin_ctz(ARM_HWCAP_ARM_LPAE )] = "lpae",
562 [__builtin_ctz(ARM_HWCAP_ARM_EVTSTRM )] = "evtstrm",
563 [__builtin_ctz(ARM_HWCAP_ARM_FPHP )] = "fphp",
564 [__builtin_ctz(ARM_HWCAP_ARM_ASIMDHP )] = "asimdhp",
565 [__builtin_ctz(ARM_HWCAP_ARM_ASIMDDP )] = "asimddp",
566 [__builtin_ctz(ARM_HWCAP_ARM_ASIMDFHM )] = "asimdfhm",
567 [__builtin_ctz(ARM_HWCAP_ARM_ASIMDBF16)] = "asimdbf16",
568 [__builtin_ctz(ARM_HWCAP_ARM_I8MM )] = "i8mm",
569 };
570
571 return bit < ARRAY_SIZE(hwcap_str) ? hwcap_str[bit] : NULL;
572 }
573
574 const char *elf_hwcap2_str(uint32_t bit)
575 {
576 static const char *hwcap_str[] = {
577 [__builtin_ctz(ARM_HWCAP2_ARM_AES )] = "aes",
578 [__builtin_ctz(ARM_HWCAP2_ARM_PMULL)] = "pmull",
579 [__builtin_ctz(ARM_HWCAP2_ARM_SHA1 )] = "sha1",
580 [__builtin_ctz(ARM_HWCAP2_ARM_SHA2 )] = "sha2",
581 [__builtin_ctz(ARM_HWCAP2_ARM_CRC32)] = "crc32",
582 [__builtin_ctz(ARM_HWCAP2_ARM_SB )] = "sb",
583 [__builtin_ctz(ARM_HWCAP2_ARM_SSBS )] = "ssbs",
584 };
585
586 return bit < ARRAY_SIZE(hwcap_str) ? hwcap_str[bit] : NULL;
587 }
588
589 #undef GET_FEATURE
590 #undef GET_FEATURE_ID
591
592 #define ELF_PLATFORM get_elf_platform()
593
594 static const char *get_elf_platform(void)
595 {
596 CPUARMState *env = cpu_env(thread_cpu);
597
598 #if TARGET_BIG_ENDIAN
599 # define END "b"
600 #else
601 # define END "l"
602 #endif
603
604 if (arm_feature(env, ARM_FEATURE_V8)) {
605 return "v8" END;
606 } else if (arm_feature(env, ARM_FEATURE_V7)) {
607 if (arm_feature(env, ARM_FEATURE_M)) {
608 return "v7m" END;
609 } else {
610 return "v7" END;
611 }
612 } else if (arm_feature(env, ARM_FEATURE_V6)) {
613 return "v6" END;
614 } else if (arm_feature(env, ARM_FEATURE_V5)) {
615 return "v5" END;
616 } else {
617 return "v4" END;
618 }
619
620 #undef END
621 }
622
623 #else
624 /* 64 bit ARM definitions */
625
626 #define ELF_ARCH EM_AARCH64
627 #define ELF_CLASS ELFCLASS64
628 #if TARGET_BIG_ENDIAN
629 # define ELF_PLATFORM "aarch64_be"
630 #else
631 # define ELF_PLATFORM "aarch64"
632 #endif
633
634 static inline void init_thread(struct target_pt_regs *regs,
635 struct image_info *infop)
636 {
637 abi_long stack = infop->start_stack;
638 memset(regs, 0, sizeof(*regs));
639
640 regs->pc = infop->entry & ~0x3ULL;
641 regs->sp = stack;
642 }
643
644 #define ELF_NREG 34
645 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
646
647 static void elf_core_copy_regs(target_elf_gregset_t *regs,
648 const CPUARMState *env)
649 {
650 int i;
651
652 for (i = 0; i < 32; i++) {
653 (*regs)[i] = tswapreg(env->xregs[i]);
654 }
655 (*regs)[32] = tswapreg(env->pc);
656 (*regs)[33] = tswapreg(pstate_read((CPUARMState *)env));
657 }
658
659 #define USE_ELF_CORE_DUMP
660 #define ELF_EXEC_PAGESIZE 4096
661
662 enum {
663 ARM_HWCAP_A64_FP = 1 << 0,
664 ARM_HWCAP_A64_ASIMD = 1 << 1,
665 ARM_HWCAP_A64_EVTSTRM = 1 << 2,
666 ARM_HWCAP_A64_AES = 1 << 3,
667 ARM_HWCAP_A64_PMULL = 1 << 4,
668 ARM_HWCAP_A64_SHA1 = 1 << 5,
669 ARM_HWCAP_A64_SHA2 = 1 << 6,
670 ARM_HWCAP_A64_CRC32 = 1 << 7,
671 ARM_HWCAP_A64_ATOMICS = 1 << 8,
672 ARM_HWCAP_A64_FPHP = 1 << 9,
673 ARM_HWCAP_A64_ASIMDHP = 1 << 10,
674 ARM_HWCAP_A64_CPUID = 1 << 11,
675 ARM_HWCAP_A64_ASIMDRDM = 1 << 12,
676 ARM_HWCAP_A64_JSCVT = 1 << 13,
677 ARM_HWCAP_A64_FCMA = 1 << 14,
678 ARM_HWCAP_A64_LRCPC = 1 << 15,
679 ARM_HWCAP_A64_DCPOP = 1 << 16,
680 ARM_HWCAP_A64_SHA3 = 1 << 17,
681 ARM_HWCAP_A64_SM3 = 1 << 18,
682 ARM_HWCAP_A64_SM4 = 1 << 19,
683 ARM_HWCAP_A64_ASIMDDP = 1 << 20,
684 ARM_HWCAP_A64_SHA512 = 1 << 21,
685 ARM_HWCAP_A64_SVE = 1 << 22,
686 ARM_HWCAP_A64_ASIMDFHM = 1 << 23,
687 ARM_HWCAP_A64_DIT = 1 << 24,
688 ARM_HWCAP_A64_USCAT = 1 << 25,
689 ARM_HWCAP_A64_ILRCPC = 1 << 26,
690 ARM_HWCAP_A64_FLAGM = 1 << 27,
691 ARM_HWCAP_A64_SSBS = 1 << 28,
692 ARM_HWCAP_A64_SB = 1 << 29,
693 ARM_HWCAP_A64_PACA = 1 << 30,
694 ARM_HWCAP_A64_PACG = 1UL << 31,
695
696 ARM_HWCAP2_A64_DCPODP = 1 << 0,
697 ARM_HWCAP2_A64_SVE2 = 1 << 1,
698 ARM_HWCAP2_A64_SVEAES = 1 << 2,
699 ARM_HWCAP2_A64_SVEPMULL = 1 << 3,
700 ARM_HWCAP2_A64_SVEBITPERM = 1 << 4,
701 ARM_HWCAP2_A64_SVESHA3 = 1 << 5,
702 ARM_HWCAP2_A64_SVESM4 = 1 << 6,
703 ARM_HWCAP2_A64_FLAGM2 = 1 << 7,
704 ARM_HWCAP2_A64_FRINT = 1 << 8,
705 ARM_HWCAP2_A64_SVEI8MM = 1 << 9,
706 ARM_HWCAP2_A64_SVEF32MM = 1 << 10,
707 ARM_HWCAP2_A64_SVEF64MM = 1 << 11,
708 ARM_HWCAP2_A64_SVEBF16 = 1 << 12,
709 ARM_HWCAP2_A64_I8MM = 1 << 13,
710 ARM_HWCAP2_A64_BF16 = 1 << 14,
711 ARM_HWCAP2_A64_DGH = 1 << 15,
712 ARM_HWCAP2_A64_RNG = 1 << 16,
713 ARM_HWCAP2_A64_BTI = 1 << 17,
714 ARM_HWCAP2_A64_MTE = 1 << 18,
715 ARM_HWCAP2_A64_ECV = 1 << 19,
716 ARM_HWCAP2_A64_AFP = 1 << 20,
717 ARM_HWCAP2_A64_RPRES = 1 << 21,
718 ARM_HWCAP2_A64_MTE3 = 1 << 22,
719 ARM_HWCAP2_A64_SME = 1 << 23,
720 ARM_HWCAP2_A64_SME_I16I64 = 1 << 24,
721 ARM_HWCAP2_A64_SME_F64F64 = 1 << 25,
722 ARM_HWCAP2_A64_SME_I8I32 = 1 << 26,
723 ARM_HWCAP2_A64_SME_F16F32 = 1 << 27,
724 ARM_HWCAP2_A64_SME_B16F32 = 1 << 28,
725 ARM_HWCAP2_A64_SME_F32F32 = 1 << 29,
726 ARM_HWCAP2_A64_SME_FA64 = 1 << 30,
727 ARM_HWCAP2_A64_WFXT = 1ULL << 31,
728 ARM_HWCAP2_A64_EBF16 = 1ULL << 32,
729 ARM_HWCAP2_A64_SVE_EBF16 = 1ULL << 33,
730 ARM_HWCAP2_A64_CSSC = 1ULL << 34,
731 ARM_HWCAP2_A64_RPRFM = 1ULL << 35,
732 ARM_HWCAP2_A64_SVE2P1 = 1ULL << 36,
733 ARM_HWCAP2_A64_SME2 = 1ULL << 37,
734 ARM_HWCAP2_A64_SME2P1 = 1ULL << 38,
735 ARM_HWCAP2_A64_SME_I16I32 = 1ULL << 39,
736 ARM_HWCAP2_A64_SME_BI32I32 = 1ULL << 40,
737 ARM_HWCAP2_A64_SME_B16B16 = 1ULL << 41,
738 ARM_HWCAP2_A64_SME_F16F16 = 1ULL << 42,
739 ARM_HWCAP2_A64_MOPS = 1ULL << 43,
740 ARM_HWCAP2_A64_HBC = 1ULL << 44,
741 };
742
743 #define ELF_HWCAP get_elf_hwcap()
744 #define ELF_HWCAP2 get_elf_hwcap2()
745
746 #define GET_FEATURE_ID(feat, hwcap) \
747 do { if (cpu_isar_feature(feat, cpu)) { hwcaps |= hwcap; } } while (0)
748
749 uint32_t get_elf_hwcap(void)
750 {
751 ARMCPU *cpu = ARM_CPU(thread_cpu);
752 uint32_t hwcaps = 0;
753
754 hwcaps |= ARM_HWCAP_A64_FP;
755 hwcaps |= ARM_HWCAP_A64_ASIMD;
756 hwcaps |= ARM_HWCAP_A64_CPUID;
757
758 /* probe for the extra features */
759
760 GET_FEATURE_ID(aa64_aes, ARM_HWCAP_A64_AES);
761 GET_FEATURE_ID(aa64_pmull, ARM_HWCAP_A64_PMULL);
762 GET_FEATURE_ID(aa64_sha1, ARM_HWCAP_A64_SHA1);
763 GET_FEATURE_ID(aa64_sha256, ARM_HWCAP_A64_SHA2);
764 GET_FEATURE_ID(aa64_sha512, ARM_HWCAP_A64_SHA512);
765 GET_FEATURE_ID(aa64_crc32, ARM_HWCAP_A64_CRC32);
766 GET_FEATURE_ID(aa64_sha3, ARM_HWCAP_A64_SHA3);
767 GET_FEATURE_ID(aa64_sm3, ARM_HWCAP_A64_SM3);
768 GET_FEATURE_ID(aa64_sm4, ARM_HWCAP_A64_SM4);
769 GET_FEATURE_ID(aa64_fp16, ARM_HWCAP_A64_FPHP | ARM_HWCAP_A64_ASIMDHP);
770 GET_FEATURE_ID(aa64_atomics, ARM_HWCAP_A64_ATOMICS);
771 GET_FEATURE_ID(aa64_rdm, ARM_HWCAP_A64_ASIMDRDM);
772 GET_FEATURE_ID(aa64_dp, ARM_HWCAP_A64_ASIMDDP);
773 GET_FEATURE_ID(aa64_fcma, ARM_HWCAP_A64_FCMA);
774 GET_FEATURE_ID(aa64_sve, ARM_HWCAP_A64_SVE);
775 GET_FEATURE_ID(aa64_pauth, ARM_HWCAP_A64_PACA | ARM_HWCAP_A64_PACG);
776 GET_FEATURE_ID(aa64_fhm, ARM_HWCAP_A64_ASIMDFHM);
777 GET_FEATURE_ID(aa64_jscvt, ARM_HWCAP_A64_JSCVT);
778 GET_FEATURE_ID(aa64_sb, ARM_HWCAP_A64_SB);
779 GET_FEATURE_ID(aa64_condm_4, ARM_HWCAP_A64_FLAGM);
780 GET_FEATURE_ID(aa64_dcpop, ARM_HWCAP_A64_DCPOP);
781 GET_FEATURE_ID(aa64_rcpc_8_3, ARM_HWCAP_A64_LRCPC);
782 GET_FEATURE_ID(aa64_rcpc_8_4, ARM_HWCAP_A64_ILRCPC);
783
784 return hwcaps;
785 }
786
787 uint32_t get_elf_hwcap2(void)
788 {
789 ARMCPU *cpu = ARM_CPU(thread_cpu);
790 uint32_t hwcaps = 0;
791
792 GET_FEATURE_ID(aa64_dcpodp, ARM_HWCAP2_A64_DCPODP);
793 GET_FEATURE_ID(aa64_sve2, ARM_HWCAP2_A64_SVE2);
794 GET_FEATURE_ID(aa64_sve2_aes, ARM_HWCAP2_A64_SVEAES);
795 GET_FEATURE_ID(aa64_sve2_pmull128, ARM_HWCAP2_A64_SVEPMULL);
796 GET_FEATURE_ID(aa64_sve2_bitperm, ARM_HWCAP2_A64_SVEBITPERM);
797 GET_FEATURE_ID(aa64_sve2_sha3, ARM_HWCAP2_A64_SVESHA3);
798 GET_FEATURE_ID(aa64_sve2_sm4, ARM_HWCAP2_A64_SVESM4);
799 GET_FEATURE_ID(aa64_condm_5, ARM_HWCAP2_A64_FLAGM2);
800 GET_FEATURE_ID(aa64_frint, ARM_HWCAP2_A64_FRINT);
801 GET_FEATURE_ID(aa64_sve_i8mm, ARM_HWCAP2_A64_SVEI8MM);
802 GET_FEATURE_ID(aa64_sve_f32mm, ARM_HWCAP2_A64_SVEF32MM);
803 GET_FEATURE_ID(aa64_sve_f64mm, ARM_HWCAP2_A64_SVEF64MM);
804 GET_FEATURE_ID(aa64_sve_bf16, ARM_HWCAP2_A64_SVEBF16);
805 GET_FEATURE_ID(aa64_i8mm, ARM_HWCAP2_A64_I8MM);
806 GET_FEATURE_ID(aa64_bf16, ARM_HWCAP2_A64_BF16);
807 GET_FEATURE_ID(aa64_rndr, ARM_HWCAP2_A64_RNG);
808 GET_FEATURE_ID(aa64_bti, ARM_HWCAP2_A64_BTI);
809 GET_FEATURE_ID(aa64_mte, ARM_HWCAP2_A64_MTE);
810 GET_FEATURE_ID(aa64_sme, (ARM_HWCAP2_A64_SME |
811 ARM_HWCAP2_A64_SME_F32F32 |
812 ARM_HWCAP2_A64_SME_B16F32 |
813 ARM_HWCAP2_A64_SME_F16F32 |
814 ARM_HWCAP2_A64_SME_I8I32));
815 GET_FEATURE_ID(aa64_sme_f64f64, ARM_HWCAP2_A64_SME_F64F64);
816 GET_FEATURE_ID(aa64_sme_i16i64, ARM_HWCAP2_A64_SME_I16I64);
817 GET_FEATURE_ID(aa64_sme_fa64, ARM_HWCAP2_A64_SME_FA64);
818 GET_FEATURE_ID(aa64_hbc, ARM_HWCAP2_A64_HBC);
819 GET_FEATURE_ID(aa64_mops, ARM_HWCAP2_A64_MOPS);
820
821 return hwcaps;
822 }
823
824 const char *elf_hwcap_str(uint32_t bit)
825 {
826 static const char *hwcap_str[] = {
827 [__builtin_ctz(ARM_HWCAP_A64_FP )] = "fp",
828 [__builtin_ctz(ARM_HWCAP_A64_ASIMD )] = "asimd",
829 [__builtin_ctz(ARM_HWCAP_A64_EVTSTRM )] = "evtstrm",
830 [__builtin_ctz(ARM_HWCAP_A64_AES )] = "aes",
831 [__builtin_ctz(ARM_HWCAP_A64_PMULL )] = "pmull",
832 [__builtin_ctz(ARM_HWCAP_A64_SHA1 )] = "sha1",
833 [__builtin_ctz(ARM_HWCAP_A64_SHA2 )] = "sha2",
834 [__builtin_ctz(ARM_HWCAP_A64_CRC32 )] = "crc32",
835 [__builtin_ctz(ARM_HWCAP_A64_ATOMICS )] = "atomics",
836 [__builtin_ctz(ARM_HWCAP_A64_FPHP )] = "fphp",
837 [__builtin_ctz(ARM_HWCAP_A64_ASIMDHP )] = "asimdhp",
838 [__builtin_ctz(ARM_HWCAP_A64_CPUID )] = "cpuid",
839 [__builtin_ctz(ARM_HWCAP_A64_ASIMDRDM)] = "asimdrdm",
840 [__builtin_ctz(ARM_HWCAP_A64_JSCVT )] = "jscvt",
841 [__builtin_ctz(ARM_HWCAP_A64_FCMA )] = "fcma",
842 [__builtin_ctz(ARM_HWCAP_A64_LRCPC )] = "lrcpc",
843 [__builtin_ctz(ARM_HWCAP_A64_DCPOP )] = "dcpop",
844 [__builtin_ctz(ARM_HWCAP_A64_SHA3 )] = "sha3",
845 [__builtin_ctz(ARM_HWCAP_A64_SM3 )] = "sm3",
846 [__builtin_ctz(ARM_HWCAP_A64_SM4 )] = "sm4",
847 [__builtin_ctz(ARM_HWCAP_A64_ASIMDDP )] = "asimddp",
848 [__builtin_ctz(ARM_HWCAP_A64_SHA512 )] = "sha512",
849 [__builtin_ctz(ARM_HWCAP_A64_SVE )] = "sve",
850 [__builtin_ctz(ARM_HWCAP_A64_ASIMDFHM)] = "asimdfhm",
851 [__builtin_ctz(ARM_HWCAP_A64_DIT )] = "dit",
852 [__builtin_ctz(ARM_HWCAP_A64_USCAT )] = "uscat",
853 [__builtin_ctz(ARM_HWCAP_A64_ILRCPC )] = "ilrcpc",
854 [__builtin_ctz(ARM_HWCAP_A64_FLAGM )] = "flagm",
855 [__builtin_ctz(ARM_HWCAP_A64_SSBS )] = "ssbs",
856 [__builtin_ctz(ARM_HWCAP_A64_SB )] = "sb",
857 [__builtin_ctz(ARM_HWCAP_A64_PACA )] = "paca",
858 [__builtin_ctz(ARM_HWCAP_A64_PACG )] = "pacg",
859 };
860
861 return bit < ARRAY_SIZE(hwcap_str) ? hwcap_str[bit] : NULL;
862 }
863
864 const char *elf_hwcap2_str(uint32_t bit)
865 {
866 static const char *hwcap_str[] = {
867 [__builtin_ctz(ARM_HWCAP2_A64_DCPODP )] = "dcpodp",
868 [__builtin_ctz(ARM_HWCAP2_A64_SVE2 )] = "sve2",
869 [__builtin_ctz(ARM_HWCAP2_A64_SVEAES )] = "sveaes",
870 [__builtin_ctz(ARM_HWCAP2_A64_SVEPMULL )] = "svepmull",
871 [__builtin_ctz(ARM_HWCAP2_A64_SVEBITPERM )] = "svebitperm",
872 [__builtin_ctz(ARM_HWCAP2_A64_SVESHA3 )] = "svesha3",
873 [__builtin_ctz(ARM_HWCAP2_A64_SVESM4 )] = "svesm4",
874 [__builtin_ctz(ARM_HWCAP2_A64_FLAGM2 )] = "flagm2",
875 [__builtin_ctz(ARM_HWCAP2_A64_FRINT )] = "frint",
876 [__builtin_ctz(ARM_HWCAP2_A64_SVEI8MM )] = "svei8mm",
877 [__builtin_ctz(ARM_HWCAP2_A64_SVEF32MM )] = "svef32mm",
878 [__builtin_ctz(ARM_HWCAP2_A64_SVEF64MM )] = "svef64mm",
879 [__builtin_ctz(ARM_HWCAP2_A64_SVEBF16 )] = "svebf16",
880 [__builtin_ctz(ARM_HWCAP2_A64_I8MM )] = "i8mm",
881 [__builtin_ctz(ARM_HWCAP2_A64_BF16 )] = "bf16",
882 [__builtin_ctz(ARM_HWCAP2_A64_DGH )] = "dgh",
883 [__builtin_ctz(ARM_HWCAP2_A64_RNG )] = "rng",
884 [__builtin_ctz(ARM_HWCAP2_A64_BTI )] = "bti",
885 [__builtin_ctz(ARM_HWCAP2_A64_MTE )] = "mte",
886 [__builtin_ctz(ARM_HWCAP2_A64_ECV )] = "ecv",
887 [__builtin_ctz(ARM_HWCAP2_A64_AFP )] = "afp",
888 [__builtin_ctz(ARM_HWCAP2_A64_RPRES )] = "rpres",
889 [__builtin_ctz(ARM_HWCAP2_A64_MTE3 )] = "mte3",
890 [__builtin_ctz(ARM_HWCAP2_A64_SME )] = "sme",
891 [__builtin_ctz(ARM_HWCAP2_A64_SME_I16I64 )] = "smei16i64",
892 [__builtin_ctz(ARM_HWCAP2_A64_SME_F64F64 )] = "smef64f64",
893 [__builtin_ctz(ARM_HWCAP2_A64_SME_I8I32 )] = "smei8i32",
894 [__builtin_ctz(ARM_HWCAP2_A64_SME_F16F32 )] = "smef16f32",
895 [__builtin_ctz(ARM_HWCAP2_A64_SME_B16F32 )] = "smeb16f32",
896 [__builtin_ctz(ARM_HWCAP2_A64_SME_F32F32 )] = "smef32f32",
897 [__builtin_ctz(ARM_HWCAP2_A64_SME_FA64 )] = "smefa64",
898 [__builtin_ctz(ARM_HWCAP2_A64_WFXT )] = "wfxt",
899 [__builtin_ctzll(ARM_HWCAP2_A64_EBF16 )] = "ebf16",
900 [__builtin_ctzll(ARM_HWCAP2_A64_SVE_EBF16 )] = "sveebf16",
901 [__builtin_ctzll(ARM_HWCAP2_A64_CSSC )] = "cssc",
902 [__builtin_ctzll(ARM_HWCAP2_A64_RPRFM )] = "rprfm",
903 [__builtin_ctzll(ARM_HWCAP2_A64_SVE2P1 )] = "sve2p1",
904 [__builtin_ctzll(ARM_HWCAP2_A64_SME2 )] = "sme2",
905 [__builtin_ctzll(ARM_HWCAP2_A64_SME2P1 )] = "sme2p1",
906 [__builtin_ctzll(ARM_HWCAP2_A64_SME_I16I32 )] = "smei16i32",
907 [__builtin_ctzll(ARM_HWCAP2_A64_SME_BI32I32)] = "smebi32i32",
908 [__builtin_ctzll(ARM_HWCAP2_A64_SME_B16B16 )] = "smeb16b16",
909 [__builtin_ctzll(ARM_HWCAP2_A64_SME_F16F16 )] = "smef16f16",
910 [__builtin_ctzll(ARM_HWCAP2_A64_MOPS )] = "mops",
911 [__builtin_ctzll(ARM_HWCAP2_A64_HBC )] = "hbc",
912 };
913
914 return bit < ARRAY_SIZE(hwcap_str) ? hwcap_str[bit] : NULL;
915 }
916
917 #undef GET_FEATURE_ID
918
919 #endif /* not TARGET_AARCH64 */
920 #endif /* TARGET_ARM */
921
922 #ifdef TARGET_SPARC
923 #ifdef TARGET_SPARC64
924
925 #define ELF_HWCAP (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
926 | HWCAP_SPARC_MULDIV | HWCAP_SPARC_V9)
927 #ifndef TARGET_ABI32
928 #define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS )
929 #else
930 #define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC )
931 #endif
932
933 #define ELF_CLASS ELFCLASS64
934 #define ELF_ARCH EM_SPARCV9
935 #else
936 #define ELF_HWCAP (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
937 | HWCAP_SPARC_MULDIV)
938 #define ELF_CLASS ELFCLASS32
939 #define ELF_ARCH EM_SPARC
940 #endif /* TARGET_SPARC64 */
941
942 static inline void init_thread(struct target_pt_regs *regs,
943 struct image_info *infop)
944 {
945 /* Note that target_cpu_copy_regs does not read psr/tstate. */
946 regs->pc = infop->entry;
947 regs->npc = regs->pc + 4;
948 regs->y = 0;
949 regs->u_regs[14] = (infop->start_stack - 16 * sizeof(abi_ulong)
950 - TARGET_STACK_BIAS);
951 }
952 #endif /* TARGET_SPARC */
953
954 #ifdef TARGET_PPC
955
956 #define ELF_MACHINE PPC_ELF_MACHINE
957
958 #if defined(TARGET_PPC64)
959
960 #define elf_check_arch(x) ( (x) == EM_PPC64 )
961
962 #define ELF_CLASS ELFCLASS64
963
964 #else
965
966 #define ELF_CLASS ELFCLASS32
967 #define EXSTACK_DEFAULT true
968
969 #endif
970
971 #define ELF_ARCH EM_PPC
972
973 /* Feature masks for the Aux Vector Hardware Capabilities (AT_HWCAP).
974 See arch/powerpc/include/asm/cputable.h. */
975 enum {
976 QEMU_PPC_FEATURE_32 = 0x80000000,
977 QEMU_PPC_FEATURE_64 = 0x40000000,
978 QEMU_PPC_FEATURE_601_INSTR = 0x20000000,
979 QEMU_PPC_FEATURE_HAS_ALTIVEC = 0x10000000,
980 QEMU_PPC_FEATURE_HAS_FPU = 0x08000000,
981 QEMU_PPC_FEATURE_HAS_MMU = 0x04000000,
982 QEMU_PPC_FEATURE_HAS_4xxMAC = 0x02000000,
983 QEMU_PPC_FEATURE_UNIFIED_CACHE = 0x01000000,
984 QEMU_PPC_FEATURE_HAS_SPE = 0x00800000,
985 QEMU_PPC_FEATURE_HAS_EFP_SINGLE = 0x00400000,
986 QEMU_PPC_FEATURE_HAS_EFP_DOUBLE = 0x00200000,
987 QEMU_PPC_FEATURE_NO_TB = 0x00100000,
988 QEMU_PPC_FEATURE_POWER4 = 0x00080000,
989 QEMU_PPC_FEATURE_POWER5 = 0x00040000,
990 QEMU_PPC_FEATURE_POWER5_PLUS = 0x00020000,
991 QEMU_PPC_FEATURE_CELL = 0x00010000,
992 QEMU_PPC_FEATURE_BOOKE = 0x00008000,
993 QEMU_PPC_FEATURE_SMT = 0x00004000,
994 QEMU_PPC_FEATURE_ICACHE_SNOOP = 0x00002000,
995 QEMU_PPC_FEATURE_ARCH_2_05 = 0x00001000,
996 QEMU_PPC_FEATURE_PA6T = 0x00000800,
997 QEMU_PPC_FEATURE_HAS_DFP = 0x00000400,
998 QEMU_PPC_FEATURE_POWER6_EXT = 0x00000200,
999 QEMU_PPC_FEATURE_ARCH_2_06 = 0x00000100,
1000 QEMU_PPC_FEATURE_HAS_VSX = 0x00000080,
1001 QEMU_PPC_FEATURE_PSERIES_PERFMON_COMPAT = 0x00000040,
1002
1003 QEMU_PPC_FEATURE_TRUE_LE = 0x00000002,
1004 QEMU_PPC_FEATURE_PPC_LE = 0x00000001,
1005
1006 /* Feature definitions in AT_HWCAP2. */
1007 QEMU_PPC_FEATURE2_ARCH_2_07 = 0x80000000, /* ISA 2.07 */
1008 QEMU_PPC_FEATURE2_HAS_HTM = 0x40000000, /* Hardware Transactional Memory */
1009 QEMU_PPC_FEATURE2_HAS_DSCR = 0x20000000, /* Data Stream Control Register */
1010 QEMU_PPC_FEATURE2_HAS_EBB = 0x10000000, /* Event Base Branching */
1011 QEMU_PPC_FEATURE2_HAS_ISEL = 0x08000000, /* Integer Select */
1012 QEMU_PPC_FEATURE2_HAS_TAR = 0x04000000, /* Target Address Register */
1013 QEMU_PPC_FEATURE2_VEC_CRYPTO = 0x02000000,
1014 QEMU_PPC_FEATURE2_HTM_NOSC = 0x01000000,
1015 QEMU_PPC_FEATURE2_ARCH_3_00 = 0x00800000, /* ISA 3.00 */
1016 QEMU_PPC_FEATURE2_HAS_IEEE128 = 0x00400000, /* VSX IEEE Bin Float 128-bit */
1017 QEMU_PPC_FEATURE2_DARN = 0x00200000, /* darn random number insn */
1018 QEMU_PPC_FEATURE2_SCV = 0x00100000, /* scv syscall */
1019 QEMU_PPC_FEATURE2_HTM_NO_SUSPEND = 0x00080000, /* TM w/o suspended state */
1020 QEMU_PPC_FEATURE2_ARCH_3_1 = 0x00040000, /* ISA 3.1 */
1021 QEMU_PPC_FEATURE2_MMA = 0x00020000, /* Matrix-Multiply Assist */
1022 };
1023
1024 #define ELF_HWCAP get_elf_hwcap()
1025
1026 static uint32_t get_elf_hwcap(void)
1027 {
1028 PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);
1029 uint32_t features = 0;
1030
1031 /* We don't have to be terribly complete here; the high points are
1032 Altivec/FP/SPE support. Anything else is just a bonus. */
1033 #define GET_FEATURE(flag, feature) \
1034 do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
1035 #define GET_FEATURE2(flags, feature) \
1036 do { \
1037 if ((cpu->env.insns_flags2 & flags) == flags) { \
1038 features |= feature; \
1039 } \
1040 } while (0)
1041 GET_FEATURE(PPC_64B, QEMU_PPC_FEATURE_64);
1042 GET_FEATURE(PPC_FLOAT, QEMU_PPC_FEATURE_HAS_FPU);
1043 GET_FEATURE(PPC_ALTIVEC, QEMU_PPC_FEATURE_HAS_ALTIVEC);
1044 GET_FEATURE(PPC_SPE, QEMU_PPC_FEATURE_HAS_SPE);
1045 GET_FEATURE(PPC_SPE_SINGLE, QEMU_PPC_FEATURE_HAS_EFP_SINGLE);
1046 GET_FEATURE(PPC_SPE_DOUBLE, QEMU_PPC_FEATURE_HAS_EFP_DOUBLE);
1047 GET_FEATURE(PPC_BOOKE, QEMU_PPC_FEATURE_BOOKE);
1048 GET_FEATURE(PPC_405_MAC, QEMU_PPC_FEATURE_HAS_4xxMAC);
1049 GET_FEATURE2(PPC2_DFP, QEMU_PPC_FEATURE_HAS_DFP);
1050 GET_FEATURE2(PPC2_VSX, QEMU_PPC_FEATURE_HAS_VSX);
1051 GET_FEATURE2((PPC2_PERM_ISA206 | PPC2_DIVE_ISA206 | PPC2_ATOMIC_ISA206 |
1052 PPC2_FP_CVT_ISA206 | PPC2_FP_TST_ISA206),
1053 QEMU_PPC_FEATURE_ARCH_2_06);
1054 #undef GET_FEATURE
1055 #undef GET_FEATURE2
1056
1057 return features;
1058 }
1059
1060 #define ELF_HWCAP2 get_elf_hwcap2()
1061
1062 static uint32_t get_elf_hwcap2(void)
1063 {
1064 PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);
1065 uint32_t features = 0;
1066
1067 #define GET_FEATURE(flag, feature) \
1068 do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
1069 #define GET_FEATURE2(flag, feature) \
1070 do { if (cpu->env.insns_flags2 & flag) { features |= feature; } } while (0)
1071
1072 GET_FEATURE(PPC_ISEL, QEMU_PPC_FEATURE2_HAS_ISEL);
1073 GET_FEATURE2(PPC2_BCTAR_ISA207, QEMU_PPC_FEATURE2_HAS_TAR);
1074 GET_FEATURE2((PPC2_BCTAR_ISA207 | PPC2_LSQ_ISA207 | PPC2_ALTIVEC_207 |
1075 PPC2_ISA207S), QEMU_PPC_FEATURE2_ARCH_2_07 |
1076 QEMU_PPC_FEATURE2_VEC_CRYPTO);
1077 GET_FEATURE2(PPC2_ISA300, QEMU_PPC_FEATURE2_ARCH_3_00 |
1078 QEMU_PPC_FEATURE2_DARN | QEMU_PPC_FEATURE2_HAS_IEEE128);
1079 GET_FEATURE2(PPC2_ISA310, QEMU_PPC_FEATURE2_ARCH_3_1 |
1080 QEMU_PPC_FEATURE2_MMA);
1081
1082 #undef GET_FEATURE
1083 #undef GET_FEATURE2
1084
1085 return features;
1086 }
1087
1088 /*
1089 * The requirements here are:
1090 * - keep the final alignment of sp (sp & 0xf)
1091 * - make sure the 32-bit value at the first 16 byte aligned position of
1092 * AUXV is greater than 16 for glibc compatibility.
1093 * AT_IGNOREPPC is used for that.
1094 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
1095 * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
1096 */
1097 #define DLINFO_ARCH_ITEMS 5
1098 #define ARCH_DLINFO \
1099 do { \
1100 PowerPCCPU *cpu = POWERPC_CPU(thread_cpu); \
1101 /* \
1102 * Handle glibc compatibility: these magic entries must \
1103 * be at the lowest addresses in the final auxv. \
1104 */ \
1105 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
1106 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
1107 NEW_AUX_ENT(AT_DCACHEBSIZE, cpu->env.dcache_line_size); \
1108 NEW_AUX_ENT(AT_ICACHEBSIZE, cpu->env.icache_line_size); \
1109 NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \
1110 } while (0)
1111
1112 static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
1113 {
1114 _regs->gpr[1] = infop->start_stack;
1115 #if defined(TARGET_PPC64)
1116 if (get_ppc64_abi(infop) < 2) {
1117 uint64_t val;
1118 get_user_u64(val, infop->entry + 8);
1119 _regs->gpr[2] = val + infop->load_bias;
1120 get_user_u64(val, infop->entry);
1121 infop->entry = val + infop->load_bias;
1122 } else {
1123 _regs->gpr[12] = infop->entry; /* r12 set to global entry address */
1124 }
1125 #endif
1126 _regs->nip = infop->entry;
1127 }
1128
1129 /* See linux kernel: arch/powerpc/include/asm/elf.h. */
1130 #define ELF_NREG 48
1131 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1132
1133 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUPPCState *env)
1134 {
1135 int i;
1136 target_ulong ccr = 0;
1137
1138 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
1139 (*regs)[i] = tswapreg(env->gpr[i]);
1140 }
1141
1142 (*regs)[32] = tswapreg(env->nip);
1143 (*regs)[33] = tswapreg(env->msr);
1144 (*regs)[35] = tswapreg(env->ctr);
1145 (*regs)[36] = tswapreg(env->lr);
1146 (*regs)[37] = tswapreg(cpu_read_xer(env));
1147
1148 ccr = ppc_get_cr(env);
1149 (*regs)[38] = tswapreg(ccr);
1150 }
1151
1152 #define USE_ELF_CORE_DUMP
1153 #define ELF_EXEC_PAGESIZE 4096
1154
1155 #endif
1156
1157 #ifdef TARGET_LOONGARCH64
1158
1159 #define ELF_CLASS ELFCLASS64
1160 #define ELF_ARCH EM_LOONGARCH
1161 #define EXSTACK_DEFAULT true
1162
1163 #define elf_check_arch(x) ((x) == EM_LOONGARCH)
1164
1165 static inline void init_thread(struct target_pt_regs *regs,
1166 struct image_info *infop)
1167 {
1168 /*Set crmd PG,DA = 1,0 */
1169 regs->csr.crmd = 2 << 3;
1170 regs->csr.era = infop->entry;
1171 regs->regs[3] = infop->start_stack;
1172 }
1173
1174 /* See linux kernel: arch/loongarch/include/asm/elf.h */
1175 #define ELF_NREG 45
1176 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1177
1178 enum {
1179 TARGET_EF_R0 = 0,
1180 TARGET_EF_CSR_ERA = TARGET_EF_R0 + 33,
1181 TARGET_EF_CSR_BADV = TARGET_EF_R0 + 34,
1182 };
1183
1184 static void elf_core_copy_regs(target_elf_gregset_t *regs,
1185 const CPULoongArchState *env)
1186 {
1187 int i;
1188
1189 (*regs)[TARGET_EF_R0] = 0;
1190
1191 for (i = 1; i < ARRAY_SIZE(env->gpr); i++) {
1192 (*regs)[TARGET_EF_R0 + i] = tswapreg(env->gpr[i]);
1193 }
1194
1195 (*regs)[TARGET_EF_CSR_ERA] = tswapreg(env->pc);
1196 (*regs)[TARGET_EF_CSR_BADV] = tswapreg(env->CSR_BADV);
1197 }
1198
1199 #define USE_ELF_CORE_DUMP
1200 #define ELF_EXEC_PAGESIZE 4096
1201
1202 #define ELF_HWCAP get_elf_hwcap()
1203
1204 /* See arch/loongarch/include/uapi/asm/hwcap.h */
1205 enum {
1206 HWCAP_LOONGARCH_CPUCFG = (1 << 0),
1207 HWCAP_LOONGARCH_LAM = (1 << 1),
1208 HWCAP_LOONGARCH_UAL = (1 << 2),
1209 HWCAP_LOONGARCH_FPU = (1 << 3),
1210 HWCAP_LOONGARCH_LSX = (1 << 4),
1211 HWCAP_LOONGARCH_LASX = (1 << 5),
1212 HWCAP_LOONGARCH_CRC32 = (1 << 6),
1213 HWCAP_LOONGARCH_COMPLEX = (1 << 7),
1214 HWCAP_LOONGARCH_CRYPTO = (1 << 8),
1215 HWCAP_LOONGARCH_LVZ = (1 << 9),
1216 HWCAP_LOONGARCH_LBT_X86 = (1 << 10),
1217 HWCAP_LOONGARCH_LBT_ARM = (1 << 11),
1218 HWCAP_LOONGARCH_LBT_MIPS = (1 << 12),
1219 };
1220
1221 static uint32_t get_elf_hwcap(void)
1222 {
1223 LoongArchCPU *cpu = LOONGARCH_CPU(thread_cpu);
1224 uint32_t hwcaps = 0;
1225
1226 hwcaps |= HWCAP_LOONGARCH_CRC32;
1227
1228 if (FIELD_EX32(cpu->env.cpucfg[1], CPUCFG1, UAL)) {
1229 hwcaps |= HWCAP_LOONGARCH_UAL;
1230 }
1231
1232 if (FIELD_EX32(cpu->env.cpucfg[2], CPUCFG2, FP)) {
1233 hwcaps |= HWCAP_LOONGARCH_FPU;
1234 }
1235
1236 if (FIELD_EX32(cpu->env.cpucfg[2], CPUCFG2, LAM)) {
1237 hwcaps |= HWCAP_LOONGARCH_LAM;
1238 }
1239
1240 if (FIELD_EX32(cpu->env.cpucfg[2], CPUCFG2, LSX)) {
1241 hwcaps |= HWCAP_LOONGARCH_LSX;
1242 }
1243
1244 if (FIELD_EX32(cpu->env.cpucfg[2], CPUCFG2, LASX)) {
1245 hwcaps |= HWCAP_LOONGARCH_LASX;
1246 }
1247
1248 return hwcaps;
1249 }
1250
1251 #define ELF_PLATFORM "loongarch"
1252
1253 #endif /* TARGET_LOONGARCH64 */
1254
1255 #ifdef TARGET_MIPS
1256
1257 #ifdef TARGET_MIPS64
1258 #define ELF_CLASS ELFCLASS64
1259 #else
1260 #define ELF_CLASS ELFCLASS32
1261 #endif
1262 #define ELF_ARCH EM_MIPS
1263 #define EXSTACK_DEFAULT true
1264
1265 #ifdef TARGET_ABI_MIPSN32
1266 #define elf_check_abi(x) ((x) & EF_MIPS_ABI2)
1267 #else
1268 #define elf_check_abi(x) (!((x) & EF_MIPS_ABI2))
1269 #endif
1270
1271 #define ELF_BASE_PLATFORM get_elf_base_platform()
1272
1273 #define MATCH_PLATFORM_INSN(_flags, _base_platform) \
1274 do { if ((cpu->env.insn_flags & (_flags)) == _flags) \
1275 { return _base_platform; } } while (0)
1276
1277 static const char *get_elf_base_platform(void)
1278 {
1279 MIPSCPU *cpu = MIPS_CPU(thread_cpu);
1280
1281 /* 64 bit ISAs goes first */
1282 MATCH_PLATFORM_INSN(CPU_MIPS64R6, "mips64r6");
1283 MATCH_PLATFORM_INSN(CPU_MIPS64R5, "mips64r5");
1284 MATCH_PLATFORM_INSN(CPU_MIPS64R2, "mips64r2");
1285 MATCH_PLATFORM_INSN(CPU_MIPS64R1, "mips64");
1286 MATCH_PLATFORM_INSN(CPU_MIPS5, "mips5");
1287 MATCH_PLATFORM_INSN(CPU_MIPS4, "mips4");
1288 MATCH_PLATFORM_INSN(CPU_MIPS3, "mips3");
1289
1290 /* 32 bit ISAs */
1291 MATCH_PLATFORM_INSN(CPU_MIPS32R6, "mips32r6");
1292 MATCH_PLATFORM_INSN(CPU_MIPS32R5, "mips32r5");
1293 MATCH_PLATFORM_INSN(CPU_MIPS32R2, "mips32r2");
1294 MATCH_PLATFORM_INSN(CPU_MIPS32R1, "mips32");
1295 MATCH_PLATFORM_INSN(CPU_MIPS2, "mips2");
1296
1297 /* Fallback */
1298 return "mips";
1299 }
1300 #undef MATCH_PLATFORM_INSN
1301
1302 static inline void init_thread(struct target_pt_regs *regs,
1303 struct image_info *infop)
1304 {
1305 regs->cp0_status = 2 << CP0St_KSU;
1306 regs->cp0_epc = infop->entry;
1307 regs->regs[29] = infop->start_stack;
1308 }
1309
1310 /* See linux kernel: arch/mips/include/asm/elf.h. */
1311 #define ELF_NREG 45
1312 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1313
1314 /* See linux kernel: arch/mips/include/asm/reg.h. */
1315 enum {
1316 #ifdef TARGET_MIPS64
1317 TARGET_EF_R0 = 0,
1318 #else
1319 TARGET_EF_R0 = 6,
1320 #endif
1321 TARGET_EF_R26 = TARGET_EF_R0 + 26,
1322 TARGET_EF_R27 = TARGET_EF_R0 + 27,
1323 TARGET_EF_LO = TARGET_EF_R0 + 32,
1324 TARGET_EF_HI = TARGET_EF_R0 + 33,
1325 TARGET_EF_CP0_EPC = TARGET_EF_R0 + 34,
1326 TARGET_EF_CP0_BADVADDR = TARGET_EF_R0 + 35,
1327 TARGET_EF_CP0_STATUS = TARGET_EF_R0 + 36,
1328 TARGET_EF_CP0_CAUSE = TARGET_EF_R0 + 37
1329 };
1330
1331 /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs. */
1332 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMIPSState *env)
1333 {
1334 int i;
1335
1336 for (i = 0; i < TARGET_EF_R0; i++) {
1337 (*regs)[i] = 0;
1338 }
1339 (*regs)[TARGET_EF_R0] = 0;
1340
1341 for (i = 1; i < ARRAY_SIZE(env->active_tc.gpr); i++) {
1342 (*regs)[TARGET_EF_R0 + i] = tswapreg(env->active_tc.gpr[i]);
1343 }
1344
1345 (*regs)[TARGET_EF_R26] = 0;
1346 (*regs)[TARGET_EF_R27] = 0;
1347 (*regs)[TARGET_EF_LO] = tswapreg(env->active_tc.LO[0]);
1348 (*regs)[TARGET_EF_HI] = tswapreg(env->active_tc.HI[0]);
1349 (*regs)[TARGET_EF_CP0_EPC] = tswapreg(env->active_tc.PC);
1350 (*regs)[TARGET_EF_CP0_BADVADDR] = tswapreg(env->CP0_BadVAddr);
1351 (*regs)[TARGET_EF_CP0_STATUS] = tswapreg(env->CP0_Status);
1352 (*regs)[TARGET_EF_CP0_CAUSE] = tswapreg(env->CP0_Cause);
1353 }
1354
1355 #define USE_ELF_CORE_DUMP
1356 #define ELF_EXEC_PAGESIZE 4096
1357
1358 /* See arch/mips/include/uapi/asm/hwcap.h. */
1359 enum {
1360 HWCAP_MIPS_R6 = (1 << 0),
1361 HWCAP_MIPS_MSA = (1 << 1),
1362 HWCAP_MIPS_CRC32 = (1 << 2),
1363 HWCAP_MIPS_MIPS16 = (1 << 3),
1364 HWCAP_MIPS_MDMX = (1 << 4),
1365 HWCAP_MIPS_MIPS3D = (1 << 5),
1366 HWCAP_MIPS_SMARTMIPS = (1 << 6),
1367 HWCAP_MIPS_DSP = (1 << 7),
1368 HWCAP_MIPS_DSP2 = (1 << 8),
1369 HWCAP_MIPS_DSP3 = (1 << 9),
1370 HWCAP_MIPS_MIPS16E2 = (1 << 10),
1371 HWCAP_LOONGSON_MMI = (1 << 11),
1372 HWCAP_LOONGSON_EXT = (1 << 12),
1373 HWCAP_LOONGSON_EXT2 = (1 << 13),
1374 HWCAP_LOONGSON_CPUCFG = (1 << 14),
1375 };
1376
1377 #define ELF_HWCAP get_elf_hwcap()
1378
1379 #define GET_FEATURE_INSN(_flag, _hwcap) \
1380 do { if (cpu->env.insn_flags & (_flag)) { hwcaps |= _hwcap; } } while (0)
1381
1382 #define GET_FEATURE_REG_SET(_reg, _mask, _hwcap) \
1383 do { if (cpu->env._reg & (_mask)) { hwcaps |= _hwcap; } } while (0)
1384
1385 #define GET_FEATURE_REG_EQU(_reg, _start, _length, _val, _hwcap) \
1386 do { \
1387 if (extract32(cpu->env._reg, (_start), (_length)) == (_val)) { \
1388 hwcaps |= _hwcap; \
1389 } \
1390 } while (0)
1391
1392 static uint32_t get_elf_hwcap(void)
1393 {
1394 MIPSCPU *cpu = MIPS_CPU(thread_cpu);
1395 uint32_t hwcaps = 0;
1396
1397 GET_FEATURE_REG_EQU(CP0_Config0, CP0C0_AR, CP0C0_AR_LENGTH,
1398 2, HWCAP_MIPS_R6);
1399 GET_FEATURE_REG_SET(CP0_Config3, 1 << CP0C3_MSAP, HWCAP_MIPS_MSA);
1400 GET_FEATURE_INSN(ASE_LMMI, HWCAP_LOONGSON_MMI);
1401 GET_FEATURE_INSN(ASE_LEXT, HWCAP_LOONGSON_EXT);
1402
1403 return hwcaps;
1404 }
1405
1406 #undef GET_FEATURE_REG_EQU
1407 #undef GET_FEATURE_REG_SET
1408 #undef GET_FEATURE_INSN
1409
1410 #endif /* TARGET_MIPS */
1411
1412 #ifdef TARGET_MICROBLAZE
1413
1414 #define elf_check_arch(x) ( (x) == EM_MICROBLAZE || (x) == EM_MICROBLAZE_OLD)
1415
1416 #define ELF_CLASS ELFCLASS32
1417 #define ELF_ARCH EM_MICROBLAZE
1418
1419 static inline void init_thread(struct target_pt_regs *regs,
1420 struct image_info *infop)
1421 {
1422 regs->pc = infop->entry;
1423 regs->r1 = infop->start_stack;
1424
1425 }
1426
1427 #define ELF_EXEC_PAGESIZE 4096
1428
1429 #define USE_ELF_CORE_DUMP
1430 #define ELF_NREG 38
1431 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1432
1433 /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs. */
1434 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMBState *env)
1435 {
1436 int i, pos = 0;
1437
1438 for (i = 0; i < 32; i++) {
1439 (*regs)[pos++] = tswapreg(env->regs[i]);
1440 }
1441
1442 (*regs)[pos++] = tswapreg(env->pc);
1443 (*regs)[pos++] = tswapreg(mb_cpu_read_msr(env));
1444 (*regs)[pos++] = 0;
1445 (*regs)[pos++] = tswapreg(env->ear);
1446 (*regs)[pos++] = 0;
1447 (*regs)[pos++] = tswapreg(env->esr);
1448 }
1449
1450 #endif /* TARGET_MICROBLAZE */
1451
1452 #ifdef TARGET_NIOS2
1453
1454 #define elf_check_arch(x) ((x) == EM_ALTERA_NIOS2)
1455
1456 #define ELF_CLASS ELFCLASS32
1457 #define ELF_ARCH EM_ALTERA_NIOS2
1458
1459 static void init_thread(struct target_pt_regs *regs, struct image_info *infop)
1460 {
1461 regs->ea = infop->entry;
1462 regs->sp = infop->start_stack;
1463 }
1464
1465 #define LO_COMMPAGE TARGET_PAGE_SIZE
1466
1467 static bool init_guest_commpage(void)
1468 {
1469 static const uint8_t kuser_page[4 + 2 * 64] = {
1470 /* __kuser_helper_version */
1471 [0x00] = 0x02, 0x00, 0x00, 0x00,
1472
1473 /* __kuser_cmpxchg */
1474 [0x04] = 0x3a, 0x6c, 0x3b, 0x00, /* trap 16 */
1475 0x3a, 0x28, 0x00, 0xf8, /* ret */
1476
1477 /* __kuser_sigtramp */
1478 [0x44] = 0xc4, 0x22, 0x80, 0x00, /* movi r2, __NR_rt_sigreturn */
1479 0x3a, 0x68, 0x3b, 0x00, /* trap 0 */
1480 };
1481
1482 void *want = g2h_untagged(LO_COMMPAGE & -qemu_host_page_size);
1483 void *addr = mmap(want, qemu_host_page_size, PROT_READ | PROT_WRITE,
1484 MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
1485
1486 if (addr == MAP_FAILED) {
1487 perror("Allocating guest commpage");
1488 exit(EXIT_FAILURE);
1489 }
1490 if (addr != want) {
1491 return false;
1492 }
1493
1494 memcpy(addr, kuser_page, sizeof(kuser_page));
1495
1496 if (mprotect(addr, qemu_host_page_size, PROT_READ)) {
1497 perror("Protecting guest commpage");
1498 exit(EXIT_FAILURE);
1499 }
1500
1501 page_set_flags(LO_COMMPAGE, LO_COMMPAGE | ~TARGET_PAGE_MASK,
1502 PAGE_READ | PAGE_EXEC | PAGE_VALID);
1503 return true;
1504 }
1505
1506 #define ELF_EXEC_PAGESIZE 4096
1507
1508 #define USE_ELF_CORE_DUMP
1509 #define ELF_NREG 49
1510 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1511
1512 /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs. */
1513 static void elf_core_copy_regs(target_elf_gregset_t *regs,
1514 const CPUNios2State *env)
1515 {
1516 int i;
1517
1518 (*regs)[0] = -1;
1519 for (i = 1; i < 8; i++) /* r0-r7 */
1520 (*regs)[i] = tswapreg(env->regs[i + 7]);
1521
1522 for (i = 8; i < 16; i++) /* r8-r15 */
1523 (*regs)[i] = tswapreg(env->regs[i - 8]);
1524
1525 for (i = 16; i < 24; i++) /* r16-r23 */
1526 (*regs)[i] = tswapreg(env->regs[i + 7]);
1527 (*regs)[24] = -1; /* R_ET */
1528 (*regs)[25] = -1; /* R_BT */
1529 (*regs)[26] = tswapreg(env->regs[R_GP]);
1530 (*regs)[27] = tswapreg(env->regs[R_SP]);
1531 (*regs)[28] = tswapreg(env->regs[R_FP]);
1532 (*regs)[29] = tswapreg(env->regs[R_EA]);
1533 (*regs)[30] = -1; /* R_SSTATUS */
1534 (*regs)[31] = tswapreg(env->regs[R_RA]);
1535
1536 (*regs)[32] = tswapreg(env->pc);
1537
1538 (*regs)[33] = -1; /* R_STATUS */
1539 (*regs)[34] = tswapreg(env->regs[CR_ESTATUS]);
1540
1541 for (i = 35; i < 49; i++) /* ... */
1542 (*regs)[i] = -1;
1543 }
1544
1545 #endif /* TARGET_NIOS2 */
1546
1547 #ifdef TARGET_OPENRISC
1548
1549 #define ELF_ARCH EM_OPENRISC
1550 #define ELF_CLASS ELFCLASS32
1551 #define ELF_DATA ELFDATA2MSB
1552
1553 static inline void init_thread(struct target_pt_regs *regs,
1554 struct image_info *infop)
1555 {
1556 regs->pc = infop->entry;
1557 regs->gpr[1] = infop->start_stack;
1558 }
1559
1560 #define USE_ELF_CORE_DUMP
1561 #define ELF_EXEC_PAGESIZE 8192
1562
1563 /* See linux kernel arch/openrisc/include/asm/elf.h. */
1564 #define ELF_NREG 34 /* gprs and pc, sr */
1565 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1566
1567 static void elf_core_copy_regs(target_elf_gregset_t *regs,
1568 const CPUOpenRISCState *env)
1569 {
1570 int i;
1571
1572 for (i = 0; i < 32; i++) {
1573 (*regs)[i] = tswapreg(cpu_get_gpr(env, i));
1574 }
1575 (*regs)[32] = tswapreg(env->pc);
1576 (*regs)[33] = tswapreg(cpu_get_sr(env));
1577 }
1578 #define ELF_HWCAP 0
1579 #define ELF_PLATFORM NULL
1580
1581 #endif /* TARGET_OPENRISC */
1582
1583 #ifdef TARGET_SH4
1584
1585 #define ELF_CLASS ELFCLASS32
1586 #define ELF_ARCH EM_SH
1587
1588 static inline void init_thread(struct target_pt_regs *regs,
1589 struct image_info *infop)
1590 {
1591 /* Check other registers XXXXX */
1592 regs->pc = infop->entry;
1593 regs->regs[15] = infop->start_stack;
1594 }
1595
1596 /* See linux kernel: arch/sh/include/asm/elf.h. */
1597 #define ELF_NREG 23
1598 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1599
1600 /* See linux kernel: arch/sh/include/asm/ptrace.h. */
1601 enum {
1602 TARGET_REG_PC = 16,
1603 TARGET_REG_PR = 17,
1604 TARGET_REG_SR = 18,
1605 TARGET_REG_GBR = 19,
1606 TARGET_REG_MACH = 20,
1607 TARGET_REG_MACL = 21,
1608 TARGET_REG_SYSCALL = 22
1609 };
1610
1611 static inline void elf_core_copy_regs(target_elf_gregset_t *regs,
1612 const CPUSH4State *env)
1613 {
1614 int i;
1615
1616 for (i = 0; i < 16; i++) {
1617 (*regs)[i] = tswapreg(env->gregs[i]);
1618 }
1619
1620 (*regs)[TARGET_REG_PC] = tswapreg(env->pc);
1621 (*regs)[TARGET_REG_PR] = tswapreg(env->pr);
1622 (*regs)[TARGET_REG_SR] = tswapreg(env->sr);
1623 (*regs)[TARGET_REG_GBR] = tswapreg(env->gbr);
1624 (*regs)[TARGET_REG_MACH] = tswapreg(env->mach);
1625 (*regs)[TARGET_REG_MACL] = tswapreg(env->macl);
1626 (*regs)[TARGET_REG_SYSCALL] = 0; /* FIXME */
1627 }
1628
1629 #define USE_ELF_CORE_DUMP
1630 #define ELF_EXEC_PAGESIZE 4096
1631
1632 enum {
1633 SH_CPU_HAS_FPU = 0x0001, /* Hardware FPU support */
1634 SH_CPU_HAS_P2_FLUSH_BUG = 0x0002, /* Need to flush the cache in P2 area */
1635 SH_CPU_HAS_MMU_PAGE_ASSOC = 0x0004, /* SH3: TLB way selection bit support */
1636 SH_CPU_HAS_DSP = 0x0008, /* SH-DSP: DSP support */
1637 SH_CPU_HAS_PERF_COUNTER = 0x0010, /* Hardware performance counters */
1638 SH_CPU_HAS_PTEA = 0x0020, /* PTEA register */
1639 SH_CPU_HAS_LLSC = 0x0040, /* movli.l/movco.l */
1640 SH_CPU_HAS_L2_CACHE = 0x0080, /* Secondary cache / URAM */
1641 SH_CPU_HAS_OP32 = 0x0100, /* 32-bit instruction support */
1642 SH_CPU_HAS_PTEAEX = 0x0200, /* PTE ASID Extension support */
1643 };
1644
1645 #define ELF_HWCAP get_elf_hwcap()
1646
1647 static uint32_t get_elf_hwcap(void)
1648 {
1649 SuperHCPU *cpu = SUPERH_CPU(thread_cpu);
1650 uint32_t hwcap = 0;
1651
1652 hwcap |= SH_CPU_HAS_FPU;
1653
1654 if (cpu->env.features & SH_FEATURE_SH4A) {
1655 hwcap |= SH_CPU_HAS_LLSC;
1656 }
1657
1658 return hwcap;
1659 }
1660
1661 #endif
1662
1663 #ifdef TARGET_CRIS
1664
1665 #define ELF_CLASS ELFCLASS32
1666 #define ELF_ARCH EM_CRIS
1667
1668 static inline void init_thread(struct target_pt_regs *regs,
1669 struct image_info *infop)
1670 {
1671 regs->erp = infop->entry;
1672 }
1673
1674 #define ELF_EXEC_PAGESIZE 8192
1675
1676 #endif
1677
1678 #ifdef TARGET_M68K
1679
1680 #define ELF_CLASS ELFCLASS32
1681 #define ELF_ARCH EM_68K
1682
1683 /* ??? Does this need to do anything?
1684 #define ELF_PLAT_INIT(_r) */
1685
1686 static inline void init_thread(struct target_pt_regs *regs,
1687 struct image_info *infop)
1688 {
1689 regs->usp = infop->start_stack;
1690 regs->sr = 0;
1691 regs->pc = infop->entry;
1692 }
1693
1694 /* See linux kernel: arch/m68k/include/asm/elf.h. */
1695 #define ELF_NREG 20
1696 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1697
1698 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUM68KState *env)
1699 {
1700 (*regs)[0] = tswapreg(env->dregs[1]);
1701 (*regs)[1] = tswapreg(env->dregs[2]);
1702 (*regs)[2] = tswapreg(env->dregs[3]);
1703 (*regs)[3] = tswapreg(env->dregs[4]);
1704 (*regs)[4] = tswapreg(env->dregs[5]);
1705 (*regs)[5] = tswapreg(env->dregs[6]);
1706 (*regs)[6] = tswapreg(env->dregs[7]);
1707 (*regs)[7] = tswapreg(env->aregs[0]);
1708 (*regs)[8] = tswapreg(env->aregs[1]);
1709 (*regs)[9] = tswapreg(env->aregs[2]);
1710 (*regs)[10] = tswapreg(env->aregs[3]);
1711 (*regs)[11] = tswapreg(env->aregs[4]);
1712 (*regs)[12] = tswapreg(env->aregs[5]);
1713 (*regs)[13] = tswapreg(env->aregs[6]);
1714 (*regs)[14] = tswapreg(env->dregs[0]);
1715 (*regs)[15] = tswapreg(env->aregs[7]);
1716 (*regs)[16] = tswapreg(env->dregs[0]); /* FIXME: orig_d0 */
1717 (*regs)[17] = tswapreg(env->sr);
1718 (*regs)[18] = tswapreg(env->pc);
1719 (*regs)[19] = 0; /* FIXME: regs->format | regs->vector */
1720 }
1721
1722 #define USE_ELF_CORE_DUMP
1723 #define ELF_EXEC_PAGESIZE 8192
1724
1725 #endif
1726
1727 #ifdef TARGET_ALPHA
1728
1729 #define ELF_CLASS ELFCLASS64
1730 #define ELF_ARCH EM_ALPHA
1731
1732 static inline void init_thread(struct target_pt_regs *regs,
1733 struct image_info *infop)
1734 {
1735 regs->pc = infop->entry;
1736 regs->ps = 8;
1737 regs->usp = infop->start_stack;
1738 }
1739
1740 #define ELF_EXEC_PAGESIZE 8192
1741
1742 #endif /* TARGET_ALPHA */
1743
1744 #ifdef TARGET_S390X
1745
1746 #define ELF_CLASS ELFCLASS64
1747 #define ELF_DATA ELFDATA2MSB
1748 #define ELF_ARCH EM_S390
1749
1750 #include "elf.h"
1751
1752 #define ELF_HWCAP get_elf_hwcap()
1753
1754 #define GET_FEATURE(_feat, _hwcap) \
1755 do { if (s390_has_feat(_feat)) { hwcap |= _hwcap; } } while (0)
1756
1757 uint32_t get_elf_hwcap(void)
1758 {
1759 /*
1760 * Let's assume we always have esan3 and zarch.
1761 * 31-bit processes can use 64-bit registers (high gprs).
1762 */
1763 uint32_t hwcap = HWCAP_S390_ESAN3 | HWCAP_S390_ZARCH | HWCAP_S390_HIGH_GPRS;
1764
1765 GET_FEATURE(S390_FEAT_STFLE, HWCAP_S390_STFLE);
1766 GET_FEATURE(S390_FEAT_MSA, HWCAP_S390_MSA);
1767 GET_FEATURE(S390_FEAT_LONG_DISPLACEMENT, HWCAP_S390_LDISP);
1768 GET_FEATURE(S390_FEAT_EXTENDED_IMMEDIATE, HWCAP_S390_EIMM);
1769 if (s390_has_feat(S390_FEAT_EXTENDED_TRANSLATION_3) &&
1770 s390_has_feat(S390_FEAT_ETF3_ENH)) {
1771 hwcap |= HWCAP_S390_ETF3EH;
1772 }
1773 GET_FEATURE(S390_FEAT_VECTOR, HWCAP_S390_VXRS);
1774 GET_FEATURE(S390_FEAT_VECTOR_ENH, HWCAP_S390_VXRS_EXT);
1775 GET_FEATURE(S390_FEAT_VECTOR_ENH2, HWCAP_S390_VXRS_EXT2);
1776
1777 return hwcap;
1778 }
1779
1780 const char *elf_hwcap_str(uint32_t bit)
1781 {
1782 static const char *hwcap_str[] = {
1783 [HWCAP_S390_NR_ESAN3] = "esan3",
1784 [HWCAP_S390_NR_ZARCH] = "zarch",
1785 [HWCAP_S390_NR_STFLE] = "stfle",
1786 [HWCAP_S390_NR_MSA] = "msa",
1787 [HWCAP_S390_NR_LDISP] = "ldisp",
1788 [HWCAP_S390_NR_EIMM] = "eimm",
1789 [HWCAP_S390_NR_DFP] = "dfp",
1790 [HWCAP_S390_NR_HPAGE] = "edat",
1791 [HWCAP_S390_NR_ETF3EH] = "etf3eh",
1792 [HWCAP_S390_NR_HIGH_GPRS] = "highgprs",
1793 [HWCAP_S390_NR_TE] = "te",
1794 [HWCAP_S390_NR_VXRS] = "vx",
1795 [HWCAP_S390_NR_VXRS_BCD] = "vxd",
1796 [HWCAP_S390_NR_VXRS_EXT] = "vxe",
1797 [HWCAP_S390_NR_GS] = "gs",
1798 [HWCAP_S390_NR_VXRS_EXT2] = "vxe2",
1799 [HWCAP_S390_NR_VXRS_PDE] = "vxp",
1800 [HWCAP_S390_NR_SORT] = "sort",
1801 [HWCAP_S390_NR_DFLT] = "dflt",
1802 [HWCAP_S390_NR_NNPA] = "nnpa",
1803 [HWCAP_S390_NR_PCI_MIO] = "pcimio",
1804 [HWCAP_S390_NR_SIE] = "sie",
1805 };
1806
1807 return bit < ARRAY_SIZE(hwcap_str) ? hwcap_str[bit] : NULL;
1808 }
1809
1810 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
1811 {
1812 regs->psw.addr = infop->entry;
1813 regs->psw.mask = PSW_MASK_DAT | PSW_MASK_IO | PSW_MASK_EXT | \
1814 PSW_MASK_MCHECK | PSW_MASK_PSTATE | PSW_MASK_64 | \
1815 PSW_MASK_32;
1816 regs->gprs[15] = infop->start_stack;
1817 }
1818
1819 /* See linux kernel: arch/s390/include/uapi/asm/ptrace.h (s390_regs). */
1820 #define ELF_NREG 27
1821 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1822
1823 enum {
1824 TARGET_REG_PSWM = 0,
1825 TARGET_REG_PSWA = 1,
1826 TARGET_REG_GPRS = 2,
1827 TARGET_REG_ARS = 18,
1828 TARGET_REG_ORIG_R2 = 26,
1829 };
1830
1831 static void elf_core_copy_regs(target_elf_gregset_t *regs,
1832 const CPUS390XState *env)
1833 {
1834 int i;
1835 uint32_t *aregs;
1836
1837 (*regs)[TARGET_REG_PSWM] = tswapreg(env->psw.mask);
1838 (*regs)[TARGET_REG_PSWA] = tswapreg(env->psw.addr);
1839 for (i = 0; i < 16; i++) {
1840 (*regs)[TARGET_REG_GPRS + i] = tswapreg(env->regs[i]);
1841 }
1842 aregs = (uint32_t *)&((*regs)[TARGET_REG_ARS]);
1843 for (i = 0; i < 16; i++) {
1844 aregs[i] = tswap32(env->aregs[i]);
1845 }
1846 (*regs)[TARGET_REG_ORIG_R2] = 0;
1847 }
1848
1849 #define USE_ELF_CORE_DUMP
1850 #define ELF_EXEC_PAGESIZE 4096
1851
1852 #endif /* TARGET_S390X */
1853
1854 #ifdef TARGET_RISCV
1855
1856 #define ELF_ARCH EM_RISCV
1857
1858 #ifdef TARGET_RISCV32
1859 #define ELF_CLASS ELFCLASS32
1860 #else
1861 #define ELF_CLASS ELFCLASS64
1862 #endif
1863
1864 #define ELF_HWCAP get_elf_hwcap()
1865
1866 static uint32_t get_elf_hwcap(void)
1867 {
1868 #define MISA_BIT(EXT) (1 << (EXT - 'A'))
1869 RISCVCPU *cpu = RISCV_CPU(thread_cpu);
1870 uint32_t mask = MISA_BIT('I') | MISA_BIT('M') | MISA_BIT('A')
1871 | MISA_BIT('F') | MISA_BIT('D') | MISA_BIT('C')
1872 | MISA_BIT('V');
1873
1874 return cpu->env.misa_ext & mask;
1875 #undef MISA_BIT
1876 }
1877
1878 static inline void init_thread(struct target_pt_regs *regs,
1879 struct image_info *infop)
1880 {
1881 regs->sepc = infop->entry;
1882 regs->sp = infop->start_stack;
1883 }
1884
1885 #define ELF_EXEC_PAGESIZE 4096
1886
1887 #endif /* TARGET_RISCV */
1888
1889 #ifdef TARGET_HPPA
1890
1891 #define ELF_CLASS ELFCLASS32
1892 #define ELF_ARCH EM_PARISC
1893 #define ELF_PLATFORM "PARISC"
1894 #define STACK_GROWS_DOWN 0
1895 #define STACK_ALIGNMENT 64
1896
1897 static inline void init_thread(struct target_pt_regs *regs,
1898 struct image_info *infop)
1899 {
1900 regs->iaoq[0] = infop->entry;
1901 regs->iaoq[1] = infop->entry + 4;
1902 regs->gr[23] = 0;
1903 regs->gr[24] = infop->argv;
1904 regs->gr[25] = infop->argc;
1905 /* The top-of-stack contains a linkage buffer. */
1906 regs->gr[30] = infop->start_stack + 64;
1907 regs->gr[31] = infop->entry;
1908 }
1909
1910 #define LO_COMMPAGE 0
1911
1912 static bool init_guest_commpage(void)
1913 {
1914 void *want = g2h_untagged(LO_COMMPAGE);
1915 void *addr = mmap(want, qemu_host_page_size, PROT_NONE,
1916 MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
1917
1918 if (addr == MAP_FAILED) {
1919 perror("Allocating guest commpage");
1920 exit(EXIT_FAILURE);
1921 }
1922 if (addr != want) {
1923 return false;
1924 }
1925
1926 /*
1927 * On Linux, page zero is normally marked execute only + gateway.
1928 * Normal read or write is supposed to fail (thus PROT_NONE above),
1929 * but specific offsets have kernel code mapped to raise permissions
1930 * and implement syscalls. Here, simply mark the page executable.
1931 * Special case the entry points during translation (see do_page_zero).
1932 */
1933 page_set_flags(LO_COMMPAGE, LO_COMMPAGE | ~TARGET_PAGE_MASK,
1934 PAGE_EXEC | PAGE_VALID);
1935 return true;
1936 }
1937
1938 #endif /* TARGET_HPPA */
1939
1940 #ifdef TARGET_XTENSA
1941
1942 #define ELF_CLASS ELFCLASS32
1943 #define ELF_ARCH EM_XTENSA
1944
1945 static inline void init_thread(struct target_pt_regs *regs,
1946 struct image_info *infop)
1947 {
1948 regs->windowbase = 0;
1949 regs->windowstart = 1;
1950 regs->areg[1] = infop->start_stack;
1951 regs->pc = infop->entry;
1952 if (info_is_fdpic(infop)) {
1953 regs->areg[4] = infop->loadmap_addr;
1954 regs->areg[5] = infop->interpreter_loadmap_addr;
1955 if (infop->interpreter_loadmap_addr) {
1956 regs->areg[6] = infop->interpreter_pt_dynamic_addr;
1957 } else {
1958 regs->areg[6] = infop->pt_dynamic_addr;
1959 }
1960 }
1961 }
1962
1963 /* See linux kernel: arch/xtensa/include/asm/elf.h. */
1964 #define ELF_NREG 128
1965 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1966
1967 enum {
1968 TARGET_REG_PC,
1969 TARGET_REG_PS,
1970 TARGET_REG_LBEG,
1971 TARGET_REG_LEND,
1972 TARGET_REG_LCOUNT,
1973 TARGET_REG_SAR,
1974 TARGET_REG_WINDOWSTART,
1975 TARGET_REG_WINDOWBASE,
1976 TARGET_REG_THREADPTR,
1977 TARGET_REG_AR0 = 64,
1978 };
1979
1980 static void elf_core_copy_regs(target_elf_gregset_t *regs,
1981 const CPUXtensaState *env)
1982 {
1983 unsigned i;
1984
1985 (*regs)[TARGET_REG_PC] = tswapreg(env->pc);
1986 (*regs)[TARGET_REG_PS] = tswapreg(env->sregs[PS] & ~PS_EXCM);
1987 (*regs)[TARGET_REG_LBEG] = tswapreg(env->sregs[LBEG]);
1988 (*regs)[TARGET_REG_LEND] = tswapreg(env->sregs[LEND]);
1989 (*regs)[TARGET_REG_LCOUNT] = tswapreg(env->sregs[LCOUNT]);
1990 (*regs)[TARGET_REG_SAR] = tswapreg(env->sregs[SAR]);
1991 (*regs)[TARGET_REG_WINDOWSTART] = tswapreg(env->sregs[WINDOW_START]);
1992 (*regs)[TARGET_REG_WINDOWBASE] = tswapreg(env->sregs[WINDOW_BASE]);
1993 (*regs)[TARGET_REG_THREADPTR] = tswapreg(env->uregs[THREADPTR]);
1994 xtensa_sync_phys_from_window((CPUXtensaState *)env);
1995 for (i = 0; i < env->config->nareg; ++i) {
1996 (*regs)[TARGET_REG_AR0 + i] = tswapreg(env->phys_regs[i]);
1997 }
1998 }
1999
2000 #define USE_ELF_CORE_DUMP
2001 #define ELF_EXEC_PAGESIZE 4096
2002
2003 #endif /* TARGET_XTENSA */
2004
2005 #ifdef TARGET_HEXAGON
2006
2007 #define ELF_CLASS ELFCLASS32
2008 #define ELF_ARCH EM_HEXAGON
2009
2010 static inline void init_thread(struct target_pt_regs *regs,
2011 struct image_info *infop)
2012 {
2013 regs->sepc = infop->entry;
2014 regs->sp = infop->start_stack;
2015 }
2016
2017 #endif /* TARGET_HEXAGON */
2018
2019 #ifndef ELF_BASE_PLATFORM
2020 #define ELF_BASE_PLATFORM (NULL)
2021 #endif
2022
2023 #ifndef ELF_PLATFORM
2024 #define ELF_PLATFORM (NULL)
2025 #endif
2026
2027 #ifndef ELF_MACHINE
2028 #define ELF_MACHINE ELF_ARCH
2029 #endif
2030
2031 #ifndef elf_check_arch
2032 #define elf_check_arch(x) ((x) == ELF_ARCH)
2033 #endif
2034
2035 #ifndef elf_check_abi
2036 #define elf_check_abi(x) (1)
2037 #endif
2038
2039 #ifndef ELF_HWCAP
2040 #define ELF_HWCAP 0
2041 #endif
2042
2043 #ifndef STACK_GROWS_DOWN
2044 #define STACK_GROWS_DOWN 1
2045 #endif
2046
2047 #ifndef STACK_ALIGNMENT
2048 #define STACK_ALIGNMENT 16
2049 #endif
2050
2051 #ifdef TARGET_ABI32
2052 #undef ELF_CLASS
2053 #define ELF_CLASS ELFCLASS32
2054 #undef bswaptls
2055 #define bswaptls(ptr) bswap32s(ptr)
2056 #endif
2057
2058 #ifndef EXSTACK_DEFAULT
2059 #define EXSTACK_DEFAULT false
2060 #endif
2061
2062 #include "elf.h"
2063
2064 /* We must delay the following stanzas until after "elf.h". */
2065 #if defined(TARGET_AARCH64)
2066
2067 static bool arch_parse_elf_property(uint32_t pr_type, uint32_t pr_datasz,
2068 const uint32_t *data,
2069 struct image_info *info,
2070 Error **errp)
2071 {
2072 if (pr_type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) {
2073 if (pr_datasz != sizeof(uint32_t)) {
2074 error_setg(errp, "Ill-formed GNU_PROPERTY_AARCH64_FEATURE_1_AND");
2075 return false;
2076 }
2077 /* We will extract GNU_PROPERTY_AARCH64_FEATURE_1_BTI later. */
2078 info->note_flags = *data;
2079 }
2080 return true;
2081 }
2082 #define ARCH_USE_GNU_PROPERTY 1
2083
2084 #else
2085
2086 static bool arch_parse_elf_property(uint32_t pr_type, uint32_t pr_datasz,
2087 const uint32_t *data,
2088 struct image_info *info,
2089 Error **errp)
2090 {
2091 g_assert_not_reached();
2092 }
2093 #define ARCH_USE_GNU_PROPERTY 0
2094
2095 #endif
2096
2097 struct exec
2098 {
2099 unsigned int a_info; /* Use macros N_MAGIC, etc for access */
2100 unsigned int a_text; /* length of text, in bytes */
2101 unsigned int a_data; /* length of data, in bytes */
2102 unsigned int a_bss; /* length of uninitialized data area, in bytes */
2103 unsigned int a_syms; /* length of symbol table data in file, in bytes */
2104 unsigned int a_entry; /* start address */
2105 unsigned int a_trsize; /* length of relocation info for text, in bytes */
2106 unsigned int a_drsize; /* length of relocation info for data, in bytes */
2107 };
2108
2109
2110 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
2111 #define OMAGIC 0407
2112 #define NMAGIC 0410
2113 #define ZMAGIC 0413
2114 #define QMAGIC 0314
2115
2116 #define DLINFO_ITEMS 16
2117
2118 static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
2119 {
2120 memcpy(to, from, n);
2121 }
2122
2123 #ifdef BSWAP_NEEDED
2124 static void bswap_ehdr(struct elfhdr *ehdr)
2125 {
2126 bswap16s(&ehdr->e_type); /* Object file type */
2127 bswap16s(&ehdr->e_machine); /* Architecture */
2128 bswap32s(&ehdr->e_version); /* Object file version */
2129 bswaptls(&ehdr->e_entry); /* Entry point virtual address */
2130 bswaptls(&ehdr->e_phoff); /* Program header table file offset */
2131 bswaptls(&ehdr->e_shoff); /* Section header table file offset */
2132 bswap32s(&ehdr->e_flags); /* Processor-specific flags */
2133 bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
2134 bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
2135 bswap16s(&ehdr->e_phnum); /* Program header table entry count */
2136 bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
2137 bswap16s(&ehdr->e_shnum); /* Section header table entry count */
2138 bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
2139 }
2140
2141 static void bswap_phdr(struct elf_phdr *phdr, int phnum)
2142 {
2143 int i;
2144 for (i = 0; i < phnum; ++i, ++phdr) {
2145 bswap32s(&phdr->p_type); /* Segment type */
2146 bswap32s(&phdr->p_flags); /* Segment flags */
2147 bswaptls(&phdr->p_offset); /* Segment file offset */
2148 bswaptls(&phdr->p_vaddr); /* Segment virtual address */
2149 bswaptls(&phdr->p_paddr); /* Segment physical address */
2150 bswaptls(&phdr->p_filesz); /* Segment size in file */
2151 bswaptls(&phdr->p_memsz); /* Segment size in memory */
2152 bswaptls(&phdr->p_align); /* Segment alignment */
2153 }
2154 }
2155
2156 static void bswap_shdr(struct elf_shdr *shdr, int shnum)
2157 {
2158 int i;
2159 for (i = 0; i < shnum; ++i, ++shdr) {
2160 bswap32s(&shdr->sh_name);
2161 bswap32s(&shdr->sh_type);
2162 bswaptls(&shdr->sh_flags);
2163 bswaptls(&shdr->sh_addr);
2164 bswaptls(&shdr->sh_offset);
2165 bswaptls(&shdr->sh_size);
2166 bswap32s(&shdr->sh_link);
2167 bswap32s(&shdr->sh_info);
2168 bswaptls(&shdr->sh_addralign);
2169 bswaptls(&shdr->sh_entsize);
2170 }
2171 }
2172
2173 static void bswap_sym(struct elf_sym *sym)
2174 {
2175 bswap32s(&sym->st_name);
2176 bswaptls(&sym->st_value);
2177 bswaptls(&sym->st_size);
2178 bswap16s(&sym->st_shndx);
2179 }
2180
2181 #ifdef TARGET_MIPS
2182 static void bswap_mips_abiflags(Mips_elf_abiflags_v0 *abiflags)
2183 {
2184 bswap16s(&abiflags->version);
2185 bswap32s(&abiflags->ases);
2186 bswap32s(&abiflags->isa_ext);
2187 bswap32s(&abiflags->flags1);
2188 bswap32s(&abiflags->flags2);
2189 }
2190 #endif
2191 #else
2192 static inline void bswap_ehdr(struct elfhdr *ehdr) { }
2193 static inline void bswap_phdr(struct elf_phdr *phdr, int phnum) { }
2194 static inline void bswap_shdr(struct elf_shdr *shdr, int shnum) { }
2195 static inline void bswap_sym(struct elf_sym *sym) { }
2196 #ifdef TARGET_MIPS
2197 static inline void bswap_mips_abiflags(Mips_elf_abiflags_v0 *abiflags) { }
2198 #endif
2199 #endif
2200
2201 #ifdef USE_ELF_CORE_DUMP
2202 static int elf_core_dump(int, const CPUArchState *);
2203 #endif /* USE_ELF_CORE_DUMP */
2204 static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias);
2205
2206 /* Verify the portions of EHDR within E_IDENT for the target.
2207 This can be performed before bswapping the entire header. */
2208 static bool elf_check_ident(struct elfhdr *ehdr)
2209 {
2210 return (ehdr->e_ident[EI_MAG0] == ELFMAG0
2211 && ehdr->e_ident[EI_MAG1] == ELFMAG1
2212 && ehdr->e_ident[EI_MAG2] == ELFMAG2
2213 && ehdr->e_ident[EI_MAG3] == ELFMAG3
2214 && ehdr->e_ident[EI_CLASS] == ELF_CLASS
2215 && ehdr->e_ident[EI_DATA] == ELF_DATA
2216 && ehdr->e_ident[EI_VERSION] == EV_CURRENT);
2217 }
2218
2219 /* Verify the portions of EHDR outside of E_IDENT for the target.
2220 This has to wait until after bswapping the header. */
2221 static bool elf_check_ehdr(struct elfhdr *ehdr)
2222 {
2223 return (elf_check_arch(ehdr->e_machine)
2224 && elf_check_abi(ehdr->e_flags)
2225 && ehdr->e_ehsize == sizeof(struct elfhdr)
2226 && ehdr->e_phentsize == sizeof(struct elf_phdr)
2227 && (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN));
2228 }
2229
2230 /*
2231 * 'copy_elf_strings()' copies argument/envelope strings from user
2232 * memory to free pages in kernel mem. These are in a format ready
2233 * to be put directly into the top of new user memory.
2234 *
2235 */
2236 static abi_ulong copy_elf_strings(int argc, char **argv, char *scratch,
2237 abi_ulong p, abi_ulong stack_limit)
2238 {
2239 char *tmp;
2240 int len, i;
2241 abi_ulong top = p;
2242
2243 if (!p) {
2244 return 0; /* bullet-proofing */
2245 }
2246
2247 if (STACK_GROWS_DOWN) {
2248 int offset = ((p - 1) % TARGET_PAGE_SIZE) + 1;
2249 for (i = argc - 1; i >= 0; --i) {
2250 tmp = argv[i];
2251 if (!tmp) {
2252 fprintf(stderr, "VFS: argc is wrong");
2253 exit(-1);
2254 }
2255 len = strlen(tmp) + 1;
2256 tmp += len;
2257
2258 if (len > (p - stack_limit)) {
2259 return 0;
2260 }
2261 while (len) {
2262 int bytes_to_copy = (len > offset) ? offset : len;
2263 tmp -= bytes_to_copy;
2264 p -= bytes_to_copy;
2265 offset -= bytes_to_copy;
2266 len -= bytes_to_copy;
2267
2268 memcpy_fromfs(scratch + offset, tmp, bytes_to_copy);
2269
2270 if (offset == 0) {
2271 memcpy_to_target(p, scratch, top - p);
2272 top = p;
2273 offset = TARGET_PAGE_SIZE;
2274 }
2275 }
2276 }
2277 if (p != top) {
2278 memcpy_to_target(p, scratch + offset, top - p);
2279 }
2280 } else {
2281 int remaining = TARGET_PAGE_SIZE - (p % TARGET_PAGE_SIZE);
2282 for (i = 0; i < argc; ++i) {
2283 tmp = argv[i];
2284 if (!tmp) {
2285 fprintf(stderr, "VFS: argc is wrong");
2286 exit(-1);
2287 }
2288 len = strlen(tmp) + 1;
2289 if (len > (stack_limit - p)) {
2290 return 0;
2291 }
2292 while (len) {
2293 int bytes_to_copy = (len > remaining) ? remaining : len;
2294
2295 memcpy_fromfs(scratch + (p - top), tmp, bytes_to_copy);
2296
2297 tmp += bytes_to_copy;
2298 remaining -= bytes_to_copy;
2299 p += bytes_to_copy;
2300 len -= bytes_to_copy;
2301
2302 if (remaining == 0) {
2303 memcpy_to_target(top, scratch, p - top);
2304 top = p;
2305 remaining = TARGET_PAGE_SIZE;
2306 }
2307 }
2308 }
2309 if (p != top) {
2310 memcpy_to_target(top, scratch, p - top);
2311 }
2312 }
2313
2314 return p;
2315 }
2316
2317 /* Older linux kernels provide up to MAX_ARG_PAGES (default: 32) of
2318 * argument/environment space. Newer kernels (>2.6.33) allow more,
2319 * dependent on stack size, but guarantee at least 32 pages for
2320 * backwards compatibility.
2321 */
2322 #define STACK_LOWER_LIMIT (32 * TARGET_PAGE_SIZE)
2323
2324 static abi_ulong setup_arg_pages(struct linux_binprm *bprm,
2325 struct image_info *info)
2326 {
2327 abi_ulong size, error, guard;
2328 int prot;
2329
2330 size = guest_stack_size;
2331 if (size < STACK_LOWER_LIMIT) {
2332 size = STACK_LOWER_LIMIT;
2333 }
2334
2335 if (STACK_GROWS_DOWN) {
2336 guard = TARGET_PAGE_SIZE;
2337 if (guard < qemu_real_host_page_size()) {
2338 guard = qemu_real_host_page_size();
2339 }
2340 } else {
2341 /* no guard page for hppa target where stack grows upwards. */
2342 guard = 0;
2343 }
2344
2345 prot = PROT_READ | PROT_WRITE;
2346 if (info->exec_stack) {
2347 prot |= PROT_EXEC;
2348 }
2349 error = target_mmap(0, size + guard, prot,
2350 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
2351 if (error == -1) {
2352 perror("mmap stack");
2353 exit(-1);
2354 }
2355
2356 /* We reserve one extra page at the top of the stack as guard. */
2357 if (STACK_GROWS_DOWN) {
2358 target_mprotect(error, guard, PROT_NONE);
2359 info->stack_limit = error + guard;
2360 return info->stack_limit + size - sizeof(void *);
2361 } else {
2362 info->stack_limit = error + size;
2363 return error;
2364 }
2365 }
2366
2367 /**
2368 * zero_bss:
2369 *
2370 * Map and zero the bss. We need to explicitly zero any fractional pages
2371 * after the data section (i.e. bss). Return false on mapping failure.
2372 */
2373 static bool zero_bss(abi_ulong start_bss, abi_ulong end_bss,
2374 int prot, Error **errp)
2375 {
2376 abi_ulong align_bss;
2377
2378 /* We only expect writable bss; the code segment shouldn't need this. */
2379 if (!(prot & PROT_WRITE)) {
2380 error_setg(errp, "PT_LOAD with non-writable bss");
2381 return false;
2382 }
2383
2384 align_bss = TARGET_PAGE_ALIGN(start_bss);
2385 end_bss = TARGET_PAGE_ALIGN(end_bss);
2386
2387 if (start_bss < align_bss) {
2388 int flags = page_get_flags(start_bss);
2389
2390 if (!(flags & PAGE_BITS)) {
2391 /*
2392 * The whole address space of the executable was reserved
2393 * at the start, therefore all pages will be VALID.
2394 * But assuming there are no PROT_NONE PT_LOAD segments,
2395 * a PROT_NONE page means no data all bss, and we can
2396 * simply extend the new anon mapping back to the start
2397 * of the page of bss.
2398 */
2399 align_bss -= TARGET_PAGE_SIZE;
2400 } else {
2401 /*
2402 * The start of the bss shares a page with something.
2403 * The only thing that we expect is the data section,
2404 * which would already be marked writable.
2405 * Overlapping the RX code segment seems malformed.
2406 */
2407 if (!(flags & PAGE_WRITE)) {
2408 error_setg(errp, "PT_LOAD with bss overlapping "
2409 "non-writable page");
2410 return false;
2411 }
2412
2413 /* The page is already mapped and writable. */
2414 memset(g2h_untagged(start_bss), 0, align_bss - start_bss);
2415 }
2416 }
2417
2418 if (align_bss < end_bss &&
2419 target_mmap(align_bss, end_bss - align_bss, prot,
2420 MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0) == -1) {
2421 error_setg_errno(errp, errno, "Error mapping bss");
2422 return false;
2423 }
2424 return true;
2425 }
2426
2427 #if defined(TARGET_ARM)
2428 static int elf_is_fdpic(struct elfhdr *exec)
2429 {
2430 return exec->e_ident[EI_OSABI] == ELFOSABI_ARM_FDPIC;
2431 }
2432 #elif defined(TARGET_XTENSA)
2433 static int elf_is_fdpic(struct elfhdr *exec)
2434 {
2435 return exec->e_ident[EI_OSABI] == ELFOSABI_XTENSA_FDPIC;
2436 }
2437 #else
2438 /* Default implementation, always false. */
2439 static int elf_is_fdpic(struct elfhdr *exec)
2440 {
2441 return 0;
2442 }
2443 #endif
2444
2445 static abi_ulong loader_build_fdpic_loadmap(struct image_info *info, abi_ulong sp)
2446 {
2447 uint16_t n;
2448 struct elf32_fdpic_loadseg *loadsegs = info->loadsegs;
2449
2450 /* elf32_fdpic_loadseg */
2451 n = info->nsegs;
2452 while (n--) {
2453 sp -= 12;
2454 put_user_u32(loadsegs[n].addr, sp+0);
2455 put_user_u32(loadsegs[n].p_vaddr, sp+4);
2456 put_user_u32(loadsegs[n].p_memsz, sp+8);
2457 }
2458
2459 /* elf32_fdpic_loadmap */
2460 sp -= 4;
2461 put_user_u16(0, sp+0); /* version */
2462 put_user_u16(info->nsegs, sp+2); /* nsegs */
2463
2464 info->personality = PER_LINUX_FDPIC;
2465 info->loadmap_addr = sp;
2466
2467 return sp;
2468 }
2469
2470 static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,
2471 struct elfhdr *exec,
2472 struct image_info *info,
2473 struct image_info *interp_info)
2474 {
2475 abi_ulong sp;
2476 abi_ulong u_argc, u_argv, u_envp, u_auxv;
2477 int size;
2478 int i;
2479 abi_ulong u_rand_bytes;
2480 uint8_t k_rand_bytes[16];
2481 abi_ulong u_platform, u_base_platform;
2482 const char *k_platform, *k_base_platform;
2483 const int n = sizeof(elf_addr_t);
2484
2485 sp = p;
2486
2487 /* Needs to be before we load the env/argc/... */
2488 if (elf_is_fdpic(exec)) {
2489 /* Need 4 byte alignment for these structs */
2490 sp &= ~3;
2491 sp = loader_build_fdpic_loadmap(info, sp);
2492 info->other_info = interp_info;
2493 if (interp_info) {
2494 interp_info->other_info = info;
2495 sp = loader_build_fdpic_loadmap(interp_info, sp);
2496 info->interpreter_loadmap_addr = interp_info->loadmap_addr;
2497 info->interpreter_pt_dynamic_addr = interp_info->pt_dynamic_addr;
2498 } else {
2499 info->interpreter_loadmap_addr = 0;
2500 info->interpreter_pt_dynamic_addr = 0;
2501 }
2502 }
2503
2504 u_base_platform = 0;
2505 k_base_platform = ELF_BASE_PLATFORM;
2506 if (k_base_platform) {
2507 size_t len = strlen(k_base_platform) + 1;
2508 if (STACK_GROWS_DOWN) {
2509 sp -= (len + n - 1) & ~(n - 1);
2510 u_base_platform = sp;
2511 /* FIXME - check return value of memcpy_to_target() for failure */
2512 memcpy_to_target(sp, k_base_platform, len);
2513 } else {
2514 memcpy_to_target(sp, k_base_platform, len);
2515 u_base_platform = sp;
2516 sp += len + 1;
2517 }
2518 }
2519
2520 u_platform = 0;
2521 k_platform = ELF_PLATFORM;
2522 if (k_platform) {
2523 size_t len = strlen(k_platform) + 1;
2524 if (STACK_GROWS_DOWN) {
2525 sp -= (len + n - 1) & ~(n - 1);
2526 u_platform = sp;
2527 /* FIXME - check return value of memcpy_to_target() for failure */
2528 memcpy_to_target(sp, k_platform, len);
2529 } else {
2530 memcpy_to_target(sp, k_platform, len);
2531 u_platform = sp;
2532 sp += len + 1;
2533 }
2534 }
2535
2536 /* Provide 16 byte alignment for the PRNG, and basic alignment for
2537 * the argv and envp pointers.
2538 */
2539 if (STACK_GROWS_DOWN) {
2540 sp = QEMU_ALIGN_DOWN(sp, 16);
2541 } else {
2542 sp = QEMU_ALIGN_UP(sp, 16);
2543 }
2544
2545 /*
2546 * Generate 16 random bytes for userspace PRNG seeding.
2547 */
2548 qemu_guest_getrandom_nofail(k_rand_bytes, sizeof(k_rand_bytes));
2549 if (STACK_GROWS_DOWN) {
2550 sp -= 16;
2551 u_rand_bytes = sp;
2552 /* FIXME - check return value of memcpy_to_target() for failure */
2553 memcpy_to_target(sp, k_rand_bytes, 16);
2554 } else {
2555 memcpy_to_target(sp, k_rand_bytes, 16);
2556 u_rand_bytes = sp;
2557 sp += 16;
2558 }
2559
2560 size = (DLINFO_ITEMS + 1) * 2;
2561 if (k_base_platform)
2562 size += 2;
2563 if (k_platform)
2564 size += 2;
2565 #ifdef DLINFO_ARCH_ITEMS
2566 size += DLINFO_ARCH_ITEMS * 2;
2567 #endif
2568 #ifdef ELF_HWCAP2
2569 size += 2;
2570 #endif
2571 info->auxv_len = size * n;
2572
2573 size += envc + argc + 2;
2574 size += 1; /* argc itself */
2575 size *= n;
2576
2577 /* Allocate space and finalize stack alignment for entry now. */
2578 if (STACK_GROWS_DOWN) {
2579 u_argc = QEMU_ALIGN_DOWN(sp - size, STACK_ALIGNMENT);
2580 sp = u_argc;
2581 } else {
2582 u_argc = sp;
2583 sp = QEMU_ALIGN_UP(sp + size, STACK_ALIGNMENT);
2584 }
2585
2586 u_argv = u_argc + n;
2587 u_envp = u_argv + (argc + 1) * n;
2588 u_auxv = u_envp + (envc + 1) * n;
2589 info->saved_auxv = u_auxv;
2590 info->argc = argc;
2591 info->envc = envc;
2592 info->argv = u_argv;
2593 info->envp = u_envp;
2594
2595 /* This is correct because Linux defines
2596 * elf_addr_t as Elf32_Off / Elf64_Off
2597 */
2598 #define NEW_AUX_ENT(id, val) do { \
2599 put_user_ual(id, u_auxv); u_auxv += n; \
2600 put_user_ual(val, u_auxv); u_auxv += n; \
2601 } while(0)
2602
2603 #ifdef ARCH_DLINFO
2604 /*
2605 * ARCH_DLINFO must come first so platform specific code can enforce
2606 * special alignment requirements on the AUXV if necessary (eg. PPC).
2607 */
2608 ARCH_DLINFO;
2609 #endif
2610 /* There must be exactly DLINFO_ITEMS entries here, or the assert
2611 * on info->auxv_len will trigger.
2612 */
2613 NEW_AUX_ENT(AT_PHDR, (abi_ulong)(info->load_addr + exec->e_phoff));
2614 NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr)));
2615 NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));
2616 if ((info->alignment & ~qemu_host_page_mask) != 0) {
2617 /* Target doesn't support host page size alignment */
2618 NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(TARGET_PAGE_SIZE));
2619 } else {
2620 NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(MAX(TARGET_PAGE_SIZE,
2621 qemu_host_page_size)));
2622 }
2623 NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_info ? interp_info->load_addr : 0));
2624 NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);
2625 NEW_AUX_ENT(AT_ENTRY, info->entry);
2626 NEW_AUX_ENT(AT_UID, (abi_ulong) getuid());
2627 NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid());
2628 NEW_AUX_ENT(AT_GID, (abi_ulong) getgid());
2629 NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid());
2630 NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP);
2631 NEW_AUX_ENT(AT_CLKTCK, (abi_ulong) sysconf(_SC_CLK_TCK));
2632 NEW_AUX_ENT(AT_RANDOM, (abi_ulong) u_rand_bytes);
2633 NEW_AUX_ENT(AT_SECURE, (abi_ulong) qemu_getauxval(AT_SECURE));
2634 NEW_AUX_ENT(AT_EXECFN, info->file_string);
2635
2636 #ifdef ELF_HWCAP2
2637 NEW_AUX_ENT(AT_HWCAP2, (abi_ulong) ELF_HWCAP2);
2638 #endif
2639
2640 if (u_base_platform) {
2641 NEW_AUX_ENT(AT_BASE_PLATFORM, u_base_platform);
2642 }
2643 if (u_platform) {
2644 NEW_AUX_ENT(AT_PLATFORM, u_platform);
2645 }
2646 NEW_AUX_ENT (AT_NULL, 0);
2647 #undef NEW_AUX_ENT
2648
2649 /* Check that our initial calculation of the auxv length matches how much
2650 * we actually put into it.
2651 */
2652 assert(info->auxv_len == u_auxv - info->saved_auxv);
2653
2654 put_user_ual(argc, u_argc);
2655
2656 p = info->arg_strings;
2657 for (i = 0; i < argc; ++i) {
2658 put_user_ual(p, u_argv);
2659 u_argv += n;
2660 p += target_strlen(p) + 1;
2661 }
2662 put_user_ual(0, u_argv);
2663
2664 p = info->env_strings;
2665 for (i = 0; i < envc; ++i) {
2666 put_user_ual(p, u_envp);
2667 u_envp += n;
2668 p += target_strlen(p) + 1;
2669 }
2670 put_user_ual(0, u_envp);
2671
2672 return sp;
2673 }
2674
2675 #if defined(HI_COMMPAGE)
2676 #define LO_COMMPAGE -1
2677 #elif defined(LO_COMMPAGE)
2678 #define HI_COMMPAGE 0
2679 #else
2680 #define HI_COMMPAGE 0
2681 #define LO_COMMPAGE -1
2682 #ifndef INIT_GUEST_COMMPAGE
2683 #define init_guest_commpage() true
2684 #endif
2685 #endif
2686
2687 /**
2688 * pgb_try_mmap:
2689 * @addr: host start address
2690 * @addr_last: host last address
2691 * @keep: do not unmap the probe region
2692 *
2693 * Return 1 if [@addr, @addr_last] is not mapped in the host,
2694 * return 0 if it is not available to map, and -1 on mmap error.
2695 * If @keep, the region is left mapped on success, otherwise unmapped.
2696 */
2697 static int pgb_try_mmap(uintptr_t addr, uintptr_t addr_last, bool keep)
2698 {
2699 size_t size = addr_last - addr + 1;
2700 void *p = mmap((void *)addr, size, PROT_NONE,
2701 MAP_ANONYMOUS | MAP_PRIVATE |
2702 MAP_NORESERVE | MAP_FIXED_NOREPLACE, -1, 0);
2703 int ret;
2704
2705 if (p == MAP_FAILED) {
2706 return errno == EEXIST ? 0 : -1;
2707 }
2708 ret = p == (void *)addr;
2709 if (!keep || !ret) {
2710 munmap(p, size);
2711 }
2712 return ret;
2713 }
2714
2715 /**
2716 * pgb_try_mmap_skip_brk(uintptr_t addr, uintptr_t size, uintptr_t brk)
2717 * @addr: host address
2718 * @addr_last: host last address
2719 * @brk: host brk
2720 *
2721 * Like pgb_try_mmap, but additionally reserve some memory following brk.
2722 */
2723 static int pgb_try_mmap_skip_brk(uintptr_t addr, uintptr_t addr_last,
2724 uintptr_t brk, bool keep)
2725 {
2726 uintptr_t brk_last = brk + 16 * MiB - 1;
2727
2728 /* Do not map anything close to the host brk. */
2729 if (addr <= brk_last && brk <= addr_last) {
2730 return 0;
2731 }
2732 return pgb_try_mmap(addr, addr_last, keep);
2733 }
2734
2735 /**
2736 * pgb_try_mmap_set:
2737 * @ga: set of guest addrs
2738 * @base: guest_base
2739 * @brk: host brk
2740 *
2741 * Return true if all @ga can be mapped by the host at @base.
2742 * On success, retain the mapping at index 0 for reserved_va.
2743 */
2744
2745 typedef struct PGBAddrs {
2746 uintptr_t bounds[3][2]; /* start/last pairs */
2747 int nbounds;
2748 } PGBAddrs;
2749
2750 static bool pgb_try_mmap_set(const PGBAddrs *ga, uintptr_t base, uintptr_t brk)
2751 {
2752 for (int i = ga->nbounds - 1; i >= 0; --i) {
2753 if (pgb_try_mmap_skip_brk(ga->bounds[i][0] + base,
2754 ga->bounds[i][1] + base,
2755 brk, i == 0 && reserved_va) <= 0) {
2756 return false;
2757 }
2758 }
2759 return true;
2760 }
2761
2762 /**
2763 * pgb_addr_set:
2764 * @ga: output set of guest addrs
2765 * @guest_loaddr: guest image low address
2766 * @guest_loaddr: guest image high address
2767 * @identity: create for identity mapping
2768 *
2769 * Fill in @ga with the image, COMMPAGE and NULL page.
2770 */
2771 static bool pgb_addr_set(PGBAddrs *ga, abi_ulong guest_loaddr,
2772 abi_ulong guest_hiaddr, bool try_identity)
2773 {
2774 int n;
2775
2776 /*
2777 * With a low commpage, or a guest mapped very low,
2778 * we may not be able to use the identity map.
2779 */
2780 if (try_identity) {
2781 if (LO_COMMPAGE != -1 && LO_COMMPAGE < mmap_min_addr) {
2782 return false;
2783 }
2784 if (guest_loaddr != 0 && guest_loaddr < mmap_min_addr) {
2785 return false;
2786 }
2787 }
2788
2789 memset(ga, 0, sizeof(*ga));
2790 n = 0;
2791
2792 if (reserved_va) {
2793 ga->bounds[n][0] = try_identity ? mmap_min_addr : 0;
2794 ga->bounds[n][1] = reserved_va;
2795 n++;
2796 /* LO_COMMPAGE and NULL handled by reserving from 0. */
2797 } else {
2798 /* Add any LO_COMMPAGE or NULL page. */
2799 if (LO_COMMPAGE != -1) {
2800 ga->bounds[n][0] = 0;
2801 ga->bounds[n][1] = LO_COMMPAGE + TARGET_PAGE_SIZE - 1;
2802 n++;
2803 } else if (!try_identity) {
2804 ga->bounds[n][0] = 0;
2805 ga->bounds[n][1] = TARGET_PAGE_SIZE - 1;
2806 n++;
2807 }
2808
2809 /* Add the guest image for ET_EXEC. */
2810 if (guest_loaddr) {
2811 ga->bounds[n][0] = guest_loaddr;
2812 ga->bounds[n][1] = guest_hiaddr;
2813 n++;
2814 }
2815 }
2816
2817 /*
2818 * Temporarily disable
2819 * "comparison is always false due to limited range of data type"
2820 * due to comparison between unsigned and (possible) 0.
2821 */
2822 #pragma GCC diagnostic push
2823 #pragma GCC diagnostic ignored "-Wtype-limits"
2824
2825 /* Add any HI_COMMPAGE not covered by reserved_va. */
2826 if (reserved_va < HI_COMMPAGE) {
2827 ga->bounds[n][0] = HI_COMMPAGE & qemu_host_page_mask;
2828 ga->bounds[n][1] = HI_COMMPAGE + TARGET_PAGE_SIZE - 1;
2829 n++;
2830 }
2831
2832 #pragma GCC diagnostic pop
2833
2834 ga->nbounds = n;
2835 return true;
2836 }
2837
2838 static void pgb_fail_in_use(const char *image_name)
2839 {
2840 error_report("%s: requires virtual address space that is in use "
2841 "(omit the -B option or choose a different value)",
2842 image_name);
2843 exit(EXIT_FAILURE);
2844 }
2845
2846 static void pgb_fixed(const char *image_name, uintptr_t guest_loaddr,
2847 uintptr_t guest_hiaddr, uintptr_t align)
2848 {
2849 PGBAddrs ga;
2850 uintptr_t brk = (uintptr_t)sbrk(0);
2851
2852 if (!QEMU_IS_ALIGNED(guest_base, align)) {
2853 fprintf(stderr, "Requested guest base %p does not satisfy "
2854 "host minimum alignment (0x%" PRIxPTR ")\n",
2855 (void *)guest_base, align);
2856 exit(EXIT_FAILURE);
2857 }
2858
2859 if (!pgb_addr_set(&ga, guest_loaddr, guest_hiaddr, !guest_base)
2860 || !pgb_try_mmap_set(&ga, guest_base, brk)) {
2861 pgb_fail_in_use(image_name);
2862 }
2863 }
2864
2865 /**
2866 * pgb_find_fallback:
2867 *
2868 * This is a fallback method for finding holes in the host address space
2869 * if we don't have the benefit of being able to access /proc/self/map.
2870 * It can potentially take a very long time as we can only dumbly iterate
2871 * up the host address space seeing if the allocation would work.
2872 */
2873 static uintptr_t pgb_find_fallback(const PGBAddrs *ga, uintptr_t align,
2874 uintptr_t brk)
2875 {
2876 /* TODO: come up with a better estimate of how much to skip. */
2877 uintptr_t skip = sizeof(uintptr_t) == 4 ? MiB : GiB;
2878
2879 for (uintptr_t base = skip; ; base += skip) {
2880 base = ROUND_UP(base, align);
2881 if (pgb_try_mmap_set(ga, base, brk)) {
2882 return base;
2883 }
2884 if (base >= -skip) {
2885 return -1;
2886 }
2887 }
2888 }
2889
2890 static uintptr_t pgb_try_itree(const PGBAddrs *ga, uintptr_t base,
2891 IntervalTreeRoot *root)
2892 {
2893 for (int i = ga->nbounds - 1; i >= 0; --i) {
2894 uintptr_t s = base + ga->bounds[i][0];
2895 uintptr_t l = base + ga->bounds[i][1];
2896 IntervalTreeNode *n;
2897
2898 if (l < s) {
2899 /* Wraparound. Skip to advance S to mmap_min_addr. */
2900 return mmap_min_addr - s;
2901 }
2902
2903 n = interval_tree_iter_first(root, s, l);
2904 if (n != NULL) {
2905 /* Conflict. Skip to advance S to LAST + 1. */
2906 return n->last - s + 1;
2907 }
2908 }
2909 return 0; /* success */
2910 }
2911
2912 static uintptr_t pgb_find_itree(const PGBAddrs *ga, IntervalTreeRoot *root,
2913 uintptr_t align, uintptr_t brk)
2914 {
2915 uintptr_t last = mmap_min_addr;
2916 uintptr_t base, skip;
2917
2918 while (true) {
2919 base = ROUND_UP(last, align);
2920 if (base < last) {
2921 return -1;
2922 }
2923
2924 skip = pgb_try_itree(ga, base, root);
2925 if (skip == 0) {
2926 break;
2927 }
2928
2929 last = base + skip;
2930 if (last < base) {
2931 return -1;
2932 }
2933 }
2934
2935 /*
2936 * We've chosen 'base' based on holes in the interval tree,
2937 * but we don't yet know if it is a valid host address.
2938 * Because it is the first matching hole, if the host addresses
2939 * are invalid we know there are no further matches.
2940 */
2941 return pgb_try_mmap_set(ga, base, brk) ? base : -1;
2942 }
2943
2944 static void pgb_dynamic(const char *image_name, uintptr_t guest_loaddr,
2945 uintptr_t guest_hiaddr, uintptr_t align)
2946 {
2947 IntervalTreeRoot *root;
2948 uintptr_t brk, ret;
2949 PGBAddrs ga;
2950
2951 assert(QEMU_IS_ALIGNED(guest_loaddr, align));
2952
2953 /* Try the identity map first. */
2954 if (pgb_addr_set(&ga, guest_loaddr, guest_hiaddr, true)) {
2955 brk = (uintptr_t)sbrk(0);
2956 if (pgb_try_mmap_set(&ga, 0, brk)) {
2957 guest_base = 0;
2958 return;
2959 }
2960 }
2961
2962 /*
2963 * Rebuild the address set for non-identity map.
2964 * This differs in the mapping of the guest NULL page.
2965 */
2966 pgb_addr_set(&ga, guest_loaddr, guest_hiaddr, false);
2967
2968 root = read_self_maps();
2969
2970 /* Read brk after we've read the maps, which will malloc. */
2971 brk = (uintptr_t)sbrk(0);
2972
2973 if (!root) {
2974 ret = pgb_find_fallback(&ga, align, brk);
2975 } else {
2976 /*
2977 * Reserve the area close to the host brk.
2978 * This will be freed with the rest of the tree.
2979 */
2980 IntervalTreeNode *b = g_new0(IntervalTreeNode, 1);
2981 b->start = brk;
2982 b->last = brk + 16 * MiB - 1;
2983 interval_tree_insert(b, root);
2984
2985 ret = pgb_find_itree(&ga, root, align, brk);
2986 free_self_maps(root);
2987 }
2988
2989 if (ret == -1) {
2990 int w = TARGET_LONG_BITS / 4;
2991
2992 error_report("%s: Unable to find a guest_base to satisfy all "
2993 "guest address mapping requirements", image_name);
2994
2995 for (int i = 0; i < ga.nbounds; ++i) {
2996 error_printf(" %0*" PRIx64 "-%0*" PRIx64 "\n",
2997 w, (uint64_t)ga.bounds[i][0],
2998 w, (uint64_t)ga.bounds[i][1]);
2999 }
3000 exit(EXIT_FAILURE);
3001 }
3002 guest_base = ret;
3003 }
3004
3005 void probe_guest_base(const char *image_name, abi_ulong guest_loaddr,
3006 abi_ulong guest_hiaddr)
3007 {
3008 /* In order to use host shmat, we must be able to honor SHMLBA. */
3009 uintptr_t align = MAX(SHMLBA, qemu_host_page_size);
3010
3011 /* Sanity check the guest binary. */
3012 if (reserved_va) {
3013 if (guest_hiaddr > reserved_va) {
3014 error_report("%s: requires more than reserved virtual "
3015 "address space (0x%" PRIx64 " > 0x%lx)",
3016 image_name, (uint64_t)guest_hiaddr, reserved_va);
3017 exit(EXIT_FAILURE);
3018 }
3019 } else {
3020 if (guest_hiaddr != (uintptr_t)guest_hiaddr) {
3021 error_report("%s: requires more virtual address space "
3022 "than the host can provide (0x%" PRIx64 ")",
3023 image_name, (uint64_t)guest_hiaddr + 1);
3024 exit(EXIT_FAILURE);
3025 }
3026 }
3027
3028 if (have_guest_base) {
3029 pgb_fixed(image_name, guest_loaddr, guest_hiaddr, align);
3030 } else {
3031 pgb_dynamic(image_name, guest_loaddr, guest_hiaddr, align);
3032 }
3033
3034 /* Reserve and initialize the commpage. */
3035 if (!init_guest_commpage()) {
3036 /* We have already probed for the commpage being free. */
3037 g_assert_not_reached();
3038 }
3039
3040 assert(QEMU_IS_ALIGNED(guest_base, align));
3041 qemu_log_mask(CPU_LOG_PAGE, "Locating guest address space "
3042 "@ 0x%" PRIx64 "\n", (uint64_t)guest_base);
3043 }
3044
3045 enum {
3046 /* The string "GNU\0" as a magic number. */
3047 GNU0_MAGIC = const_le32('G' | 'N' << 8 | 'U' << 16),
3048 NOTE_DATA_SZ = 1 * KiB,
3049 NOTE_NAME_SZ = 4,
3050 ELF_GNU_PROPERTY_ALIGN = ELF_CLASS == ELFCLASS32 ? 4 : 8,
3051 };
3052
3053 /*
3054 * Process a single gnu_property entry.
3055 * Return false for error.
3056 */
3057 static bool parse_elf_property(const uint32_t *data, int *off, int datasz,
3058 struct image_info *info, bool have_prev_type,
3059 uint32_t *prev_type, Error **errp)
3060 {
3061 uint32_t pr_type, pr_datasz, step;
3062
3063 if (*off > datasz || !QEMU_IS_ALIGNED(*off, ELF_GNU_PROPERTY_ALIGN)) {
3064 goto error_data;
3065 }
3066 datasz -= *off;
3067 data += *off / sizeof(uint32_t);
3068
3069 if (datasz < 2 * sizeof(uint32_t)) {
3070 goto error_data;
3071 }
3072 pr_type = data[0];
3073 pr_datasz = data[1];
3074 data += 2;
3075 datasz -= 2 * sizeof(uint32_t);
3076 step = ROUND_UP(pr_datasz, ELF_GNU_PROPERTY_ALIGN);
3077 if (step > datasz) {
3078 goto error_data;
3079 }
3080
3081 /* Properties are supposed to be unique and sorted on pr_type. */
3082 if (have_prev_type && pr_type <= *prev_type) {
3083 if (pr_type == *prev_type) {
3084 error_setg(errp, "Duplicate property in PT_GNU_PROPERTY");
3085 } else {
3086 error_setg(errp, "Unsorted property in PT_GNU_PROPERTY");
3087 }
3088 return false;
3089 }
3090 *prev_type = pr_type;
3091
3092 if (!arch_parse_elf_property(pr_type, pr_datasz, data, info, errp)) {
3093 return false;
3094 }
3095
3096 *off += 2 * sizeof(uint32_t) + step;
3097 return true;
3098
3099 error_data:
3100 error_setg(errp, "Ill-formed property in PT_GNU_PROPERTY");
3101 return false;
3102 }
3103
3104 /* Process NT_GNU_PROPERTY_TYPE_0. */
3105 static bool parse_elf_properties(int image_fd,
3106 struct image_info *info,
3107 const struct elf_phdr *phdr,
3108 char bprm_buf[BPRM_BUF_SIZE],
3109 Error **errp)
3110 {
3111 union {
3112 struct elf_note nhdr;
3113 uint32_t data[NOTE_DATA_SZ / sizeof(uint32_t)];
3114 } note;
3115
3116 int n, off, datasz;
3117 bool have_prev_type;
3118 uint32_t prev_type;
3119
3120 /* Unless the arch requires properties, ignore them. */
3121 if (!ARCH_USE_GNU_PROPERTY) {
3122 return true;
3123 }
3124
3125 /* If the properties are crazy large, that's too bad. */
3126 n = phdr->p_filesz;
3127 if (n > sizeof(note)) {
3128 error_setg(errp, "PT_GNU_PROPERTY too large");
3129 return false;
3130 }
3131 if (n < sizeof(note.nhdr)) {
3132 error_setg(errp, "PT_GNU_PROPERTY too small");
3133 return false;
3134 }
3135
3136 if (phdr->p_offset + n <= BPRM_BUF_SIZE) {
3137 memcpy(&note, bprm_buf + phdr->p_offset, n);
3138 } else {
3139 ssize_t len = pread(image_fd, &note, n, phdr->p_offset);
3140 if (len != n) {
3141 error_setg_errno(errp, errno, "Error reading file header");
3142 return false;
3143 }
3144 }
3145
3146 /*
3147 * The contents of a valid PT_GNU_PROPERTY is a sequence
3148 * of uint32_t -- swap them all now.
3149 */
3150 #ifdef BSWAP_NEEDED
3151 for (int i = 0; i < n / 4; i++) {
3152 bswap32s(note.data + i);
3153 }
3154 #endif
3155
3156 /*
3157 * Note that nhdr is 3 words, and that the "name" described by namesz
3158 * immediately follows nhdr and is thus at the 4th word. Further, all
3159 * of the inputs to the kernel's round_up are multiples of 4.
3160 */
3161 if (note.nhdr.n_type != NT_GNU_PROPERTY_TYPE_0 ||
3162 note.nhdr.n_namesz != NOTE_NAME_SZ ||
3163 note.data[3] != GNU0_MAGIC) {
3164 error_setg(errp, "Invalid note in PT_GNU_PROPERTY");
3165 return false;
3166 }
3167 off = sizeof(note.nhdr) + NOTE_NAME_SZ;
3168
3169 datasz = note.nhdr.n_descsz + off;
3170 if (datasz > n) {
3171 error_setg(errp, "Invalid note size in PT_GNU_PROPERTY");
3172 return false;
3173 }
3174
3175 have_prev_type = false;
3176 prev_type = 0;
3177 while (1) {
3178 if (off == datasz) {
3179 return true; /* end, exit ok */
3180 }
3181 if (!parse_elf_property(note.data, &off, datasz, info,
3182 have_prev_type, &prev_type, errp)) {
3183 return false;
3184 }
3185 have_prev_type = true;
3186 }
3187 }
3188
3189 /* Load an ELF image into the address space.
3190
3191 IMAGE_NAME is the filename of the image, to use in error messages.
3192 IMAGE_FD is the open file descriptor for the image.
3193
3194 BPRM_BUF is a copy of the beginning of the file; this of course
3195 contains the elf file header at offset 0. It is assumed that this
3196 buffer is sufficiently aligned to present no problems to the host
3197 in accessing data at aligned offsets within the buffer.
3198
3199 On return: INFO values will be filled in, as necessary or available. */
3200
3201 static void load_elf_image(const char *image_name, int image_fd,
3202 struct image_info *info, char **pinterp_name,
3203 char bprm_buf[BPRM_BUF_SIZE])
3204 {
3205 struct elfhdr *ehdr = (struct elfhdr *)bprm_buf;
3206 struct elf_phdr *phdr;
3207 abi_ulong load_addr, load_bias, loaddr, hiaddr, error;
3208 int i, retval, prot_exec;
3209 Error *err = NULL;
3210
3211 /* First of all, some simple consistency checks */
3212 if (!elf_check_ident(ehdr)) {
3213 error_setg(&err, "Invalid ELF image for this architecture");
3214 goto exit_errmsg;
3215 }
3216 bswap_ehdr(ehdr);
3217 if (!elf_check_ehdr(ehdr)) {
3218 error_setg(&err, "Invalid ELF image for this architecture");
3219 goto exit_errmsg;
3220 }
3221
3222 i = ehdr->e_phnum * sizeof(struct elf_phdr);
3223 if (ehdr->e_phoff + i <= BPRM_BUF_SIZE) {
3224 phdr = (struct elf_phdr *)(bprm_buf + ehdr->e_phoff);
3225 } else {
3226 phdr = (struct elf_phdr *) alloca(i);
3227 retval = pread(image_fd, phdr, i, ehdr->e_phoff);
3228 if (retval != i) {
3229 goto exit_read;
3230 }
3231 }
3232 bswap_phdr(phdr, ehdr->e_phnum);
3233
3234 info->nsegs = 0;
3235 info->pt_dynamic_addr = 0;
3236
3237 mmap_lock();
3238
3239 /*
3240 * Find the maximum size of the image and allocate an appropriate
3241 * amount of memory to handle that. Locate the interpreter, if any.
3242 */
3243 loaddr = -1, hiaddr = 0;
3244 info->alignment = 0;
3245 info->exec_stack = EXSTACK_DEFAULT;
3246 for (i = 0; i < ehdr->e_phnum; ++i) {
3247 struct elf_phdr *eppnt = phdr + i;
3248 if (eppnt->p_type == PT_LOAD) {
3249 abi_ulong a = eppnt->p_vaddr - eppnt->p_offset;
3250 if (a < loaddr) {
3251 loaddr = a;
3252 }
3253 a = eppnt->p_vaddr + eppnt->p_memsz - 1;
3254 if (a > hiaddr) {
3255 hiaddr = a;
3256 }
3257 ++info->nsegs;
3258 info->alignment |= eppnt->p_align;
3259 } else if (eppnt->p_type == PT_INTERP && pinterp_name) {
3260 g_autofree char *interp_name = NULL;
3261
3262 if (*pinterp_name) {
3263 error_setg(&err, "Multiple PT_INTERP entries");
3264 goto exit_errmsg;
3265 }
3266
3267 interp_name = g_malloc(eppnt->p_filesz);
3268
3269 if (eppnt->p_offset + eppnt->p_filesz <= BPRM_BUF_SIZE) {
3270 memcpy(interp_name, bprm_buf + eppnt->p_offset,
3271 eppnt->p_filesz);
3272 } else {
3273 retval = pread(image_fd, interp_name, eppnt->p_filesz,
3274 eppnt->p_offset);
3275 if (retval != eppnt->p_filesz) {
3276 goto exit_read;
3277 }
3278 }
3279 if (interp_name[eppnt->p_filesz - 1] != 0) {
3280 error_setg(&err, "Invalid PT_INTERP entry");
3281 goto exit_errmsg;
3282 }
3283 *pinterp_name = g_steal_pointer(&interp_name);
3284 } else if (eppnt->p_type == PT_GNU_PROPERTY) {
3285 if (!parse_elf_properties(image_fd, info, eppnt, bprm_buf, &err)) {
3286 goto exit_errmsg;
3287 }
3288 } else if (eppnt->p_type == PT_GNU_STACK) {
3289 info->exec_stack = eppnt->p_flags & PF_X;
3290 }
3291 }
3292
3293 load_addr = loaddr;
3294
3295 if (pinterp_name != NULL) {
3296 if (ehdr->e_type == ET_EXEC) {
3297 /*
3298 * Make sure that the low address does not conflict with
3299 * MMAP_MIN_ADDR or the QEMU application itself.
3300 */
3301 probe_guest_base(image_name, loaddr, hiaddr);
3302 } else {
3303 abi_ulong align;
3304
3305 /*
3306 * The binary is dynamic, but we still need to
3307 * select guest_base. In this case we pass a size.
3308 */
3309 probe_guest_base(image_name, 0, hiaddr - loaddr);
3310
3311 /*
3312 * Avoid collision with the loader by providing a different
3313 * default load address.
3314 */
3315 load_addr += elf_et_dyn_base;
3316
3317 /*
3318 * TODO: Better support for mmap alignment is desirable.
3319 * Since we do not have complete control over the guest
3320 * address space, we prefer the kernel to choose some address
3321 * rather than force the use of LOAD_ADDR via MAP_FIXED.
3322 * But without MAP_FIXED we cannot guarantee alignment,
3323 * only suggest it.
3324 */
3325 align = pow2ceil(info->alignment);
3326 if (align) {
3327 load_addr &= -align;
3328 }
3329 }
3330 }
3331
3332 /*
3333 * Reserve address space for all of this.
3334 *
3335 * In the case of ET_EXEC, we supply MAP_FIXED_NOREPLACE so that we get
3336 * exactly the address range that is required. Without reserved_va,
3337 * the guest address space is not isolated. We have attempted to avoid
3338 * conflict with the host program itself via probe_guest_base, but using
3339 * MAP_FIXED_NOREPLACE instead of MAP_FIXED provides an extra check.
3340 *
3341 * Otherwise this is ET_DYN, and we are searching for a location
3342 * that can hold the memory space required. If the image is
3343 * pre-linked, LOAD_ADDR will be non-zero, and the kernel should
3344 * honor that address if it happens to be free.
3345 *
3346 * In both cases, we will overwrite pages in this range with mappings
3347 * from the executable.
3348 */
3349 load_addr = target_mmap(load_addr, (size_t)hiaddr - loaddr + 1, PROT_NONE,
3350 MAP_PRIVATE | MAP_ANON | MAP_NORESERVE |
3351 (ehdr->e_type == ET_EXEC ? MAP_FIXED_NOREPLACE : 0),
3352 -1, 0);
3353 if (load_addr == -1) {
3354 goto exit_mmap;
3355 }
3356 load_bias = load_addr - loaddr;
3357
3358 if (elf_is_fdpic(ehdr)) {
3359 struct elf32_fdpic_loadseg *loadsegs = info->loadsegs =
3360 g_malloc(sizeof(*loadsegs) * info->nsegs);
3361
3362 for (i = 0; i < ehdr->e_phnum; ++i) {
3363 switch (phdr[i].p_type) {
3364 case PT_DYNAMIC:
3365 info->pt_dynamic_addr = phdr[i].p_vaddr + load_bias;
3366 break;
3367 case PT_LOAD:
3368 loadsegs->addr = phdr[i].p_vaddr + load_bias;
3369 loadsegs->p_vaddr = phdr[i].p_vaddr;
3370 loadsegs->p_memsz = phdr[i].p_memsz;
3371 ++loadsegs;
3372 break;
3373 }
3374 }
3375 }
3376
3377 info->load_bias = load_bias;
3378 info->code_offset = load_bias;
3379 info->data_offset = load_bias;
3380 info->load_addr = load_addr;
3381 info->entry = ehdr->e_entry + load_bias;
3382 info->start_code = -1;
3383 info->end_code = 0;
3384 info->start_data = -1;
3385 info->end_data = 0;
3386 /* Usual start for brk is after all sections of the main executable. */
3387 info->brk = TARGET_PAGE_ALIGN(hiaddr + load_bias);
3388 info->elf_flags = ehdr->e_flags;
3389
3390 prot_exec = PROT_EXEC;
3391 #ifdef TARGET_AARCH64
3392 /*
3393 * If the BTI feature is present, this indicates that the executable
3394 * pages of the startup binary should be mapped with PROT_BTI, so that
3395 * branch targets are enforced.
3396 *
3397 * The startup binary is either the interpreter or the static executable.
3398 * The interpreter is responsible for all pages of a dynamic executable.
3399 *
3400 * Elf notes are backward compatible to older cpus.
3401 * Do not enable BTI unless it is supported.
3402 */
3403 if ((info->note_flags & GNU_PROPERTY_AARCH64_FEATURE_1_BTI)
3404 && (pinterp_name == NULL || *pinterp_name == 0)
3405 && cpu_isar_feature(aa64_bti, ARM_CPU(thread_cpu))) {
3406 prot_exec |= TARGET_PROT_BTI;
3407 }
3408 #endif
3409
3410 for (i = 0; i < ehdr->e_phnum; i++) {
3411 struct elf_phdr *eppnt = phdr + i;
3412 if (eppnt->p_type == PT_LOAD) {
3413 abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em;
3414 int elf_prot = 0;
3415
3416 if (eppnt->p_flags & PF_R) {
3417 elf_prot |= PROT_READ;
3418 }
3419 if (eppnt->p_flags & PF_W) {
3420 elf_prot |= PROT_WRITE;
3421 }
3422 if (eppnt->p_flags & PF_X) {
3423 elf_prot |= prot_exec;
3424 }
3425
3426 vaddr = load_bias + eppnt->p_vaddr;
3427 vaddr_po = vaddr & ~TARGET_PAGE_MASK;
3428 vaddr_ps = vaddr & TARGET_PAGE_MASK;
3429
3430 vaddr_ef = vaddr + eppnt->p_filesz;
3431 vaddr_em = vaddr + eppnt->p_memsz;
3432
3433 /*
3434 * Some segments may be completely empty, with a non-zero p_memsz
3435 * but no backing file segment.
3436 */
3437 if (eppnt->p_filesz != 0) {
3438 error = target_mmap(vaddr_ps, eppnt->p_filesz + vaddr_po,
3439 elf_prot, MAP_PRIVATE | MAP_FIXED,
3440 image_fd, eppnt->p_offset - vaddr_po);
3441 if (error == -1) {
3442 goto exit_mmap;
3443 }
3444 }
3445
3446 /* If the load segment requests extra zeros (e.g. bss), map it. */
3447 if (vaddr_ef < vaddr_em &&
3448 !zero_bss(vaddr_ef, vaddr_em, elf_prot, &err)) {
3449 goto exit_errmsg;
3450 }
3451
3452 /* Find the full program boundaries. */
3453 if (elf_prot & PROT_EXEC) {
3454 if (vaddr < info->start_code) {
3455 info->start_code = vaddr;
3456 }
3457 if (vaddr_ef > info->end_code) {
3458 info->end_code = vaddr_ef;
3459 }
3460 }
3461 if (elf_prot & PROT_WRITE) {
3462 if (vaddr < info->start_data) {
3463 info->start_data = vaddr;
3464 }
3465 if (vaddr_ef > info->end_data) {
3466 info->end_data = vaddr_ef;
3467 }
3468 }
3469 #ifdef TARGET_MIPS
3470 } else if (eppnt->p_type == PT_MIPS_ABIFLAGS) {
3471 Mips_elf_abiflags_v0 abiflags;
3472 if (eppnt->p_filesz < sizeof(Mips_elf_abiflags_v0)) {
3473 error_setg(&err, "Invalid PT_MIPS_ABIFLAGS entry");
3474 goto exit_errmsg;
3475 }
3476 if (eppnt->p_offset + eppnt->p_filesz <= BPRM_BUF_SIZE) {
3477 memcpy(&abiflags, bprm_buf + eppnt->p_offset,
3478 sizeof(Mips_elf_abiflags_v0));
3479 } else {
3480 retval = pread(image_fd, &abiflags, sizeof(Mips_elf_abiflags_v0),
3481 eppnt->p_offset);
3482 if (retval != sizeof(Mips_elf_abiflags_v0)) {
3483 goto exit_read;
3484 }
3485 }
3486 bswap_mips_abiflags(&abiflags);
3487 info->fp_abi = abiflags.fp_abi;
3488 #endif
3489 }
3490 }
3491
3492 if (info->end_data == 0) {
3493 info->start_data = info->end_code;
3494 info->end_data = info->end_code;
3495 }
3496
3497 if (qemu_log_enabled()) {
3498 load_symbols(ehdr, image_fd, load_bias);
3499 }
3500
3501 debuginfo_report_elf(image_name, image_fd, load_bias);
3502
3503 mmap_unlock();
3504
3505 close(image_fd);
3506 return;
3507
3508 exit_read:
3509 if (retval >= 0) {
3510 error_setg(&err, "Incomplete read of file header");
3511 } else {
3512 error_setg_errno(&err, errno, "Error reading file header");
3513 }
3514 goto exit_errmsg;
3515 exit_mmap:
3516 error_setg_errno(&err, errno, "Error mapping file");
3517 goto exit_errmsg;
3518 exit_errmsg:
3519 error_reportf_err(err, "%s: ", image_name);
3520 exit(-1);
3521 }
3522
3523 static void load_elf_interp(const char *filename, struct image_info *info,
3524 char bprm_buf[BPRM_BUF_SIZE])
3525 {
3526 int fd, retval;
3527 Error *err = NULL;
3528
3529 fd = open(path(filename), O_RDONLY);
3530 if (fd < 0) {
3531 error_setg_file_open(&err, errno, filename);
3532 error_report_err(err);
3533 exit(-1);
3534 }
3535
3536 retval = read(fd, bprm_buf, BPRM_BUF_SIZE);
3537 if (retval < 0) {
3538 error_setg_errno(&err, errno, "Error reading file header");
3539 error_reportf_err(err, "%s: ", filename);
3540 exit(-1);
3541 }
3542
3543 if (retval < BPRM_BUF_SIZE) {
3544 memset(bprm_buf + retval, 0, BPRM_BUF_SIZE - retval);
3545 }
3546
3547 load_elf_image(filename, fd, info, NULL, bprm_buf);
3548 }
3549
3550 static int symfind(const void *s0, const void *s1)
3551 {
3552 struct elf_sym *sym = (struct elf_sym *)s1;
3553 __typeof(sym->st_value) addr = *(uint64_t *)s0;
3554 int result = 0;
3555
3556 if (addr < sym->st_value) {
3557 result = -1;
3558 } else if (addr >= sym->st_value + sym->st_size) {
3559 result = 1;
3560 }
3561 return result;
3562 }
3563
3564 static const char *lookup_symbolxx(struct syminfo *s, uint64_t orig_addr)
3565 {
3566 #if ELF_CLASS == ELFCLASS32
3567 struct elf_sym *syms = s->disas_symtab.elf32;
3568 #else
3569 struct elf_sym *syms = s->disas_symtab.elf64;
3570 #endif
3571
3572 // binary search
3573 struct elf_sym *sym;
3574
3575 sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind);
3576 if (sym != NULL) {
3577 return s->disas_strtab + sym->st_name;
3578 }
3579
3580 return "";
3581 }
3582
3583 /* FIXME: This should use elf_ops.h */
3584 static int symcmp(const void *s0, const void *s1)
3585 {
3586 struct elf_sym *sym0 = (struct elf_sym *)s0;
3587 struct elf_sym *sym1 = (struct elf_sym *)s1;
3588 return (sym0->st_value < sym1->st_value)
3589 ? -1
3590 : ((sym0->st_value > sym1->st_value) ? 1 : 0);
3591 }
3592
3593 /* Best attempt to load symbols from this ELF object. */
3594 static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias)
3595 {
3596 int i, shnum, nsyms, sym_idx = 0, str_idx = 0;
3597 uint64_t segsz;
3598 struct elf_shdr *shdr;
3599 char *strings = NULL;
3600 struct syminfo *s = NULL;
3601 struct elf_sym *new_syms, *syms = NULL;
3602
3603 shnum = hdr->e_shnum;
3604 i = shnum * sizeof(struct elf_shdr);
3605 shdr = (struct elf_shdr *)alloca(i);
3606 if (pread(fd, shdr, i, hdr->e_shoff) != i) {
3607 return;
3608 }
3609
3610 bswap_shdr(shdr, shnum);
3611 for (i = 0; i < shnum; ++i) {
3612 if (shdr[i].sh_type == SHT_SYMTAB) {
3613 sym_idx = i;
3614 str_idx = shdr[i].sh_link;
3615 goto found;
3616 }
3617 }
3618
3619 /* There will be no symbol table if the file was stripped. */
3620 return;
3621
3622 found:
3623 /* Now know where the strtab and symtab are. Snarf them. */
3624 s = g_try_new(struct syminfo, 1);
3625 if (!s) {
3626 goto give_up;
3627 }
3628
3629 segsz = shdr[str_idx].sh_size;
3630 s->disas_strtab = strings = g_try_malloc(segsz);
3631 if (!strings ||
3632 pread(fd, strings, segsz, shdr[str_idx].sh_offset) != segsz) {
3633 goto give_up;
3634 }
3635
3636 segsz = shdr[sym_idx].sh_size;
3637 syms = g_try_malloc(segsz);
3638 if (!syms || pread(fd, syms, segsz, shdr[sym_idx].sh_offset) != segsz) {
3639 goto give_up;
3640 }
3641
3642 if (segsz / sizeof(struct elf_sym) > INT_MAX) {
3643 /* Implausibly large symbol table: give up rather than ploughing
3644 * on with the number of symbols calculation overflowing
3645 */
3646 goto give_up;
3647 }
3648 nsyms = segsz / sizeof(struct elf_sym);
3649 for (i = 0; i < nsyms; ) {
3650 bswap_sym(syms + i);
3651 /* Throw away entries which we do not need. */
3652 if (syms[i].st_shndx == SHN_UNDEF
3653 || syms[i].st_shndx >= SHN_LORESERVE
3654 || ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) {
3655 if (i < --nsyms) {
3656 syms[i] = syms[nsyms];
3657 }
3658 } else {
3659 #if defined(TARGET_ARM) || defined (TARGET_MIPS)
3660 /* The bottom address bit marks a Thumb or MIPS16 symbol. */
3661 syms[i].st_value &= ~(target_ulong)1;
3662 #endif
3663 syms[i].st_value += load_bias;
3664 i++;
3665 }
3666 }
3667
3668 /* No "useful" symbol. */
3669 if (nsyms == 0) {
3670 goto give_up;
3671 }
3672
3673 /* Attempt to free the storage associated with the local symbols
3674 that we threw away. Whether or not this has any effect on the
3675 memory allocation depends on the malloc implementation and how
3676 many symbols we managed to discard. */
3677 new_syms = g_try_renew(struct elf_sym, syms, nsyms);
3678 if (new_syms == NULL) {
3679 goto give_up;
3680 }
3681 syms = new_syms;
3682
3683 qsort(syms, nsyms, sizeof(*syms), symcmp);
3684
3685 s->disas_num_syms = nsyms;
3686 #if ELF_CLASS == ELFCLASS32
3687 s->disas_symtab.elf32 = syms;
3688 #else
3689 s->disas_symtab.elf64 = syms;
3690 #endif
3691 s->lookup_symbol = lookup_symbolxx;
3692 s->next = syminfos;
3693 syminfos = s;
3694
3695 return;
3696
3697 give_up:
3698 g_free(s);
3699 g_free(strings);
3700 g_free(syms);
3701 }
3702
3703 uint32_t get_elf_eflags(int fd)
3704 {
3705 struct elfhdr ehdr;
3706 off_t offset;
3707 int ret;
3708
3709 /* Read ELF header */
3710 offset = lseek(fd, 0, SEEK_SET);
3711 if (offset == (off_t) -1) {
3712 return 0;
3713 }
3714 ret = read(fd, &ehdr, sizeof(ehdr));
3715 if (ret < sizeof(ehdr)) {
3716 return 0;
3717 }
3718 offset = lseek(fd, offset, SEEK_SET);
3719 if (offset == (off_t) -1) {
3720 return 0;
3721 }
3722
3723 /* Check ELF signature */
3724 if (!elf_check_ident(&ehdr)) {
3725 return 0;
3726 }
3727
3728 /* check header */
3729 bswap_ehdr(&ehdr);
3730 if (!elf_check_ehdr(&ehdr)) {
3731 return 0;
3732 }
3733
3734 /* return architecture id */
3735 return ehdr.e_flags;
3736 }
3737
3738 int load_elf_binary(struct linux_binprm *bprm, struct image_info *info)
3739 {
3740 struct image_info interp_info;
3741 struct elfhdr elf_ex;
3742 char *elf_interpreter = NULL;
3743 char *scratch;
3744
3745 memset(&interp_info, 0, sizeof(interp_info));
3746 #ifdef TARGET_MIPS
3747 interp_info.fp_abi = MIPS_ABI_FP_UNKNOWN;
3748 #endif
3749
3750 load_elf_image(bprm->filename, bprm->fd, info,
3751 &elf_interpreter, bprm->buf);
3752
3753 /* ??? We need a copy of the elf header for passing to create_elf_tables.
3754 If we do nothing, we'll have overwritten this when we re-use bprm->buf
3755 when we load the interpreter. */
3756 elf_ex = *(struct elfhdr *)bprm->buf;
3757
3758 /* Do this so that we can load the interpreter, if need be. We will
3759 change some of these later */
3760 bprm->p = setup_arg_pages(bprm, info);
3761
3762 scratch = g_new0(char, TARGET_PAGE_SIZE);
3763 if (STACK_GROWS_DOWN) {
3764 bprm->p = copy_elf_strings(1, &bprm->filename, scratch,
3765 bprm->p, info->stack_limit);
3766 info->file_string = bprm->p;
3767 bprm->p = copy_elf_strings(bprm->envc, bprm->envp, scratch,
3768 bprm->p, info->stack_limit);
3769 info->env_strings = bprm->p;
3770 bprm->p = copy_elf_strings(bprm->argc, bprm->argv, scratch,
3771 bprm->p, info->stack_limit);
3772 info->arg_strings = bprm->p;
3773 } else {
3774 info->arg_strings = bprm->p;
3775 bprm->p = copy_elf_strings(bprm->argc, bprm->argv, scratch,
3776 bprm->p, info->stack_limit);
3777 info->env_strings = bprm->p;
3778 bprm->p = copy_elf_strings(bprm->envc, bprm->envp, scratch,
3779 bprm->p, info->stack_limit);
3780 info->file_string = bprm->p;
3781 bprm->p = copy_elf_strings(1, &bprm->filename, scratch,
3782 bprm->p, info->stack_limit);
3783 }
3784
3785 g_free(scratch);
3786
3787 if (!bprm->p) {
3788 fprintf(stderr, "%s: %s\n", bprm->filename, strerror(E2BIG));
3789 exit(-1);
3790 }
3791
3792 if (elf_interpreter) {
3793 load_elf_interp(elf_interpreter, &interp_info, bprm->buf);
3794
3795 /*
3796 * While unusual because of ELF_ET_DYN_BASE, if we are unlucky
3797 * with the mappings the interpreter can be loaded above but
3798 * near the main executable, which can leave very little room
3799 * for the heap.
3800 * If the current brk has less than 16MB, use the end of the
3801 * interpreter.
3802 */
3803 if (interp_info.brk > info->brk &&
3804 interp_info.load_bias - info->brk < 16 * MiB) {
3805 info->brk = interp_info.brk;
3806 }
3807
3808 /* If the program interpreter is one of these two, then assume
3809 an iBCS2 image. Otherwise assume a native linux image. */
3810
3811 if (strcmp(elf_interpreter, "/usr/lib/libc.so.1") == 0
3812 || strcmp(elf_interpreter, "/usr/lib/ld.so.1") == 0) {
3813 info->personality = PER_SVR4;
3814
3815 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
3816 and some applications "depend" upon this behavior. Since
3817 we do not have the power to recompile these, we emulate
3818 the SVr4 behavior. Sigh. */
3819 target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
3820 MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
3821 }
3822 #ifdef TARGET_MIPS
3823 info->interp_fp_abi = interp_info.fp_abi;
3824 #endif
3825 }
3826
3827 /*
3828 * TODO: load a vdso, which would also contain the signal trampolines.
3829 * Otherwise, allocate a private page to hold them.
3830 */
3831 if (TARGET_ARCH_HAS_SIGTRAMP_PAGE) {
3832 abi_long tramp_page = target_mmap(0, TARGET_PAGE_SIZE,
3833 PROT_READ | PROT_WRITE,
3834 MAP_PRIVATE | MAP_ANON, -1, 0);
3835 if (tramp_page == -1) {
3836 return -errno;
3837 }
3838
3839 setup_sigtramp(tramp_page);
3840 target_mprotect(tramp_page, TARGET_PAGE_SIZE, PROT_READ | PROT_EXEC);
3841 }
3842
3843 bprm->p = create_elf_tables(bprm->p, bprm->argc, bprm->envc, &elf_ex,
3844 info, (elf_interpreter ? &interp_info : NULL));
3845 info->start_stack = bprm->p;
3846
3847 /* If we have an interpreter, set that as the program's entry point.
3848 Copy the load_bias as well, to help PPC64 interpret the entry
3849 point as a function descriptor. Do this after creating elf tables
3850 so that we copy the original program entry point into the AUXV. */
3851 if (elf_interpreter) {
3852 info->load_bias = interp_info.load_bias;
3853 info->entry = interp_info.entry;
3854 g_free(elf_interpreter);
3855 }
3856
3857 #ifdef USE_ELF_CORE_DUMP
3858 bprm->core_dump = &elf_core_dump;
3859 #endif
3860
3861 return 0;
3862 }
3863
3864 #ifdef USE_ELF_CORE_DUMP
3865 /*
3866 * Definitions to generate Intel SVR4-like core files.
3867 * These mostly have the same names as the SVR4 types with "target_elf_"
3868 * tacked on the front to prevent clashes with linux definitions,
3869 * and the typedef forms have been avoided. This is mostly like
3870 * the SVR4 structure, but more Linuxy, with things that Linux does
3871 * not support and which gdb doesn't really use excluded.
3872 *
3873 * Fields we don't dump (their contents is zero) in linux-user qemu
3874 * are marked with XXX.
3875 *
3876 * Core dump code is copied from linux kernel (fs/binfmt_elf.c).
3877 *
3878 * Porting ELF coredump for target is (quite) simple process. First you
3879 * define USE_ELF_CORE_DUMP in target ELF code (where init_thread() for
3880 * the target resides):
3881 *
3882 * #define USE_ELF_CORE_DUMP
3883 *
3884 * Next you define type of register set used for dumping. ELF specification
3885 * says that it needs to be array of elf_greg_t that has size of ELF_NREG.
3886 *
3887 * typedef <target_regtype> target_elf_greg_t;
3888 * #define ELF_NREG <number of registers>
3889 * typedef taret_elf_greg_t target_elf_gregset_t[ELF_NREG];
3890 *
3891 * Last step is to implement target specific function that copies registers
3892 * from given cpu into just specified register set. Prototype is:
3893 *
3894 * static void elf_core_copy_regs(taret_elf_gregset_t *regs,
3895 * const CPUArchState *env);
3896 *
3897 * Parameters:
3898 * regs - copy register values into here (allocated and zeroed by caller)
3899 * env - copy registers from here
3900 *
3901 * Example for ARM target is provided in this file.
3902 */
3903
3904 /* An ELF note in memory */
3905 struct memelfnote {
3906 const char *name;
3907 size_t namesz;
3908 size_t namesz_rounded;
3909 int type;
3910 size_t datasz;
3911 size_t datasz_rounded;
3912 void *data;
3913 size_t notesz;
3914 };
3915
3916 struct target_elf_siginfo {
3917 abi_int si_signo; /* signal number */
3918 abi_int si_code; /* extra code */
3919 abi_int si_errno; /* errno */
3920 };
3921
3922 struct target_elf_prstatus {
3923 struct target_elf_siginfo pr_info; /* Info associated with signal */
3924 abi_short pr_cursig; /* Current signal */
3925 abi_ulong pr_sigpend; /* XXX */
3926 abi_ulong pr_sighold; /* XXX */
3927 target_pid_t pr_pid;
3928 target_pid_t pr_ppid;
3929 target_pid_t pr_pgrp;
3930 target_pid_t pr_sid;
3931 struct target_timeval pr_utime; /* XXX User time */
3932 struct target_timeval pr_stime; /* XXX System time */
3933 struct target_timeval pr_cutime; /* XXX Cumulative user time */
3934 struct target_timeval pr_cstime; /* XXX Cumulative system time */
3935 target_elf_gregset_t pr_reg; /* GP registers */
3936 abi_int pr_fpvalid; /* XXX */
3937 };
3938
3939 #define ELF_PRARGSZ (80) /* Number of chars for args */
3940
3941 struct target_elf_prpsinfo {
3942 char pr_state; /* numeric process state */
3943 char pr_sname; /* char for pr_state */
3944 char pr_zomb; /* zombie */
3945 char pr_nice; /* nice val */
3946 abi_ulong pr_flag; /* flags */
3947 target_uid_t pr_uid;
3948 target_gid_t pr_gid;
3949 target_pid_t pr_pid, pr_ppid, pr_pgrp, pr_sid;
3950 /* Lots missing */
3951 char pr_fname[16] QEMU_NONSTRING; /* filename of executable */
3952 char pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
3953 };
3954
3955 /* Here is the structure in which status of each thread is captured. */
3956 struct elf_thread_status {
3957 QTAILQ_ENTRY(elf_thread_status) ets_link;
3958 struct target_elf_prstatus prstatus; /* NT_PRSTATUS */
3959 #if 0
3960 elf_fpregset_t fpu; /* NT_PRFPREG */
3961 struct task_struct *thread;
3962 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
3963 #endif
3964 struct memelfnote notes[1];
3965 int num_notes;
3966 };
3967
3968 struct elf_note_info {
3969 struct memelfnote *notes;
3970 struct target_elf_prstatus *prstatus; /* NT_PRSTATUS */
3971 struct target_elf_prpsinfo *psinfo; /* NT_PRPSINFO */
3972
3973 QTAILQ_HEAD(, elf_thread_status) thread_list;
3974 #if 0
3975 /*
3976 * Current version of ELF coredump doesn't support
3977 * dumping fp regs etc.
3978 */
3979 elf_fpregset_t *fpu;
3980 elf_fpxregset_t *xfpu;
3981 int thread_status_size;
3982 #endif
3983 int notes_size;
3984 int numnote;
3985 };
3986
3987 struct vm_area_struct {
3988 target_ulong vma_start; /* start vaddr of memory region */
3989 target_ulong vma_end; /* end vaddr of memory region */
3990 abi_ulong vma_flags; /* protection etc. flags for the region */
3991 QTAILQ_ENTRY(vm_area_struct) vma_link;
3992 };
3993
3994 struct mm_struct {
3995 QTAILQ_HEAD(, vm_area_struct) mm_mmap;
3996 int mm_count; /* number of mappings */
3997 };
3998
3999 static struct mm_struct *vma_init(void);
4000 static void vma_delete(struct mm_struct *);
4001 static int vma_add_mapping(struct mm_struct *, target_ulong,
4002 target_ulong, abi_ulong);
4003 static int vma_get_mapping_count(const struct mm_struct *);
4004 static struct vm_area_struct *vma_first(const struct mm_struct *);
4005 static struct vm_area_struct *vma_next(struct vm_area_struct *);
4006 static abi_ulong vma_dump_size(const struct vm_area_struct *);
4007 static int vma_walker(void *priv, target_ulong start, target_ulong end,
4008 unsigned long flags);
4009
4010 static void fill_elf_header(struct elfhdr *, int, uint16_t, uint32_t);
4011 static void fill_note(struct memelfnote *, const char *, int,
4012 unsigned int, void *);
4013 static void fill_prstatus(struct target_elf_prstatus *, const TaskState *, int);
4014 static int fill_psinfo(struct target_elf_prpsinfo *, const TaskState *);
4015 static void fill_auxv_note(struct memelfnote *, const TaskState *);
4016 static void fill_elf_note_phdr(struct elf_phdr *, int, off_t);
4017 static size_t note_size(const struct memelfnote *);
4018 static void free_note_info(struct elf_note_info *);
4019 static int fill_note_info(struct elf_note_info *, long, const CPUArchState *);
4020 static void fill_thread_info(struct elf_note_info *, const CPUArchState *);
4021
4022 static int dump_write(int, const void *, size_t);
4023 static int write_note(struct memelfnote *, int);
4024 static int write_note_info(struct elf_note_info *, int);
4025
4026 #ifdef BSWAP_NEEDED
4027 static void bswap_prstatus(struct target_elf_prstatus *prstatus)
4028 {
4029 prstatus->pr_info.si_signo = tswap32(prstatus->pr_info.si_signo);
4030 prstatus->pr_info.si_code = tswap32(prstatus->pr_info.si_code);
4031 prstatus->pr_info.si_errno = tswap32(prstatus->pr_info.si_errno);
4032 prstatus->pr_cursig = tswap16(prstatus->pr_cursig);
4033 prstatus->pr_sigpend = tswapal(prstatus->pr_sigpend);
4034 prstatus->pr_sighold = tswapal(prstatus->pr_sighold);
4035 prstatus->pr_pid = tswap32(prstatus->pr_pid);
4036 prstatus->pr_ppid = tswap32(prstatus->pr_ppid);
4037 prstatus->pr_pgrp = tswap32(prstatus->pr_pgrp);
4038 prstatus->pr_sid = tswap32(prstatus->pr_sid);
4039 /* cpu times are not filled, so we skip them */
4040 /* regs should be in correct format already */
4041 prstatus->pr_fpvalid = tswap32(prstatus->pr_fpvalid);
4042 }
4043
4044 static void bswap_psinfo(struct target_elf_prpsinfo *psinfo)
4045 {
4046 psinfo->pr_flag = tswapal(psinfo->pr_flag);
4047 psinfo->pr_uid = tswap16(psinfo->pr_uid);
4048 psinfo->pr_gid = tswap16(psinfo->pr_gid);
4049 psinfo->pr_pid = tswap32(psinfo->pr_pid);
4050 psinfo->pr_ppid = tswap32(psinfo->pr_ppid);
4051 psinfo->pr_pgrp = tswap32(psinfo->pr_pgrp);
4052 psinfo->pr_sid = tswap32(psinfo->pr_sid);
4053 }
4054
4055 static void bswap_note(struct elf_note *en)
4056 {
4057 bswap32s(&en->n_namesz);
4058 bswap32s(&en->n_descsz);
4059 bswap32s(&en->n_type);
4060 }
4061 #else
4062 static inline void bswap_prstatus(struct target_elf_prstatus *p) { }
4063 static inline void bswap_psinfo(struct target_elf_prpsinfo *p) {}
4064 static inline void bswap_note(struct elf_note *en) { }
4065 #endif /* BSWAP_NEEDED */
4066
4067 /*
4068 * Minimal support for linux memory regions. These are needed
4069 * when we are finding out what memory exactly belongs to
4070 * emulated process. No locks needed here, as long as
4071 * thread that received the signal is stopped.
4072 */
4073
4074 static struct mm_struct *vma_init(void)
4075 {
4076 struct mm_struct *mm;
4077
4078 if ((mm = g_malloc(sizeof (*mm))) == NULL)
4079 return (NULL);
4080
4081 mm->mm_count = 0;
4082 QTAILQ_INIT(&mm->mm_mmap);
4083
4084 return (mm);
4085 }
4086
4087 static void vma_delete(struct mm_struct *mm)
4088 {
4089 struct vm_area_struct *vma;
4090
4091 while ((vma = vma_first(mm)) != NULL) {
4092 QTAILQ_REMOVE(&mm->mm_mmap, vma, vma_link);
4093 g_free(vma);
4094 }
4095 g_free(mm);
4096 }
4097
4098 static int vma_add_mapping(struct mm_struct *mm, target_ulong start,
4099 target_ulong end, abi_ulong flags)
4100 {
4101 struct vm_area_struct *vma;
4102
4103 if ((vma = g_malloc0(sizeof (*vma))) == NULL)
4104 return (-1);
4105
4106 vma->vma_start = start;
4107 vma->vma_end = end;
4108 vma->vma_flags = flags;
4109
4110 QTAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link);
4111 mm->mm_count++;
4112
4113 return (0);
4114 }
4115
4116 static struct vm_area_struct *vma_first(const struct mm_struct *mm)
4117 {
4118 return (QTAILQ_FIRST(&mm->mm_mmap));
4119 }
4120
4121 static struct vm_area_struct *vma_next(struct vm_area_struct *vma)
4122 {
4123 return (QTAILQ_NEXT(vma, vma_link));
4124 }
4125
4126 static int vma_get_mapping_count(const struct mm_struct *mm)
4127 {
4128 return (mm->mm_count);
4129 }
4130
4131 /*
4132 * Calculate file (dump) size of given memory region.
4133 */
4134 static abi_ulong vma_dump_size(const struct vm_area_struct *vma)
4135 {
4136 /* if we cannot even read the first page, skip it */
4137 if (!access_ok_untagged(VERIFY_READ, vma->vma_start, TARGET_PAGE_SIZE))
4138 return (0);
4139
4140 /*
4141 * Usually we don't dump executable pages as they contain
4142 * non-writable code that debugger can read directly from
4143 * target library etc. However, thread stacks are marked
4144 * also executable so we read in first page of given region
4145 * and check whether it contains elf header. If there is
4146 * no elf header, we dump it.
4147 */
4148 if (vma->vma_flags & PROT_EXEC) {
4149 char page[TARGET_PAGE_SIZE];
4150
4151 if (copy_from_user(page, vma->vma_start, sizeof (page))) {
4152 return 0;
4153 }
4154 if ((page[EI_MAG0] == ELFMAG0) &&
4155 (page[EI_MAG1] == ELFMAG1) &&
4156 (page[EI_MAG2] == ELFMAG2) &&
4157 (page[EI_MAG3] == ELFMAG3)) {
4158 /*
4159 * Mappings are possibly from ELF binary. Don't dump
4160 * them.
4161 */
4162 return (0);
4163 }
4164 }
4165
4166 return (vma->vma_end - vma->vma_start);
4167 }
4168
4169 static int vma_walker(void *priv, target_ulong start, target_ulong end,
4170 unsigned long flags)
4171 {
4172 struct mm_struct *mm = (struct mm_struct *)priv;
4173
4174 vma_add_mapping(mm, start, end, flags);
4175 return (0);
4176 }
4177
4178 static void fill_note(struct memelfnote *note, const char *name, int type,
4179 unsigned int sz, void *data)
4180 {
4181 unsigned int namesz;
4182
4183 namesz = strlen(name) + 1;
4184 note->name = name;
4185 note->namesz = namesz;
4186 note->namesz_rounded = roundup(namesz, sizeof (int32_t));
4187 note->type = type;
4188 note->datasz = sz;
4189 note->datasz_rounded = roundup(sz, sizeof (int32_t));
4190
4191 note->data = data;
4192
4193 /*
4194 * We calculate rounded up note size here as specified by
4195 * ELF document.
4196 */
4197 note->notesz = sizeof (struct elf_note) +
4198 note->namesz_rounded + note->datasz_rounded;
4199 }
4200
4201 static void fill_elf_header(struct elfhdr *elf, int segs, uint16_t machine,
4202 uint32_t flags)
4203 {
4204 (void) memset(elf, 0, sizeof(*elf));
4205
4206 (void) memcpy(elf->e_ident, ELFMAG, SELFMAG);
4207 elf->e_ident[EI_CLASS] = ELF_CLASS;
4208 elf->e_ident[EI_DATA] = ELF_DATA;
4209 elf->e_ident[EI_VERSION] = EV_CURRENT;
4210 elf->e_ident[EI_OSABI] = ELF_OSABI;
4211
4212 elf->e_type = ET_CORE;
4213 elf->e_machine = machine;
4214 elf->e_version = EV_CURRENT;
4215 elf->e_phoff = sizeof(struct elfhdr);
4216 elf->e_flags = flags;
4217 elf->e_ehsize = sizeof(struct elfhdr);
4218 elf->e_phentsize = sizeof(struct elf_phdr);
4219 elf->e_phnum = segs;
4220
4221 bswap_ehdr(elf);
4222 }
4223
4224 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
4225 {
4226 phdr->p_type = PT_NOTE;
4227 phdr->p_offset = offset;
4228 phdr->p_vaddr = 0;
4229 phdr->p_paddr = 0;
4230 phdr->p_filesz = sz;
4231 phdr->p_memsz = 0;
4232 phdr->p_flags = 0;
4233 phdr->p_align = 0;
4234
4235 bswap_phdr(phdr, 1);
4236 }
4237
4238 static size_t note_size(const struct memelfnote *note)
4239 {
4240 return (note->notesz);
4241 }
4242
4243 static void fill_prstatus(struct target_elf_prstatus *prstatus,
4244 const TaskState *ts, int signr)
4245 {
4246 (void) memset(prstatus, 0, sizeof (*prstatus));
4247 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
4248 prstatus->pr_pid = ts->ts_tid;
4249 prstatus->pr_ppid = getppid();
4250 prstatus->pr_pgrp = getpgrp();
4251 prstatus->pr_sid = getsid(0);
4252
4253 bswap_prstatus(prstatus);
4254 }
4255
4256 static int fill_psinfo(struct target_elf_prpsinfo *psinfo, const TaskState *ts)
4257 {
4258 char *base_filename;
4259 unsigned int i, len;
4260
4261 (void) memset(psinfo, 0, sizeof (*psinfo));
4262
4263 len = ts->info->env_strings - ts->info->arg_strings;
4264 if (len >= ELF_PRARGSZ)
4265 len = ELF_PRARGSZ - 1;
4266 if (copy_from_user(&psinfo->pr_psargs, ts->info->arg_strings, len)) {
4267 return -EFAULT;
4268 }
4269 for (i = 0; i < len; i++)
4270 if (psinfo->pr_psargs[i] == 0)
4271 psinfo->pr_psargs[i] = ' ';
4272 psinfo->pr_psargs[len] = 0;
4273
4274 psinfo->pr_pid = getpid();
4275 psinfo->pr_ppid = getppid();
4276 psinfo->pr_pgrp = getpgrp();
4277 psinfo->pr_sid = getsid(0);
4278 psinfo->pr_uid = getuid();
4279 psinfo->pr_gid = getgid();
4280
4281 base_filename = g_path_get_basename(ts->bprm->filename);
4282 /*
4283 * Using strncpy here is fine: at max-length,
4284 * this field is not NUL-terminated.
4285 */
4286 (void) strncpy(psinfo->pr_fname, base_filename,
4287 sizeof(psinfo->pr_fname));
4288
4289 g_free(base_filename);
4290 bswap_psinfo(psinfo);
4291 return (0);
4292 }
4293
4294 static void fill_auxv_note(struct memelfnote *note, const TaskState *ts)
4295 {
4296 elf_addr_t auxv = (elf_addr_t)ts->info->saved_auxv;
4297 elf_addr_t orig_auxv = auxv;
4298 void *ptr;
4299 int len = ts->info->auxv_len;
4300
4301 /*
4302 * Auxiliary vector is stored in target process stack. It contains
4303 * {type, value} pairs that we need to dump into note. This is not
4304 * strictly necessary but we do it here for sake of completeness.
4305 */
4306
4307 /* read in whole auxv vector and copy it to memelfnote */
4308 ptr = lock_user(VERIFY_READ, orig_auxv, len, 0);
4309 if (ptr != NULL) {
4310 fill_note(note, "CORE", NT_AUXV, len, ptr);
4311 unlock_user(ptr, auxv, len);
4312 }
4313 }
4314
4315 /*
4316 * Constructs name of coredump file. We have following convention
4317 * for the name:
4318 * qemu_<basename-of-target-binary>_<date>-<time>_<pid>.core
4319 *
4320 * Returns the filename
4321 */
4322 static char *core_dump_filename(const TaskState *ts)
4323 {
4324 g_autoptr(GDateTime) now = g_date_time_new_now_local();
4325 g_autofree char *nowstr = g_date_time_format(now, "%Y%m%d-%H%M%S");
4326 g_autofree char *base_filename = g_path_get_basename(ts->bprm->filename);
4327
4328 return g_strdup_printf("qemu_%s_%s_%d.core",
4329 base_filename, nowstr, (int)getpid());
4330 }
4331
4332 static int dump_write(int fd, const void *ptr, size_t size)
4333 {
4334 const char *bufp = (const char *)ptr;
4335 ssize_t bytes_written, bytes_left;
4336 struct rlimit dumpsize;
4337 off_t pos;
4338
4339 bytes_written = 0;
4340 getrlimit(RLIMIT_CORE, &dumpsize);
4341 if ((pos = lseek(fd, 0, SEEK_CUR))==-1) {
4342 if (errno == ESPIPE) { /* not a seekable stream */
4343 bytes_left = size;
4344 } else {
4345 return pos;
4346 }
4347 } else {
4348 if (dumpsize.rlim_cur <= pos) {
4349 return -1;
4350 } else if (dumpsize.rlim_cur == RLIM_INFINITY) {
4351 bytes_left = size;
4352 } else {
4353 size_t limit_left=dumpsize.rlim_cur - pos;
4354 bytes_left = limit_left >= size ? size : limit_left ;
4355 }
4356 }
4357
4358 /*
4359 * In normal conditions, single write(2) should do but
4360 * in case of socket etc. this mechanism is more portable.
4361 */
4362 do {
4363 bytes_written = write(fd, bufp, bytes_left);
4364 if (bytes_written < 0) {
4365 if (errno == EINTR)
4366 continue;
4367 return (-1);
4368 } else if (bytes_written == 0) { /* eof */
4369 return (-1);
4370 }
4371 bufp += bytes_written;
4372 bytes_left -= bytes_written;
4373 } while (bytes_left > 0);
4374
4375 return (0);
4376 }
4377
4378 static int write_note(struct memelfnote *men, int fd)
4379 {
4380 struct elf_note en;
4381
4382 en.n_namesz = men->namesz;
4383 en.n_type = men->type;
4384 en.n_descsz = men->datasz;
4385
4386 bswap_note(&en);
4387
4388 if (dump_write(fd, &en, sizeof(en)) != 0)
4389 return (-1);
4390 if (dump_write(fd, men->name, men->namesz_rounded) != 0)
4391 return (-1);
4392 if (dump_write(fd, men->data, men->datasz_rounded) != 0)
4393 return (-1);
4394
4395 return (0);
4396 }
4397
4398 static void fill_thread_info(struct elf_note_info *info, const CPUArchState *env)
4399 {
4400 CPUState *cpu = env_cpu((CPUArchState *)env);
4401 TaskState *ts = (TaskState *)cpu->opaque;
4402 struct elf_thread_status *ets;
4403
4404 ets = g_malloc0(sizeof (*ets));
4405 ets->num_notes = 1; /* only prstatus is dumped */
4406 fill_prstatus(&ets->prstatus, ts, 0);
4407 elf_core_copy_regs(&ets->prstatus.pr_reg, env);
4408 fill_note(&ets->notes[0], "CORE", NT_PRSTATUS, sizeof (ets->prstatus),
4409 &ets->prstatus);
4410
4411 QTAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link);
4412
4413 info->notes_size += note_size(&ets->notes[0]);
4414 }
4415
4416 static void init_note_info(struct elf_note_info *info)
4417 {
4418 /* Initialize the elf_note_info structure so that it is at
4419 * least safe to call free_note_info() on it. Must be
4420 * called before calling fill_note_info().
4421 */
4422 memset(info, 0, sizeof (*info));
4423 QTAILQ_INIT(&info->thread_list);
4424 }
4425
4426 static int fill_note_info(struct elf_note_info *info,
4427 long signr, const CPUArchState *env)
4428 {
4429 #define NUMNOTES 3
4430 CPUState *cpu = env_cpu((CPUArchState *)env);
4431 TaskState *ts = (TaskState *)cpu->opaque;
4432 int i;
4433
4434 info->notes = g_new0(struct memelfnote, NUMNOTES);
4435 if (info->notes == NULL)
4436 return (-ENOMEM);
4437 info->prstatus = g_malloc0(sizeof (*info->prstatus));
4438 if (info->prstatus == NULL)
4439 return (-ENOMEM);
4440 info->psinfo = g_malloc0(sizeof (*info->psinfo));
4441 if (info->prstatus == NULL)
4442 return (-ENOMEM);
4443
4444 /*
4445 * First fill in status (and registers) of current thread
4446 * including process info & aux vector.
4447 */
4448 fill_prstatus(info->prstatus, ts, signr);
4449 elf_core_copy_regs(&info->prstatus->pr_reg, env);
4450 fill_note(&info->notes[0], "CORE", NT_PRSTATUS,
4451 sizeof (*info->prstatus), info->prstatus);
4452 fill_psinfo(info->psinfo, ts);
4453 fill_note(&info->notes[1], "CORE", NT_PRPSINFO,
4454 sizeof (*info->psinfo), info->psinfo);
4455 fill_auxv_note(&info->notes[2], ts);
4456 info->numnote = 3;
4457
4458 info->notes_size = 0;
4459 for (i = 0; i < info->numnote; i++)
4460 info->notes_size += note_size(&info->notes[i]);
4461
4462 /* read and fill status of all threads */
4463 WITH_QEMU_LOCK_GUARD(&qemu_cpu_list_lock) {
4464 CPU_FOREACH(cpu) {
4465 if (cpu == thread_cpu) {
4466 continue;
4467 }
4468 fill_thread_info(info, cpu_env(cpu));
4469 }
4470 }
4471
4472 return (0);
4473 }
4474
4475 static void free_note_info(struct elf_note_info *info)
4476 {
4477 struct elf_thread_status *ets;
4478
4479 while (!QTAILQ_EMPTY(&info->thread_list)) {
4480 ets = QTAILQ_FIRST(&info->thread_list);
4481 QTAILQ_REMOVE(&info->thread_list, ets, ets_link);
4482 g_free(ets);
4483 }
4484
4485 g_free(info->prstatus);
4486 g_free(info->psinfo);
4487 g_free(info->notes);
4488 }
4489
4490 static int write_note_info(struct elf_note_info *info, int fd)
4491 {
4492 struct elf_thread_status *ets;
4493 int i, error = 0;
4494
4495 /* write prstatus, psinfo and auxv for current thread */
4496 for (i = 0; i < info->numnote; i++)
4497 if ((error = write_note(&info->notes[i], fd)) != 0)
4498 return (error);
4499
4500 /* write prstatus for each thread */
4501 QTAILQ_FOREACH(ets, &info->thread_list, ets_link) {
4502 if ((error = write_note(&ets->notes[0], fd)) != 0)
4503 return (error);
4504 }
4505
4506 return (0);
4507 }
4508
4509 /*
4510 * Write out ELF coredump.
4511 *
4512 * See documentation of ELF object file format in:
4513 * http://www.caldera.com/developers/devspecs/gabi41.pdf
4514 *
4515 * Coredump format in linux is following:
4516 *
4517 * 0 +----------------------+ \
4518 * | ELF header | ET_CORE |
4519 * +----------------------+ |
4520 * | ELF program headers | |--- headers
4521 * | - NOTE section | |
4522 * | - PT_LOAD sections | |
4523 * +----------------------+ /
4524 * | NOTEs: |
4525 * | - NT_PRSTATUS |
4526 * | - NT_PRSINFO |
4527 * | - NT_AUXV |
4528 * +----------------------+ <-- aligned to target page
4529 * | Process memory dump |
4530 * : :
4531 * . .
4532 * : :
4533 * | |
4534 * +----------------------+
4535 *
4536 * NT_PRSTATUS -> struct elf_prstatus (per thread)
4537 * NT_PRSINFO -> struct elf_prpsinfo
4538 * NT_AUXV is array of { type, value } pairs (see fill_auxv_note()).
4539 *
4540 * Format follows System V format as close as possible. Current
4541 * version limitations are as follows:
4542 * - no floating point registers are dumped
4543 *
4544 * Function returns 0 in case of success, negative errno otherwise.
4545 *
4546 * TODO: make this work also during runtime: it should be
4547 * possible to force coredump from running process and then
4548 * continue processing. For example qemu could set up SIGUSR2
4549 * handler (provided that target process haven't registered
4550 * handler for that) that does the dump when signal is received.
4551 */
4552 static int elf_core_dump(int signr, const CPUArchState *env)
4553 {
4554 const CPUState *cpu = env_cpu((CPUArchState *)env);
4555 const TaskState *ts = (const TaskState *)cpu->opaque;
4556 struct vm_area_struct *vma = NULL;
4557 g_autofree char *corefile = NULL;
4558 struct elf_note_info info;
4559 struct elfhdr elf;
4560 struct elf_phdr phdr;
4561 struct rlimit dumpsize;
4562 struct mm_struct *mm = NULL;
4563 off_t offset = 0, data_offset = 0;
4564 int segs = 0;
4565 int fd = -1;
4566
4567 init_note_info(&info);
4568
4569 errno = 0;
4570 getrlimit(RLIMIT_CORE, &dumpsize);
4571 if (dumpsize.rlim_cur == 0)
4572 return 0;
4573
4574 corefile = core_dump_filename(ts);
4575
4576 if ((fd = open(corefile, O_WRONLY | O_CREAT,
4577 S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
4578 return (-errno);
4579
4580 /*
4581 * Walk through target process memory mappings and
4582 * set up structure containing this information. After
4583 * this point vma_xxx functions can be used.
4584 */
4585 if ((mm = vma_init()) == NULL)
4586 goto out;
4587
4588 walk_memory_regions(mm, vma_walker);
4589 segs = vma_get_mapping_count(mm);
4590
4591 /*
4592 * Construct valid coredump ELF header. We also
4593 * add one more segment for notes.
4594 */
4595 fill_elf_header(&elf, segs + 1, ELF_MACHINE, 0);
4596 if (dump_write(fd, &elf, sizeof (elf)) != 0)
4597 goto out;
4598
4599 /* fill in the in-memory version of notes */
4600 if (fill_note_info(&info, signr, env) < 0)
4601 goto out;
4602
4603 offset += sizeof (elf); /* elf header */
4604 offset += (segs + 1) * sizeof (struct elf_phdr); /* program headers */
4605
4606 /* write out notes program header */
4607 fill_elf_note_phdr(&phdr, info.notes_size, offset);
4608
4609 offset += info.notes_size;
4610 if (dump_write(fd, &phdr, sizeof (phdr)) != 0)
4611 goto out;
4612
4613 /*
4614 * ELF specification wants data to start at page boundary so
4615 * we align it here.
4616 */
4617 data_offset = offset = roundup(offset, ELF_EXEC_PAGESIZE);
4618
4619 /*
4620 * Write program headers for memory regions mapped in
4621 * the target process.
4622 */
4623 for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
4624 (void) memset(&phdr, 0, sizeof (phdr));
4625
4626 phdr.p_type = PT_LOAD;
4627 phdr.p_offset = offset;
4628 phdr.p_vaddr = vma->vma_start;
4629 phdr.p_paddr = 0;
4630 phdr.p_filesz = vma_dump_size(vma);
4631 offset += phdr.p_filesz;
4632 phdr.p_memsz = vma->vma_end - vma->vma_start;
4633 phdr.p_flags = vma->vma_flags & PROT_READ ? PF_R : 0;
4634 if (vma->vma_flags & PROT_WRITE)
4635 phdr.p_flags |= PF_W;
4636 if (vma->vma_flags & PROT_EXEC)
4637 phdr.p_flags |= PF_X;
4638 phdr.p_align = ELF_EXEC_PAGESIZE;
4639
4640 bswap_phdr(&phdr, 1);
4641 if (dump_write(fd, &phdr, sizeof(phdr)) != 0) {
4642 goto out;
4643 }
4644 }
4645
4646 /*
4647 * Next we write notes just after program headers. No
4648 * alignment needed here.
4649 */
4650 if (write_note_info(&info, fd) < 0)
4651 goto out;
4652
4653 /* align data to page boundary */
4654 if (lseek(fd, data_offset, SEEK_SET) != data_offset)
4655 goto out;
4656
4657 /*
4658 * Finally we can dump process memory into corefile as well.
4659 */
4660 for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
4661 abi_ulong addr;
4662 abi_ulong end;
4663
4664 end = vma->vma_start + vma_dump_size(vma);
4665
4666 for (addr = vma->vma_start; addr < end;
4667 addr += TARGET_PAGE_SIZE) {
4668 char page[TARGET_PAGE_SIZE];
4669 int error;
4670
4671 /*
4672 * Read in page from target process memory and
4673 * write it to coredump file.
4674 */
4675 error = copy_from_user(page, addr, sizeof (page));
4676 if (error != 0) {
4677 (void) fprintf(stderr, "unable to dump " TARGET_ABI_FMT_lx "\n",
4678 addr);
4679 errno = -error;
4680 goto out;
4681 }
4682 if (dump_write(fd, page, TARGET_PAGE_SIZE) < 0)
4683 goto out;
4684 }
4685 }
4686
4687 out:
4688 free_note_info(&info);
4689 if (mm != NULL)
4690 vma_delete(mm);
4691 (void) close(fd);
4692
4693 if (errno != 0)
4694 return (-errno);
4695 return (0);
4696 }
4697 #endif /* USE_ELF_CORE_DUMP */
4698
4699 void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
4700 {
4701 init_thread(regs, infop);
4702 }
QEMU mirror