File:  [Qemu by Fabrice Bellard] / qemu / linux-user / qemu.h
Revision 1.1.1.10 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:35:43 2018 UTC (3 years, 3 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu0150, qemu0141, qemu0140, HEAD
qemu 0.14.0

    1: #ifndef QEMU_H
    2: #define QEMU_H
    3: 
    4: #include <signal.h>
    5: #include <string.h>
    6: 
    7: #include "cpu.h"
    8: 
    9: #undef DEBUG_REMAP
   10: #ifdef DEBUG_REMAP
   11: #include <stdlib.h>
   12: #endif /* DEBUG_REMAP */
   13: 
   14: #include "qemu-types.h"
   15: 
   16: #include "thunk.h"
   17: #include "syscall_defs.h"
   18: #include "syscall.h"
   19: #include "target_signal.h"
   20: #include "gdbstub.h"
   21: #include "qemu-queue.h"
   22: 
   23: #if defined(CONFIG_USE_NPTL)
   24: #define THREAD __thread
   25: #else
   26: #define THREAD
   27: #endif
   28: 
   29: /* This struct is used to hold certain information about the image.
   30:  * Basically, it replicates in user space what would be certain
   31:  * task_struct fields in the kernel
   32:  */
   33: struct image_info {
   34:         abi_ulong       load_bias;
   35:         abi_ulong       load_addr;
   36:         abi_ulong       start_code;
   37:         abi_ulong       end_code;
   38:         abi_ulong       start_data;
   39:         abi_ulong       end_data;
   40:         abi_ulong       start_brk;
   41:         abi_ulong       brk;
   42:         abi_ulong       start_mmap;
   43:         abi_ulong       mmap;
   44:         abi_ulong       rss;
   45:         abi_ulong       start_stack;
   46:         abi_ulong       stack_limit;
   47:         abi_ulong       entry;
   48:         abi_ulong       code_offset;
   49:         abi_ulong       data_offset;
   50:         abi_ulong       saved_auxv;
   51:         abi_ulong       arg_start;
   52:         abi_ulong       arg_end;
   53: 	int		personality;
   54: };
   55: 
   56: #ifdef TARGET_I386
   57: /* Information about the current linux thread */
   58: struct vm86_saved_state {
   59:     uint32_t eax; /* return code */
   60:     uint32_t ebx;
   61:     uint32_t ecx;
   62:     uint32_t edx;
   63:     uint32_t esi;
   64:     uint32_t edi;
   65:     uint32_t ebp;
   66:     uint32_t esp;
   67:     uint32_t eflags;
   68:     uint32_t eip;
   69:     uint16_t cs, ss, ds, es, fs, gs;
   70: };
   71: #endif
   72: 
   73: #ifdef TARGET_ARM
   74: /* FPU emulator */
   75: #include "nwfpe/fpa11.h"
   76: #endif
   77: 
   78: #define MAX_SIGQUEUE_SIZE 1024
   79: 
   80: struct sigqueue {
   81:     struct sigqueue *next;
   82:     target_siginfo_t info;
   83: };
   84: 
   85: struct emulated_sigtable {
   86:     int pending; /* true if signal is pending */
   87:     struct sigqueue *first;
   88:     struct sigqueue info; /* in order to always have memory for the
   89:                              first signal, we put it here */
   90: };
   91: 
   92: /* NOTE: we force a big alignment so that the stack stored after is
   93:    aligned too */
   94: typedef struct TaskState {
   95:     pid_t ts_tid;     /* tid (or pid) of this task */
   96: #ifdef TARGET_ARM
   97:     /* FPA state */
   98:     FPA11 fpa;
   99:     int swi_errno;
  100: #endif
  101: #if defined(TARGET_I386) && !defined(TARGET_X86_64)
  102:     abi_ulong target_v86;
  103:     struct vm86_saved_state vm86_saved_regs;
  104:     struct target_vm86plus_struct vm86plus;
  105:     uint32_t v86flags;
  106:     uint32_t v86mask;
  107: #endif
  108: #ifdef CONFIG_USE_NPTL
  109:     abi_ulong child_tidptr;
  110: #endif
  111: #ifdef TARGET_M68K
  112:     int sim_syscalls;
  113: #endif
  114: #if defined(TARGET_ARM) || defined(TARGET_M68K)
  115:     /* Extra fields for semihosted binaries.  */
  116:     uint32_t stack_base;
  117:     uint32_t heap_base;
  118:     uint32_t heap_limit;
  119: #endif
  120:     int used; /* non zero if used */
  121:     struct image_info *info;
  122:     struct linux_binprm *bprm;
  123: 
  124:     struct emulated_sigtable sigtab[TARGET_NSIG];
  125:     struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
  126:     struct sigqueue *first_free; /* first free siginfo queue entry */
  127:     int signal_pending; /* non zero if a signal may be pending */
  128: } __attribute__((aligned(16))) TaskState;
  129: 
  130: extern char *exec_path;
  131: void init_task_state(TaskState *ts);
  132: void task_settid(TaskState *);
  133: void stop_all_tasks(void);
  134: extern const char *qemu_uname_release;
  135: extern unsigned long mmap_min_addr;
  136: 
  137: /* ??? See if we can avoid exposing so much of the loader internals.  */
  138: /*
  139:  * MAX_ARG_PAGES defines the number of pages allocated for arguments
  140:  * and envelope for the new program. 32 should suffice, this gives
  141:  * a maximum env+arg of 128kB w/4KB pages!
  142:  */
  143: #define MAX_ARG_PAGES 33
  144: 
  145: /* Read a good amount of data initially, to hopefully get all the
  146:    program headers loaded.  */
  147: #define BPRM_BUF_SIZE  1024
  148: 
  149: /*
  150:  * This structure is used to hold the arguments that are
  151:  * used when loading binaries.
  152:  */
  153: struct linux_binprm {
  154:         char buf[BPRM_BUF_SIZE] __attribute__((aligned));
  155:         void *page[MAX_ARG_PAGES];
  156:         abi_ulong p;
  157: 	int fd;
  158:         int e_uid, e_gid;
  159:         int argc, envc;
  160:         char **argv;
  161:         char **envp;
  162:         char * filename;        /* Name of binary */
  163:         int (*core_dump)(int, const CPUState *); /* coredump routine */
  164: };
  165: 
  166: void do_init_thread(struct target_pt_regs *regs, struct image_info *infop);
  167: abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
  168:                               abi_ulong stringp, int push_ptr);
  169: int loader_exec(const char * filename, char ** argv, char ** envp,
  170:              struct target_pt_regs * regs, struct image_info *infop,
  171:              struct linux_binprm *);
  172: 
  173: int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
  174:                     struct image_info * info);
  175: int load_flt_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
  176:                     struct image_info * info);
  177: 
  178: abi_long memcpy_to_target(abi_ulong dest, const void *src,
  179:                           unsigned long len);
  180: void target_set_brk(abi_ulong new_brk);
  181: abi_long do_brk(abi_ulong new_brk);
  182: void syscall_init(void);
  183: abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
  184:                     abi_long arg2, abi_long arg3, abi_long arg4,
  185:                     abi_long arg5, abi_long arg6);
  186: void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
  187: extern THREAD CPUState *thread_env;
  188: void cpu_loop(CPUState *env);
  189: char *target_strerror(int err);
  190: int get_osversion(void);
  191: void fork_start(void);
  192: void fork_end(int child);
  193: 
  194: #include "qemu-log.h"
  195: 
  196: /* strace.c */
  197: void print_syscall(int num,
  198:                    abi_long arg1, abi_long arg2, abi_long arg3,
  199:                    abi_long arg4, abi_long arg5, abi_long arg6);
  200: void print_syscall_ret(int num, abi_long arg1);
  201: extern int do_strace;
  202: 
  203: /* signal.c */
  204: void process_pending_signals(CPUState *cpu_env);
  205: void signal_init(void);
  206: int queue_signal(CPUState *env, int sig, target_siginfo_t *info);
  207: void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
  208: void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo);
  209: int target_to_host_signal(int sig);
  210: int host_to_target_signal(int sig);
  211: long do_sigreturn(CPUState *env);
  212: long do_rt_sigreturn(CPUState *env);
  213: abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
  214: 
  215: #ifdef TARGET_I386
  216: /* vm86.c */
  217: void save_v86_state(CPUX86State *env);
  218: void handle_vm86_trap(CPUX86State *env, int trapno);
  219: void handle_vm86_fault(CPUX86State *env);
  220: int do_vm86(CPUX86State *env, long subfunction, abi_ulong v86_addr);
  221: #elif defined(TARGET_SPARC64)
  222: void sparc64_set_context(CPUSPARCState *env);
  223: void sparc64_get_context(CPUSPARCState *env);
  224: #endif
  225: 
  226: /* mmap.c */
  227: int target_mprotect(abi_ulong start, abi_ulong len, int prot);
  228: abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
  229:                      int flags, int fd, abi_ulong offset);
  230: int target_munmap(abi_ulong start, abi_ulong len);
  231: abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
  232:                        abi_ulong new_size, unsigned long flags,
  233:                        abi_ulong new_addr);
  234: int target_msync(abi_ulong start, abi_ulong len, int flags);
  235: extern unsigned long last_brk;
  236: void mmap_lock(void);
  237: void mmap_unlock(void);
  238: abi_ulong mmap_find_vma(abi_ulong, abi_ulong);
  239: void cpu_list_lock(void);
  240: void cpu_list_unlock(void);
  241: #if defined(CONFIG_USE_NPTL)
  242: void mmap_fork_start(void);
  243: void mmap_fork_end(int child);
  244: #endif
  245: 
  246: /* main.c */
  247: extern unsigned long guest_stack_size;
  248: 
  249: /* user access */
  250: 
  251: #define VERIFY_READ 0
  252: #define VERIFY_WRITE 1 /* implies read access */
  253: 
  254: static inline int access_ok(int type, abi_ulong addr, abi_ulong size)
  255: {
  256:     return page_check_range((target_ulong)addr, size,
  257:                             (type == VERIFY_READ) ? PAGE_READ : (PAGE_READ | PAGE_WRITE)) == 0;
  258: }
  259: 
  260: /* NOTE __get_user and __put_user use host pointers and don't check access. */
  261: /* These are usually used to access struct data members once the
  262:  * struct has been locked - usually with lock_user_struct().
  263:  */
  264: #define __put_user(x, hptr)\
  265: ({\
  266:     switch(sizeof(*hptr)) {\
  267:     case 1:\
  268:         *(uint8_t *)(hptr) = (uint8_t)(typeof(*hptr))(x);\
  269:         break;\
  270:     case 2:\
  271:         *(uint16_t *)(hptr) = tswap16((uint16_t)(typeof(*hptr))(x));\
  272:         break;\
  273:     case 4:\
  274:         *(uint32_t *)(hptr) = tswap32((uint32_t)(typeof(*hptr))(x));\
  275:         break;\
  276:     case 8:\
  277:         *(uint64_t *)(hptr) = tswap64((typeof(*hptr))(x));\
  278:         break;\
  279:     default:\
  280:         abort();\
  281:     }\
  282:     0;\
  283: })
  284: 
  285: #define __get_user(x, hptr) \
  286: ({\
  287:     switch(sizeof(*hptr)) {\
  288:     case 1:\
  289:         x = (typeof(*hptr))*(uint8_t *)(hptr);\
  290:         break;\
  291:     case 2:\
  292:         x = (typeof(*hptr))tswap16(*(uint16_t *)(hptr));\
  293:         break;\
  294:     case 4:\
  295:         x = (typeof(*hptr))tswap32(*(uint32_t *)(hptr));\
  296:         break;\
  297:     case 8:\
  298:         x = (typeof(*hptr))tswap64(*(uint64_t *)(hptr));\
  299:         break;\
  300:     default:\
  301:         /* avoid warning */\
  302:         x = 0;\
  303:         abort();\
  304:     }\
  305:     0;\
  306: })
  307: 
  308: /* put_user()/get_user() take a guest address and check access */
  309: /* These are usually used to access an atomic data type, such as an int,
  310:  * that has been passed by address.  These internally perform locking
  311:  * and unlocking on the data type.
  312:  */
  313: #define put_user(x, gaddr, target_type)					\
  314: ({									\
  315:     abi_ulong __gaddr = (gaddr);					\
  316:     target_type *__hptr;						\
  317:     abi_long __ret;							\
  318:     if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
  319:         __ret = __put_user((x), __hptr);				\
  320:         unlock_user(__hptr, __gaddr, sizeof(target_type));		\
  321:     } else								\
  322:         __ret = -TARGET_EFAULT;						\
  323:     __ret;								\
  324: })
  325: 
  326: #define get_user(x, gaddr, target_type)					\
  327: ({									\
  328:     abi_ulong __gaddr = (gaddr);					\
  329:     target_type *__hptr;						\
  330:     abi_long __ret;							\
  331:     if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
  332:         __ret = __get_user((x), __hptr);				\
  333:         unlock_user(__hptr, __gaddr, 0);				\
  334:     } else {								\
  335:         /* avoid warning */						\
  336:         (x) = 0;							\
  337:         __ret = -TARGET_EFAULT;						\
  338:     }									\
  339:     __ret;								\
  340: })
  341: 
  342: #define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
  343: #define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
  344: #define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
  345: #define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
  346: #define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
  347: #define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
  348: #define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
  349: #define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
  350: #define put_user_u8(x, gaddr)  put_user((x), (gaddr), uint8_t)
  351: #define put_user_s8(x, gaddr)  put_user((x), (gaddr), int8_t)
  352: 
  353: #define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
  354: #define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
  355: #define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
  356: #define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
  357: #define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
  358: #define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
  359: #define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
  360: #define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
  361: #define get_user_u8(x, gaddr)  get_user((x), (gaddr), uint8_t)
  362: #define get_user_s8(x, gaddr)  get_user((x), (gaddr), int8_t)
  363: 
  364: /* copy_from_user() and copy_to_user() are usually used to copy data
  365:  * buffers between the target and host.  These internally perform
  366:  * locking/unlocking of the memory.
  367:  */
  368: abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
  369: abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
  370: 
  371: /* Functions for accessing guest memory.  The tget and tput functions
  372:    read/write single values, byteswapping as neccessary.  The lock_user
  373:    gets a pointer to a contiguous area of guest memory, but does not perform
  374:    and byteswapping.  lock_user may return either a pointer to the guest
  375:    memory, or a temporary buffer.  */
  376: 
  377: /* Lock an area of guest memory into the host.  If copy is true then the
  378:    host area will have the same contents as the guest.  */
  379: static inline void *lock_user(int type, abi_ulong guest_addr, long len, int copy)
  380: {
  381:     if (!access_ok(type, guest_addr, len))
  382:         return NULL;
  383: #ifdef DEBUG_REMAP
  384:     {
  385:         void *addr;
  386:         addr = malloc(len);
  387:         if (copy)
  388:             memcpy(addr, g2h(guest_addr), len);
  389:         else
  390:             memset(addr, 0, len);
  391:         return addr;
  392:     }
  393: #else
  394:     return g2h(guest_addr);
  395: #endif
  396: }
  397: 
  398: /* Unlock an area of guest memory.  The first LEN bytes must be
  399:    flushed back to guest memory. host_ptr = NULL is explicitly
  400:    allowed and does nothing. */
  401: static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
  402:                                long len)
  403: {
  404: 
  405: #ifdef DEBUG_REMAP
  406:     if (!host_ptr)
  407:         return;
  408:     if (host_ptr == g2h(guest_addr))
  409:         return;
  410:     if (len > 0)
  411:         memcpy(g2h(guest_addr), host_ptr, len);
  412:     free(host_ptr);
  413: #endif
  414: }
  415: 
  416: /* Return the length of a string in target memory or -TARGET_EFAULT if
  417:    access error. */
  418: abi_long target_strlen(abi_ulong gaddr);
  419: 
  420: /* Like lock_user but for null terminated strings.  */
  421: static inline void *lock_user_string(abi_ulong guest_addr)
  422: {
  423:     abi_long len;
  424:     len = target_strlen(guest_addr);
  425:     if (len < 0)
  426:         return NULL;
  427:     return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
  428: }
  429: 
  430: /* Helper macros for locking/ulocking a target struct.  */
  431: #define lock_user_struct(type, host_ptr, guest_addr, copy)	\
  432:     (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
  433: #define unlock_user_struct(host_ptr, guest_addr, copy)		\
  434:     unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
  435: 
  436: #if defined(CONFIG_USE_NPTL)
  437: #include <pthread.h>
  438: #endif
  439: 
  440: #endif /* QEMU_H */

unix.superglobalmegacorp.com