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

unix.superglobalmegacorp.com