![[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.1.4 ! root 32: char **host_argv;
1.1 root 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
1.1.1.2 root 72: target_ulong target_v86;
1.1 root 73: struct vm86_saved_state vm86_saved_regs;
74: struct target_vm86plus_struct vm86plus;
75: uint32_t v86flags;
76: uint32_t v86mask;
77: #endif
1.1.1.4 ! root 78: #ifdef TARGET_M68K
! 79: int sim_syscalls;
! 80: #endif
1.1 root 81: int used; /* non zero if used */
1.1.1.3 root 82: struct image_info *info;
1.1 root 83: uint8_t stack[0];
84: } __attribute__((aligned(16))) TaskState;
85:
86: extern TaskState *first_task_state;
1.1.1.3 root 87: extern const char *qemu_uname_release;
1.1 root 88:
1.1.1.3 root 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,
1.1 root 117: struct target_pt_regs * regs, struct image_info *infop);
118:
1.1.1.3 root 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);
1.1.1.2 root 126: void target_set_brk(target_ulong new_brk);
127: long do_brk(target_ulong new_brk);
1.1 root 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);
1.1.1.2 root 154: int do_vm86(CPUX86State *env, long subfunction, target_ulong v86_addr);
1.1 root 155: #endif
156:
157: /* mmap.c */
1.1.1.2 root 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);
1.1 root 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:
1.1.1.2 root 174: /* NOTE get_user and put_user use host addresses. */
1.1 root 175: #define __put_user(x,ptr)\
176: ({\
177: int size = sizeof(*ptr);\
178: switch(size) {\
179: case 1:\
1.1.1.2 root 180: *(uint8_t *)(ptr) = (typeof(*ptr))(x);\
1.1 root 181: break;\
182: case 2:\
1.1.1.2 root 183: *(uint16_t *)(ptr) = tswap16((typeof(*ptr))(x));\
1.1 root 184: break;\
185: case 4:\
1.1.1.2 root 186: *(uint32_t *)(ptr) = tswap32((typeof(*ptr))(x));\
1.1 root 187: break;\
188: case 8:\
1.1.1.2 root 189: *(uint64_t *)(ptr) = tswap64((typeof(*ptr))(x));\
1.1 root 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:\
1.1.1.2 root 202: x = (typeof(*ptr))*(uint8_t *)(ptr);\
1.1 root 203: break;\
204: case 2:\
1.1.1.2 root 205: x = (typeof(*ptr))tswap16(*(uint16_t *)(ptr));\
1.1 root 206: break;\
207: case 4:\
1.1.1.2 root 208: x = (typeof(*ptr))tswap32(*(uint32_t *)(ptr));\
1.1 root 209: break;\
210: case 8:\
1.1.1.2 root 211: x = (typeof(*ptr))tswap64(*(uint64_t *)(ptr));\
1.1 root 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:
1.1.1.2 root 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);
1.1 root 254: else
1.1.1.2 root 255: memset(addr, 0, len);
256: return addr;
257: #else
258: return g2h(guest_addr);
259: #endif
1.1 root 260: }
261:
1.1.1.2 root 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
1.1 root 274: }
275:
1.1.1.2 root 276: /* Return the length of a string in target memory. */
277: static inline int target_strlen(target_ulong ptr)
1.1 root 278: {
1.1.1.2 root 279: return strlen(g2h(ptr));
1.1 root 280: }
281:
1.1.1.2 root 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:
1.1 root 312: #endif /* QEMU_H */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.