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);
365extern int do_strace;
366
367
368void process_pending_signals(CPUArchState *cpu_env);
369void signal_init(void);
370int queue_signal(CPUArchState *env, int sig, target_siginfo_t *info);
371void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
372void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo);
373int target_to_host_signal(int sig);
374int host_to_target_signal(int sig);
375long do_sigreturn(CPUArchState *env);
376long do_rt_sigreturn(CPUArchState *env);
377abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
378int do_sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397int block_signals(void);
398
399#ifdef TARGET_I386
400
401void save_v86_state(CPUX86State *env);
402void handle_vm86_trap(CPUX86State *env, int trapno);
403void handle_vm86_fault(CPUX86State *env);
404int do_vm86(CPUX86State *env, long subfunction, abi_ulong v86_addr);
405#elif defined(TARGET_SPARC64)
406void sparc64_set_context(CPUSPARCState *env);
407void sparc64_get_context(CPUSPARCState *env);
408#endif
409
410
411int target_mprotect(abi_ulong start, abi_ulong len, int prot);
412abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
413 int flags, int fd, abi_ulong offset);
414int target_munmap(abi_ulong start, abi_ulong len);
415abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
416 abi_ulong new_size, unsigned long flags,
417 abi_ulong new_addr);
418int target_msync(abi_ulong start, abi_ulong len, int flags);
419extern unsigned long last_brk;
420extern abi_ulong mmap_next_start;
421abi_ulong mmap_find_vma(abi_ulong, abi_ulong);
422void mmap_fork_start(void);
423void mmap_fork_end(int child);
424
425
426extern unsigned long guest_stack_size;
427
428
429
430#define VERIFY_READ 0
431#define VERIFY_WRITE 1
432
433static inline int access_ok(int type, abi_ulong addr, abi_ulong size)
434{
435 return page_check_range((target_ulong)addr, size,
436 (type == VERIFY_READ) ? PAGE_READ : (PAGE_READ | PAGE_WRITE)) == 0;
437}
438
439
440
441
442
443
444
445
446
447
448
449
450#define __put_user_e(x, hptr, e) \
451 (__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \
452 __builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \
453 __builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \
454 __builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \
455 ((hptr), (x)), (void)0)
456
457#define __get_user_e(x, hptr, e) \
458 ((x) = (typeof(*hptr))( \
459 __builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \
460 __builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \
461 __builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \
462 __builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \
463 (hptr)), (void)0)
464
465#ifdef TARGET_WORDS_BIGENDIAN
466# define __put_user(x, hptr) __put_user_e(x, hptr, be)
467# define __get_user(x, hptr) __get_user_e(x, hptr, be)
468#else
469# define __put_user(x, hptr) __put_user_e(x, hptr, le)
470# define __get_user(x, hptr) __get_user_e(x, hptr, le)
471#endif
472
473
474
475
476
477
478#define put_user(x, gaddr, target_type) \
479({ \
480 abi_ulong __gaddr = (gaddr); \
481 target_type *__hptr; \
482 abi_long __ret = 0; \
483 if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
484 __put_user((x), __hptr); \
485 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
486 } else \
487 __ret = -TARGET_EFAULT; \
488 __ret; \
489})
490
491#define get_user(x, gaddr, target_type) \
492({ \
493 abi_ulong __gaddr = (gaddr); \
494 target_type *__hptr; \
495 abi_long __ret = 0; \
496 if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
497 __get_user((x), __hptr); \
498 unlock_user(__hptr, __gaddr, 0); \
499 } else { \
500 \
501 (x) = 0; \
502 __ret = -TARGET_EFAULT; \
503 } \
504 __ret; \
505})
506
507#define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
508#define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
509#define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
510#define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
511#define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
512#define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
513#define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
514#define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
515#define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
516#define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
517
518#define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
519#define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
520#define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
521#define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
522#define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
523#define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
524#define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
525#define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
526#define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
527#define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
528
529
530
531
532
533abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
534abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
535
536
537
538
539
540
541
542
543
544static inline void *lock_user(int type, abi_ulong guest_addr, long len, int copy)
545{
546 if (!access_ok(type, guest_addr, len))
547 return NULL;
548#ifdef DEBUG_REMAP
549 {
550 void *addr;
551 addr = malloc(len);
552 if (copy)
553 memcpy(addr, g2h(guest_addr), len);
554 else
555 memset(addr, 0, len);
556 return addr;
557 }
558#else
559 return g2h(guest_addr);
560#endif
561}
562
563
564
565
566static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
567 long len)
568{
569
570#ifdef DEBUG_REMAP
571 if (!host_ptr)
572 return;
573 if (host_ptr == g2h(guest_addr))
574 return;
575 if (len > 0)
576 memcpy(g2h(guest_addr), host_ptr, len);
577 free(host_ptr);
578#endif
579}
580
581
582
583abi_long target_strlen(abi_ulong gaddr);
584
585
586static inline void *lock_user_string(abi_ulong guest_addr)
587{
588 abi_long len;
589 len = target_strlen(guest_addr);
590 if (len < 0)
591 return NULL;
592 return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
593}
594
595
596#define lock_user_struct(type, host_ptr, guest_addr, copy) \
597 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
598#define unlock_user_struct(host_ptr, guest_addr, copy) \
599 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
600
601#include <pthread.h>
602
603
604
605
606
607#include "target_cpu.h"
608#include "target_signal.h"
609#include "target_structs.h"
610
611#endif
612