5 #include "exec/cpu_ldst.h"
9 #include "exec/user/abitypes.h"
11 #include "syscall_defs.h"
12 #include "target_syscall.h"
15 * This is the size of the host kernel's sigset_t, needed where we make
16 * direct system calls that take a sigset_t pointer and a size.
18 #define SIGSET_T_SIZE (_NSIG / 8)
21 * This struct is used to hold certain information about the image.
22 * Basically, it replicates in user space what would be certain
23 * task_struct fields in the kernel
34 abi_ulong reserve_brk
;
36 abi_ulong start_stack
;
37 abi_ulong stack_limit
;
39 abi_ulong code_offset
;
40 abi_ulong data_offset
;
47 abi_ulong file_string
;
53 /* Generic semihosting knows about these pointers. */
54 abi_ulong arg_strings
; /* strings for argv */
55 abi_ulong env_strings
; /* strings for envp; ends arg_strings */
57 /* The fields below are used in FDPIC mode. */
58 abi_ulong loadmap_addr
;
61 abi_ulong pt_dynamic_addr
;
62 abi_ulong interpreter_loadmap_addr
;
63 abi_ulong interpreter_pt_dynamic_addr
;
64 struct image_info
*other_info
;
66 /* For target-specific processing of NT_GNU_PROPERTY_TYPE_0. */
76 /* Information about the current linux thread */
77 struct vm86_saved_state
{
78 uint32_t eax
; /* return code */
88 uint16_t cs
, ss
, ds
, es
, fs
, gs
;
92 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
94 #include "nwfpe/fpa11.h"
97 struct emulated_sigtable
{
98 int pending
; /* true if signal is pending */
99 target_siginfo_t info
;
102 typedef struct TaskState
{
103 pid_t ts_tid
; /* tid (or pid) of this task */
110 #if defined(TARGET_ARM) || defined(TARGET_RISCV)
113 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
114 abi_ulong target_v86
;
115 struct vm86_saved_state vm86_saved_regs
;
116 struct target_vm86plus_struct vm86plus
;
120 abi_ulong child_tidptr
;
124 #if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_RISCV)
125 /* Extra fields for semihosted binaries. */
127 abi_ulong heap_limit
;
129 abi_ulong stack_base
;
130 int used
; /* non zero if used */
131 struct image_info
*info
;
132 struct linux_binprm
*bprm
;
134 struct emulated_sigtable sync_signal
;
135 struct emulated_sigtable sigtab
[TARGET_NSIG
];
137 * This thread's signal mask, as requested by the guest program.
138 * The actual signal mask of this thread may differ:
139 * + we don't let SIGSEGV and SIGBUS be blocked while running guest code
140 * + sometimes we block all signals to avoid races
142 sigset_t signal_mask
;
144 * The signal mask imposed by a guest sigsuspend syscall, if we are
145 * currently in the middle of such a syscall
147 sigset_t sigsuspend_mask
;
148 /* Nonzero if we're leaving a sigsuspend and sigsuspend_mask is valid. */
152 * Nonzero if process_pending_signals() needs to do something (either
153 * handle a pending signal or unblock signals).
154 * This flag is written from a signal handler so should be accessed via
155 * the qatomic_read() and qatomic_set() functions. (It is not accessed
156 * from multiple threads.)
160 /* This thread's sigaltstack, if it has one */
161 struct target_sigaltstack sigaltstack_used
;
163 /* Start time of task after system boot in clock ticks */
164 uint64_t start_boottime
;
167 abi_long
do_brk(abi_ulong new_brk
);
168 int do_guest_openat(CPUArchState
*cpu_env
, int dirfd
, const char *pathname
,
169 int flags
, mode_t mode
, bool safe
);
170 ssize_t
do_guest_readlink(const char *pathname
, char *buf
, size_t bufsiz
);
174 #define VERIFY_NONE 0
175 #define VERIFY_READ PAGE_READ
176 #define VERIFY_WRITE (PAGE_READ | PAGE_WRITE)
178 static inline bool access_ok_untagged(int type
, abi_ulong addr
, abi_ulong size
)
181 ? !guest_addr_valid_untagged(addr
)
182 : !guest_range_valid_untagged(addr
, size
)) {
185 return page_check_range((target_ulong
)addr
, size
, type
);
188 static inline bool access_ok(CPUState
*cpu
, int type
,
189 abi_ulong addr
, abi_ulong size
)
191 return access_ok_untagged(type
, cpu_untagged_addr(cpu
, addr
), size
);
194 /* NOTE __get_user and __put_user use host pointers and don't check access.
195 These are usually used to access struct data members once the struct has
196 been locked - usually with lock_user_struct. */
200 * - Use __builtin_choose_expr to avoid type promotion from ?:,
201 * - Invalid sizes result in a compile time error stemming from
202 * the fact that abort has no parameters.
203 * - It's easier to use the endian-specific unaligned load/store
204 * functions than host-endian unaligned load/store plus tswapN.
205 * - The pragmas are necessary only to silence a clang false-positive
206 * warning: see https://bugs.llvm.org/show_bug.cgi?id=39113 .
207 * - gcc has bugs in its _Pragma() support in some versions, eg
208 * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83256 -- so we only
209 * include the warning-suppression pragmas for clang
211 #if defined(__clang__) && __has_warning("-Waddress-of-packed-member")
212 #define PRAGMA_DISABLE_PACKED_WARNING \
213 _Pragma("GCC diagnostic push"); \
214 _Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\"")
216 #define PRAGMA_REENABLE_PACKED_WARNING \
217 _Pragma("GCC diagnostic pop")
220 #define PRAGMA_DISABLE_PACKED_WARNING
221 #define PRAGMA_REENABLE_PACKED_WARNING
224 #define __put_user_e(x, hptr, e) \
226 PRAGMA_DISABLE_PACKED_WARNING; \
227 (__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \
228 __builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \
229 __builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \
230 __builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \
231 ((hptr), (x)), (void)0); \
232 PRAGMA_REENABLE_PACKED_WARNING; \
235 #define __get_user_e(x, hptr, e) \
237 PRAGMA_DISABLE_PACKED_WARNING; \
238 ((x) = (typeof(*hptr))( \
239 __builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \
240 __builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \
241 __builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \
242 __builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \
244 PRAGMA_REENABLE_PACKED_WARNING; \
248 #if TARGET_BIG_ENDIAN
249 # define __put_user(x, hptr) __put_user_e(x, hptr, be)
250 # define __get_user(x, hptr) __get_user_e(x, hptr, be)
252 # define __put_user(x, hptr) __put_user_e(x, hptr, le)
253 # define __get_user(x, hptr) __get_user_e(x, hptr, le)
256 /* put_user()/get_user() take a guest address and check access */
257 /* These are usually used to access an atomic data type, such as an int,
258 * that has been passed by address. These internally perform locking
259 * and unlocking on the data type.
261 #define put_user(x, gaddr, target_type) \
263 abi_ulong __gaddr = (gaddr); \
264 target_type *__hptr; \
265 abi_long __ret = 0; \
266 if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
267 __put_user((x), __hptr); \
268 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
270 __ret = -TARGET_EFAULT; \
274 #define get_user(x, gaddr, target_type) \
276 abi_ulong __gaddr = (gaddr); \
277 target_type *__hptr; \
278 abi_long __ret = 0; \
279 if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
280 __get_user((x), __hptr); \
281 unlock_user(__hptr, __gaddr, 0); \
283 /* avoid warning */ \
285 __ret = -TARGET_EFAULT; \
290 #define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
291 #define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
292 #define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
293 #define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
294 #define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
295 #define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
296 #define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
297 #define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
298 #define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
299 #define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
301 #define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
302 #define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
303 #define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
304 #define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
305 #define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
306 #define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
307 #define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
308 #define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
309 #define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
310 #define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
312 /* copy_from_user() and copy_to_user() are usually used to copy data
313 * buffers between the target and host. These internally perform
314 * locking/unlocking of the memory.
316 int copy_from_user(void *hptr
, abi_ulong gaddr
, ssize_t len
);
317 int copy_to_user(abi_ulong gaddr
, void *hptr
, ssize_t len
);
319 /* Functions for accessing guest memory. The tget and tput functions
320 read/write single values, byteswapping as necessary. The lock_user function
321 gets a pointer to a contiguous area of guest memory, but does not perform
322 any byteswapping. lock_user may return either a pointer to the guest
323 memory, or a temporary buffer. */
325 /* Lock an area of guest memory into the host. If copy is true then the
326 host area will have the same contents as the guest. */
327 void *lock_user(int type
, abi_ulong guest_addr
, ssize_t len
, bool copy
);
329 /* Unlock an area of guest memory. The first LEN bytes must be
330 flushed back to guest memory. host_ptr = NULL is explicitly
331 allowed and does nothing. */
333 static inline void unlock_user(void *host_ptr
, abi_ulong guest_addr
,
339 void unlock_user(void *host_ptr
, abi_ulong guest_addr
, ssize_t len
);
342 /* Return the length of a string in target memory or -TARGET_EFAULT if
344 ssize_t
target_strlen(abi_ulong gaddr
);
346 /* Like lock_user but for null terminated strings. */
347 void *lock_user_string(abi_ulong guest_addr
);
349 /* Helper macros for locking/unlocking a target struct. */
350 #define lock_user_struct(type, host_ptr, guest_addr, copy) \
351 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
352 #define unlock_user_struct(host_ptr, guest_addr, copy) \
353 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)