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