]> git.proxmox.com Git - mirror_qemu.git/blame - bsd-user/qemu.h
bsd-user: Bring in docs from linux-user for signal_pending
[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
202/* signal.c */
9349b4f9 203void process_pending_signals(CPUArchState *cpu_env);
84778508 204void signal_init(void);
9349b4f9
AF
205long do_sigreturn(CPUArchState *env);
206long do_rt_sigreturn(CPUArchState *env);
5abfac27 207void queue_signal(CPUArchState *env, int sig, target_siginfo_t *info);
84778508
BS
208abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
209
210/* mmap.c */
211int target_mprotect(abi_ulong start, abi_ulong len, int prot);
212abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
be04f210 213 int flags, int fd, off_t offset);
84778508
BS
214int target_munmap(abi_ulong start, abi_ulong len);
215abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
216 abi_ulong new_size, unsigned long flags,
217 abi_ulong new_addr);
218int target_msync(abi_ulong start, abi_ulong len, int flags);
219extern unsigned long last_brk;
be04f210
WL
220extern abi_ulong mmap_next_start;
221abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size);
84778508
BS
222void mmap_fork_start(void);
223void mmap_fork_end(int child);
84778508 224
28e738dc 225/* main.c */
01a298a5 226extern char qemu_proc_pathname[];
312a0b1c
WL
227extern unsigned long target_maxtsiz;
228extern unsigned long target_dfldsiz;
229extern unsigned long target_maxdsiz;
230extern unsigned long target_dflssiz;
231extern unsigned long target_maxssiz;
232extern unsigned long target_sgrowsiz;
28e738dc 233
e5f674f0
WL
234/* syscall.c */
235abi_long get_errno(abi_long ret);
236bool is_error(abi_long ret);
237
da07e694
WL
238/* os-sys.c */
239abi_long do_freebsd_sysarch(void *cpu_env, abi_long arg1, abi_long arg2);
240
84778508
BS
241/* user access */
242
1720751f
RH
243#define VERIFY_READ PAGE_READ
244#define VERIFY_WRITE (PAGE_READ | PAGE_WRITE)
84778508 245
1720751f 246static inline bool access_ok(int type, abi_ulong addr, abi_ulong size)
84778508 247{
1720751f 248 return page_check_range((target_ulong)addr, size, type) == 0;
84778508
BS
249}
250
c2bdd9a1
WL
251/*
252 * NOTE __get_user and __put_user use host pointers and don't check access.
253 *
254 * These are usually used to access struct data members once the struct has been
255 * locked - usually with lock_user_struct().
84778508
BS
256 */
257#define __put_user(x, hptr)\
258({\
259 int size = sizeof(*hptr);\
cefbade1 260 switch (size) {\
84778508
BS
261 case 1:\
262 *(uint8_t *)(hptr) = (uint8_t)(typeof(*hptr))(x);\
263 break;\
264 case 2:\
265 *(uint16_t *)(hptr) = tswap16((typeof(*hptr))(x));\
266 break;\
267 case 4:\
268 *(uint32_t *)(hptr) = tswap32((typeof(*hptr))(x));\
269 break;\
270 case 8:\
271 *(uint64_t *)(hptr) = tswap64((typeof(*hptr))(x));\
272 break;\
273 default:\
274 abort();\
036a013f 275 } \
84778508
BS
276 0;\
277})
278
279#define __get_user(x, hptr) \
280({\
281 int size = sizeof(*hptr);\
cefbade1 282 switch (size) {\
84778508
BS
283 case 1:\
284 x = (typeof(*hptr))*(uint8_t *)(hptr);\
285 break;\
286 case 2:\
287 x = (typeof(*hptr))tswap16(*(uint16_t *)(hptr));\
288 break;\
289 case 4:\
290 x = (typeof(*hptr))tswap32(*(uint32_t *)(hptr));\
291 break;\
292 case 8:\
293 x = (typeof(*hptr))tswap64(*(uint64_t *)(hptr));\
294 break;\
295 default:\
84778508
BS
296 x = 0;\
297 abort();\
036a013f 298 } \
84778508
BS
299 0;\
300})
301
c2bdd9a1
WL
302/*
303 * put_user()/get_user() take a guest address and check access
304 *
305 * These are usually used to access an atomic data type, such as an int, that
306 * has been passed by address. These internally perform locking and unlocking
307 * on the data type.
84778508
BS
308 */
309#define put_user(x, gaddr, target_type) \
310({ \
311 abi_ulong __gaddr = (gaddr); \
312 target_type *__hptr; \
313 abi_long __ret; \
33066934
WL
314 __hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0); \
315 if (__hptr) { \
84778508
BS
316 __ret = __put_user((x), __hptr); \
317 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
318 } else \
319 __ret = -TARGET_EFAULT; \
320 __ret; \
321})
322
323#define get_user(x, gaddr, target_type) \
324({ \
325 abi_ulong __gaddr = (gaddr); \
326 target_type *__hptr; \
327 abi_long __ret; \
33066934
WL
328 __hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1); \
329 if (__hptr) { \
84778508
BS
330 __ret = __get_user((x), __hptr); \
331 unlock_user(__hptr, __gaddr, 0); \
332 } else { \
84778508
BS
333 (x) = 0; \
334 __ret = -TARGET_EFAULT; \
335 } \
336 __ret; \
337})
338
339#define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
340#define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
341#define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
342#define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
343#define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
344#define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
345#define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
346#define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
347#define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
348#define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
349
350#define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
351#define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
352#define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
353#define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
354#define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
355#define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
356#define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
357#define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
358#define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
359#define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
360
c2bdd9a1
WL
361/*
362 * copy_from_user() and copy_to_user() are usually used to copy data
84778508
BS
363 * buffers between the target and host. These internally perform
364 * locking/unlocking of the memory.
365 */
366abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
367abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
368
c2bdd9a1
WL
369/*
370 * Functions for accessing guest memory. The tget and tput functions
371 * read/write single values, byteswapping as necessary. The lock_user function
372 * gets a pointer to a contiguous area of guest memory, but does not perform
373 * any byteswapping. lock_user may return either a pointer to the guest
374 * memory, or a temporary buffer.
375 */
84778508 376
c2bdd9a1
WL
377/*
378 * Lock an area of guest memory into the host. If copy is true then the
379 * host area will have the same contents as the guest.
380 */
381static inline void *lock_user(int type, abi_ulong guest_addr, long len,
382 int copy)
84778508 383{
cb0ea019 384 if (!access_ok(type, guest_addr, len)) {
84778508 385 return NULL;
cb0ea019 386 }
84778508
BS
387#ifdef DEBUG_REMAP
388 {
389 void *addr;
fd9a3048 390 addr = g_malloc(len);
cb0ea019 391 if (copy) {
3e8f1628 392 memcpy(addr, g2h_untagged(guest_addr), len);
cb0ea019 393 } else {
84778508 394 memset(addr, 0, len);
cb0ea019 395 }
84778508
BS
396 return addr;
397 }
398#else
3e8f1628 399 return g2h_untagged(guest_addr);
84778508
BS
400#endif
401}
402
c2bdd9a1
WL
403/*
404 * Unlock an area of guest memory. The first LEN bytes must be flushed back to
405 * guest memory. host_ptr = NULL is explicitly allowed and does nothing.
406 */
84778508
BS
407static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
408 long len)
409{
410
411#ifdef DEBUG_REMAP
cb0ea019 412 if (!host_ptr) {
84778508 413 return;
cb0ea019
WL
414 }
415 if (host_ptr == g2h_untagged(guest_addr)) {
84778508 416 return;
cb0ea019
WL
417 }
418 if (len > 0) {
3e8f1628 419 memcpy(g2h_untagged(guest_addr), host_ptr, len);
cb0ea019 420 }
fd9a3048 421 g_free(host_ptr);
84778508
BS
422#endif
423}
424
c2bdd9a1
WL
425/*
426 * Return the length of a string in target memory or -TARGET_EFAULT if access
427 * error.
428 */
84778508
BS
429abi_long target_strlen(abi_ulong gaddr);
430
431/* Like lock_user but for null terminated strings. */
432static inline void *lock_user_string(abi_ulong guest_addr)
433{
434 abi_long len;
435 len = target_strlen(guest_addr);
cb0ea019 436 if (len < 0) {
84778508 437 return NULL;
cb0ea019 438 }
84778508
BS
439 return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
440}
441
41d1af4d 442/* Helper macros for locking/unlocking a target struct. */
84778508
BS
443#define lock_user_struct(type, host_ptr, guest_addr, copy) \
444 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
445#define unlock_user_struct(host_ptr, guest_addr, copy) \
446 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
447
84778508 448#include <pthread.h>
84778508
BS
449
450#endif /* QEMU_H */