![[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;
21: unsigned long end_data;
22: unsigned long start_brk;
23: unsigned long brk;
24: unsigned long start_mmap;
25: unsigned long mmap;
26: unsigned long rss;
27: unsigned long start_stack;
28: unsigned long arg_start;
29: unsigned long arg_end;
30: unsigned long env_start;
31: unsigned long env_end;
32: unsigned long entry;
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: struct target_vm86plus_struct *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: int used; /* non zero if used */
79: uint8_t stack[0];
80: } __attribute__((aligned(16))) TaskState;
81:
82: extern TaskState *first_task_state;
83:
84: int elf_exec(const char * filename, char ** argv, char ** envp,
85: struct target_pt_regs * regs, struct image_info *infop);
86:
87: void target_set_brk(char *new_brk);
88: long do_brk(char *new_brk);
89: void syscall_init(void);
90: long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3,
91: long arg4, long arg5, long arg6);
92: void gemu_log(const char *fmt, ...) __attribute__((format(printf,1,2)));
93: extern CPUState *global_env;
94: void cpu_loop(CPUState *env);
95: void init_paths(const char *prefix);
96: const char *path(const char *pathname);
97:
98: extern int loglevel;
99: extern FILE *logfile;
100:
101: /* signal.c */
102: void process_pending_signals(void *cpu_env);
103: void signal_init(void);
104: int queue_signal(int sig, target_siginfo_t *info);
105: void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
106: void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo);
107: long do_sigreturn(CPUState *env);
108: long do_rt_sigreturn(CPUState *env);
109:
110: #ifdef TARGET_I386
111: /* vm86.c */
112: void save_v86_state(CPUX86State *env);
113: void handle_vm86_trap(CPUX86State *env, int trapno);
114: void handle_vm86_fault(CPUX86State *env);
115: int do_vm86(CPUX86State *env, long subfunction,
116: struct target_vm86plus_struct * target_v86);
117: #endif
118:
119: /* mmap.c */
120: int target_mprotect(unsigned long start, unsigned long len, int prot);
121: long target_mmap(unsigned long start, unsigned long len, int prot,
122: int flags, int fd, unsigned long offset);
123: int target_munmap(unsigned long start, unsigned long len);
124: long target_mremap(unsigned long old_addr, unsigned long old_size,
125: unsigned long new_size, unsigned long flags,
126: unsigned long new_addr);
127: int target_msync(unsigned long start, unsigned long len, int flags);
128:
129: /* user access */
130:
131: #define VERIFY_READ 0
132: #define VERIFY_WRITE 1
133:
134: #define access_ok(type,addr,size) (1)
135:
136: #define __put_user(x,ptr)\
137: ({\
138: int size = sizeof(*ptr);\
139: switch(size) {\
140: case 1:\
141: stb(ptr, (typeof(*ptr))(x));\
142: break;\
143: case 2:\
144: stw(ptr, (typeof(*ptr))(x));\
145: break;\
146: case 4:\
147: stl(ptr, (typeof(*ptr))(x));\
148: break;\
149: case 8:\
150: stq(ptr, (typeof(*ptr))(x));\
151: break;\
152: default:\
153: abort();\
154: }\
155: 0;\
156: })
157:
158: #define __get_user(x, ptr) \
159: ({\
160: int size = sizeof(*ptr);\
161: switch(size) {\
162: case 1:\
163: x = (typeof(*ptr))ldub((void *)ptr);\
164: break;\
165: case 2:\
166: x = (typeof(*ptr))lduw((void *)ptr);\
167: break;\
168: case 4:\
169: x = (typeof(*ptr))ldl((void *)ptr);\
170: break;\
171: case 8:\
172: x = (typeof(*ptr))ldq((void *)ptr);\
173: break;\
174: default:\
175: abort();\
176: }\
177: 0;\
178: })
179:
180: static inline unsigned long __copy_to_user(void *dst, const void *src,
181: unsigned long size)
182: {
183: memcpy(dst, src, size);
184: return 0;
185: }
186:
187: static inline unsigned long __copy_from_user(void *dst, const void *src,
188: unsigned long size)
189: {
190: memcpy(dst, src, size);
191: return 0;
192: }
193:
194: static inline unsigned long __clear_user(void *dst, unsigned long size)
195: {
196: memset(dst, 0, size);
197: return 0;
198: }
199:
200: #define put_user(x,ptr)\
201: ({\
202: int __ret;\
203: if (access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)))\
204: __ret = __put_user(x, ptr);\
205: else\
206: __ret = -EFAULT;\
207: __ret;\
208: })
209:
210: #define get_user(x,ptr)\
211: ({\
212: int __ret;\
213: if (access_ok(VERIFY_READ, ptr, sizeof(*ptr)))\
214: __ret = __get_user(x, ptr);\
215: else\
216: __ret = -EFAULT;\
217: __ret;\
218: })
219:
220: static inline unsigned long copy_to_user(void *dst, const void *src,
221: unsigned long size)
222: {
223: if (access_ok(VERIFY_WRITE, dst, size))
224: return __copy_to_user(dst, src, size);
225: else
226: return size;
227: }
228:
229: static inline unsigned long copy_from_user(void *dst, const void *src,
230: unsigned long size)
231: {
232: if (access_ok(VERIFY_READ, src, size))
233: return __copy_from_user(dst, src, size);
234: else
235: return size;
236: }
237:
238: static inline unsigned long clear_user(void *dst, unsigned long size)
239: {
240: if (access_ok(VERIFY_WRITE, dst, size))
241: return __clear_user(dst, size);
242: else
243: return size;
244: }
245:
246: #endif /* QEMU_H */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.