]>
Commit | Line | Data |
---|---|---|
e88de099 FB |
1 | #ifndef QEMU_H |
2 | #define QEMU_H | |
31e31b8a | 3 | |
6180a181 | 4 | #include "cpu.h" |
f08b6170 | 5 | #include "exec/cpu_ldst.h" |
992f48a0 | 6 | |
06177d36 | 7 | #undef DEBUG_REMAP |
06177d36 | 8 | |
022c62cb | 9 | #include "exec/user/abitypes.h" |
992f48a0 | 10 | |
992f48a0 | 11 | #include "syscall_defs.h" |
460c579f | 12 | #include "target_syscall.h" |
66fb9763 | 13 | |
400b7f6d PM |
14 | /* |
15 | * This is the size of the host kernel's sigset_t, needed where we make | |
1d48fdd9 PM |
16 | * direct system calls that take a sigset_t pointer and a size. |
17 | */ | |
18 | #define SIGSET_T_SIZE (_NSIG / 8) | |
19 | ||
400b7f6d PM |
20 | /* |
21 | * This struct is used to hold certain information about the image. | |
31e31b8a FB |
22 | * Basically, it replicates in user space what would be certain |
23 | * task_struct fields in the kernel | |
24 | */ | |
25 | struct image_info { | |
9955ffac | 26 | abi_ulong load_bias; |
992f48a0 BS |
27 | abi_ulong load_addr; |
28 | abi_ulong start_code; | |
29 | abi_ulong end_code; | |
30 | abi_ulong start_data; | |
31 | abi_ulong end_data; | |
32 | abi_ulong start_brk; | |
33 | abi_ulong brk; | |
6fd59449 | 34 | abi_ulong reserve_brk; |
992f48a0 | 35 | abi_ulong start_mmap; |
992f48a0 | 36 | abi_ulong start_stack; |
97374d38 | 37 | abi_ulong stack_limit; |
992f48a0 BS |
38 | abi_ulong entry; |
39 | abi_ulong code_offset; | |
40 | abi_ulong data_offset; | |
edf8e2af | 41 | abi_ulong saved_auxv; |
125b0f55 | 42 | abi_ulong auxv_len; |
60f1c801 RH |
43 | abi_ulong argc; |
44 | abi_ulong argv; | |
45 | abi_ulong envc; | |
46 | abi_ulong envp; | |
7c4ee5bc | 47 | abi_ulong file_string; |
d8fd2954 | 48 | uint32_t elf_flags; |
400b7f6d | 49 | int personality; |
33143c44 | 50 | abi_ulong alignment; |
872f3d04 | 51 | bool exec_stack; |
a99856cd | 52 | |
60f1c801 RH |
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 */ | |
56 | ||
a99856cd | 57 | /* The fields below are used in FDPIC mode. */ |
1af02e83 MF |
58 | abi_ulong loadmap_addr; |
59 | uint16_t nsegs; | |
400b7f6d | 60 | void *loadsegs; |
1af02e83 | 61 | abi_ulong pt_dynamic_addr; |
3cb10cfa CL |
62 | abi_ulong interpreter_loadmap_addr; |
63 | abi_ulong interpreter_pt_dynamic_addr; | |
1af02e83 | 64 | struct image_info *other_info; |
83f990eb RH |
65 | |
66 | /* For target-specific processing of NT_GNU_PROPERTY_TYPE_0. */ | |
67 | uint32_t note_flags; | |
68 | ||
74cfc704 SM |
69 | #ifdef TARGET_MIPS |
70 | int fp_abi; | |
71 | int interp_fp_abi; | |
72 | #endif | |
31e31b8a FB |
73 | }; |
74 | ||
b346ff46 | 75 | #ifdef TARGET_I386 |
851e67a1 FB |
76 | /* Information about the current linux thread */ |
77 | struct vm86_saved_state { | |
78 | uint32_t eax; /* return code */ | |
79 | uint32_t ebx; | |
80 | uint32_t ecx; | |
81 | uint32_t edx; | |
82 | uint32_t esi; | |
83 | uint32_t edi; | |
84 | uint32_t ebp; | |
85 | uint32_t esp; | |
86 | uint32_t eflags; | |
87 | uint32_t eip; | |
88 | uint16_t cs, ss, ds, es, fs, gs; | |
89 | }; | |
b346ff46 | 90 | #endif |
851e67a1 | 91 | |
848d72cd | 92 | #if defined(TARGET_ARM) && defined(TARGET_ABI32) |
28c4f361 FB |
93 | /* FPU emulator */ |
94 | #include "nwfpe/fpa11.h" | |
28c4f361 FB |
95 | #endif |
96 | ||
624f7979 PB |
97 | struct emulated_sigtable { |
98 | int pending; /* true if signal is pending */ | |
907f5fdd | 99 | target_siginfo_t info; |
624f7979 PB |
100 | }; |
101 | ||
851e67a1 | 102 | typedef struct TaskState { |
edf8e2af | 103 | pid_t ts_tid; /* tid (or pid) of this task */ |
28c4f361 | 104 | #ifdef TARGET_ARM |
848d72cd | 105 | # ifdef TARGET_ABI32 |
28c4f361 FB |
106 | /* FPA state */ |
107 | FPA11 fpa; | |
848d72cd | 108 | # endif |
a10b9d93 KP |
109 | #endif |
110 | #if defined(TARGET_ARM) || defined(TARGET_RISCV) | |
a4f81979 | 111 | int swi_errno; |
28c4f361 | 112 | #endif |
84409ddb | 113 | #if defined(TARGET_I386) && !defined(TARGET_X86_64) |
992f48a0 | 114 | abi_ulong target_v86; |
851e67a1 | 115 | struct vm86_saved_state vm86_saved_regs; |
b333af06 | 116 | struct target_vm86plus_struct vm86plus; |
631271d7 FB |
117 | uint32_t v86flags; |
118 | uint32_t v86mask; | |
e6e5906b | 119 | #endif |
c2764719 | 120 | abi_ulong child_tidptr; |
e6e5906b | 121 | #ifdef TARGET_M68K |
1ccd9374 | 122 | abi_ulong tp_value; |
a87295e8 | 123 | #endif |
a10b9d93 | 124 | #if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_RISCV) |
a87295e8 | 125 | /* Extra fields for semihosted binaries. */ |
d317091d PM |
126 | abi_ulong heap_base; |
127 | abi_ulong heap_limit; | |
b346ff46 | 128 | #endif |
d317091d | 129 | abi_ulong stack_base; |
851e67a1 | 130 | int used; /* non zero if used */ |
978efd6a | 131 | struct image_info *info; |
edf8e2af | 132 | struct linux_binprm *bprm; |
624f7979 | 133 | |
655ed67c | 134 | struct emulated_sigtable sync_signal; |
624f7979 | 135 | struct emulated_sigtable sigtab[TARGET_NSIG]; |
400b7f6d PM |
136 | /* |
137 | * This thread's signal mask, as requested by the guest program. | |
3d3efba0 PM |
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 | |
141 | */ | |
142 | sigset_t signal_mask; | |
400b7f6d PM |
143 | /* |
144 | * The signal mask imposed by a guest sigsuspend syscall, if we are | |
3d3efba0 PM |
145 | * currently in the middle of such a syscall |
146 | */ | |
147 | sigset_t sigsuspend_mask; | |
148 | /* Nonzero if we're leaving a sigsuspend and sigsuspend_mask is valid. */ | |
149 | int in_sigsuspend; | |
150 | ||
400b7f6d PM |
151 | /* |
152 | * Nonzero if process_pending_signals() needs to do something (either | |
3d3efba0 PM |
153 | * handle a pending signal or unblock signals). |
154 | * This flag is written from a signal handler so should be accessed via | |
d73415a3 | 155 | * the qatomic_read() and qatomic_set() functions. (It is not accessed |
3d3efba0 PM |
156 | * from multiple threads.) |
157 | */ | |
158 | int signal_pending; | |
159 | ||
5bfce0b7 PM |
160 | /* This thread's sigaltstack, if it has one */ |
161 | struct target_sigaltstack sigaltstack_used; | |
eb33cdae CE |
162 | |
163 | /* Start time of task after system boot in clock ticks */ | |
164 | uint64_t start_boottime; | |
b1b21387 | 165 | } TaskState; |
851e67a1 | 166 | |
3b249d26 | 167 | abi_long do_brk(abi_ulong new_brk); |
631271d7 | 168 | |
edf779ff FB |
169 | /* user access */ |
170 | ||
68f77666 RH |
171 | #define VERIFY_READ PAGE_READ |
172 | #define VERIFY_WRITE (PAGE_READ | PAGE_WRITE) | |
edf779ff | 173 | |
c7169b02 | 174 | static inline bool access_ok_untagged(int type, abi_ulong addr, abi_ulong size) |
dae3270c | 175 | { |
114556c5 | 176 | if (size == 0 |
46b12f46 RH |
177 | ? !guest_addr_valid_untagged(addr) |
178 | : !guest_range_valid_untagged(addr, size)) { | |
4feac83a RH |
179 | return false; |
180 | } | |
68f77666 | 181 | return page_check_range((target_ulong)addr, size, type) == 0; |
dae3270c | 182 | } |
edf779ff | 183 | |
c7169b02 RH |
184 | static inline bool access_ok(CPUState *cpu, int type, |
185 | abi_ulong addr, abi_ulong size) | |
186 | { | |
187 | return access_ok_untagged(type, cpu_untagged_addr(cpu, addr), size); | |
188 | } | |
189 | ||
658f2dc9 RH |
190 | /* NOTE __get_user and __put_user use host pointers and don't check access. |
191 | These are usually used to access struct data members once the struct has | |
192 | been locked - usually with lock_user_struct. */ | |
193 | ||
850d5e33 PM |
194 | /* |
195 | * Tricky points: | |
196 | * - Use __builtin_choose_expr to avoid type promotion from ?:, | |
197 | * - Invalid sizes result in a compile time error stemming from | |
198 | * the fact that abort has no parameters. | |
199 | * - It's easier to use the endian-specific unaligned load/store | |
200 | * functions than host-endian unaligned load/store plus tswapN. | |
201 | * - The pragmas are necessary only to silence a clang false-positive | |
202 | * warning: see https://bugs.llvm.org/show_bug.cgi?id=39113 . | |
850d5e33 PM |
203 | * - gcc has bugs in its _Pragma() support in some versions, eg |
204 | * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83256 -- so we only | |
205 | * include the warning-suppression pragmas for clang | |
206 | */ | |
798b8581 | 207 | #if defined(__clang__) && __has_warning("-Waddress-of-packed-member") |
850d5e33 PM |
208 | #define PRAGMA_DISABLE_PACKED_WARNING \ |
209 | _Pragma("GCC diagnostic push"); \ | |
850d5e33 PM |
210 | _Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\"") |
211 | ||
212 | #define PRAGMA_REENABLE_PACKED_WARNING \ | |
213 | _Pragma("GCC diagnostic pop") | |
214 | ||
215 | #else | |
216 | #define PRAGMA_DISABLE_PACKED_WARNING | |
217 | #define PRAGMA_REENABLE_PACKED_WARNING | |
218 | #endif | |
219 | ||
220 | #define __put_user_e(x, hptr, e) \ | |
221 | do { \ | |
222 | PRAGMA_DISABLE_PACKED_WARNING; \ | |
223 | (__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \ | |
224 | __builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \ | |
225 | __builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \ | |
226 | __builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \ | |
227 | ((hptr), (x)), (void)0); \ | |
228 | PRAGMA_REENABLE_PACKED_WARNING; \ | |
229 | } while (0) | |
230 | ||
231 | #define __get_user_e(x, hptr, e) \ | |
232 | do { \ | |
233 | PRAGMA_DISABLE_PACKED_WARNING; \ | |
234 | ((x) = (typeof(*hptr))( \ | |
235 | __builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \ | |
236 | __builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \ | |
237 | __builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \ | |
238 | __builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \ | |
239 | (hptr)), (void)0); \ | |
240 | PRAGMA_REENABLE_PACKED_WARNING; \ | |
241 | } while (0) | |
242 | ||
658f2dc9 | 243 | |
ee3eb3a7 | 244 | #if TARGET_BIG_ENDIAN |
658f2dc9 RH |
245 | # define __put_user(x, hptr) __put_user_e(x, hptr, be) |
246 | # define __get_user(x, hptr) __get_user_e(x, hptr, be) | |
247 | #else | |
248 | # define __put_user(x, hptr) __put_user_e(x, hptr, le) | |
249 | # define __get_user(x, hptr) __get_user_e(x, hptr, le) | |
250 | #endif | |
edf779ff | 251 | |
579a97f7 FB |
252 | /* put_user()/get_user() take a guest address and check access */ |
253 | /* These are usually used to access an atomic data type, such as an int, | |
254 | * that has been passed by address. These internally perform locking | |
255 | * and unlocking on the data type. | |
256 | */ | |
257 | #define put_user(x, gaddr, target_type) \ | |
258 | ({ \ | |
259 | abi_ulong __gaddr = (gaddr); \ | |
260 | target_type *__hptr; \ | |
a42267ef | 261 | abi_long __ret = 0; \ |
579a97f7 | 262 | if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \ |
a42267ef | 263 | __put_user((x), __hptr); \ |
579a97f7 FB |
264 | unlock_user(__hptr, __gaddr, sizeof(target_type)); \ |
265 | } else \ | |
266 | __ret = -TARGET_EFAULT; \ | |
267 | __ret; \ | |
edf779ff FB |
268 | }) |
269 | ||
579a97f7 FB |
270 | #define get_user(x, gaddr, target_type) \ |
271 | ({ \ | |
272 | abi_ulong __gaddr = (gaddr); \ | |
273 | target_type *__hptr; \ | |
a42267ef | 274 | abi_long __ret = 0; \ |
579a97f7 | 275 | if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \ |
a42267ef | 276 | __get_user((x), __hptr); \ |
579a97f7 | 277 | unlock_user(__hptr, __gaddr, 0); \ |
2f619698 FB |
278 | } else { \ |
279 | /* avoid warning */ \ | |
280 | (x) = 0; \ | |
579a97f7 | 281 | __ret = -TARGET_EFAULT; \ |
2f619698 | 282 | } \ |
579a97f7 | 283 | __ret; \ |
edf779ff FB |
284 | }) |
285 | ||
2f619698 FB |
286 | #define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong) |
287 | #define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long) | |
288 | #define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t) | |
289 | #define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t) | |
290 | #define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t) | |
291 | #define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t) | |
292 | #define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t) | |
293 | #define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t) | |
294 | #define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t) | |
295 | #define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t) | |
296 | ||
297 | #define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong) | |
298 | #define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long) | |
299 | #define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t) | |
300 | #define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t) | |
301 | #define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t) | |
302 | #define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t) | |
303 | #define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t) | |
304 | #define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t) | |
305 | #define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t) | |
306 | #define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t) | |
307 | ||
579a97f7 FB |
308 | /* copy_from_user() and copy_to_user() are usually used to copy data |
309 | * buffers between the target and host. These internally perform | |
310 | * locking/unlocking of the memory. | |
311 | */ | |
360f0abd RH |
312 | int copy_from_user(void *hptr, abi_ulong gaddr, ssize_t len); |
313 | int copy_to_user(abi_ulong gaddr, void *hptr, ssize_t len); | |
579a97f7 | 314 | |
53a5960a | 315 | /* Functions for accessing guest memory. The tget and tput functions |
6f20f55b | 316 | read/write single values, byteswapping as necessary. The lock_user function |
53a5960a | 317 | gets a pointer to a contiguous area of guest memory, but does not perform |
6f20f55b | 318 | any byteswapping. lock_user may return either a pointer to the guest |
53a5960a PB |
319 | memory, or a temporary buffer. */ |
320 | ||
321 | /* Lock an area of guest memory into the host. If copy is true then the | |
322 | host area will have the same contents as the guest. */ | |
360f0abd | 323 | void *lock_user(int type, abi_ulong guest_addr, ssize_t len, bool copy); |
edf779ff | 324 | |
579a97f7 | 325 | /* Unlock an area of guest memory. The first LEN bytes must be |
1235fc06 | 326 | flushed back to guest memory. host_ptr = NULL is explicitly |
579a97f7 | 327 | allowed and does nothing. */ |
687ca797 | 328 | #ifndef DEBUG_REMAP |
360f0abd RH |
329 | static inline void unlock_user(void *host_ptr, abi_ulong guest_addr, |
330 | ssize_t len) | |
331 | { | |
332 | /* no-op */ | |
333 | } | |
687ca797 | 334 | #else |
360f0abd | 335 | void unlock_user(void *host_ptr, abi_ulong guest_addr, ssize_t len); |
53a5960a | 336 | #endif |
edf779ff | 337 | |
579a97f7 FB |
338 | /* Return the length of a string in target memory or -TARGET_EFAULT if |
339 | access error. */ | |
09f679b6 | 340 | ssize_t target_strlen(abi_ulong gaddr); |
53a5960a PB |
341 | |
342 | /* Like lock_user but for null terminated strings. */ | |
687ca797 | 343 | void *lock_user_string(abi_ulong guest_addr); |
edf779ff | 344 | |
41d1af4d | 345 | /* Helper macros for locking/unlocking a target struct. */ |
579a97f7 FB |
346 | #define lock_user_struct(type, host_ptr, guest_addr, copy) \ |
347 | (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy)) | |
348 | #define unlock_user_struct(host_ptr, guest_addr, copy) \ | |
53a5960a PB |
349 | unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0) |
350 | ||
e88de099 | 351 | #endif /* QEMU_H */ |