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