![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qemu.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / linux-user|
Return to qemu.h CVS log | Up to [Qemu by Fabrice Bellard] / qemu / linux-user |
1.1 root 1: #ifndef QEMU_H
2: #define QEMU_H
3:
4: #include <signal.h>
5: #include <string.h>
6:
7: #include "cpu.h"
1.1.1.5 root 8:
9: #undef DEBUG_REMAP
10: #ifdef DEBUG_REMAP
11: #include <stdlib.h>
12: #endif /* DEBUG_REMAP */
13:
1.1.1.6 ! root 14: #include "qemu-types.h"
1.1.1.5 root 15:
16: #include "thunk.h"
17: #include "syscall_defs.h"
1.1 root 18: #include "syscall.h"
1.1.1.5 root 19: #include "target_signal.h"
1.1 root 20: #include "gdbstub.h"
21:
1.1.1.6 ! root 22: #if defined(USE_NPTL)
! 23: #define THREAD __thread
! 24: #else
! 25: #define THREAD
! 26: #endif
! 27:
1.1 root 28: /* This struct is used to hold certain information about the image.
29: * Basically, it replicates in user space what would be certain
30: * task_struct fields in the kernel
31: */
32: struct image_info {
1.1.1.5 root 33: abi_ulong load_addr;
34: abi_ulong start_code;
35: abi_ulong end_code;
36: abi_ulong start_data;
37: abi_ulong end_data;
38: abi_ulong start_brk;
39: abi_ulong brk;
40: abi_ulong start_mmap;
41: abi_ulong mmap;
42: abi_ulong rss;
43: abi_ulong start_stack;
44: abi_ulong entry;
45: abi_ulong code_offset;
46: abi_ulong data_offset;
1.1.1.4 root 47: char **host_argv;
1.1 root 48: int personality;
49: };
50:
51: #ifdef TARGET_I386
52: /* Information about the current linux thread */
53: struct vm86_saved_state {
54: uint32_t eax; /* return code */
55: uint32_t ebx;
56: uint32_t ecx;
57: uint32_t edx;
58: uint32_t esi;
59: uint32_t edi;
60: uint32_t ebp;
61: uint32_t esp;
62: uint32_t eflags;
63: uint32_t eip;
64: uint16_t cs, ss, ds, es, fs, gs;
65: };
66: #endif
67:
68: #ifdef TARGET_ARM
69: /* FPU emulator */
70: #include "nwfpe/fpa11.h"
71: #endif
72:
1.1.1.6 ! root 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:
1.1 root 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: #ifdef TARGET_ARM
92: /* FPA state */
93: FPA11 fpa;
94: int swi_errno;
95: #endif
1.1.1.5 root 96: #if defined(TARGET_I386) && !defined(TARGET_X86_64)
97: abi_ulong target_v86;
1.1 root 98: struct vm86_saved_state vm86_saved_regs;
99: struct target_vm86plus_struct vm86plus;
100: uint32_t v86flags;
101: uint32_t v86mask;
102: #endif
1.1.1.4 root 103: #ifdef TARGET_M68K
104: int sim_syscalls;
105: #endif
1.1.1.5 root 106: #if defined(TARGET_ARM) || defined(TARGET_M68K)
107: /* Extra fields for semihosted binaries. */
108: uint32_t stack_base;
109: uint32_t heap_base;
110: uint32_t heap_limit;
111: #endif
1.1 root 112: int used; /* non zero if used */
1.1.1.3 root 113: struct image_info *info;
1.1.1.6 ! root 114:
! 115: struct emulated_sigtable sigtab[TARGET_NSIG];
! 116: struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
! 117: struct sigqueue *first_free; /* first free siginfo queue entry */
! 118: int signal_pending; /* non zero if a signal may be pending */
! 119:
1.1 root 120: uint8_t stack[0];
121: } __attribute__((aligned(16))) TaskState;
122:
1.1.1.6 ! root 123: extern char *exec_path;
! 124: void init_task_state(TaskState *ts);
1.1.1.3 root 125: extern const char *qemu_uname_release;
1.1 root 126:
1.1.1.3 root 127: /* ??? See if we can avoid exposing so much of the loader internals. */
128: /*
129: * MAX_ARG_PAGES defines the number of pages allocated for arguments
130: * and envelope for the new program. 32 should suffice, this gives
131: * a maximum env+arg of 128kB w/4KB pages!
132: */
133: #define MAX_ARG_PAGES 32
134:
135: /*
1.1.1.5 root 136: * This structure is used to hold the arguments that are
1.1.1.3 root 137: * used when loading binaries.
138: */
139: struct linux_binprm {
140: char buf[128];
141: void *page[MAX_ARG_PAGES];
1.1.1.5 root 142: abi_ulong p;
1.1.1.3 root 143: int fd;
144: int e_uid, e_gid;
145: int argc, envc;
146: char **argv;
147: char **envp;
148: char * filename; /* Name of binary */
149: };
150:
151: void do_init_thread(struct target_pt_regs *regs, struct image_info *infop);
1.1.1.5 root 152: abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
153: abi_ulong stringp, int push_ptr);
154: int loader_exec(const char * filename, char ** argv, char ** envp,
1.1 root 155: struct target_pt_regs * regs, struct image_info *infop);
156:
1.1.1.3 root 157: int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
158: struct image_info * info);
159: int load_flt_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
160: struct image_info * info);
1.1.1.5 root 161: #ifdef TARGET_HAS_ELFLOAD32
162: int load_elf_binary_multi(struct linux_binprm *bprm,
163: struct target_pt_regs *regs,
164: struct image_info *info);
165: #endif
1.1.1.3 root 166:
1.1.1.5 root 167: abi_long memcpy_to_target(abi_ulong dest, const void *src,
168: unsigned long len);
169: void target_set_brk(abi_ulong new_brk);
170: abi_long do_brk(abi_ulong new_brk);
1.1 root 171: void syscall_init(void);
1.1.1.5 root 172: abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
173: abi_long arg2, abi_long arg3, abi_long arg4,
174: abi_long arg5, abi_long arg6);
1.1 root 175: void gemu_log(const char *fmt, ...) __attribute__((format(printf,1,2)));
1.1.1.6 ! root 176: extern THREAD CPUState *thread_env;
1.1 root 177: void cpu_loop(CPUState *env);
178: void init_paths(const char *prefix);
179: const char *path(const char *pathname);
1.1.1.5 root 180: char *target_strerror(int err);
1.1.1.6 ! root 181: int get_osversion(void);
! 182: void fork_start(void);
! 183: void fork_end(int child);
1.1 root 184:
1.1.1.6 ! root 185: #include "qemu-log.h"
1.1 root 186:
1.1.1.5 root 187: /* strace.c */
188: void print_syscall(int num,
189: abi_long arg1, abi_long arg2, abi_long arg3,
190: abi_long arg4, abi_long arg5, abi_long arg6);
191: void print_syscall_ret(int num, abi_long arg1);
192: extern int do_strace;
193:
1.1 root 194: /* signal.c */
1.1.1.6 ! root 195: void process_pending_signals(CPUState *cpu_env);
1.1 root 196: void signal_init(void);
1.1.1.6 ! root 197: int queue_signal(CPUState *env, int sig, target_siginfo_t *info);
1.1 root 198: void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
199: void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo);
1.1.1.6 ! root 200: int target_to_host_signal(int sig);
1.1 root 201: long do_sigreturn(CPUState *env);
202: long do_rt_sigreturn(CPUState *env);
1.1.1.5 root 203: abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
1.1 root 204:
205: #ifdef TARGET_I386
206: /* vm86.c */
207: void save_v86_state(CPUX86State *env);
208: void handle_vm86_trap(CPUX86State *env, int trapno);
209: void handle_vm86_fault(CPUX86State *env);
1.1.1.5 root 210: int do_vm86(CPUX86State *env, long subfunction, abi_ulong v86_addr);
211: #elif defined(TARGET_SPARC64)
212: void sparc64_set_context(CPUSPARCState *env);
213: void sparc64_get_context(CPUSPARCState *env);
1.1 root 214: #endif
215:
216: /* mmap.c */
1.1.1.5 root 217: int target_mprotect(abi_ulong start, abi_ulong len, int prot);
218: abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
219: int flags, int fd, abi_ulong offset);
220: int target_munmap(abi_ulong start, abi_ulong len);
221: abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
222: abi_ulong new_size, unsigned long flags,
223: abi_ulong new_addr);
224: int target_msync(abi_ulong start, abi_ulong len, int flags);
1.1.1.6 ! root 225: extern unsigned long last_brk;
! 226: void mmap_lock(void);
! 227: void mmap_unlock(void);
! 228: #if defined(USE_NPTL)
! 229: void mmap_fork_start(void);
! 230: void mmap_fork_end(int child);
! 231: #endif
! 232:
! 233: /* main.c */
! 234: extern unsigned long x86_stack_size;
1.1 root 235:
236: /* user access */
237:
238: #define VERIFY_READ 0
1.1.1.5 root 239: #define VERIFY_WRITE 1 /* implies read access */
1.1 root 240:
1.1.1.5 root 241: static inline int access_ok(int type, abi_ulong addr, abi_ulong size)
242: {
243: return page_check_range((target_ulong)addr, size,
244: (type == VERIFY_READ) ? PAGE_READ : (PAGE_READ | PAGE_WRITE)) == 0;
245: }
1.1 root 246:
1.1.1.5 root 247: /* NOTE __get_user and __put_user use host pointers and don't check access. */
248: /* These are usually used to access struct data members once the
249: * struct has been locked - usually with lock_user_struct().
250: */
251: #define __put_user(x, hptr)\
1.1 root 252: ({\
1.1.1.5 root 253: int size = sizeof(*hptr);\
1.1 root 254: switch(size) {\
255: case 1:\
1.1.1.5 root 256: *(uint8_t *)(hptr) = (uint8_t)(typeof(*hptr))(x);\
1.1 root 257: break;\
258: case 2:\
1.1.1.5 root 259: *(uint16_t *)(hptr) = tswap16((typeof(*hptr))(x));\
1.1 root 260: break;\
261: case 4:\
1.1.1.5 root 262: *(uint32_t *)(hptr) = tswap32((typeof(*hptr))(x));\
1.1 root 263: break;\
264: case 8:\
1.1.1.5 root 265: *(uint64_t *)(hptr) = tswap64((typeof(*hptr))(x));\
1.1 root 266: break;\
267: default:\
268: abort();\
269: }\
270: 0;\
271: })
272:
1.1.1.5 root 273: #define __get_user(x, hptr) \
1.1 root 274: ({\
1.1.1.5 root 275: int size = sizeof(*hptr);\
1.1 root 276: switch(size) {\
277: case 1:\
1.1.1.5 root 278: x = (typeof(*hptr))*(uint8_t *)(hptr);\
1.1 root 279: break;\
280: case 2:\
1.1.1.5 root 281: x = (typeof(*hptr))tswap16(*(uint16_t *)(hptr));\
1.1 root 282: break;\
283: case 4:\
1.1.1.5 root 284: x = (typeof(*hptr))tswap32(*(uint32_t *)(hptr));\
1.1 root 285: break;\
286: case 8:\
1.1.1.5 root 287: x = (typeof(*hptr))tswap64(*(uint64_t *)(hptr));\
1.1 root 288: break;\
289: default:\
1.1.1.5 root 290: /* avoid warning */\
291: x = 0;\
1.1 root 292: abort();\
293: }\
294: 0;\
295: })
296:
1.1.1.5 root 297: /* put_user()/get_user() take a guest address and check access */
298: /* These are usually used to access an atomic data type, such as an int,
299: * that has been passed by address. These internally perform locking
300: * and unlocking on the data type.
301: */
302: #define put_user(x, gaddr, target_type) \
303: ({ \
304: abi_ulong __gaddr = (gaddr); \
305: target_type *__hptr; \
306: abi_long __ret; \
307: if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
308: __ret = __put_user((x), __hptr); \
309: unlock_user(__hptr, __gaddr, sizeof(target_type)); \
310: } else \
311: __ret = -TARGET_EFAULT; \
312: __ret; \
1.1 root 313: })
314:
1.1.1.5 root 315: #define get_user(x, gaddr, target_type) \
316: ({ \
317: abi_ulong __gaddr = (gaddr); \
318: target_type *__hptr; \
319: abi_long __ret; \
320: if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
321: __ret = __get_user((x), __hptr); \
322: unlock_user(__hptr, __gaddr, 0); \
323: } else { \
324: /* avoid warning */ \
325: (x) = 0; \
326: __ret = -TARGET_EFAULT; \
327: } \
328: __ret; \
1.1 root 329: })
330:
1.1.1.5 root 331: #define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
332: #define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
333: #define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
334: #define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
335: #define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
336: #define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
337: #define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
338: #define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
339: #define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
340: #define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
341:
342: #define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
343: #define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
344: #define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
345: #define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
346: #define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
347: #define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
348: #define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
349: #define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
350: #define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
351: #define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
352:
353: /* copy_from_user() and copy_to_user() are usually used to copy data
354: * buffers between the target and host. These internally perform
355: * locking/unlocking of the memory.
356: */
357: abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
358: abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
359:
1.1.1.2 root 360: /* Functions for accessing guest memory. The tget and tput functions
361: read/write single values, byteswapping as neccessary. The lock_user
362: gets a pointer to a contiguous area of guest memory, but does not perform
363: and byteswapping. lock_user may return either a pointer to the guest
364: memory, or a temporary buffer. */
365:
366: /* Lock an area of guest memory into the host. If copy is true then the
367: host area will have the same contents as the guest. */
1.1.1.5 root 368: static inline void *lock_user(int type, abi_ulong guest_addr, long len, int copy)
1.1.1.2 root 369: {
1.1.1.5 root 370: if (!access_ok(type, guest_addr, len))
371: return NULL;
1.1.1.2 root 372: #ifdef DEBUG_REMAP
1.1.1.5 root 373: {
374: void *addr;
375: addr = malloc(len);
376: if (copy)
377: memcpy(addr, g2h(guest_addr), len);
378: else
379: memset(addr, 0, len);
380: return addr;
381: }
1.1.1.2 root 382: #else
383: return g2h(guest_addr);
384: #endif
1.1 root 385: }
386:
1.1.1.5 root 387: /* Unlock an area of guest memory. The first LEN bytes must be
1.1.1.6 ! root 388: flushed back to guest memory. host_ptr = NULL is explicitly
1.1.1.5 root 389: allowed and does nothing. */
390: static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
391: long len)
1.1.1.2 root 392: {
1.1.1.5 root 393:
1.1.1.2 root 394: #ifdef DEBUG_REMAP
1.1.1.5 root 395: if (!host_ptr)
396: return;
397: if (host_ptr == g2h(guest_addr))
1.1.1.2 root 398: return;
399: if (len > 0)
1.1.1.5 root 400: memcpy(g2h(guest_addr), host_ptr, len);
401: free(host_ptr);
1.1.1.2 root 402: #endif
1.1 root 403: }
404:
1.1.1.5 root 405: /* Return the length of a string in target memory or -TARGET_EFAULT if
406: access error. */
407: abi_long target_strlen(abi_ulong gaddr);
1.1 root 408:
1.1.1.2 root 409: /* Like lock_user but for null terminated strings. */
1.1.1.5 root 410: static inline void *lock_user_string(abi_ulong guest_addr)
1.1.1.2 root 411: {
1.1.1.5 root 412: abi_long len;
413: len = target_strlen(guest_addr);
414: if (len < 0)
415: return NULL;
416: return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
1.1.1.2 root 417: }
418:
419: /* Helper macros for locking/ulocking a target struct. */
1.1.1.5 root 420: #define lock_user_struct(type, host_ptr, guest_addr, copy) \
421: (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
422: #define unlock_user_struct(host_ptr, guest_addr, copy) \
1.1.1.2 root 423: unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
424:
1.1.1.6 ! root 425: #if defined(USE_NPTL)
! 426: #include <pthread.h>
! 427: #endif
! 428:
1.1 root 429: #endif /* QEMU_H */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.