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