]> git.proxmox.com Git - mirror_qemu.git/blame - bsd-user/qemu.h
bsd-user/signal.c: implement abstract target / host signal translation
[mirror_qemu.git] / bsd-user / qemu.h
CommitLineData
88dae46d
SB
1/*
2 * qemu bsd user mode definition
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
84778508
BS
17#ifndef QEMU_H
18#define QEMU_H
19
ab77bd84 20#include "qemu/osdep.h"
84778508 21#include "cpu.h"
e5e44263 22#include "qemu/units.h"
f08b6170 23#include "exec/cpu_ldst.h"
ab77bd84 24#include "exec/exec-all.h"
84778508
BS
25
26#undef DEBUG_REMAP
84778508 27
022c62cb 28#include "exec/user/abitypes.h"
84778508 29
4b599848
WL
30extern char **environ;
31
84778508
BS
32enum BSDType {
33 target_freebsd,
34 target_netbsd,
35 target_openbsd,
36};
78cfb07f 37extern enum BSDType bsd_type;
84778508 38
ab77bd84
WL
39#include "exec/user/thunk.h"
40#include "target_arch.h"
84778508 41#include "syscall_defs.h"
0c6940d0 42#include "target_syscall.h"
82792244 43#include "target_os_vmparam.h"
790baacc 44#include "target_os_signal.h"
022c62cb 45#include "exec/gdbstub.h"
84778508 46
c2bdd9a1
WL
47/*
48 * This struct is used to hold certain information about the image. Basically,
49 * it replicates in user space what would be certain task_struct fields in the
50 * kernel
84778508
BS
51 */
52struct image_info {
0475f8fa 53 abi_ulong load_bias;
84778508
BS
54 abi_ulong load_addr;
55 abi_ulong start_code;
56 abi_ulong end_code;
57 abi_ulong start_data;
58 abi_ulong end_data;
59 abi_ulong start_brk;
60 abi_ulong brk;
61 abi_ulong start_mmap;
62 abi_ulong mmap;
63 abi_ulong rss;
64 abi_ulong start_stack;
65 abi_ulong entry;
66 abi_ulong code_offset;
67 abi_ulong data_offset;
0475f8fa
WL
68 abi_ulong arg_start;
69 abi_ulong arg_end;
70 uint32_t elf_flags;
84778508
BS
71};
72
84778508
BS
73struct emulated_sigtable {
74 int pending; /* true if signal is pending */
b46d4ad7 75 target_siginfo_t info;
84778508
BS
76};
77
c2bdd9a1
WL
78/*
79 * NOTE: we force a big alignment so that the stack stored after is aligned too
80 */
84778508 81typedef struct TaskState {
bd88c780
AB
82 pid_t ts_tid; /* tid (or pid) of this task */
83
84778508 84 struct TaskState *next;
031fe7af 85 struct bsd_binprm *bprm;
84778508
BS
86 struct image_info *info;
87
88 struct emulated_sigtable sigtab[TARGET_NSIG];
48047225
WL
89 /*
90 * Nonzero if process_pending_signals() needs to do something (either
91 * handle a pending signal or unblock signals).
92 * This flag is written from a signal handler so should be accessed via
93 * the qatomic_read() and qatomic_set() functions. (It is not accessed
94 * from multiple threads.)
95 */
96 int signal_pending;
84778508 97
f7795e40 98 uint8_t stack[];
84778508
BS
99} __attribute__((aligned(16))) TaskState;
100
653ccec2 101void stop_all_tasks(void);
84778508
BS
102extern const char *qemu_uname_release;
103
84778508 104/*
e5e44263
WL
105 * TARGET_ARG_MAX defines the number of bytes allocated for arguments
106 * and envelope for the new program. 256k should suffice for a reasonable
107 * maxiumum env+arg in 32-bit environments, bump it up to 512k for !ILP32
108 * platforms.
84778508 109 */
e5e44263
WL
110#if TARGET_ABI_BITS > 32
111#define TARGET_ARG_MAX (512 * KiB)
112#else
113#define TARGET_ARG_MAX (256 * KiB)
114#endif
115#define MAX_ARG_PAGES (TARGET_ARG_MAX / TARGET_PAGE_SIZE)
84778508
BS
116
117/*
118 * This structure is used to hold the arguments that are
119 * used when loading binaries.
120 */
afcbcff8 121struct bsd_binprm {
84778508
BS
122 char buf[128];
123 void *page[MAX_ARG_PAGES];
124 abi_ulong p;
98b34d35 125 abi_ulong stringp;
84778508
BS
126 int fd;
127 int e_uid, e_gid;
128 int argc, envc;
129 char **argv;
130 char **envp;
1b50ff64
WL
131 char *filename; /* (Given) Name of binary */
132 char *fullpath; /* Full path of binary */
0475f8fa 133 int (*core_dump)(int, CPUArchState *);
84778508
BS
134};
135
136void do_init_thread(struct target_pt_regs *regs, struct image_info *infop);
137abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
ffa03665 138 abi_ulong stringp);
036a013f 139int loader_exec(const char *filename, char **argv, char **envp,
d37853f9
WL
140 struct target_pt_regs *regs, struct image_info *infop,
141 struct bsd_binprm *bprm);
84778508 142
afcbcff8 143int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
036a013f 144 struct image_info *info);
afcbcff8 145int load_flt_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
036a013f 146 struct image_info *info);
0475f8fa 147int is_target_elf_binary(int fd);
84778508
BS
148
149abi_long memcpy_to_target(abi_ulong dest, const void *src,
150 unsigned long len);
151void target_set_brk(abi_ulong new_brk);
152abi_long do_brk(abi_ulong new_brk);
153void syscall_init(void);
154abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
155 abi_long arg2, abi_long arg3, abi_long arg4,
78cfb07f
JL
156 abi_long arg5, abi_long arg6, abi_long arg7,
157 abi_long arg8);
84778508
BS
158abi_long do_netbsd_syscall(void *cpu_env, int num, abi_long arg1,
159 abi_long arg2, abi_long arg3, abi_long arg4,
160 abi_long arg5, abi_long arg6);
161abi_long do_openbsd_syscall(void *cpu_env, int num, abi_long arg1,
162 abi_long arg2, abi_long arg3, abi_long arg4,
163 abi_long arg5, abi_long arg6);
e5924d89 164void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
d42df502 165extern __thread CPUState *thread_cpu;
9349b4f9 166void cpu_loop(CPUArchState *env);
84778508
BS
167char *target_strerror(int err);
168int get_osversion(void);
169void fork_start(void);
170void fork_end(int child);
171
1de7afc9 172#include "qemu/log.h"
84778508
BS
173
174/* strace.c */
88dae46d
SB
175struct syscallname {
176 int nr;
177 const char *name;
178 const char *format;
179 void (*call)(const struct syscallname *,
180 abi_long, abi_long, abi_long,
181 abi_long, abi_long, abi_long);
182 void (*result)(const struct syscallname *, abi_long);
183};
184
84778508
BS
185void
186print_freebsd_syscall(int num,
187 abi_long arg1, abi_long arg2, abi_long arg3,
188 abi_long arg4, abi_long arg5, abi_long arg6);
189void print_freebsd_syscall_ret(int num, abi_long ret);
190void
191print_netbsd_syscall(int num,
192 abi_long arg1, abi_long arg2, abi_long arg3,
193 abi_long arg4, abi_long arg5, abi_long arg6);
194void print_netbsd_syscall_ret(int num, abi_long ret);
195void
196print_openbsd_syscall(int num,
197 abi_long arg1, abi_long arg2, abi_long arg3,
198 abi_long arg4, abi_long arg5, abi_long arg6);
199void print_openbsd_syscall_ret(int num, abi_long ret);
200extern int do_strace;
201
84778508
BS
202/* mmap.c */
203int target_mprotect(abi_ulong start, abi_ulong len, int prot);
204abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
be04f210 205 int flags, int fd, off_t offset);
84778508
BS
206int target_munmap(abi_ulong start, abi_ulong len);
207abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
208 abi_ulong new_size, unsigned long flags,
209 abi_ulong new_addr);
210int target_msync(abi_ulong start, abi_ulong len, int flags);
211extern unsigned long last_brk;
be04f210
WL
212extern abi_ulong mmap_next_start;
213abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size);
84778508
BS
214void mmap_fork_start(void);
215void mmap_fork_end(int child);
84778508 216
28e738dc 217/* main.c */
01a298a5 218extern char qemu_proc_pathname[];
312a0b1c
WL
219extern unsigned long target_maxtsiz;
220extern unsigned long target_dfldsiz;
221extern unsigned long target_maxdsiz;
222extern unsigned long target_dflssiz;
223extern unsigned long target_maxssiz;
224extern unsigned long target_sgrowsiz;
28e738dc 225
e5f674f0
WL
226/* syscall.c */
227abi_long get_errno(abi_long ret);
228bool is_error(abi_long ret);
229
da07e694
WL
230/* os-sys.c */
231abi_long do_freebsd_sysarch(void *cpu_env, abi_long arg1, abi_long arg2);
232
84778508
BS
233/* user access */
234
1720751f
RH
235#define VERIFY_READ PAGE_READ
236#define VERIFY_WRITE (PAGE_READ | PAGE_WRITE)
84778508 237
1720751f 238static inline bool access_ok(int type, abi_ulong addr, abi_ulong size)
84778508 239{
1720751f 240 return page_check_range((target_ulong)addr, size, type) == 0;
84778508
BS
241}
242
c2bdd9a1
WL
243/*
244 * NOTE __get_user and __put_user use host pointers and don't check access.
245 *
246 * These are usually used to access struct data members once the struct has been
247 * locked - usually with lock_user_struct().
84778508
BS
248 */
249#define __put_user(x, hptr)\
250({\
251 int size = sizeof(*hptr);\
cefbade1 252 switch (size) {\
84778508
BS
253 case 1:\
254 *(uint8_t *)(hptr) = (uint8_t)(typeof(*hptr))(x);\
255 break;\
256 case 2:\
257 *(uint16_t *)(hptr) = tswap16((typeof(*hptr))(x));\
258 break;\
259 case 4:\
260 *(uint32_t *)(hptr) = tswap32((typeof(*hptr))(x));\
261 break;\
262 case 8:\
263 *(uint64_t *)(hptr) = tswap64((typeof(*hptr))(x));\
264 break;\
265 default:\
266 abort();\
036a013f 267 } \
84778508
BS
268 0;\
269})
270
271#define __get_user(x, hptr) \
272({\
273 int size = sizeof(*hptr);\
cefbade1 274 switch (size) {\
84778508
BS
275 case 1:\
276 x = (typeof(*hptr))*(uint8_t *)(hptr);\
277 break;\
278 case 2:\
279 x = (typeof(*hptr))tswap16(*(uint16_t *)(hptr));\
280 break;\
281 case 4:\
282 x = (typeof(*hptr))tswap32(*(uint32_t *)(hptr));\
283 break;\
284 case 8:\
285 x = (typeof(*hptr))tswap64(*(uint64_t *)(hptr));\
286 break;\
287 default:\
84778508
BS
288 x = 0;\
289 abort();\
036a013f 290 } \
84778508
BS
291 0;\
292})
293
c2bdd9a1
WL
294/*
295 * put_user()/get_user() take a guest address and check access
296 *
297 * These are usually used to access an atomic data type, such as an int, that
298 * has been passed by address. These internally perform locking and unlocking
299 * on the data type.
84778508
BS
300 */
301#define put_user(x, gaddr, target_type) \
302({ \
303 abi_ulong __gaddr = (gaddr); \
304 target_type *__hptr; \
305 abi_long __ret; \
33066934
WL
306 __hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0); \
307 if (__hptr) { \
84778508
BS
308 __ret = __put_user((x), __hptr); \
309 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
310 } else \
311 __ret = -TARGET_EFAULT; \
312 __ret; \
313})
314
315#define get_user(x, gaddr, target_type) \
316({ \
317 abi_ulong __gaddr = (gaddr); \
318 target_type *__hptr; \
319 abi_long __ret; \
33066934
WL
320 __hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1); \
321 if (__hptr) { \
84778508
BS
322 __ret = __get_user((x), __hptr); \
323 unlock_user(__hptr, __gaddr, 0); \
324 } else { \
84778508
BS
325 (x) = 0; \
326 __ret = -TARGET_EFAULT; \
327 } \
328 __ret; \
329})
330
331#define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
332#define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
333#define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
334#define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
335#define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
336#define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
337#define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
338#define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
339#define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
340#define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
341
342#define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
343#define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
344#define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
345#define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
346#define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
347#define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
348#define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
349#define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
350#define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
351#define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
352
c2bdd9a1
WL
353/*
354 * copy_from_user() and copy_to_user() are usually used to copy data
84778508
BS
355 * buffers between the target and host. These internally perform
356 * locking/unlocking of the memory.
357 */
358abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
359abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
360
c2bdd9a1
WL
361/*
362 * Functions for accessing guest memory. The tget and tput functions
363 * read/write single values, byteswapping as necessary. The lock_user function
364 * gets a pointer to a contiguous area of guest memory, but does not perform
365 * any byteswapping. lock_user may return either a pointer to the guest
366 * memory, or a temporary buffer.
367 */
84778508 368
c2bdd9a1
WL
369/*
370 * Lock an area of guest memory into the host. If copy is true then the
371 * host area will have the same contents as the guest.
372 */
373static inline void *lock_user(int type, abi_ulong guest_addr, long len,
374 int copy)
84778508 375{
cb0ea019 376 if (!access_ok(type, guest_addr, len)) {
84778508 377 return NULL;
cb0ea019 378 }
84778508
BS
379#ifdef DEBUG_REMAP
380 {
381 void *addr;
fd9a3048 382 addr = g_malloc(len);
cb0ea019 383 if (copy) {
3e8f1628 384 memcpy(addr, g2h_untagged(guest_addr), len);
cb0ea019 385 } else {
84778508 386 memset(addr, 0, len);
cb0ea019 387 }
84778508
BS
388 return addr;
389 }
390#else
3e8f1628 391 return g2h_untagged(guest_addr);
84778508
BS
392#endif
393}
394
c2bdd9a1
WL
395/*
396 * Unlock an area of guest memory. The first LEN bytes must be flushed back to
397 * guest memory. host_ptr = NULL is explicitly allowed and does nothing.
398 */
84778508
BS
399static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
400 long len)
401{
402
403#ifdef DEBUG_REMAP
cb0ea019 404 if (!host_ptr) {
84778508 405 return;
cb0ea019
WL
406 }
407 if (host_ptr == g2h_untagged(guest_addr)) {
84778508 408 return;
cb0ea019
WL
409 }
410 if (len > 0) {
3e8f1628 411 memcpy(g2h_untagged(guest_addr), host_ptr, len);
cb0ea019 412 }
fd9a3048 413 g_free(host_ptr);
84778508
BS
414#endif
415}
416
c2bdd9a1
WL
417/*
418 * Return the length of a string in target memory or -TARGET_EFAULT if access
419 * error.
420 */
84778508
BS
421abi_long target_strlen(abi_ulong gaddr);
422
423/* Like lock_user but for null terminated strings. */
424static inline void *lock_user_string(abi_ulong guest_addr)
425{
426 abi_long len;
427 len = target_strlen(guest_addr);
cb0ea019 428 if (len < 0) {
84778508 429 return NULL;
cb0ea019 430 }
84778508
BS
431 return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
432}
433
41d1af4d 434/* Helper macros for locking/unlocking a target struct. */
84778508
BS
435#define lock_user_struct(type, host_ptr, guest_addr, copy) \
436 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
437#define unlock_user_struct(host_ptr, guest_addr, copy) \
438 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
439
84778508 440#include <pthread.h>
84778508
BS
441
442#endif /* QEMU_H */