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