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