For newer target architectures, glibc can be picky about the kernel version: for example, it will not run on an aarch64 system unless the kernel reports itself as at least 3.8.0. Accommodate this by enhancing the existing support for faking the kernel version so that each target can optionally specify a minimum version: if the user doesn't force a specific fake version then we will override with the minimum required version only if the real host kernel version is insufficient. Use this facility to let aarch64 report a minimum of 3.8.0. Signed-off-by: Peter Maydell <peter.maydell@linaro.org> Message-id: 1378235544-22290-21-git-send-email-peter.maydell@linaro.org
457 lines
15 KiB
C
457 lines
15 KiB
C
#ifndef QEMU_H
|
|
#define QEMU_H
|
|
|
|
#include <signal.h>
|
|
#include <string.h>
|
|
|
|
#include "cpu.h"
|
|
|
|
#undef DEBUG_REMAP
|
|
#ifdef DEBUG_REMAP
|
|
#include <stdlib.h>
|
|
#endif /* DEBUG_REMAP */
|
|
|
|
#include "exec/user/abitypes.h"
|
|
|
|
#include "exec/user/thunk.h"
|
|
#include "syscall_defs.h"
|
|
#include "syscall.h"
|
|
#include "exec/gdbstub.h"
|
|
#include "qemu/queue.h"
|
|
|
|
#define THREAD __thread
|
|
|
|
/* This struct is used to hold certain information about the image.
|
|
* Basically, it replicates in user space what would be certain
|
|
* task_struct fields in the kernel
|
|
*/
|
|
struct image_info {
|
|
abi_ulong load_bias;
|
|
abi_ulong load_addr;
|
|
abi_ulong start_code;
|
|
abi_ulong end_code;
|
|
abi_ulong start_data;
|
|
abi_ulong end_data;
|
|
abi_ulong start_brk;
|
|
abi_ulong brk;
|
|
abi_ulong start_mmap;
|
|
abi_ulong mmap;
|
|
abi_ulong rss;
|
|
abi_ulong start_stack;
|
|
abi_ulong stack_limit;
|
|
abi_ulong entry;
|
|
abi_ulong code_offset;
|
|
abi_ulong data_offset;
|
|
abi_ulong saved_auxv;
|
|
abi_ulong auxv_len;
|
|
abi_ulong arg_start;
|
|
abi_ulong arg_end;
|
|
uint32_t elf_flags;
|
|
int personality;
|
|
#ifdef CONFIG_USE_FDPIC
|
|
abi_ulong loadmap_addr;
|
|
uint16_t nsegs;
|
|
void *loadsegs;
|
|
abi_ulong pt_dynamic_addr;
|
|
struct image_info *other_info;
|
|
#endif
|
|
};
|
|
|
|
#ifdef TARGET_I386
|
|
/* Information about the current linux thread */
|
|
struct vm86_saved_state {
|
|
uint32_t eax; /* return code */
|
|
uint32_t ebx;
|
|
uint32_t ecx;
|
|
uint32_t edx;
|
|
uint32_t esi;
|
|
uint32_t edi;
|
|
uint32_t ebp;
|
|
uint32_t esp;
|
|
uint32_t eflags;
|
|
uint32_t eip;
|
|
uint16_t cs, ss, ds, es, fs, gs;
|
|
};
|
|
#endif
|
|
|
|
#if defined(TARGET_ARM) && defined(TARGET_ABI32)
|
|
/* FPU emulator */
|
|
#include "nwfpe/fpa11.h"
|
|
#endif
|
|
|
|
#define MAX_SIGQUEUE_SIZE 1024
|
|
|
|
struct sigqueue {
|
|
struct sigqueue *next;
|
|
target_siginfo_t info;
|
|
};
|
|
|
|
struct emulated_sigtable {
|
|
int pending; /* true if signal is pending */
|
|
struct sigqueue *first;
|
|
struct sigqueue info; /* in order to always have memory for the
|
|
first signal, we put it here */
|
|
};
|
|
|
|
/* NOTE: we force a big alignment so that the stack stored after is
|
|
aligned too */
|
|
typedef struct TaskState {
|
|
pid_t ts_tid; /* tid (or pid) of this task */
|
|
#ifdef TARGET_ARM
|
|
# ifdef TARGET_ABI32
|
|
/* FPA state */
|
|
FPA11 fpa;
|
|
# endif
|
|
int swi_errno;
|
|
#endif
|
|
#ifdef TARGET_UNICORE32
|
|
int swi_errno;
|
|
#endif
|
|
#if defined(TARGET_I386) && !defined(TARGET_X86_64)
|
|
abi_ulong target_v86;
|
|
struct vm86_saved_state vm86_saved_regs;
|
|
struct target_vm86plus_struct vm86plus;
|
|
uint32_t v86flags;
|
|
uint32_t v86mask;
|
|
#endif
|
|
abi_ulong child_tidptr;
|
|
#ifdef TARGET_M68K
|
|
int sim_syscalls;
|
|
abi_ulong tp_value;
|
|
#endif
|
|
#if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32)
|
|
/* Extra fields for semihosted binaries. */
|
|
uint32_t heap_base;
|
|
uint32_t heap_limit;
|
|
#endif
|
|
uint32_t stack_base;
|
|
int used; /* non zero if used */
|
|
struct image_info *info;
|
|
struct linux_binprm *bprm;
|
|
|
|
struct emulated_sigtable sigtab[TARGET_NSIG];
|
|
struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
|
|
struct sigqueue *first_free; /* first free siginfo queue entry */
|
|
int signal_pending; /* non zero if a signal may be pending */
|
|
} __attribute__((aligned(16))) TaskState;
|
|
|
|
extern char *exec_path;
|
|
void init_task_state(TaskState *ts);
|
|
void task_settid(TaskState *);
|
|
void stop_all_tasks(void);
|
|
extern const char *qemu_uname_release;
|
|
extern unsigned long mmap_min_addr;
|
|
|
|
/* ??? See if we can avoid exposing so much of the loader internals. */
|
|
/*
|
|
* MAX_ARG_PAGES defines the number of pages allocated for arguments
|
|
* and envelope for the new program. 32 should suffice, this gives
|
|
* a maximum env+arg of 128kB w/4KB pages!
|
|
*/
|
|
#define MAX_ARG_PAGES 33
|
|
|
|
/* Read a good amount of data initially, to hopefully get all the
|
|
program headers loaded. */
|
|
#define BPRM_BUF_SIZE 1024
|
|
|
|
/*
|
|
* This structure is used to hold the arguments that are
|
|
* used when loading binaries.
|
|
*/
|
|
struct linux_binprm {
|
|
char buf[BPRM_BUF_SIZE] __attribute__((aligned));
|
|
void *page[MAX_ARG_PAGES];
|
|
abi_ulong p;
|
|
int fd;
|
|
int e_uid, e_gid;
|
|
int argc, envc;
|
|
char **argv;
|
|
char **envp;
|
|
char * filename; /* Name of binary */
|
|
int (*core_dump)(int, const CPUArchState *); /* coredump routine */
|
|
};
|
|
|
|
void do_init_thread(struct target_pt_regs *regs, struct image_info *infop);
|
|
abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
|
|
abi_ulong stringp, int push_ptr);
|
|
int loader_exec(const char * filename, char ** argv, char ** envp,
|
|
struct target_pt_regs * regs, struct image_info *infop,
|
|
struct linux_binprm *);
|
|
|
|
int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
|
|
struct image_info * info);
|
|
int load_flt_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
|
|
struct image_info * info);
|
|
|
|
abi_long memcpy_to_target(abi_ulong dest, const void *src,
|
|
unsigned long len);
|
|
void target_set_brk(abi_ulong new_brk);
|
|
abi_long do_brk(abi_ulong new_brk);
|
|
void syscall_init(void);
|
|
abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
|
|
abi_long arg2, abi_long arg3, abi_long arg4,
|
|
abi_long arg5, abi_long arg6, abi_long arg7,
|
|
abi_long arg8);
|
|
void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
|
|
extern THREAD CPUState *thread_cpu;
|
|
void cpu_loop(CPUArchState *env);
|
|
char *target_strerror(int err);
|
|
int get_osversion(void);
|
|
void init_qemu_uname_release(void);
|
|
void fork_start(void);
|
|
void fork_end(int child);
|
|
|
|
/* Creates the initial guest address space in the host memory space using
|
|
* the given host start address hint and size. The guest_start parameter
|
|
* specifies the start address of the guest space. guest_base will be the
|
|
* difference between the host start address computed by this function and
|
|
* guest_start. If fixed is specified, then the mapped address space must
|
|
* start at host_start. The real start address of the mapped memory space is
|
|
* returned or -1 if there was an error.
|
|
*/
|
|
unsigned long init_guest_space(unsigned long host_start,
|
|
unsigned long host_size,
|
|
unsigned long guest_start,
|
|
bool fixed);
|
|
|
|
#include "qemu/log.h"
|
|
|
|
/* syscall.c */
|
|
int host_to_target_waitstatus(int status);
|
|
|
|
/* strace.c */
|
|
void print_syscall(int num,
|
|
abi_long arg1, abi_long arg2, abi_long arg3,
|
|
abi_long arg4, abi_long arg5, abi_long arg6);
|
|
void print_syscall_ret(int num, abi_long arg1);
|
|
extern int do_strace;
|
|
|
|
/* signal.c */
|
|
void process_pending_signals(CPUArchState *cpu_env);
|
|
void signal_init(void);
|
|
int queue_signal(CPUArchState *env, int sig, target_siginfo_t *info);
|
|
void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
|
|
void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo);
|
|
int target_to_host_signal(int sig);
|
|
int host_to_target_signal(int sig);
|
|
long do_sigreturn(CPUArchState *env);
|
|
long do_rt_sigreturn(CPUArchState *env);
|
|
abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
|
|
|
|
#ifdef TARGET_I386
|
|
/* vm86.c */
|
|
void save_v86_state(CPUX86State *env);
|
|
void handle_vm86_trap(CPUX86State *env, int trapno);
|
|
void handle_vm86_fault(CPUX86State *env);
|
|
int do_vm86(CPUX86State *env, long subfunction, abi_ulong v86_addr);
|
|
#elif defined(TARGET_SPARC64)
|
|
void sparc64_set_context(CPUSPARCState *env);
|
|
void sparc64_get_context(CPUSPARCState *env);
|
|
#endif
|
|
|
|
/* mmap.c */
|
|
int target_mprotect(abi_ulong start, abi_ulong len, int prot);
|
|
abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
|
|
int flags, int fd, abi_ulong offset);
|
|
int target_munmap(abi_ulong start, abi_ulong len);
|
|
abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
|
|
abi_ulong new_size, unsigned long flags,
|
|
abi_ulong new_addr);
|
|
int target_msync(abi_ulong start, abi_ulong len, int flags);
|
|
extern unsigned long last_brk;
|
|
extern abi_ulong mmap_next_start;
|
|
void mmap_lock(void);
|
|
void mmap_unlock(void);
|
|
abi_ulong mmap_find_vma(abi_ulong, abi_ulong);
|
|
void cpu_list_lock(void);
|
|
void cpu_list_unlock(void);
|
|
void mmap_fork_start(void);
|
|
void mmap_fork_end(int child);
|
|
|
|
/* main.c */
|
|
extern unsigned long guest_stack_size;
|
|
|
|
/* user access */
|
|
|
|
#define VERIFY_READ 0
|
|
#define VERIFY_WRITE 1 /* implies read access */
|
|
|
|
static inline int access_ok(int type, abi_ulong addr, abi_ulong size)
|
|
{
|
|
return page_check_range((target_ulong)addr, size,
|
|
(type == VERIFY_READ) ? PAGE_READ : (PAGE_READ | PAGE_WRITE)) == 0;
|
|
}
|
|
|
|
/* NOTE __get_user and __put_user use host pointers and don't check access.
|
|
These are usually used to access struct data members once the struct has
|
|
been locked - usually with lock_user_struct. */
|
|
|
|
/* Tricky points:
|
|
- Use __builtin_choose_expr to avoid type promotion from ?:,
|
|
- Invalid sizes result in a compile time error stemming from
|
|
the fact that abort has no parameters.
|
|
- It's easier to use the endian-specific unaligned load/store
|
|
functions than host-endian unaligned load/store plus tswapN. */
|
|
|
|
#define __put_user_e(x, hptr, e) \
|
|
(__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \
|
|
__builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \
|
|
__builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \
|
|
__builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \
|
|
((hptr), (x)), 0)
|
|
|
|
#define __get_user_e(x, hptr, e) \
|
|
((x) = (typeof(*hptr))( \
|
|
__builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \
|
|
__builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \
|
|
__builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \
|
|
__builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \
|
|
(hptr)), 0)
|
|
|
|
#ifdef TARGET_WORDS_BIGENDIAN
|
|
# define __put_user(x, hptr) __put_user_e(x, hptr, be)
|
|
# define __get_user(x, hptr) __get_user_e(x, hptr, be)
|
|
#else
|
|
# define __put_user(x, hptr) __put_user_e(x, hptr, le)
|
|
# define __get_user(x, hptr) __get_user_e(x, hptr, le)
|
|
#endif
|
|
|
|
/* put_user()/get_user() take a guest address and check access */
|
|
/* These are usually used to access an atomic data type, such as an int,
|
|
* that has been passed by address. These internally perform locking
|
|
* and unlocking on the data type.
|
|
*/
|
|
#define put_user(x, gaddr, target_type) \
|
|
({ \
|
|
abi_ulong __gaddr = (gaddr); \
|
|
target_type *__hptr; \
|
|
abi_long __ret; \
|
|
if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
|
|
__ret = __put_user((x), __hptr); \
|
|
unlock_user(__hptr, __gaddr, sizeof(target_type)); \
|
|
} else \
|
|
__ret = -TARGET_EFAULT; \
|
|
__ret; \
|
|
})
|
|
|
|
#define get_user(x, gaddr, target_type) \
|
|
({ \
|
|
abi_ulong __gaddr = (gaddr); \
|
|
target_type *__hptr; \
|
|
abi_long __ret; \
|
|
if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
|
|
__ret = __get_user((x), __hptr); \
|
|
unlock_user(__hptr, __gaddr, 0); \
|
|
} else { \
|
|
/* avoid warning */ \
|
|
(x) = 0; \
|
|
__ret = -TARGET_EFAULT; \
|
|
} \
|
|
__ret; \
|
|
})
|
|
|
|
#define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
|
|
#define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
|
|
#define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
|
|
#define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
|
|
#define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
|
|
#define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
|
|
#define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
|
|
#define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
|
|
#define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
|
|
#define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
|
|
|
|
#define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
|
|
#define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
|
|
#define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
|
|
#define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
|
|
#define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
|
|
#define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
|
|
#define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
|
|
#define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
|
|
#define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
|
|
#define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
|
|
|
|
/* copy_from_user() and copy_to_user() are usually used to copy data
|
|
* buffers between the target and host. These internally perform
|
|
* locking/unlocking of the memory.
|
|
*/
|
|
abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
|
|
abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
|
|
|
|
/* Functions for accessing guest memory. The tget and tput functions
|
|
read/write single values, byteswapping as necessary. The lock_user
|
|
gets a pointer to a contiguous area of guest memory, but does not perform
|
|
and byteswapping. lock_user may return either a pointer to the guest
|
|
memory, or a temporary buffer. */
|
|
|
|
/* Lock an area of guest memory into the host. If copy is true then the
|
|
host area will have the same contents as the guest. */
|
|
static inline void *lock_user(int type, abi_ulong guest_addr, long len, int copy)
|
|
{
|
|
if (!access_ok(type, guest_addr, len))
|
|
return NULL;
|
|
#ifdef DEBUG_REMAP
|
|
{
|
|
void *addr;
|
|
addr = malloc(len);
|
|
if (copy)
|
|
memcpy(addr, g2h(guest_addr), len);
|
|
else
|
|
memset(addr, 0, len);
|
|
return addr;
|
|
}
|
|
#else
|
|
return g2h(guest_addr);
|
|
#endif
|
|
}
|
|
|
|
/* Unlock an area of guest memory. The first LEN bytes must be
|
|
flushed back to guest memory. host_ptr = NULL is explicitly
|
|
allowed and does nothing. */
|
|
static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
|
|
long len)
|
|
{
|
|
|
|
#ifdef DEBUG_REMAP
|
|
if (!host_ptr)
|
|
return;
|
|
if (host_ptr == g2h(guest_addr))
|
|
return;
|
|
if (len > 0)
|
|
memcpy(g2h(guest_addr), host_ptr, len);
|
|
free(host_ptr);
|
|
#endif
|
|
}
|
|
|
|
/* Return the length of a string in target memory or -TARGET_EFAULT if
|
|
access error. */
|
|
abi_long target_strlen(abi_ulong gaddr);
|
|
|
|
/* Like lock_user but for null terminated strings. */
|
|
static inline void *lock_user_string(abi_ulong guest_addr)
|
|
{
|
|
abi_long len;
|
|
len = target_strlen(guest_addr);
|
|
if (len < 0)
|
|
return NULL;
|
|
return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
|
|
}
|
|
|
|
/* Helper macros for locking/ulocking a target struct. */
|
|
#define lock_user_struct(type, host_ptr, guest_addr, copy) \
|
|
(host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
|
|
#define unlock_user_struct(host_ptr, guest_addr, copy) \
|
|
unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
|
|
|
|
#include <pthread.h>
|
|
|
|
/* Include target-specific struct and function definitions;
|
|
* they may need access to the target-independent structures
|
|
* above, so include them last.
|
|
*/
|
|
#include "target_cpu.h"
|
|
#include "target_signal.h"
|
|
|
|
#endif /* QEMU_H */
|