]> git.proxmox.com Git - mirror_qemu.git/blob - bsd-user/qemu.h
bsd-user: export get_errno and is_error from syscall.c
[mirror_qemu.git] / bsd-user / qemu.h
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
21 #include "qemu/osdep.h"
22 #include "cpu.h"
23 #include "qemu/units.h"
24 #include "exec/cpu_ldst.h"
25 #include "exec/exec-all.h"
26
27 #undef DEBUG_REMAP
28
29 #include "exec/user/abitypes.h"
30
31 extern char **environ;
32
33 enum BSDType {
34 target_freebsd,
35 target_netbsd,
36 target_openbsd,
37 };
38 extern enum BSDType bsd_type;
39
40 #include "exec/user/thunk.h"
41 #include "target_arch.h"
42 #include "syscall_defs.h"
43 #include "target_syscall.h"
44 #include "target_os_vmparam.h"
45 #include "target_os_signal.h"
46 #include "exec/gdbstub.h"
47
48 /*
49 * This struct is used to hold certain information about the image. Basically,
50 * it replicates in user space what would be certain task_struct fields in the
51 * kernel
52 */
53 struct image_info {
54 abi_ulong load_bias;
55 abi_ulong load_addr;
56 abi_ulong start_code;
57 abi_ulong end_code;
58 abi_ulong start_data;
59 abi_ulong end_data;
60 abi_ulong start_brk;
61 abi_ulong brk;
62 abi_ulong start_mmap;
63 abi_ulong mmap;
64 abi_ulong rss;
65 abi_ulong start_stack;
66 abi_ulong entry;
67 abi_ulong code_offset;
68 abi_ulong data_offset;
69 abi_ulong arg_start;
70 abi_ulong arg_end;
71 uint32_t elf_flags;
72 };
73
74 #define MAX_SIGQUEUE_SIZE 1024
75
76 struct sigqueue {
77 struct sigqueue *next;
78 };
79
80 struct emulated_sigtable {
81 int pending; /* true if signal is pending */
82 struct sigqueue *first;
83 /* in order to always have memory for the first signal, we put it here */
84 struct sigqueue info;
85 };
86
87 /*
88 * NOTE: we force a big alignment so that the stack stored after is aligned too
89 */
90 typedef struct TaskState {
91 pid_t ts_tid; /* tid (or pid) of this task */
92
93 struct TaskState *next;
94 struct bsd_binprm *bprm;
95 int used; /* non zero if used */
96 struct image_info *info;
97
98 struct emulated_sigtable sigtab[TARGET_NSIG];
99 struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
100 struct sigqueue *first_free; /* first free siginfo queue entry */
101 int signal_pending; /* non zero if a signal may be pending */
102
103 uint8_t stack[];
104 } __attribute__((aligned(16))) TaskState;
105
106 void init_task_state(TaskState *ts);
107 extern const char *qemu_uname_release;
108
109 /*
110 * TARGET_ARG_MAX defines the number of bytes allocated for arguments
111 * and envelope for the new program. 256k should suffice for a reasonable
112 * maxiumum env+arg in 32-bit environments, bump it up to 512k for !ILP32
113 * platforms.
114 */
115 #if TARGET_ABI_BITS > 32
116 #define TARGET_ARG_MAX (512 * KiB)
117 #else
118 #define TARGET_ARG_MAX (256 * KiB)
119 #endif
120 #define MAX_ARG_PAGES (TARGET_ARG_MAX / TARGET_PAGE_SIZE)
121
122 /*
123 * This structure is used to hold the arguments that are
124 * used when loading binaries.
125 */
126 struct bsd_binprm {
127 char buf[128];
128 void *page[MAX_ARG_PAGES];
129 abi_ulong p;
130 abi_ulong stringp;
131 int fd;
132 int e_uid, e_gid;
133 int argc, envc;
134 char **argv;
135 char **envp;
136 char *filename; /* (Given) Name of binary */
137 char *fullpath; /* Full path of binary */
138 int (*core_dump)(int, CPUArchState *);
139 };
140
141 void do_init_thread(struct target_pt_regs *regs, struct image_info *infop);
142 abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
143 abi_ulong stringp);
144 int loader_exec(const char *filename, char **argv, char **envp,
145 struct target_pt_regs *regs, struct image_info *infop,
146 struct bsd_binprm *bprm);
147
148 int load_elf_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
149 struct image_info *info);
150 int load_flt_binary(struct bsd_binprm *bprm, struct target_pt_regs *regs,
151 struct image_info *info);
152 int is_target_elf_binary(int fd);
153
154 abi_long memcpy_to_target(abi_ulong dest, const void *src,
155 unsigned long len);
156 void target_set_brk(abi_ulong new_brk);
157 abi_long do_brk(abi_ulong new_brk);
158 void syscall_init(void);
159 abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
160 abi_long arg2, abi_long arg3, abi_long arg4,
161 abi_long arg5, abi_long arg6, abi_long arg7,
162 abi_long arg8);
163 abi_long do_netbsd_syscall(void *cpu_env, int num, abi_long arg1,
164 abi_long arg2, abi_long arg3, abi_long arg4,
165 abi_long arg5, abi_long arg6);
166 abi_long do_openbsd_syscall(void *cpu_env, int num, abi_long arg1,
167 abi_long arg2, abi_long arg3, abi_long arg4,
168 abi_long arg5, abi_long arg6);
169 void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
170 extern __thread CPUState *thread_cpu;
171 void cpu_loop(CPUArchState *env);
172 char *target_strerror(int err);
173 int get_osversion(void);
174 void fork_start(void);
175 void fork_end(int child);
176
177 #include "qemu/log.h"
178
179 /* strace.c */
180 struct syscallname {
181 int nr;
182 const char *name;
183 const char *format;
184 void (*call)(const struct syscallname *,
185 abi_long, abi_long, abi_long,
186 abi_long, abi_long, abi_long);
187 void (*result)(const struct syscallname *, abi_long);
188 };
189
190 void
191 print_freebsd_syscall(int num,
192 abi_long arg1, abi_long arg2, abi_long arg3,
193 abi_long arg4, abi_long arg5, abi_long arg6);
194 void print_freebsd_syscall_ret(int num, abi_long ret);
195 void
196 print_netbsd_syscall(int num,
197 abi_long arg1, abi_long arg2, abi_long arg3,
198 abi_long arg4, abi_long arg5, abi_long arg6);
199 void print_netbsd_syscall_ret(int num, abi_long ret);
200 void
201 print_openbsd_syscall(int num,
202 abi_long arg1, abi_long arg2, abi_long arg3,
203 abi_long arg4, abi_long arg5, abi_long arg6);
204 void print_openbsd_syscall_ret(int num, abi_long ret);
205 extern int do_strace;
206
207 /* signal.c */
208 void process_pending_signals(CPUArchState *cpu_env);
209 void signal_init(void);
210 long do_sigreturn(CPUArchState *env);
211 long do_rt_sigreturn(CPUArchState *env);
212 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
213
214 /* mmap.c */
215 int target_mprotect(abi_ulong start, abi_ulong len, int prot);
216 abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
217 int flags, int fd, off_t offset);
218 int target_munmap(abi_ulong start, abi_ulong len);
219 abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
220 abi_ulong new_size, unsigned long flags,
221 abi_ulong new_addr);
222 int target_msync(abi_ulong start, abi_ulong len, int flags);
223 extern unsigned long last_brk;
224 extern abi_ulong mmap_next_start;
225 abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size);
226 void mmap_fork_start(void);
227 void mmap_fork_end(int child);
228
229 /* main.c */
230 extern char qemu_proc_pathname[];
231 extern unsigned long target_maxtsiz;
232 extern unsigned long target_dfldsiz;
233 extern unsigned long target_maxdsiz;
234 extern unsigned long target_dflssiz;
235 extern unsigned long target_maxssiz;
236 extern unsigned long target_sgrowsiz;
237
238 /* syscall.c */
239 abi_long get_errno(abi_long ret);
240 bool is_error(abi_long ret);
241
242 /* user access */
243
244 #define VERIFY_READ PAGE_READ
245 #define VERIFY_WRITE (PAGE_READ | PAGE_WRITE)
246
247 static inline bool access_ok(int type, abi_ulong addr, abi_ulong size)
248 {
249 return page_check_range((target_ulong)addr, size, type) == 0;
250 }
251
252 /*
253 * NOTE __get_user and __put_user use host pointers and don't check access.
254 *
255 * These are usually used to access struct data members once the struct has been
256 * locked - usually with lock_user_struct().
257 */
258 #define __put_user(x, hptr)\
259 ({\
260 int size = sizeof(*hptr);\
261 switch (size) {\
262 case 1:\
263 *(uint8_t *)(hptr) = (uint8_t)(typeof(*hptr))(x);\
264 break;\
265 case 2:\
266 *(uint16_t *)(hptr) = tswap16((typeof(*hptr))(x));\
267 break;\
268 case 4:\
269 *(uint32_t *)(hptr) = tswap32((typeof(*hptr))(x));\
270 break;\
271 case 8:\
272 *(uint64_t *)(hptr) = tswap64((typeof(*hptr))(x));\
273 break;\
274 default:\
275 abort();\
276 } \
277 0;\
278 })
279
280 #define __get_user(x, hptr) \
281 ({\
282 int size = sizeof(*hptr);\
283 switch (size) {\
284 case 1:\
285 x = (typeof(*hptr))*(uint8_t *)(hptr);\
286 break;\
287 case 2:\
288 x = (typeof(*hptr))tswap16(*(uint16_t *)(hptr));\
289 break;\
290 case 4:\
291 x = (typeof(*hptr))tswap32(*(uint32_t *)(hptr));\
292 break;\
293 case 8:\
294 x = (typeof(*hptr))tswap64(*(uint64_t *)(hptr));\
295 break;\
296 default:\
297 x = 0;\
298 abort();\
299 } \
300 0;\
301 })
302
303 /*
304 * put_user()/get_user() take a guest address and check access
305 *
306 * These are usually used to access an atomic data type, such as an int, that
307 * has been passed by address. These internally perform locking and unlocking
308 * on the data type.
309 */
310 #define put_user(x, gaddr, target_type) \
311 ({ \
312 abi_ulong __gaddr = (gaddr); \
313 target_type *__hptr; \
314 abi_long __ret; \
315 __hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0); \
316 if (__hptr) { \
317 __ret = __put_user((x), __hptr); \
318 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
319 } else \
320 __ret = -TARGET_EFAULT; \
321 __ret; \
322 })
323
324 #define get_user(x, gaddr, target_type) \
325 ({ \
326 abi_ulong __gaddr = (gaddr); \
327 target_type *__hptr; \
328 abi_long __ret; \
329 __hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1); \
330 if (__hptr) { \
331 __ret = __get_user((x), __hptr); \
332 unlock_user(__hptr, __gaddr, 0); \
333 } else { \
334 (x) = 0; \
335 __ret = -TARGET_EFAULT; \
336 } \
337 __ret; \
338 })
339
340 #define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
341 #define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
342 #define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
343 #define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
344 #define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
345 #define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
346 #define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
347 #define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
348 #define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
349 #define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
350
351 #define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
352 #define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
353 #define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
354 #define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
355 #define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
356 #define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
357 #define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
358 #define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
359 #define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
360 #define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
361
362 /*
363 * copy_from_user() and copy_to_user() are usually used to copy data
364 * buffers between the target and host. These internally perform
365 * locking/unlocking of the memory.
366 */
367 abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
368 abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
369
370 /*
371 * Functions for accessing guest memory. The tget and tput functions
372 * read/write single values, byteswapping as necessary. The lock_user function
373 * gets a pointer to a contiguous area of guest memory, but does not perform
374 * any byteswapping. lock_user may return either a pointer to the guest
375 * memory, or a temporary buffer.
376 */
377
378 /*
379 * Lock an area of guest memory into the host. If copy is true then the
380 * host area will have the same contents as the guest.
381 */
382 static inline void *lock_user(int type, abi_ulong guest_addr, long len,
383 int copy)
384 {
385 if (!access_ok(type, guest_addr, len)) {
386 return NULL;
387 }
388 #ifdef DEBUG_REMAP
389 {
390 void *addr;
391 addr = g_malloc(len);
392 if (copy) {
393 memcpy(addr, g2h_untagged(guest_addr), len);
394 } else {
395 memset(addr, 0, len);
396 }
397 return addr;
398 }
399 #else
400 return g2h_untagged(guest_addr);
401 #endif
402 }
403
404 /*
405 * Unlock an area of guest memory. The first LEN bytes must be flushed back to
406 * guest memory. host_ptr = NULL is explicitly allowed and does nothing.
407 */
408 static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
409 long len)
410 {
411
412 #ifdef DEBUG_REMAP
413 if (!host_ptr) {
414 return;
415 }
416 if (host_ptr == g2h_untagged(guest_addr)) {
417 return;
418 }
419 if (len > 0) {
420 memcpy(g2h_untagged(guest_addr), host_ptr, len);
421 }
422 g_free(host_ptr);
423 #endif
424 }
425
426 /*
427 * Return the length of a string in target memory or -TARGET_EFAULT if access
428 * error.
429 */
430 abi_long target_strlen(abi_ulong gaddr);
431
432 /* Like lock_user but for null terminated strings. */
433 static inline void *lock_user_string(abi_ulong guest_addr)
434 {
435 abi_long len;
436 len = target_strlen(guest_addr);
437 if (len < 0) {
438 return NULL;
439 }
440 return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
441 }
442
443 /* Helper macros for locking/unlocking a target struct. */
444 #define lock_user_struct(type, host_ptr, guest_addr, copy) \
445 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
446 #define unlock_user_struct(host_ptr, guest_addr, copy) \
447 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
448
449 #include <pthread.h>
450
451 #endif /* QEMU_H */