1#ifndef QEMU_H
2#define QEMU_H
3
4#include "hostdep.h"
5#include "cpu.h"
6#include "exec/exec-all.h"
7#include "exec/cpu_ldst.h"
8
9#undef DEBUG_REMAP
10#ifdef DEBUG_REMAP
11#endif
12
13#include "exec/user/abitypes.h"
14
15#include "exec/user/thunk.h"
16#include "syscall_defs.h"
17#include "target_syscall.h"
18#include "exec/gdbstub.h"
19#include "qemu/queue.h"
20
21
22
23
24#define SIGSET_T_SIZE (_NSIG / 8)
25
26
27
28
29
30struct image_info {
31 abi_ulong load_bias;
32 abi_ulong load_addr;
33 abi_ulong start_code;
34 abi_ulong end_code;
35 abi_ulong start_data;
36 abi_ulong end_data;
37 abi_ulong start_brk;
38 abi_ulong brk;
39 abi_ulong start_mmap;
40 abi_ulong start_stack;
41 abi_ulong stack_limit;
42 abi_ulong entry;
43 abi_ulong code_offset;
44 abi_ulong data_offset;
45 abi_ulong saved_auxv;
46 abi_ulong auxv_len;
47 abi_ulong arg_start;
48 abi_ulong arg_end;
49 abi_ulong arg_strings;
50 abi_ulong env_strings;
51 abi_ulong file_string;
52 uint32_t elf_flags;
53 int personality;
54 abi_ulong alignment;
55
56
57 abi_ulong loadmap_addr;
58 uint16_t nsegs;
59 void *loadsegs;
60 abi_ulong pt_dynamic_addr;
61 abi_ulong interpreter_loadmap_addr;
62 abi_ulong interpreter_pt_dynamic_addr;
63 struct image_info *other_info;
64#ifdef TARGET_MIPS
65 int fp_abi;
66 int interp_fp_abi;
67#endif
68};
69
70#ifdef TARGET_I386
71
72struct vm86_saved_state {
73 uint32_t eax;
74 uint32_t ebx;
75 uint32_t ecx;
76 uint32_t edx;
77 uint32_t esi;
78 uint32_t edi;
79 uint32_t ebp;
80 uint32_t esp;
81 uint32_t eflags;
82 uint32_t eip;
83 uint16_t cs, ss, ds, es, fs, gs;
84};
85#endif
86
87#if defined(TARGET_ARM) && defined(TARGET_ABI32)
88
89#include "nwfpe/fpa11.h"
90#endif
91
92#define MAX_SIGQUEUE_SIZE 1024
93
94struct emulated_sigtable {
95 int pending;
96 target_siginfo_t info;
97};
98
99
100
101typedef struct TaskState {
102 pid_t ts_tid;
103#ifdef TARGET_ARM
104# ifdef TARGET_ABI32
105
106 FPA11 fpa;
107# endif
108 int swi_errno;
109#endif
110#if defined(TARGET_I386) && !defined(TARGET_X86_64)
111 abi_ulong target_v86;
112 struct vm86_saved_state vm86_saved_regs;
113 struct target_vm86plus_struct vm86plus;
114 uint32_t v86flags;
115 uint32_t v86mask;
116#endif
117 abi_ulong child_tidptr;
118#ifdef TARGET_M68K
119 abi_ulong tp_value;
120#endif
121#if defined(TARGET_ARM) || defined(TARGET_M68K)
122
123 abi_ulong heap_base;
124 abi_ulong heap_limit;
125#endif
126 abi_ulong stack_base;
127 int used;
128 struct image_info *info;
129 struct linux_binprm *bprm;
130
131 struct emulated_sigtable sync_signal;
132 struct emulated_sigtable sigtab[TARGET_NSIG];
133
134
135
136
137
138 sigset_t signal_mask;
139
140
141
142 sigset_t sigsuspend_mask;
143
144 int in_sigsuspend;
145
146
147
148
149
150
151
152 int signal_pending;
153
154
155 struct target_sigaltstack sigaltstack_used;
156} __attribute__((aligned(16))) TaskState;
157
158extern char *exec_path;
159void init_task_state(TaskState *ts);
160void task_settid(TaskState *);
161void stop_all_tasks(void);
162extern const char *qemu_uname_release;
163extern unsigned long mmap_min_addr;
164
165
166
167
168
169#define BPRM_BUF_SIZE 1024
170
171
172
173
174
175struct linux_binprm {
176 char buf[BPRM_BUF_SIZE] __attribute__((aligned));
177 abi_ulong p;
178 int fd;
179 int e_uid, e_gid;
180 int argc, envc;
181 char **argv;
182 char **envp;
183 char * filename;
184 int (*core_dump)(int, const CPUArchState *);
185};
186
187void do_init_thread(struct target_pt_regs *regs, struct image_info *infop);
188abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
189 abi_ulong stringp, int push_ptr);
190int loader_exec(int fdexec, const char *filename, char **argv, char **envp,
191 struct target_pt_regs * regs, struct image_info *infop,
192 struct linux_binprm *);
193
194
195
196
197
198
199int info_is_fdpic(struct image_info *info);
200
201uint32_t get_elf_eflags(int fd);
202int load_elf_binary(struct linux_binprm *bprm, struct image_info *info);
203int load_flt_binary(struct linux_binprm *bprm, struct image_info *info);
204
205abi_long memcpy_to_target(abi_ulong dest, const void *src,
206 unsigned long len);
207void target_set_brk(abi_ulong new_brk);
208abi_long do_brk(abi_ulong new_brk);
209void syscall_init(void);
210abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
211 abi_long arg2, abi_long arg3, abi_long arg4,
212 abi_long arg5, abi_long arg6, abi_long arg7,
213 abi_long arg8);
214void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
215extern __thread CPUState *thread_cpu;
216void cpu_loop(CPUArchState *env);
217const char *target_strerror(int err);
218int get_osversion(void);
219void init_qemu_uname_release(void);
220void fork_start(void);
221void fork_end(int child);
222
223
224
225
226
227
228
229
230
231unsigned long init_guest_space(unsigned long host_start,
232 unsigned long host_size,
233 unsigned long guest_start,
234 bool fixed);
235
236#include "qemu/log.h"
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345#ifdef HAVE_SAFE_SYSCALL
346
347extern long safe_syscall_base(int *pending, long number, ...);
348
349#define safe_syscall(...) \
350 ({ \
351 long ret_; \
352 int *psp_ = &((TaskState *)thread_cpu->opaque)->signal_pending; \
353 ret_ = safe_syscall_base(psp_, __VA_ARGS__); \
354 if (is_error(ret_)) { \
355 errno = -ret_; \
356 ret_ = -1; \
357 } \
358 ret_; \
359 })
360
361#else
362
363
364
365
366
367#define safe_syscall syscall
368
369#endif
370
371
372int host_to_target_waitstatus(int status);
373
374
375void print_syscall(int num,
376 abi_long arg1, abi_long arg2, abi_long arg3,
377 abi_long arg4, abi_long arg5, abi_long arg6);
378void print_syscall_ret(int num, abi_long arg1);
379
380
381
382
383
384
385
386
387
388void print_taken_signal(int target_signum, const target_siginfo_t *tinfo);
389extern int do_strace;
390
391
392void process_pending_signals(CPUArchState *cpu_env);
393void signal_init(void);
394int queue_signal(CPUArchState *env, int sig, int si_type,
395 target_siginfo_t *info);
396void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
397void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo);
398int target_to_host_signal(int sig);
399int host_to_target_signal(int sig);
400long do_sigreturn(CPUArchState *env);
401long do_rt_sigreturn(CPUArchState *env);
402abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
403int do_sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
404abi_long do_swapcontext(CPUArchState *env, abi_ulong uold_ctx,
405 abi_ulong unew_ctx, abi_long ctx_size);
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424int block_signals(void);
425
426#ifdef TARGET_I386
427
428void save_v86_state(CPUX86State *env);
429void handle_vm86_trap(CPUX86State *env, int trapno);
430void handle_vm86_fault(CPUX86State *env);
431int do_vm86(CPUX86State *env, long subfunction, abi_ulong v86_addr);
432#elif defined(TARGET_SPARC64)
433void sparc64_set_context(CPUSPARCState *env);
434void sparc64_get_context(CPUSPARCState *env);
435#endif
436
437
438int target_mprotect(abi_ulong start, abi_ulong len, int prot);
439abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
440 int flags, int fd, abi_ulong offset);
441int target_munmap(abi_ulong start, abi_ulong len);
442abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
443 abi_ulong new_size, unsigned long flags,
444 abi_ulong new_addr);
445extern unsigned long last_brk;
446extern abi_ulong mmap_next_start;
447abi_ulong mmap_find_vma(abi_ulong, abi_ulong, abi_ulong);
448void mmap_fork_start(void);
449void mmap_fork_end(int child);
450
451
452extern unsigned long guest_stack_size;
453
454
455
456#define VERIFY_READ 0
457#define VERIFY_WRITE 1
458
459static inline int access_ok(int type, abi_ulong addr, abi_ulong size)
460{
461 return guest_addr_valid(addr) &&
462 (size == 0 || guest_addr_valid(addr + size - 1)) &&
463 page_check_range((target_ulong)addr, size,
464 (type == VERIFY_READ) ? PAGE_READ : (PAGE_READ | PAGE_WRITE)) == 0;
465}
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484#if defined(__clang__) && __has_warning("-Waddress-of-packed-member")
485#define PRAGMA_DISABLE_PACKED_WARNING \
486 _Pragma("GCC diagnostic push"); \
487 _Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\"")
488
489#define PRAGMA_REENABLE_PACKED_WARNING \
490 _Pragma("GCC diagnostic pop")
491
492#else
493#define PRAGMA_DISABLE_PACKED_WARNING
494#define PRAGMA_REENABLE_PACKED_WARNING
495#endif
496
497#define __put_user_e(x, hptr, e) \
498 do { \
499 PRAGMA_DISABLE_PACKED_WARNING; \
500 (__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \
501 __builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \
502 __builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \
503 __builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \
504 ((hptr), (x)), (void)0); \
505 PRAGMA_REENABLE_PACKED_WARNING; \
506 } while (0)
507
508#define __get_user_e(x, hptr, e) \
509 do { \
510 PRAGMA_DISABLE_PACKED_WARNING; \
511 ((x) = (typeof(*hptr))( \
512 __builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \
513 __builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \
514 __builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \
515 __builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \
516 (hptr)), (void)0); \
517 PRAGMA_REENABLE_PACKED_WARNING; \
518 } while (0)
519
520
521#ifdef TARGET_WORDS_BIGENDIAN
522# define __put_user(x, hptr) __put_user_e(x, hptr, be)
523# define __get_user(x, hptr) __get_user_e(x, hptr, be)
524#else
525# define __put_user(x, hptr) __put_user_e(x, hptr, le)
526# define __get_user(x, hptr) __get_user_e(x, hptr, le)
527#endif
528
529
530
531
532
533
534#define put_user(x, gaddr, target_type) \
535({ \
536 abi_ulong __gaddr = (gaddr); \
537 target_type *__hptr; \
538 abi_long __ret = 0; \
539 if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
540 __put_user((x), __hptr); \
541 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
542 } else \
543 __ret = -TARGET_EFAULT; \
544 __ret; \
545})
546
547#define get_user(x, gaddr, target_type) \
548({ \
549 abi_ulong __gaddr = (gaddr); \
550 target_type *__hptr; \
551 abi_long __ret = 0; \
552 if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
553 __get_user((x), __hptr); \
554 unlock_user(__hptr, __gaddr, 0); \
555 } else { \
556 \
557 (x) = 0; \
558 __ret = -TARGET_EFAULT; \
559 } \
560 __ret; \
561})
562
563#define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
564#define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
565#define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
566#define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
567#define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
568#define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
569#define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
570#define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
571#define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
572#define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
573
574#define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
575#define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
576#define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
577#define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
578#define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
579#define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
580#define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
581#define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
582#define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
583#define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
584
585
586
587
588
589abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
590abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
591
592
593
594
595
596
597
598
599
600static inline void *lock_user(int type, abi_ulong guest_addr, long len, int copy)
601{
602 if (!access_ok(type, guest_addr, len))
603 return NULL;
604#ifdef DEBUG_REMAP
605 {
606 void *addr;
607 addr = g_malloc(len);
608 if (copy)
609 memcpy(addr, g2h(guest_addr), len);
610 else
611 memset(addr, 0, len);
612 return addr;
613 }
614#else
615 return g2h(guest_addr);
616#endif
617}
618
619
620
621
622static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
623 long len)
624{
625
626#ifdef DEBUG_REMAP
627 if (!host_ptr)
628 return;
629 if (host_ptr == g2h(guest_addr))
630 return;
631 if (len > 0)
632 memcpy(g2h(guest_addr), host_ptr, len);
633 g_free(host_ptr);
634#endif
635}
636
637
638
639abi_long target_strlen(abi_ulong gaddr);
640
641
642static inline void *lock_user_string(abi_ulong guest_addr)
643{
644 abi_long len;
645 len = target_strlen(guest_addr);
646 if (len < 0)
647 return NULL;
648 return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
649}
650
651
652#define lock_user_struct(type, host_ptr, guest_addr, copy) \
653 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
654#define unlock_user_struct(host_ptr, guest_addr, copy) \
655 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
656
657#include <pthread.h>
658
659static inline int is_error(abi_long ret)
660{
661 return (abi_ulong)ret >= (abi_ulong)(-4096);
662}
663
664
665
666
667
668
669
670void preexit_cleanup(CPUArchState *env, int code);
671
672
673
674
675
676#include "target_cpu.h"
677#include "target_structs.h"
678
679#endif
680