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