linux-user/qemu.h

   1 #ifndef GEMU_H
   2 #define GEMU_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
  13 /* This struct is used to hold certain information about the image.
  14  * Basically, it replicates in user space what would be certain
  15  * task_struct fields in the kernel
  16  */
  17 struct image_info {
  18         unsigned long   start_code;
  19         unsigned long   end_code;
  20         unsigned long   end_data;
  21         unsigned long   start_brk;
  22         unsigned long   brk;
  23         unsigned long   start_mmap;
  24         unsigned long   mmap;
  25         unsigned long   rss;
  26         unsigned long   start_stack;
  27         unsigned long   arg_start;
  28         unsigned long   arg_end;
  29         unsigned long   env_start;
  30         unsigned long   env_end;
  31         unsigned long   entry;
  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 #undef put_user
  56 #undef get_user
  57 #endif
  58
  59 /* NOTE: we force a big alignment so that the stack stored after is
  60    aligned too */
  61 typedef struct TaskState {
  62     struct TaskState *next;
  63 #ifdef TARGET_ARM
  64     /* FPA state */
  65     FPA11 fpa;
  66 #endif
  67 #ifdef TARGET_I386
  68     struct target_vm86plus_struct *target_v86;
  69     struct vm86_saved_state vm86_saved_regs;
  70     struct target_vm86plus_struct vm86plus;
  71     uint32_t v86flags;
  72     uint32_t v86mask;
  73 #endif
  74     int used; /* non zero if used */
  75     uint8_t stack[0];
  76 } __attribute__((aligned(16))) TaskState;
  77
  78 extern TaskState *first_task_state;
  79
  80 int elf_exec(const char * filename, char ** argv, char ** envp,
  81              struct target_pt_regs * regs, struct image_info *infop);
  82
  83 void target_set_brk(char *new_brk);
  84 void syscall_init(void);
  85 long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3,
  86                 long arg4, long arg5, long arg6);
  87 void gemu_log(const char *fmt, ...) __attribute__((format(printf,1,2)));
  88 extern CPUState *global_env;
  89 void cpu_loop(CPUState *env);
  90 void init_paths(const char *prefix);
  91 const char *path(const char *pathname);
  92
  93 extern int loglevel;
  94 extern FILE *logfile;
  95
  96 /* signal.c */
  97 void process_pending_signals(void *cpu_env);
  98 void signal_init(void);
  99 int queue_signal(int sig, target_siginfo_t *info);
 100 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
 101 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo);
 102 long do_sigreturn(CPUState *env);
 103 long do_rt_sigreturn(CPUState *env);
 104
 105 #ifdef TARGET_I386
 106 /* vm86.c */
 107 void save_v86_state(CPUX86State *env);
 108 void handle_vm86_trap(CPUX86State *env, int trapno);
 109 void handle_vm86_fault(CPUX86State *env);
 110 int do_vm86(CPUX86State *env, long subfunction,
 111             struct target_vm86plus_struct * target_v86);
 112 #endif
 113
 114 /* mmap.c */
 115 int target_mprotect(unsigned long start, unsigned long len, int prot);
 116 long target_mmap(unsigned long start, unsigned long len, int prot,
 117                  int flags, int fd, unsigned long offset);
 118 int target_munmap(unsigned long start, unsigned long len);
 119 long target_mremap(unsigned long old_addr, unsigned long old_size,
 120                    unsigned long new_size, unsigned long flags,
 121                    unsigned long new_addr);
 122 int target_msync(unsigned long start, unsigned long len, int flags);
 123
 124 /* user access */
 125
 126 #define VERIFY_READ 0
 127 #define VERIFY_WRITE 1
 128
 129 #define access_ok(type,addr,size) (1)
 130
 131 #define __put_user(x,ptr)\
 132 ({\
 133     int size = sizeof(*ptr);\
 134     switch(size) {\
 135     case 1:\
 136         stb(ptr, (typeof(*ptr))(x));\
 137         break;\
 138     case 2:\
 139         stw(ptr, (typeof(*ptr))(x));\
 140         break;\
 141     case 4:\
 142         stl(ptr, (typeof(*ptr))(x));\
 143         break;\
 144     case 8:\
 145         stq(ptr, (typeof(*ptr))(x));\
 146         break;\
 147     default:\
 148         abort();\
 149     }\
 150     0;\
 151 })
 152
 153 #define __get_user(x, ptr) \
 154 ({\
 155     int size = sizeof(*ptr);\
 156     switch(size) {\
 157     case 1:\
 158         x = (typeof(*ptr))ldub(ptr);\
 159         break;\
 160     case 2:\
 161         x = (typeof(*ptr))lduw(ptr);\
 162         break;\
 163     case 4:\
 164         x = (typeof(*ptr))ldl(ptr);\
 165         break;\
 166     case 8:\
 167         x = (typeof(*ptr))ldq(ptr);\
 168         break;\
 169     default:\
 170         abort();\
 171     }\
 172     0;\
 173 })
 174
 175 static inline unsigned long __copy_to_user(void *dst, const void *src,
 176                                            unsigned long size)
 177 {
 178     memcpy(dst, src, size);
 179     return 0;
 180 }
 181
 182 static inline unsigned long __copy_from_user(void *dst, const void *src,
 183                                              unsigned long size)
 184 {
 185     memcpy(dst, src, size);
 186     return 0;
 187 }
 188
 189 static inline unsigned long __clear_user(void *dst, unsigned long size)
 190 {
 191     memset(dst, 0, size);
 192     return 0;
 193 }
 194
 195 #define put_user(x,ptr)\
 196 ({\
 197     int __ret;\
 198     if (access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)))\
 199         __ret = __put_user(x, ptr);\
 200     else\
 201         __ret = -EFAULT;\
 202     __ret;\
 203 })
 204
 205 #define get_user(x,ptr)\
 206 ({\
 207     int __ret;\
 208     if (access_ok(VERIFY_READ, ptr, sizeof(*ptr)))\
 209         __ret = __get_user(x, ptr);\
 210     else\
 211         __ret = -EFAULT;\
 212     __ret;\
 213 })
 214
 215 static inline unsigned long copy_to_user(void *dst, const void *src,
 216                                          unsigned long size)
 217 {
 218     if (access_ok(VERIFY_WRITE, dst, size))
 219         return __copy_to_user(dst, src, size);
 220     else
 221         return size;
 222 }
 223
 224 static inline unsigned long copy_from_user(void *dst, const void *src,
 225                                              unsigned long size)
 226 {
 227     if (access_ok(VERIFY_READ, src, size))
 228         return __copy_from_user(dst, src, size);
 229     else
 230         return size;
 231 }
 232
 233 static inline unsigned long clear_user(void *dst, unsigned long size)
 234 {
 235     if (access_ok(VERIFY_WRITE, dst, size))
 236         return __clear_user(dst, size);
 237     else
 238         return size;
 239 }
 240
 241 #endif