| #ifndef QEMU_H |
| #define QEMU_H |
| |
| #include "cpu.h" |
| #include "exec/cpu_ldst.h" |
| |
| #include "user/abitypes.h" |
| |
| #include "syscall_defs.h" |
| #include "target_syscall.h" |
| #include "accel/tcg/vcpu-state.h" |
| |
| /* |
| * This is the size of the host kernel's sigset_t, needed where we make |
| * direct system calls that take a sigset_t pointer and a size. |
| */ |
| #define SIGSET_T_SIZE (_NSIG / 8) |
| |
| /* |
| * This struct is used to hold certain information about the image. |
| * Basically, it replicates in user space what would be certain |
| * task_struct fields in the kernel |
| */ |
| struct image_info { |
| abi_ulong load_bias; |
| abi_ulong load_addr; |
| abi_ulong start_code; |
| abi_ulong end_code; |
| abi_ulong start_data; |
| abi_ulong end_data; |
| abi_ulong brk; |
| abi_ulong start_stack; |
| abi_ulong stack_limit; |
| abi_ulong vdso; |
| abi_ulong entry; |
| abi_ulong code_offset; |
| abi_ulong data_offset; |
| abi_ulong saved_auxv; |
| abi_ulong auxv_len; |
| abi_ulong argc; |
| abi_ulong argv; |
| abi_ulong envc; |
| abi_ulong envp; |
| abi_ulong file_string; |
| uint32_t elf_flags; |
| int personality; |
| abi_ulong alignment; |
| bool exec_stack; |
| |
| /* Generic semihosting knows about these pointers. */ |
| abi_ulong arg_strings; /* strings for argv */ |
| abi_ulong env_strings; /* strings for envp; ends arg_strings */ |
| |
| /* The fields below are used in FDPIC mode. */ |
| abi_ulong loadmap_addr; |
| uint16_t nsegs; |
| void *loadsegs; |
| abi_ulong pt_dynamic_addr; |
| abi_ulong interpreter_loadmap_addr; |
| abi_ulong interpreter_pt_dynamic_addr; |
| struct image_info *other_info; |
| |
| /* For target-specific processing of NT_GNU_PROPERTY_TYPE_0. */ |
| uint32_t note_flags; |
| |
| #ifdef TARGET_MIPS |
| int fp_abi; |
| int interp_fp_abi; |
| #endif |
| }; |
| |
| #ifdef TARGET_I386 |
| /* Information about the current linux thread */ |
| struct vm86_saved_state { |
| uint32_t eax; /* return code */ |
| uint32_t ebx; |
| uint32_t ecx; |
| uint32_t edx; |
| uint32_t esi; |
| uint32_t edi; |
| uint32_t ebp; |
| uint32_t esp; |
| uint32_t eflags; |
| uint32_t eip; |
| uint16_t cs, ss, ds, es, fs, gs; |
| }; |
| #endif |
| |
| #if defined(TARGET_ARM) && defined(TARGET_ABI32) |
| /* FPU emulator */ |
| #include "nwfpe/fpa11.h" |
| #endif |
| |
| struct emulated_sigtable { |
| int pending; /* true if signal is pending */ |
| target_siginfo_t info; |
| }; |
| |
| struct TaskState { |
| pid_t ts_tid; /* tid (or pid) of this task */ |
| #ifdef TARGET_ARM |
| # ifdef TARGET_ABI32 |
| /* FPA state */ |
| FPA11 fpa; |
| # endif |
| #endif |
| #if defined(TARGET_ARM) || defined(TARGET_RISCV) |
| int swi_errno; |
| #endif |
| #if defined(TARGET_I386) && !defined(TARGET_X86_64) |
| abi_ulong target_v86; |
| struct vm86_saved_state vm86_saved_regs; |
| struct target_vm86plus_struct vm86plus; |
| uint32_t v86flags; |
| uint32_t v86mask; |
| #endif |
| abi_ulong child_tidptr; |
| #ifdef TARGET_M68K |
| abi_ulong tp_value; |
| #endif |
| #if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_RISCV) |
| /* Extra fields for semihosted binaries. */ |
| abi_ulong heap_base; |
| abi_ulong heap_limit; |
| #endif |
| abi_ulong stack_base; |
| int used; /* non zero if used */ |
| struct image_info *info; |
| struct linux_binprm *bprm; |
| |
| struct emulated_sigtable sync_signal; |
| struct emulated_sigtable sigtab[TARGET_NSIG]; |
| /* |
| * This thread's signal mask, as requested by the guest program. |
| * The actual signal mask of this thread may differ: |
| * + we don't let SIGSEGV and SIGBUS be blocked while running guest code |
| * + sometimes we block all signals to avoid races |
| */ |
| sigset_t signal_mask; |
| /* |
| * The signal mask imposed by a guest sigsuspend syscall, if we are |
| * currently in the middle of such a syscall |
| */ |
| sigset_t sigsuspend_mask; |
| /* Nonzero if we're leaving a sigsuspend and sigsuspend_mask is valid. */ |
| int in_sigsuspend; |
| |
| /* |
| * Nonzero if process_pending_signals() needs to do something (either |
| * handle a pending signal or unblock signals). |
| * This flag is written from a signal handler so should be accessed via |
| * the qatomic_read() and qatomic_set() functions. (It is not accessed |
| * from multiple threads.) |
| */ |
| int signal_pending; |
| |
| /* This thread's sigaltstack, if it has one */ |
| struct target_sigaltstack sigaltstack_used; |
| |
| /* Start time of task after system boot in clock ticks */ |
| uint64_t start_boottime; |
| }; |
| |
| abi_long do_brk(abi_ulong new_brk); |
| int do_guest_openat(CPUArchState *cpu_env, int dirfd, const char *pathname, |
| int flags, mode_t mode, bool safe); |
| ssize_t do_guest_readlink(const char *pathname, char *buf, size_t bufsiz); |
| |
| /* user access */ |
| |
| #define VERIFY_NONE 0 |
| #define VERIFY_READ PAGE_READ |
| #define VERIFY_WRITE (PAGE_READ | PAGE_WRITE) |
| |
| static inline bool access_ok_untagged(int type, abi_ulong addr, abi_ulong size) |
| { |
| if (size == 0 |
| ? !guest_addr_valid_untagged(addr) |
| : !guest_range_valid_untagged(addr, size)) { |
| return false; |
| } |
| return page_check_range((target_ulong)addr, size, type); |
| } |
| |
| static inline bool access_ok(CPUState *cpu, int type, |
| abi_ulong addr, abi_ulong size) |
| { |
| return access_ok_untagged(type, cpu_untagged_addr(cpu, addr), size); |
| } |
| |
| /* NOTE __get_user and __put_user use host pointers and don't check access. |
| These are usually used to access struct data members once the struct has |
| been locked - usually with lock_user_struct. */ |
| |
| /* |
| * Tricky points: |
| * - Use __builtin_choose_expr to avoid type promotion from ?:, |
| * - Invalid sizes result in a compile time error stemming from |
| * the fact that abort has no parameters. |
| * - It's easier to use the endian-specific unaligned load/store |
| * functions than host-endian unaligned load/store plus tswapN. |
| * - The pragmas are necessary only to silence a clang false-positive |
| * warning: see https://bugs.llvm.org/show_bug.cgi?id=39113 . |
| * - gcc has bugs in its _Pragma() support in some versions, eg |
| * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83256 -- so we only |
| * include the warning-suppression pragmas for clang |
| */ |
| #if defined(__clang__) && __has_warning("-Waddress-of-packed-member") |
| #define PRAGMA_DISABLE_PACKED_WARNING \ |
| _Pragma("GCC diagnostic push"); \ |
| _Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\"") |
| |
| #define PRAGMA_REENABLE_PACKED_WARNING \ |
| _Pragma("GCC diagnostic pop") |
| |
| #else |
| #define PRAGMA_DISABLE_PACKED_WARNING |
| #define PRAGMA_REENABLE_PACKED_WARNING |
| #endif |
| |
| #define __put_user_e(x, hptr, e) \ |
| do { \ |
| PRAGMA_DISABLE_PACKED_WARNING; \ |
| (__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \ |
| __builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \ |
| __builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \ |
| __builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \ |
| ((hptr), (x)), (void)0); \ |
| PRAGMA_REENABLE_PACKED_WARNING; \ |
| } while (0) |
| |
| #define __get_user_e(x, hptr, e) \ |
| do { \ |
| PRAGMA_DISABLE_PACKED_WARNING; \ |
| ((x) = (typeof(*hptr))( \ |
| __builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \ |
| __builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \ |
| __builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \ |
| __builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \ |
| (hptr)), (void)0); \ |
| PRAGMA_REENABLE_PACKED_WARNING; \ |
| } while (0) |
| |
| |
| #if TARGET_BIG_ENDIAN |
| # define __put_user(x, hptr) __put_user_e(x, hptr, be) |
| # define __get_user(x, hptr) __get_user_e(x, hptr, be) |
| #else |
| # define __put_user(x, hptr) __put_user_e(x, hptr, le) |
| # define __get_user(x, hptr) __get_user_e(x, hptr, le) |
| #endif |
| |
| /* put_user()/get_user() take a guest address and check access */ |
| /* These are usually used to access an atomic data type, such as an int, |
| * that has been passed by address. These internally perform locking |
| * and unlocking on the data type. |
| */ |
| #define put_user(x, gaddr, target_type) \ |
| ({ \ |
| abi_ulong __gaddr = (gaddr); \ |
| target_type *__hptr; \ |
| abi_long __ret = 0; \ |
| if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \ |
| __put_user((x), __hptr); \ |
| unlock_user(__hptr, __gaddr, sizeof(target_type)); \ |
| } else \ |
| __ret = -TARGET_EFAULT; \ |
| __ret; \ |
| }) |
| |
| #define get_user(x, gaddr, target_type) \ |
| ({ \ |
| abi_ulong __gaddr = (gaddr); \ |
| target_type *__hptr; \ |
| abi_long __ret = 0; \ |
| if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \ |
| __get_user((x), __hptr); \ |
| unlock_user(__hptr, __gaddr, 0); \ |
| } else { \ |
| /* avoid warning */ \ |
| (x) = 0; \ |
| __ret = -TARGET_EFAULT; \ |
| } \ |
| __ret; \ |
| }) |
| |
| #define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong) |
| #define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long) |
| #define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t) |
| #define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t) |
| #define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t) |
| #define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t) |
| #define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t) |
| #define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t) |
| #define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t) |
| #define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t) |
| |
| #define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong) |
| #define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long) |
| #define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t) |
| #define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t) |
| #define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t) |
| #define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t) |
| #define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t) |
| #define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t) |
| #define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t) |
| #define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t) |
| |
| /* copy_from_user() and copy_to_user() are usually used to copy data |
| * buffers between the target and host. These internally perform |
| * locking/unlocking of the memory. |
| */ |
| int copy_from_user(void *hptr, abi_ulong gaddr, ssize_t len); |
| int copy_to_user(abi_ulong gaddr, void *hptr, ssize_t len); |
| |
| /* |
| * copy_struct_from_user() copies a target struct to a host struct, in |
| * a way that guarantees backwards-compatibility for struct syscall |
| * arguments. |
| * |
| * Similar to kernels uaccess.h:copy_struct_from_user() |
| */ |
| int copy_struct_from_user(void *dst, size_t ksize, abi_ptr src, size_t usize); |
| |
| /* Functions for accessing guest memory. The tget and tput functions |
| read/write single values, byteswapping as necessary. The lock_user function |
| gets a pointer to a contiguous area of guest memory, but does not perform |
| any byteswapping. lock_user may return either a pointer to the guest |
| memory, or a temporary buffer. */ |
| |
| /* Lock an area of guest memory into the host. If copy is true then the |
| host area will have the same contents as the guest. */ |
| void *lock_user(int type, abi_ulong guest_addr, ssize_t len, bool copy); |
| |
| /* Unlock an area of guest memory. The first LEN bytes must be |
| flushed back to guest memory. host_ptr = NULL is explicitly |
| allowed and does nothing. */ |
| #ifndef CONFIG_DEBUG_REMAP |
| static inline void unlock_user(void *host_ptr, abi_ulong guest_addr, |
| ssize_t len) |
| { |
| /* no-op */ |
| } |
| #else |
| void unlock_user(void *host_ptr, abi_ulong guest_addr, ssize_t len); |
| #endif |
| |
| /* Return the length of a string in target memory or -TARGET_EFAULT if |
| access error. */ |
| ssize_t target_strlen(abi_ulong gaddr); |
| |
| /* Like lock_user but for null terminated strings. */ |
| void *lock_user_string(abi_ulong guest_addr); |
| |
| /* Helper macros for locking/unlocking a target struct. */ |
| #define lock_user_struct(type, host_ptr, guest_addr, copy) \ |
| (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy)) |
| #define unlock_user_struct(host_ptr, guest_addr, copy) \ |
| unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0) |
| |
| #endif /* QEMU_H */ |
