1 #ifndef QEMU_H 2 #define QEMU_H 3 4 #include "thunk.h" 5 6 #include <signal.h> 7 #include <string.h> 8 #include "syscall_defs.h" 9 10 #include "cpu.h" 11 #include "syscall.h" 12 #include "gdbstub.h" 13 14 /* This struct is used to hold certain information about the image. 15 * Basically, it replicates in user space what would be certain 16 * task_struct fields in the kernel 17 */ 18 struct image_info { 19 unsigned long start_code; 20 unsigned long end_code; 21 unsigned long start_data; 22 unsigned long end_data; 23 unsigned long start_brk; 24 unsigned long brk; 25 unsigned long start_mmap; 26 unsigned long mmap; 27 unsigned long rss; 28 unsigned long start_stack; 29 unsigned long entry; 30 target_ulong code_offset; 31 target_ulong data_offset; 32 char **host_argv; 33 int personality; 34 }; 35 36 #ifdef TARGET_I386 37 /* Information about the current linux thread */ 38 struct vm86_saved_state { 39 uint32_t eax; /* return code */ 40 uint32_t ebx; 41 uint32_t ecx; 42 uint32_t edx; 43 uint32_t esi; 44 uint32_t edi; 45 uint32_t ebp; 46 uint32_t esp; 47 uint32_t eflags; 48 uint32_t eip; 49 uint16_t cs, ss, ds, es, fs, gs; 50 }; 51 #endif 52 53 #ifdef TARGET_ARM 54 /* FPU emulator */ 55 #include "nwfpe/fpa11.h" 56 #endif 57 58 /* NOTE: we force a big alignment so that the stack stored after is 59 aligned too */ 60 typedef struct TaskState { 61 struct TaskState *next; 62 #ifdef TARGET_ARM 63 /* FPA state */ 64 FPA11 fpa; 65 /* Extra fields for semihosted binaries. */ 66 uint32_t stack_base; 67 uint32_t heap_base; 68 uint32_t heap_limit; 69 int swi_errno; 70 #endif 71 #ifdef TARGET_I386 72 target_ulong target_v86; 73 struct vm86_saved_state vm86_saved_regs; 74 struct target_vm86plus_struct vm86plus; 75 uint32_t v86flags; 76 uint32_t v86mask; 77 #endif 78 #ifdef TARGET_M68K 79 int sim_syscalls; 80 #endif 81 int used; /* non zero if used */ 82 struct image_info *info; 83 uint8_t stack[0]; 84 } __attribute__((aligned(16))) TaskState; 85 86 extern TaskState *first_task_state; 87 extern const char *qemu_uname_release; 88 89 /* ??? See if we can avoid exposing so much of the loader internals. */ 90 /* 91 * MAX_ARG_PAGES defines the number of pages allocated for arguments 92 * and envelope for the new program. 32 should suffice, this gives 93 * a maximum env+arg of 128kB w/4KB pages! 94 */ 95 #define MAX_ARG_PAGES 32 96 97 /* 98 * This structure is used to hold the arguments that are 99 * used when loading binaries. 100 */ 101 struct linux_binprm { 102 char buf[128]; 103 void *page[MAX_ARG_PAGES]; 104 unsigned long p; 105 int fd; 106 int e_uid, e_gid; 107 int argc, envc; 108 char **argv; 109 char **envp; 110 char * filename; /* Name of binary */ 111 }; 112 113 void do_init_thread(struct target_pt_regs *regs, struct image_info *infop); 114 target_ulong loader_build_argptr(int envc, int argc, target_ulong sp, 115 target_ulong stringp, int push_ptr); 116 int loader_exec(const char * filename, char ** argv, char ** envp, 117 struct target_pt_regs * regs, struct image_info *infop); 118 119 int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs, 120 struct image_info * info); 121 int load_flt_binary(struct linux_binprm * bprm, struct target_pt_regs * regs, 122 struct image_info * info); 123 124 void memcpy_to_target(target_ulong dest, const void *src, 125 unsigned long len); 126 void target_set_brk(target_ulong new_brk); 127 long do_brk(target_ulong new_brk); 128 void syscall_init(void); 129 long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3, 130 long arg4, long arg5, long arg6); 131 void gemu_log(const char *fmt, ...) __attribute__((format(printf,1,2))); 132 extern CPUState *global_env; 133 void cpu_loop(CPUState *env); 134 void init_paths(const char *prefix); 135 const char *path(const char *pathname); 136 137 extern int loglevel; 138 extern FILE *logfile; 139 140 /* signal.c */ 141 void process_pending_signals(void *cpu_env); 142 void signal_init(void); 143 int queue_signal(int sig, target_siginfo_t *info); 144 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info); 145 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo); 146 long do_sigreturn(CPUState *env); 147 long do_rt_sigreturn(CPUState *env); 148 149 #ifdef TARGET_I386 150 /* vm86.c */ 151 void save_v86_state(CPUX86State *env); 152 void handle_vm86_trap(CPUX86State *env, int trapno); 153 void handle_vm86_fault(CPUX86State *env); 154 int do_vm86(CPUX86State *env, long subfunction, target_ulong v86_addr); 155 #endif 156 157 /* mmap.c */ 158 int target_mprotect(target_ulong start, target_ulong len, int prot); 159 long target_mmap(target_ulong start, target_ulong len, int prot, 160 int flags, int fd, target_ulong offset); 161 int target_munmap(target_ulong start, target_ulong len); 162 long target_mremap(target_ulong old_addr, target_ulong old_size, 163 target_ulong new_size, unsigned long flags, 164 target_ulong new_addr); 165 int target_msync(target_ulong start, target_ulong len, int flags); 166 167 /* user access */ 168 169 #define VERIFY_READ 0 170 #define VERIFY_WRITE 1 171 172 #define access_ok(type,addr,size) (1) 173 174 /* NOTE get_user and put_user use host addresses. */ 175 #define __put_user(x,ptr)\ 176 ({\ 177 int size = sizeof(*ptr);\ 178 switch(size) {\ 179 case 1:\ 180 *(uint8_t *)(ptr) = (typeof(*ptr))(x);\ 181 break;\ 182 case 2:\ 183 *(uint16_t *)(ptr) = tswap16((typeof(*ptr))(x));\ 184 break;\ 185 case 4:\ 186 *(uint32_t *)(ptr) = tswap32((typeof(*ptr))(x));\ 187 break;\ 188 case 8:\ 189 *(uint64_t *)(ptr) = tswap64((typeof(*ptr))(x));\ 190 break;\ 191 default:\ 192 abort();\ 193 }\ 194 0;\ 195 }) 196 197 #define __get_user(x, ptr) \ 198 ({\ 199 int size = sizeof(*ptr);\ 200 switch(size) {\ 201 case 1:\ 202 x = (typeof(*ptr))*(uint8_t *)(ptr);\ 203 break;\ 204 case 2:\ 205 x = (typeof(*ptr))tswap16(*(uint16_t *)(ptr));\ 206 break;\ 207 case 4:\ 208 x = (typeof(*ptr))tswap32(*(uint32_t *)(ptr));\ 209 break;\ 210 case 8:\ 211 x = (typeof(*ptr))tswap64(*(uint64_t *)(ptr));\ 212 break;\ 213 default:\ 214 abort();\ 215 }\ 216 0;\ 217 }) 218 219 #define put_user(x,ptr)\ 220 ({\ 221 int __ret;\ 222 if (access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)))\ 223 __ret = __put_user(x, ptr);\ 224 else\ 225 __ret = -EFAULT;\ 226 __ret;\ 227 }) 228 229 #define get_user(x,ptr)\ 230 ({\ 231 int __ret;\ 232 if (access_ok(VERIFY_READ, ptr, sizeof(*ptr)))\ 233 __ret = __get_user(x, ptr);\ 234 else\ 235 __ret = -EFAULT;\ 236 __ret;\ 237 }) 238 239 /* Functions for accessing guest memory. The tget and tput functions 240 read/write single values, byteswapping as neccessary. The lock_user 241 gets a pointer to a contiguous area of guest memory, but does not perform 242 and byteswapping. lock_user may return either a pointer to the guest 243 memory, or a temporary buffer. */ 244 245 /* Lock an area of guest memory into the host. If copy is true then the 246 host area will have the same contents as the guest. */ 247 static inline void *lock_user(target_ulong guest_addr, long len, int copy) 248 { 249 #ifdef DEBUG_REMAP 250 void *addr; 251 addr = malloc(len); 252 if (copy) 253 memcpy(addr, g2h(guest_addr), len); 254 else 255 memset(addr, 0, len); 256 return addr; 257 #else 258 return g2h(guest_addr); 259 #endif 260 } 261 262 /* Unlock an area of guest memory. The first LEN bytes must be flushed back 263 to guest memory. */ 264 static inline void unlock_user(void *host_addr, target_ulong guest_addr, 265 long len) 266 { 267 #ifdef DEBUG_REMAP 268 if (host_addr == g2h(guest_addr)) 269 return; 270 if (len > 0) 271 memcpy(g2h(guest_addr), host_addr, len); 272 free(host_addr); 273 #endif 274 } 275 276 /* Return the length of a string in target memory. */ 277 static inline int target_strlen(target_ulong ptr) 278 { 279 return strlen(g2h(ptr)); 280 } 281 282 /* Like lock_user but for null terminated strings. */ 283 static inline void *lock_user_string(target_ulong guest_addr) 284 { 285 long len; 286 len = target_strlen(guest_addr) + 1; 287 return lock_user(guest_addr, len, 1); 288 } 289 290 /* Helper macros for locking/ulocking a target struct. */ 291 #define lock_user_struct(host_ptr, guest_addr, copy) \ 292 host_ptr = lock_user(guest_addr, sizeof(*host_ptr), copy) 293 #define unlock_user_struct(host_ptr, guest_addr, copy) \ 294 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0) 295 296 #define tget8(addr) ldub(addr) 297 #define tput8(addr, val) stb(addr, val) 298 #define tget16(addr) lduw(addr) 299 #define tput16(addr, val) stw(addr, val) 300 #define tget32(addr) ldl(addr) 301 #define tput32(addr, val) stl(addr, val) 302 #define tget64(addr) ldq(addr) 303 #define tput64(addr, val) stq(addr, val) 304 #if TARGET_LONG_BITS == 64 305 #define tgetl(addr) ldq(addr) 306 #define tputl(addr, val) stq(addr, val) 307 #else 308 #define tgetl(addr) ldl(addr) 309 #define tputl(addr, val) stl(addr, val) 310 #endif 311 312 #endif /* QEMU_H */ 313