1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#ifndef QEMU_H
18#define QEMU_H
19
20
21#include "cpu.h"
22#include "exec/cpu_ldst.h"
23
24#undef DEBUG_REMAP
25#ifdef DEBUG_REMAP
26#endif
27
28#include "exec/user/abitypes.h"
29
30enum BSDType {
31 target_freebsd,
32 target_netbsd,
33 target_openbsd,
34};
35extern enum BSDType bsd_type;
36
37#include "syscall_defs.h"
38#include "target_syscall.h"
39#include "target_signal.h"
40#include "exec/gdbstub.h"
41
42#if defined(CONFIG_USE_NPTL)
43#define THREAD __thread
44#else
45#define THREAD
46#endif
47
48
49
50
51
52struct image_info {
53 abi_ulong load_addr;
54 abi_ulong start_code;
55 abi_ulong end_code;
56 abi_ulong start_data;
57 abi_ulong end_data;
58 abi_ulong start_brk;
59 abi_ulong brk;
60 abi_ulong start_mmap;
61 abi_ulong mmap;
62 abi_ulong rss;
63 abi_ulong start_stack;
64 abi_ulong entry;
65 abi_ulong code_offset;
66 abi_ulong data_offset;
67 int personality;
68};
69
70#define MAX_SIGQUEUE_SIZE 1024
71
72struct sigqueue {
73 struct sigqueue *next;
74
75};
76
77struct emulated_sigtable {
78 int pending;
79 struct sigqueue *first;
80 struct sigqueue info;
81
82};
83
84
85
86typedef struct TaskState {
87 struct TaskState *next;
88 int used;
89 struct image_info *info;
90
91 struct emulated_sigtable sigtab[TARGET_NSIG];
92 struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE];
93 struct sigqueue *first_free;
94 int signal_pending;
95
96 uint8_t stack[0];
97} __attribute__((aligned(16))) TaskState;
98
99void init_task_state(TaskState *ts);
100extern const char *qemu_uname_release;
101extern unsigned long mmap_min_addr;
102
103
104
105
106
107
108
109#define MAX_ARG_PAGES 32
110
111
112
113
114
115struct linux_binprm {
116 char buf[128];
117 void *page[MAX_ARG_PAGES];
118 abi_ulong p;
119 int fd;
120 int e_uid, e_gid;
121 int argc, envc;
122 char **argv;
123 char **envp;
124 char * filename;
125};
126
127void do_init_thread(struct target_pt_regs *regs, struct image_info *infop);
128abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
129 abi_ulong stringp, int push_ptr);
130int loader_exec(const char * filename, char ** argv, char ** envp,
131 struct target_pt_regs * regs, struct image_info *infop);
132
133int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
134 struct image_info * info);
135int load_flt_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
136 struct image_info * info);
137
138abi_long memcpy_to_target(abi_ulong dest, const void *src,
139 unsigned long len);
140void target_set_brk(abi_ulong new_brk);
141abi_long do_brk(abi_ulong new_brk);
142void syscall_init(void);
143abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
144 abi_long arg2, abi_long arg3, abi_long arg4,
145 abi_long arg5, abi_long arg6, abi_long arg7,
146 abi_long arg8);
147abi_long do_netbsd_syscall(void *cpu_env, int num, abi_long arg1,
148 abi_long arg2, abi_long arg3, abi_long arg4,
149 abi_long arg5, abi_long arg6);
150abi_long do_openbsd_syscall(void *cpu_env, int num, abi_long arg1,
151 abi_long arg2, abi_long arg3, abi_long arg4,
152 abi_long arg5, abi_long arg6);
153void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
154extern THREAD CPUState *thread_cpu;
155void cpu_loop(CPUArchState *env);
156char *target_strerror(int err);
157int get_osversion(void);
158void fork_start(void);
159void fork_end(int child);
160
161#include "qemu/log.h"
162
163
164struct syscallname {
165 int nr;
166 const char *name;
167 const char *format;
168 void (*call)(const struct syscallname *,
169 abi_long, abi_long, abi_long,
170 abi_long, abi_long, abi_long);
171 void (*result)(const struct syscallname *, abi_long);
172};
173
174void
175print_freebsd_syscall(int num,
176 abi_long arg1, abi_long arg2, abi_long arg3,
177 abi_long arg4, abi_long arg5, abi_long arg6);
178void print_freebsd_syscall_ret(int num, abi_long ret);
179void
180print_netbsd_syscall(int num,
181 abi_long arg1, abi_long arg2, abi_long arg3,
182 abi_long arg4, abi_long arg5, abi_long arg6);
183void print_netbsd_syscall_ret(int num, abi_long ret);
184void
185print_openbsd_syscall(int num,
186 abi_long arg1, abi_long arg2, abi_long arg3,
187 abi_long arg4, abi_long arg5, abi_long arg6);
188void print_openbsd_syscall_ret(int num, abi_long ret);
189extern int do_strace;
190
191
192void process_pending_signals(CPUArchState *cpu_env);
193void signal_init(void);
194
195
196
197long do_sigreturn(CPUArchState *env);
198long do_rt_sigreturn(CPUArchState *env);
199abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
200
201
202int target_mprotect(abi_ulong start, abi_ulong len, int prot);
203abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
204 int flags, int fd, abi_ulong offset);
205int target_munmap(abi_ulong start, abi_ulong len);
206abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
207 abi_ulong new_size, unsigned long flags,
208 abi_ulong new_addr);
209int target_msync(abi_ulong start, abi_ulong len, int flags);
210extern unsigned long last_brk;
211void cpu_list_lock(void);
212void cpu_list_unlock(void);
213#if defined(CONFIG_USE_NPTL)
214void mmap_fork_start(void);
215void mmap_fork_end(int child);
216#endif
217
218
219extern unsigned long x86_stack_size;
220
221
222
223#define VERIFY_READ 0
224#define VERIFY_WRITE 1
225
226static inline int access_ok(int type, abi_ulong addr, abi_ulong size)
227{
228 return page_check_range((target_ulong)addr, size,
229 (type == VERIFY_READ) ? PAGE_READ : (PAGE_READ | PAGE_WRITE)) == 0;
230}
231
232
233
234
235
236#define __put_user(x, hptr)\
237({\
238 int size = sizeof(*hptr);\
239 switch(size) {\
240 case 1:\
241 *(uint8_t *)(hptr) = (uint8_t)(typeof(*hptr))(x);\
242 break;\
243 case 2:\
244 *(uint16_t *)(hptr) = tswap16((typeof(*hptr))(x));\
245 break;\
246 case 4:\
247 *(uint32_t *)(hptr) = tswap32((typeof(*hptr))(x));\
248 break;\
249 case 8:\
250 *(uint64_t *)(hptr) = tswap64((typeof(*hptr))(x));\
251 break;\
252 default:\
253 abort();\
254 }\
255 0;\
256})
257
258#define __get_user(x, hptr) \
259({\
260 int size = sizeof(*hptr);\
261 switch(size) {\
262 case 1:\
263 x = (typeof(*hptr))*(uint8_t *)(hptr);\
264 break;\
265 case 2:\
266 x = (typeof(*hptr))tswap16(*(uint16_t *)(hptr));\
267 break;\
268 case 4:\
269 x = (typeof(*hptr))tswap32(*(uint32_t *)(hptr));\
270 break;\
271 case 8:\
272 x = (typeof(*hptr))tswap64(*(uint64_t *)(hptr));\
273 break;\
274 default:\
275 \
276 x = 0;\
277 abort();\
278 }\
279 0;\
280})
281
282
283
284
285
286
287#define put_user(x, gaddr, target_type) \
288({ \
289 abi_ulong __gaddr = (gaddr); \
290 target_type *__hptr; \
291 abi_long __ret; \
292 if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
293 __ret = __put_user((x), __hptr); \
294 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
295 } else \
296 __ret = -TARGET_EFAULT; \
297 __ret; \
298})
299
300#define get_user(x, gaddr, target_type) \
301({ \
302 abi_ulong __gaddr = (gaddr); \
303 target_type *__hptr; \
304 abi_long __ret; \
305 if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
306 __ret = __get_user((x), __hptr); \
307 unlock_user(__hptr, __gaddr, 0); \
308 } else { \
309 \
310 (x) = 0; \
311 __ret = -TARGET_EFAULT; \
312 } \
313 __ret; \
314})
315
316#define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
317#define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
318#define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
319#define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
320#define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
321#define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
322#define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
323#define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
324#define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
325#define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
326
327#define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
328#define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
329#define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
330#define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
331#define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
332#define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
333#define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
334#define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
335#define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
336#define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
337
338
339
340
341
342abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
343abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
344
345
346
347
348
349
350
351
352
353static inline void *lock_user(int type, abi_ulong guest_addr, long len, int copy)
354{
355 if (!access_ok(type, guest_addr, len))
356 return NULL;
357#ifdef DEBUG_REMAP
358 {
359 void *addr;
360 addr = malloc(len);
361 if (copy)
362 memcpy(addr, g2h(guest_addr), len);
363 else
364 memset(addr, 0, len);
365 return addr;
366 }
367#else
368 return g2h(guest_addr);
369#endif
370}
371
372
373
374
375static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
376 long len)
377{
378
379#ifdef DEBUG_REMAP
380 if (!host_ptr)
381 return;
382 if (host_ptr == g2h(guest_addr))
383 return;
384 if (len > 0)
385 memcpy(g2h(guest_addr), host_ptr, len);
386 free(host_ptr);
387#endif
388}
389
390
391
392abi_long target_strlen(abi_ulong gaddr);
393
394
395static inline void *lock_user_string(abi_ulong guest_addr)
396{
397 abi_long len;
398 len = target_strlen(guest_addr);
399 if (len < 0)
400 return NULL;
401 return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
402}
403
404
405#define lock_user_struct(type, host_ptr, guest_addr, copy) \
406 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
407#define unlock_user_struct(host_ptr, guest_addr, copy) \
408 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
409
410#if defined(CONFIG_USE_NPTL)
411#include <pthread.h>
412#endif
413
414#endif
415