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

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

unix.superglobalmegacorp.com