Return to qemu.h CVS log

Up to [Qemu by Fabrice Bellard] / qemu / linux-user

Annotation of qemu/linux-user/qemu.h, revision 1.1

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.