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 int sim_syscalls;
120 abi_ulong tp_value;
121#endif
122#if defined(TARGET_ARM) || defined(TARGET_M68K)
123
124 abi_ulong heap_base;
125 abi_ulong heap_limit;
126#endif
127 abi_ulong stack_base;
128 int used;
129 struct image_info *info;
130 struct linux_binprm *bprm;
131
132 struct emulated_sigtable sync_signal;
133 struct emulated_sigtable sigtab[TARGET_NSIG];
134
135
136
137
138
139 sigset_t signal_mask;
140
141
142
143 sigset_t sigsuspend_mask;
144
145 int in_sigsuspend;
146
147
148
149
150
151
152
153 int signal_pending;
154
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);
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 page_check_range((target_ulong)addr, size,
461 (type == VERIFY_READ) ? PAGE_READ : (PAGE_READ | PAGE_WRITE)) == 0;
462}
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481#if defined(__clang__) && __has_warning("-Waddress-of-packed-member")
482#define PRAGMA_DISABLE_PACKED_WARNING \
483 _Pragma("GCC diagnostic push"); \
484 _Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\"")
485
486#define PRAGMA_REENABLE_PACKED_WARNING \
487 _Pragma("GCC diagnostic pop")
488
489#else
490#define PRAGMA_DISABLE_PACKED_WARNING
491#define PRAGMA_REENABLE_PACKED_WARNING
492#endif
493
494#define __put_user_e(x, hptr, e) \
495 do { \
496 PRAGMA_DISABLE_PACKED_WARNING; \
497 (__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \
498 __builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \
499 __builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \
500 __builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \
501 ((hptr), (x)), (void)0); \
502 PRAGMA_REENABLE_PACKED_WARNING; \
503 } while (0)
504
505#define __get_user_e(x, hptr, e) \
506 do { \
507 PRAGMA_DISABLE_PACKED_WARNING; \
508 ((x) = (typeof(*hptr))( \
509 __builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \
510 __builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \
511 __builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \
512 __builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \
513 (hptr)), (void)0); \
514 PRAGMA_REENABLE_PACKED_WARNING; \
515 } while (0)
516
517
518#ifdef TARGET_WORDS_BIGENDIAN
519# define __put_user(x, hptr) __put_user_e(x, hptr, be)
520# define __get_user(x, hptr) __get_user_e(x, hptr, be)
521#else
522# define __put_user(x, hptr) __put_user_e(x, hptr, le)
523# define __get_user(x, hptr) __get_user_e(x, hptr, le)
524#endif
525
526
527
528
529
530
531#define put_user(x, gaddr, target_type) \
532({ \
533 abi_ulong __gaddr = (gaddr); \
534 target_type *__hptr; \
535 abi_long __ret = 0; \
536 if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
537 __put_user((x), __hptr); \
538 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
539 } else \
540 __ret = -TARGET_EFAULT; \
541 __ret; \
542})
543
544#define get_user(x, gaddr, target_type) \
545({ \
546 abi_ulong __gaddr = (gaddr); \
547 target_type *__hptr; \
548 abi_long __ret = 0; \
549 if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
550 __get_user((x), __hptr); \
551 unlock_user(__hptr, __gaddr, 0); \
552 } else { \
553 \
554 (x) = 0; \
555 __ret = -TARGET_EFAULT; \
556 } \
557 __ret; \
558})
559
560#define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
561#define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
562#define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
563#define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
564#define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
565#define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
566#define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
567#define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
568#define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
569#define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
570
571#define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
572#define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
573#define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
574#define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
575#define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
576#define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
577#define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
578#define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
579#define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
580#define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
581
582
583
584
585
586abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
587abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
588
589
590
591
592
593
594
595
596
597static inline void *lock_user(int type, abi_ulong guest_addr, long len, int copy)
598{
599 if (!access_ok(type, guest_addr, len))
600 return NULL;
601#ifdef DEBUG_REMAP
602 {
603 void *addr;
604 addr = g_malloc(len);
605 if (copy)
606 memcpy(addr, g2h(guest_addr), len);
607 else
608 memset(addr, 0, len);
609 return addr;
610 }
611#else
612 return g2h(guest_addr);
613#endif
614}
615
616
617
618
619static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
620 long len)
621{
622
623#ifdef DEBUG_REMAP
624 if (!host_ptr)
625 return;
626 if (host_ptr == g2h(guest_addr))
627 return;
628 if (len > 0)
629 memcpy(g2h(guest_addr), host_ptr, len);
630 g_free(host_ptr);
631#endif
632}
633
634
635
636abi_long target_strlen(abi_ulong gaddr);
637
638
639static inline void *lock_user_string(abi_ulong guest_addr)
640{
641 abi_long len;
642 len = target_strlen(guest_addr);
643 if (len < 0)
644 return NULL;
645 return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
646}
647
648
649#define lock_user_struct(type, host_ptr, guest_addr, copy) \
650 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
651#define unlock_user_struct(host_ptr, guest_addr, copy) \
652 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
653
654#include <pthread.h>
655
656static inline int is_error(abi_long ret)
657{
658 return (abi_ulong)ret >= (abi_ulong)(-4096);
659}
660
661
662
663
664
665
666
667void preexit_cleanup(CPUArchState *env, int code);
668
669
670
671
672
673#include "target_cpu.h"
674#include "target_structs.h"
675
676#endif
677