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 */
17 #ifndef QEMU_H
18 #define QEMU_H
19
20 #include <sys/param.h>
21
22 #include "qemu/int128.h"
23 #include "cpu.h"
24 #include "qemu/units.h"
25 #include "accel/tcg/cpu-ldst.h"
26
27 #include "user/abitypes.h"
28 #include "user/cpu_loop.h"
29 #include "user/page-protection.h"
30
31 extern char **environ;
32
33 #include "user/thunk.h"
34 #include "user/mmap.h"
35 #include "target_arch.h"
36 #include "syscall_defs.h"
37 #include "target_syscall.h"
38 #include "target_os_vmparam.h"
39 #include "target_os_signal.h"
40 #include "target.h"
41 #include "exec/gdbstub.h"
42 #include "exec/page-protection.h"
43 #include "accel/tcg/vcpu-state.h"
44
45 #include "qemu-os.h"
46 /*
47 * TODO: Remove these and rely only on qemu_real_host_page_size().
48 */
49 extern uintptr_t qemu_host_page_size;
50 extern intptr_t qemu_host_page_mask;
51 #define HOST_PAGE_ALIGN(addr) ROUND_UP((addr), qemu_host_page_size)
52
53 /*
54 * This struct is used to hold certain information about the image. Basically,
55 * it replicates in user space what would be certain task_struct fields in the
56 * kernel
57 */
58 struct image_info {
59 abi_ulong load_bias;
60 abi_ulong load_addr;
61 abi_ulong start_code;
62 abi_ulong end_code;
63 abi_ulong start_data;
64 abi_ulong end_data;
65 abi_ulong brk;
66 abi_ulong rss;
67 abi_ulong start_stack;
68 abi_ulong entry;
69 abi_ulong code_offset;
70 abi_ulong data_offset;
71 abi_ulong arg_start;
72 abi_ulong arg_end;
73 uint32_t elf_flags;
74 };
75
76 struct emulated_sigtable {
77 int pending; /* true if signal is pending */
78 target_siginfo_t info;
79 };
80
81 /*
82 * NOTE: we force a big alignment so that the stack stored after is aligned too
83 */
84 struct TaskState {
85 pid_t ts_tid; /* tid (or pid) of this task */
86
87 struct TaskState *next;
88 struct bsd_binprm *bprm;
89 struct image_info *info;
90
91 struct emulated_sigtable sync_signal;
92 /*
93 * TODO: Since we block all signals while returning to the main CPU
94 * loop, this needn't be an array
95 */
96 struct emulated_sigtable sigtab[TARGET_NSIG];
97 /*
98 * Nonzero if process_pending_signals() needs to do something (either
99 * handle a pending signal or unblock signals).
100 * This flag is written from a signal handler so should be accessed via
101 * the qatomic_read() and qatomic_set() functions. (It is not accessed
102 * from multiple threads.)
103 */
104 int signal_pending;
105 /* True if we're leaving a sigsuspend and sigsuspend_mask is valid. */
106 bool in_sigsuspend;
107 /*
108 * This thread's signal mask, as requested by the guest program.
109 * The actual signal mask of this thread may differ:
110 * + we don't let SIGSEGV and SIGBUS be blocked while running guest code
111 * + sometimes we block all signals to avoid races
112 */
113 sigset_t signal_mask;
114 /*
115 * The signal mask imposed by a guest sigsuspend syscall, if we are
116 * currently in the middle of such a syscall
117 */
118 sigset_t sigsuspend_mask;
119
120 /* This thread's sigaltstack, if it has one */
121 struct target_sigaltstack sigaltstack_used;
122 } __attribute__((aligned(16)));
123
124 void stop_all_tasks(void);
125 extern const char *interp_prefix;
126 extern const char *qemu_uname_release;
127
128 /*
129 * TARGET_ARG_MAX defines the number of bytes allocated for arguments
130 * and envelope for the new program. 256k should suffice for a reasonable
131 * maximum env+arg in 32-bit environments, bump it up to 512k for !ILP32
132 * platforms.
133 */
134 #if TARGET_ABI_BITS > 32
135 #define TARGET_ARG_MAX (512 * KiB)
136 #else
137 #define TARGET_ARG_MAX (256 * KiB)
138 #endif
139 #define MAX_ARG_PAGES (TARGET_ARG_MAX / TARGET_PAGE_SIZE)
140
141 /*
142 * This structure is used to hold the arguments that are
143 * used when loading binaries.
144 */
145 struct bsd_binprm {
146 char buf[128];
147 void *page[MAX_ARG_PAGES];
148 abi_ulong p;
149 abi_ulong stringp;
150 int fd;
151 int e_uid, e_gid;
152 int argc, envc;
153 char **argv;
154 char **envp;
155 char *filename; /* (Given) Name of binary */
156 char *fullpath; /* Full path of binary */
157 int (*core_dump)(int, CPUArchState *);
158 };
159
160 void do_init_thread(struct target_pt_regs *regs, struct image_info *infop);
161 abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
162 abi_ulong stringp);
163 int loader_exec(const char *filename, char **argv, char **envp,
164 struct target_pt_regs *regs, struct image_info *infop,
165 struct bsd_binprm *bprm);
166
167 int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
168 struct image_info *info);
169 int load_flt_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
170 struct image_info *info);
171 int is_target_elf_binary(int fd);
172
173 abi_long memcpy_to_target(abi_ulong dest, const void *src,
174 unsigned long len);
175 void target_set_brk(abi_ulong new_brk);
176 abi_long do_brk(abi_ulong new_brk);
177 void syscall_init(void);
178 abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
179 abi_long arg2, abi_long arg3, abi_long arg4,
180 abi_long arg5, abi_long arg6, abi_long arg7,
181 abi_long arg8);
182 abi_long do_netbsd_syscall(void *cpu_env, int num, abi_long arg1,
183 abi_long arg2, abi_long arg3, abi_long arg4,
184 abi_long arg5, abi_long arg6);
185 abi_long do_openbsd_syscall(void *cpu_env, int num, abi_long arg1,
186 abi_long arg2, abi_long arg3, abi_long arg4,
187 abi_long arg5, abi_long arg6);
188 void gemu_log(const char *fmt, ...) G_GNUC_PRINTF(1, 2);
189 extern __thread CPUState *thread_cpu;
190 char *target_strerror(int err);
191 int get_osversion(void);
192 void fork_start(void);
193 void fork_end(pid_t pid);
194
195 #include "qemu/log.h"
196
197 /* strace.c */
198 struct syscallname {
199 int nr;
200 const char *name;
201 const char *format;
202 void (*call)(const struct syscallname *,
203 abi_long, abi_long, abi_long,
204 abi_long, abi_long, abi_long);
205 void (*result)(const struct syscallname *, abi_long);
206 };
207
208 void
209 print_freebsd_syscall(int num,
210 abi_long arg1, abi_long arg2, abi_long arg3,
211 abi_long arg4, abi_long arg5, abi_long arg6);
212 void print_freebsd_syscall_ret(int num, abi_long ret);
213 void
214 print_netbsd_syscall(int num,
215 abi_long arg1, abi_long arg2, abi_long arg3,
216 abi_long arg4, abi_long arg5, abi_long arg6);
217 void print_netbsd_syscall_ret(int num, abi_long ret);
218 void
219 print_openbsd_syscall(int num,
220 abi_long arg1, abi_long arg2, abi_long arg3,
221 abi_long arg4, abi_long arg5, abi_long arg6);
222 void print_openbsd_syscall_ret(int num, abi_long ret);
223 /**
224 * print_taken_signal:
225 * @target_signum: target signal being taken
226 * @tinfo: target_siginfo_t which will be passed to the guest for the signal
227 *
228 * Print strace output indicating that this signal is being taken by the guest,
229 * in a format similar to:
230 * --- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} ---
231 */
232 void print_taken_signal(int target_signum, const target_siginfo_t *tinfo);
233 extern int do_strace;
234
235 /* mmap.c */
236 int target_msync(abi_ulong start, abi_ulong len, int flags);
237 void mmap_reserve(abi_ulong start, abi_ulong size);
238
239 /* main.c */
240 extern char qemu_proc_pathname[];
241 extern unsigned long target_maxtsiz;
242 extern unsigned long target_dfldsiz;
243 extern unsigned long target_maxdsiz;
244 extern unsigned long target_dflssiz;
245 extern unsigned long target_maxssiz;
246 extern unsigned long target_sgrowsiz;
247
248 /* os-syscall.c */
249 abi_long get_errno(abi_long ret);
250 bool is_error(abi_long ret);
251 int host_to_target_errno(int err);
252
253 /* os-proc.c */
254 abi_long freebsd_exec_common(abi_ulong path_or_fd, abi_ulong guest_argp,
255 abi_ulong guest_envp, int do_fexec);
256 abi_long do_freebsd_procctl(void *cpu_env, int idtype, abi_ulong arg2,
257 abi_ulong arg3, abi_ulong arg4, abi_ulong arg5, abi_ulong arg6);
258
259 /* os-sys.c */
260 abi_long do_freebsd_sysctl(CPUArchState *env, abi_ulong namep, int32_t namelen,
261 abi_ulong oldp, abi_ulong oldlenp, abi_ulong newp, abi_ulong newlen);
262 abi_long do_freebsd_sysctlbyname(CPUArchState *env, abi_ulong namep,
263 int32_t namelen, abi_ulong oldp, abi_ulong oldlenp, abi_ulong newp,
264 abi_ulong newlen);
265 abi_long do_freebsd_sysarch(void *cpu_env, abi_long arg1, abi_long arg2);
266
267 /* user access */
268
269 #define VERIFY_READ PAGE_READ
270 #define VERIFY_WRITE (PAGE_READ | PAGE_WRITE)
271
access_ok(int type,abi_ulong addr,abi_ulong size)272 static inline bool access_ok(int type, abi_ulong addr, abi_ulong size)
273 {
274 return page_check_range((target_ulong)addr, size, type);
275 }
276
277 /*
278 * NOTE __get_user and __put_user use host pointers and don't check access.
279 *
280 * These are usually used to access struct data members once the struct has been
281 * locked - usually with lock_user_struct().
282 */
283
284 /*
285 * Tricky points:
286 * - Use __builtin_choose_expr to avoid type promotion from ?:,
287 * - Invalid sizes result in a compile time error stemming from
288 * the fact that abort has no parameters.
289 * - It's easier to use the endian-specific unaligned load/store
290 * functions than host-endian unaligned load/store plus tswapN.
291 * - The pragmas are necessary only to silence a clang false-positive
292 * warning: see https://bugs.llvm.org/show_bug.cgi?id=39113 .
293 * - gcc has bugs in its _Pragma() support in some versions, eg
294 * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83256 -- so we only
295 * include the warning-suppression pragmas for clang
296 */
297 #if defined(__clang__) && __has_warning("-Waddress-of-packed-member")
298 #define PRAGMA_DISABLE_PACKED_WARNING \
299 _Pragma("GCC diagnostic push"); \
300 _Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\"")
301
302 #define PRAGMA_REENABLE_PACKED_WARNING \
303 _Pragma("GCC diagnostic pop")
304
305 #else
306 #define PRAGMA_DISABLE_PACKED_WARNING
307 #define PRAGMA_REENABLE_PACKED_WARNING
308 #endif
309
310 #define __put_user_e(x, hptr, e) \
311 do { \
312 PRAGMA_DISABLE_PACKED_WARNING; \
313 (__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \
314 __builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \
315 __builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \
316 __builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \
317 ((hptr), (x)), (void)0); \
318 PRAGMA_REENABLE_PACKED_WARNING; \
319 } while (0)
320
321 #define __get_user_e(x, hptr, e) \
322 do { \
323 PRAGMA_DISABLE_PACKED_WARNING; \
324 ((x) = (typeof(*hptr))( \
325 __builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \
326 __builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \
327 __builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \
328 __builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \
329 (hptr)), (void)0); \
330 PRAGMA_REENABLE_PACKED_WARNING; \
331 } while (0)
332
333
334 #if TARGET_BIG_ENDIAN
335 # define __put_user(x, hptr) __put_user_e(x, hptr, be)
336 # define __get_user(x, hptr) __get_user_e(x, hptr, be)
337 #else
338 # define __put_user(x, hptr) __put_user_e(x, hptr, le)
339 # define __get_user(x, hptr) __get_user_e(x, hptr, le)
340 #endif
341
342 /*
343 * put_user()/get_user() take a guest address and check access
344 *
345 * These are usually used to access an atomic data type, such as an int, that
346 * has been passed by address. These internally perform locking and unlocking
347 * on the data type.
348 */
349 #define put_user(x, gaddr, target_type) \
350 ({ \
351 abi_ulong __gaddr = (gaddr); \
352 target_type *__hptr; \
353 abi_long __ret = 0; \
354 __hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0); \
355 if (__hptr) { \
356 __put_user((x), __hptr); \
357 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
358 } else \
359 __ret = -TARGET_EFAULT; \
360 __ret; \
361 })
362
363 #define get_user(x, gaddr, target_type) \
364 ({ \
365 abi_ulong __gaddr = (gaddr); \
366 target_type *__hptr; \
367 abi_long __ret = 0; \
368 __hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1); \
369 if (__hptr) { \
370 __get_user((x), __hptr); \
371 unlock_user(__hptr, __gaddr, 0); \
372 } else { \
373 (x) = 0; \
374 __ret = -TARGET_EFAULT; \
375 } \
376 __ret; \
377 })
378
379 #define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
380 #define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
381 #define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
382 #define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
383 #define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
384 #define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
385 #define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
386 #define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
387 #define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
388 #define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
389
390 #define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
391 #define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
392 #define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
393 #define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
394 #define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
395 #define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
396 #define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
397 #define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
398 #define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
399 #define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
400
401 /*
402 * copy_from_user() and copy_to_user() are usually used to copy data
403 * buffers between the target and host. These internally perform
404 * locking/unlocking of the memory.
405 */
406 abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
407 abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
408
409 /*
410 * Functions for accessing guest memory. The tget and tput functions
411 * read/write single values, byteswapping as necessary. The lock_user function
412 * gets a pointer to a contiguous area of guest memory, but does not perform
413 * any byteswapping. lock_user may return either a pointer to the guest
414 * memory, or a temporary buffer.
415 */
416
417 /*
418 * Lock an area of guest memory into the host. If copy is true then the
419 * host area will have the same contents as the guest.
420 */
lock_user(int type,abi_ulong guest_addr,long len,int copy)421 static inline void *lock_user(int type, abi_ulong guest_addr, long len,
422 int copy)
423 {
424 if (!access_ok(type, guest_addr, len)) {
425 return NULL;
426 }
427 #ifdef CONFIG_DEBUG_REMAP
428 {
429 void *addr;
430 addr = g_malloc(len);
431 if (copy) {
432 memcpy(addr, g2h_untagged(guest_addr), len);
433 } else {
434 memset(addr, 0, len);
435 }
436 return addr;
437 }
438 #else
439 return g2h_untagged(guest_addr);
440 #endif
441 }
442
443 /*
444 * Unlock an area of guest memory. The first LEN bytes must be flushed back to
445 * guest memory. host_ptr = NULL is explicitly allowed and does nothing.
446 */
unlock_user(void * host_ptr,abi_ulong guest_addr,long len)447 static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
448 long len)
449 {
450
451 #ifdef CONFIG_DEBUG_REMAP
452 if (!host_ptr) {
453 return;
454 }
455 if (host_ptr == g2h_untagged(guest_addr)) {
456 return;
457 }
458 if (len > 0) {
459 memcpy(g2h_untagged(guest_addr), host_ptr, len);
460 }
461 g_free(host_ptr);
462 #endif
463 }
464
465 /*
466 * Return the length of a string in target memory or -TARGET_EFAULT if access
467 * error.
468 */
469 abi_long target_strlen(abi_ulong gaddr);
470
471 /* Like lock_user but for null terminated strings. */
lock_user_string(abi_ulong guest_addr)472 static inline void *lock_user_string(abi_ulong guest_addr)
473 {
474 abi_long len;
475 len = target_strlen(guest_addr);
476 if (len < 0) {
477 return NULL;
478 }
479 return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
480 }
481
482 /* Helper macros for locking/unlocking a target struct. */
483 #define lock_user_struct(type, host_ptr, guest_addr, copy) \
484 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
485 #define unlock_user_struct(host_ptr, guest_addr, copy) \
486 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
487
target_arg64(uint32_t word0,uint32_t word1)488 static inline uint64_t target_arg64(uint32_t word0, uint32_t word1)
489 {
490 #if TARGET_ABI_BITS == 32
491 #if TARGET_BIG_ENDIAN
492 return ((uint64_t)word0 << 32) | word1;
493 #else
494 return ((uint64_t)word1 << 32) | word0;
495 #endif
496 #else /* TARGET_ABI_BITS != 32 */
497 return word0;
498 #endif /* TARGET_ABI_BITS != 32 */
499 }
500
501 #include <pthread.h>
502
503 #include "user/safe-syscall.h"
504
505 #endif /* QEMU_H */
506