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