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