blob: 8012cc2f5b866fde4ce62d8dea969cfe5e7a02b4 [file] [log] [blame]
bellarde88de092005-02-07 12:35:39 +00001#ifndef QEMU_H
2#define QEMU_H
bellard31e31b82003-02-18 22:55:36 +00003
bellard9de5e442003-03-23 16:49:39 +00004#include <signal.h>
bellardedf779f2004-02-22 13:40:13 +00005#include <string.h>
bellard9de5e442003-03-23 16:49:39 +00006
bellard6180a182003-09-30 21:04:53 +00007#include "cpu.h"
Paolo Bonzinif08b6172014-03-28 19:42:10 +01008#include "exec/cpu_ldst.h"
blueswir1992f48a2007-10-14 16:27:31 +00009
balrog06177d32007-12-24 13:47:52 +000010#undef DEBUG_REMAP
11#ifdef DEBUG_REMAP
12#include <stdlib.h>
13#endif /* DEBUG_REMAP */
14
Paolo Bonzini022c62c2012-12-17 18:19:49 +010015#include "exec/user/abitypes.h"
blueswir1992f48a2007-10-14 16:27:31 +000016
Paolo Bonzini022c62c2012-12-17 18:19:49 +010017#include "exec/user/thunk.h"
blueswir1992f48a2007-10-14 16:27:31 +000018#include "syscall_defs.h"
bellard6180a182003-09-30 21:04:53 +000019#include "syscall.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010020#include "exec/gdbstub.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010021#include "qemu/queue.h"
bellard66fb9762003-03-23 01:06:05 +000022
pbrookd5975362008-06-07 20:50:51 +000023#define THREAD __thread
pbrookd5975362008-06-07 20:50:51 +000024
bellard31e31b82003-02-18 22:55:36 +000025/* This struct is used to hold certain information about the image.
26 * Basically, it replicates in user space what would be certain
27 * task_struct fields in the kernel
28 */
29struct image_info {
Richard Henderson9955ffa2010-07-27 10:25:30 -070030 abi_ulong load_bias;
blueswir1992f48a2007-10-14 16:27:31 +000031 abi_ulong load_addr;
32 abi_ulong start_code;
33 abi_ulong end_code;
34 abi_ulong start_data;
35 abi_ulong end_data;
36 abi_ulong start_brk;
37 abi_ulong brk;
38 abi_ulong start_mmap;
39 abi_ulong mmap;
40 abi_ulong rss;
41 abi_ulong start_stack;
Paul Brook97374d32010-06-16 13:03:51 +010042 abi_ulong stack_limit;
blueswir1992f48a2007-10-14 16:27:31 +000043 abi_ulong entry;
44 abi_ulong code_offset;
45 abi_ulong data_offset;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +030046 abi_ulong saved_auxv;
Alexander Graf125b0f52012-01-28 21:12:14 +020047 abi_ulong auxv_len;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +030048 abi_ulong arg_start;
49 abi_ulong arg_end;
Paul Brookd8fd2952012-03-30 18:02:50 +010050 uint32_t elf_flags;
bellard31e31b82003-02-18 22:55:36 +000051 int personality;
Mike Frysinger1af02e82011-02-07 01:05:50 -050052#ifdef CONFIG_USE_FDPIC
53 abi_ulong loadmap_addr;
54 uint16_t nsegs;
55 void *loadsegs;
56 abi_ulong pt_dynamic_addr;
57 struct image_info *other_info;
58#endif
bellard31e31b82003-02-18 22:55:36 +000059};
60
bellardb346ff42003-06-15 20:05:50 +000061#ifdef TARGET_I386
bellard851e67a2003-03-29 16:53:14 +000062/* Information about the current linux thread */
63struct vm86_saved_state {
64 uint32_t eax; /* return code */
65 uint32_t ebx;
66 uint32_t ecx;
67 uint32_t edx;
68 uint32_t esi;
69 uint32_t edi;
70 uint32_t ebp;
71 uint32_t esp;
72 uint32_t eflags;
73 uint32_t eip;
74 uint16_t cs, ss, ds, es, fs, gs;
75};
bellardb346ff42003-06-15 20:05:50 +000076#endif
bellard851e67a2003-03-29 16:53:14 +000077
Peter Maydell848d72c2013-09-03 20:12:17 +010078#if defined(TARGET_ARM) && defined(TARGET_ABI32)
bellard28c4f362004-02-16 21:47:43 +000079/* FPU emulator */
80#include "nwfpe/fpa11.h"
bellard28c4f362004-02-16 21:47:43 +000081#endif
82
pbrook624f7972008-05-31 16:11:38 +000083#define MAX_SIGQUEUE_SIZE 1024
84
85struct sigqueue {
86 struct sigqueue *next;
Anthony Liguoric227f092009-10-01 16:12:16 -050087 target_siginfo_t info;
pbrook624f7972008-05-31 16:11:38 +000088};
89
90struct emulated_sigtable {
91 int pending; /* true if signal is pending */
92 struct sigqueue *first;
93 struct sigqueue info; /* in order to always have memory for the
94 first signal, we put it here */
95};
96
bellard851e67a2003-03-29 16:53:14 +000097/* NOTE: we force a big alignment so that the stack stored after is
98 aligned too */
99typedef struct TaskState {
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300100 pid_t ts_tid; /* tid (or pid) of this task */
bellard28c4f362004-02-16 21:47:43 +0000101#ifdef TARGET_ARM
Peter Maydell848d72c2013-09-03 20:12:17 +0100102# ifdef TARGET_ABI32
bellard28c4f362004-02-16 21:47:43 +0000103 /* FPA state */
104 FPA11 fpa;
Peter Maydell848d72c2013-09-03 20:12:17 +0100105# endif
bellarda4f81972005-04-23 18:25:41 +0000106 int swi_errno;
bellard28c4f362004-02-16 21:47:43 +0000107#endif
Guan Xuetaod2fbca92011-04-12 16:27:03 +0800108#ifdef TARGET_UNICORE32
109 int swi_errno;
110#endif
j_mayer84409dd2007-04-06 08:56:50 +0000111#if defined(TARGET_I386) && !defined(TARGET_X86_64)
blueswir1992f48a2007-10-14 16:27:31 +0000112 abi_ulong target_v86;
bellard851e67a2003-03-29 16:53:14 +0000113 struct vm86_saved_state vm86_saved_regs;
bellardb333af02003-05-14 21:48:51 +0000114 struct target_vm86plus_struct vm86plus;
bellard631271d2003-05-10 13:14:52 +0000115 uint32_t v86flags;
116 uint32_t v86mask;
bellardb346ff42003-06-15 20:05:50 +0000117#endif
pbrookc2764712009-03-07 15:24:59 +0000118 abi_ulong child_tidptr;
pbrooke6e59062006-10-22 00:18:54 +0000119#ifdef TARGET_M68K
120 int sim_syscalls;
Peter Maydell1ccd9372013-07-16 18:44:55 +0100121 abi_ulong tp_value;
pbrooke6e59062006-10-22 00:18:54 +0000122#endif
Guan Xuetaod2fbca92011-04-12 16:27:03 +0800123#if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32)
pbrooka87295e2007-05-26 15:09:38 +0000124 /* Extra fields for semihosted binaries. */
pbrooka87295e2007-05-26 15:09:38 +0000125 uint32_t heap_base;
126 uint32_t heap_limit;
127#endif
Riku Voipiod0fd11f2012-01-28 22:00:17 +0200128 uint32_t stack_base;
bellard851e67a2003-03-29 16:53:14 +0000129 int used; /* non zero if used */
Peter Maydella7ec0f92014-03-14 14:36:56 +0000130 bool sigsegv_blocked; /* SIGSEGV blocked by guest */
pbrook978efd62006-06-17 18:30:42 +0000131 struct image_info *info;
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300132 struct linux_binprm *bprm;
pbrook624f7972008-05-31 16:11:38 +0000133
134 struct emulated_sigtable sigtab[TARGET_NSIG];
135 struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
136 struct sigqueue *first_free; /* first free siginfo queue entry */
137 int signal_pending; /* non zero if a signal may be pending */
bellard851e67a2003-03-29 16:53:14 +0000138} __attribute__((aligned(16))) TaskState;
139
aurel32d088d662009-01-30 20:09:01 +0000140extern char *exec_path;
pbrook624f7972008-05-31 16:11:38 +0000141void init_task_state(TaskState *ts);
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300142void task_settid(TaskState *);
143void stop_all_tasks(void);
pbrookc5937222006-05-14 11:30:38 +0000144extern const char *qemu_uname_release;
Paul Brook379f6692009-07-17 12:48:08 +0100145extern unsigned long mmap_min_addr;
bellard851e67a2003-03-29 16:53:14 +0000146
pbrooke5fe0c52006-06-11 13:32:59 +0000147/* ??? See if we can avoid exposing so much of the loader internals. */
148/*
149 * MAX_ARG_PAGES defines the number of pages allocated for arguments
150 * and envelope for the new program. 32 should suffice, this gives
151 * a maximum env+arg of 128kB w/4KB pages!
152 */
Arnaud Patardfd4d81d2009-06-19 10:39:36 +0300153#define MAX_ARG_PAGES 33
pbrooke5fe0c52006-06-11 13:32:59 +0000154
Richard Henderson9955ffa2010-07-27 10:25:30 -0700155/* Read a good amount of data initially, to hopefully get all the
156 program headers loaded. */
157#define BPRM_BUF_SIZE 1024
158
pbrooke5fe0c52006-06-11 13:32:59 +0000159/*
ths5fafdf22007-09-16 21:08:06 +0000160 * This structure is used to hold the arguments that are
pbrooke5fe0c52006-06-11 13:32:59 +0000161 * used when loading binaries.
162 */
163struct linux_binprm {
Richard Henderson9955ffa2010-07-27 10:25:30 -0700164 char buf[BPRM_BUF_SIZE] __attribute__((aligned));
pbrooke5fe0c52006-06-11 13:32:59 +0000165 void *page[MAX_ARG_PAGES];
blueswir1992f48a2007-10-14 16:27:31 +0000166 abi_ulong p;
pbrooke5fe0c52006-06-11 13:32:59 +0000167 int fd;
168 int e_uid, e_gid;
169 int argc, envc;
170 char **argv;
171 char **envp;
172 char * filename; /* Name of binary */
Andreas Färber9349b4f2012-03-14 01:38:32 +0100173 int (*core_dump)(int, const CPUArchState *); /* coredump routine */
pbrooke5fe0c52006-06-11 13:32:59 +0000174};
175
176void do_init_thread(struct target_pt_regs *regs, struct image_info *infop);
blueswir1992f48a2007-10-14 16:27:31 +0000177abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
178 abi_ulong stringp, int push_ptr);
Laurent Vivier03cfd8f2013-08-30 01:46:44 +0200179int loader_exec(int fdexec, const char *filename, char **argv, char **envp,
Mika Westerbergedf8e2a2009-04-07 09:57:11 +0300180 struct target_pt_regs * regs, struct image_info *infop,
181 struct linux_binprm *);
bellard31e31b82003-02-18 22:55:36 +0000182
Will Newtonf0116c52014-01-09 09:10:50 +0000183int load_elf_binary(struct linux_binprm *bprm, struct image_info *info);
184int load_flt_binary(struct linux_binprm *bprm, struct image_info *info);
pbrooke5fe0c52006-06-11 13:32:59 +0000185
bellard579a97f2007-11-11 14:26:47 +0000186abi_long memcpy_to_target(abi_ulong dest, const void *src,
187 unsigned long len);
blueswir1992f48a2007-10-14 16:27:31 +0000188void target_set_brk(abi_ulong new_brk);
189abi_long do_brk(abi_ulong new_brk);
bellard31e31b82003-02-18 22:55:36 +0000190void syscall_init(void);
blueswir1992f48a2007-10-14 16:27:31 +0000191abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
192 abi_long arg2, abi_long arg3, abi_long arg4,
Peter Maydell5945cfc2011-06-16 17:37:13 +0100193 abi_long arg5, abi_long arg6, abi_long arg7,
194 abi_long arg8);
Stefan Weile5924d82010-09-23 21:28:03 +0200195void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
Andreas Färbera2247f82013-06-09 19:47:04 +0200196extern THREAD CPUState *thread_cpu;
Andreas Färber9349b4f2012-03-14 01:38:32 +0100197void cpu_loop(CPUArchState *env);
thsb92c47c2007-11-01 00:07:38 +0000198char *target_strerror(int err);
pbrooka745ec62008-05-06 15:36:17 +0000199int get_osversion(void);
Peter Maydell4a24a752013-09-03 20:12:20 +0100200void init_qemu_uname_release(void);
pbrookd5975362008-06-07 20:50:51 +0000201void fork_start(void);
202void fork_end(int child);
bellard6977fbf2003-04-29 20:39:23 +0000203
Meador Ingedce10402012-07-26 16:50:01 +0000204/* Creates the initial guest address space in the host memory space using
205 * the given host start address hint and size. The guest_start parameter
206 * specifies the start address of the guest space. guest_base will be the
207 * difference between the host start address computed by this function and
208 * guest_start. If fixed is specified, then the mapped address space must
209 * start at host_start. The real start address of the mapped memory space is
210 * returned or -1 if there was an error.
211 */
212unsigned long init_guest_space(unsigned long host_start,
213 unsigned long host_size,
214 unsigned long guest_start,
215 bool fixed);
216
Paolo Bonzini1de7afc2012-12-17 18:20:00 +0100217#include "qemu/log.h"
bellard631271d2003-05-10 13:14:52 +0000218
Richard Hendersona05c6402012-09-15 11:34:20 -0700219/* syscall.c */
220int host_to_target_waitstatus(int status);
221
thsb92c47c2007-11-01 00:07:38 +0000222/* strace.c */
223void print_syscall(int num,
bellardc16f9ed2007-11-11 17:23:29 +0000224 abi_long arg1, abi_long arg2, abi_long arg3,
225 abi_long arg4, abi_long arg5, abi_long arg6);
226void print_syscall_ret(int num, abi_long arg1);
thsb92c47c2007-11-01 00:07:38 +0000227extern int do_strace;
228
bellardb346ff42003-06-15 20:05:50 +0000229/* signal.c */
Andreas Färber9349b4f2012-03-14 01:38:32 +0100230void process_pending_signals(CPUArchState *cpu_env);
bellardb346ff42003-06-15 20:05:50 +0000231void signal_init(void);
Andreas Färber9349b4f2012-03-14 01:38:32 +0100232int queue_signal(CPUArchState *env, int sig, target_siginfo_t *info);
Anthony Liguoric227f092009-10-01 16:12:16 -0500233void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
234void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo);
pbrook4cb05962008-05-30 18:05:19 +0000235int target_to_host_signal(int sig);
pbrook1d9d8b52009-04-16 15:17:02 +0000236int host_to_target_signal(int sig);
Andreas Färber9349b4f2012-03-14 01:38:32 +0100237long do_sigreturn(CPUArchState *env);
238long do_rt_sigreturn(CPUArchState *env);
bellard579a97f2007-11-11 14:26:47 +0000239abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
Alex Barcelo1c275922014-03-14 14:36:55 +0000240int do_sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
bellardb346ff42003-06-15 20:05:50 +0000241
242#ifdef TARGET_I386
bellard631271d2003-05-10 13:14:52 +0000243/* vm86.c */
244void save_v86_state(CPUX86State *env);
bellard447db212003-05-10 15:10:36 +0000245void handle_vm86_trap(CPUX86State *env, int trapno);
bellard631271d2003-05-10 13:14:52 +0000246void handle_vm86_fault(CPUX86State *env);
blueswir1992f48a2007-10-14 16:27:31 +0000247int do_vm86(CPUX86State *env, long subfunction, abi_ulong v86_addr);
blueswir15bfb56b2007-10-05 17:01:51 +0000248#elif defined(TARGET_SPARC64)
249void sparc64_set_context(CPUSPARCState *env);
250void sparc64_get_context(CPUSPARCState *env);
bellardb346ff42003-06-15 20:05:50 +0000251#endif
bellard631271d2003-05-10 13:14:52 +0000252
bellard54936002003-05-13 00:25:15 +0000253/* mmap.c */
blueswir1992f48a2007-10-14 16:27:31 +0000254int target_mprotect(abi_ulong start, abi_ulong len, int prot);
255abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
256 int flags, int fd, abi_ulong offset);
257int target_munmap(abi_ulong start, abi_ulong len);
258abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
259 abi_ulong new_size, unsigned long flags,
260 abi_ulong new_addr);
261int target_msync(abi_ulong start, abi_ulong len, int flags);
pbrook07765902008-05-31 16:33:53 +0000262extern unsigned long last_brk;
Peter Maydell59e9d912012-03-08 14:40:33 +0000263extern abi_ulong mmap_next_start;
pbrookc8a706f2008-06-02 16:16:42 +0000264void mmap_lock(void);
265void mmap_unlock(void);
Riku Voipio9ad197d2009-04-21 17:23:23 +0300266abi_ulong mmap_find_vma(abi_ulong, abi_ulong);
pbrookc2764712009-03-07 15:24:59 +0000267void cpu_list_lock(void);
268void cpu_list_unlock(void);
pbrookd5975362008-06-07 20:50:51 +0000269void mmap_fork_start(void);
270void mmap_fork_end(int child);
bellard54936002003-05-13 00:25:15 +0000271
blueswir1440c7e82008-10-05 11:05:14 +0000272/* main.c */
Richard Henderson703e0e82010-03-19 14:21:13 -0700273extern unsigned long guest_stack_size;
blueswir1440c7e82008-10-05 11:05:14 +0000274
bellardedf779f2004-02-22 13:40:13 +0000275/* user access */
276
277#define VERIFY_READ 0
bellard579a97f2007-11-11 14:26:47 +0000278#define VERIFY_WRITE 1 /* implies read access */
bellardedf779f2004-02-22 13:40:13 +0000279
bellarddae32702007-11-14 10:51:00 +0000280static inline int access_ok(int type, abi_ulong addr, abi_ulong size)
281{
282 return page_check_range((target_ulong)addr, size,
283 (type == VERIFY_READ) ? PAGE_READ : (PAGE_READ | PAGE_WRITE)) == 0;
284}
bellardedf779f2004-02-22 13:40:13 +0000285
Richard Henderson658f2dc2013-01-04 16:39:31 -0800286/* NOTE __get_user and __put_user use host pointers and don't check access.
287 These are usually used to access struct data members once the struct has
288 been locked - usually with lock_user_struct. */
bellardedf779f2004-02-22 13:40:13 +0000289
Richard Henderson658f2dc2013-01-04 16:39:31 -0800290/* Tricky points:
291 - Use __builtin_choose_expr to avoid type promotion from ?:,
292 - Invalid sizes result in a compile time error stemming from
293 the fact that abort has no parameters.
294 - It's easier to use the endian-specific unaligned load/store
295 functions than host-endian unaligned load/store plus tswapN. */
296
297#define __put_user_e(x, hptr, e) \
298 (__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \
299 __builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \
300 __builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \
301 __builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \
Riku Voipioa42267e2014-04-22 15:40:50 +0300302 ((hptr), (x)), (void)0)
Richard Henderson658f2dc2013-01-04 16:39:31 -0800303
304#define __get_user_e(x, hptr, e) \
Peter Maydell0bc8ce92013-01-31 12:50:40 +0000305 ((x) = (typeof(*hptr))( \
Richard Henderson658f2dc2013-01-04 16:39:31 -0800306 __builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \
307 __builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \
308 __builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \
309 __builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \
Riku Voipioa42267e2014-04-22 15:40:50 +0300310 (hptr)), (void)0)
Richard Henderson658f2dc2013-01-04 16:39:31 -0800311
312#ifdef TARGET_WORDS_BIGENDIAN
313# define __put_user(x, hptr) __put_user_e(x, hptr, be)
314# define __get_user(x, hptr) __get_user_e(x, hptr, be)
315#else
316# define __put_user(x, hptr) __put_user_e(x, hptr, le)
317# define __get_user(x, hptr) __get_user_e(x, hptr, le)
318#endif
bellardedf779f2004-02-22 13:40:13 +0000319
bellard579a97f2007-11-11 14:26:47 +0000320/* put_user()/get_user() take a guest address and check access */
321/* These are usually used to access an atomic data type, such as an int,
322 * that has been passed by address. These internally perform locking
323 * and unlocking on the data type.
324 */
325#define put_user(x, gaddr, target_type) \
326({ \
327 abi_ulong __gaddr = (gaddr); \
328 target_type *__hptr; \
Riku Voipioa42267e2014-04-22 15:40:50 +0300329 abi_long __ret = 0; \
bellard579a97f2007-11-11 14:26:47 +0000330 if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
Riku Voipioa42267e2014-04-22 15:40:50 +0300331 __put_user((x), __hptr); \
bellard579a97f2007-11-11 14:26:47 +0000332 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
333 } else \
334 __ret = -TARGET_EFAULT; \
335 __ret; \
bellardedf779f2004-02-22 13:40:13 +0000336})
337
bellard579a97f2007-11-11 14:26:47 +0000338#define get_user(x, gaddr, target_type) \
339({ \
340 abi_ulong __gaddr = (gaddr); \
341 target_type *__hptr; \
Riku Voipioa42267e2014-04-22 15:40:50 +0300342 abi_long __ret = 0; \
bellard579a97f2007-11-11 14:26:47 +0000343 if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
Riku Voipioa42267e2014-04-22 15:40:50 +0300344 __get_user((x), __hptr); \
bellard579a97f2007-11-11 14:26:47 +0000345 unlock_user(__hptr, __gaddr, 0); \
bellard2f619692007-11-16 10:46:05 +0000346 } else { \
347 /* avoid warning */ \
348 (x) = 0; \
bellard579a97f2007-11-11 14:26:47 +0000349 __ret = -TARGET_EFAULT; \
bellard2f619692007-11-16 10:46:05 +0000350 } \
bellard579a97f2007-11-11 14:26:47 +0000351 __ret; \
bellardedf779f2004-02-22 13:40:13 +0000352})
353
bellard2f619692007-11-16 10:46:05 +0000354#define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
355#define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
356#define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
357#define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
358#define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
359#define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
360#define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
361#define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
362#define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
363#define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
364
365#define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
366#define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
367#define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
368#define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
369#define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
370#define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
371#define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
372#define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
373#define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
374#define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
375
bellard579a97f2007-11-11 14:26:47 +0000376/* copy_from_user() and copy_to_user() are usually used to copy data
377 * buffers between the target and host. These internally perform
378 * locking/unlocking of the memory.
379 */
380abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len);
381abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len);
382
pbrook53a59602006-03-25 19:31:22 +0000383/* Functions for accessing guest memory. The tget and tput functions
Stefan Weil6f20f552013-09-12 19:57:15 +0200384 read/write single values, byteswapping as necessary. The lock_user function
pbrook53a59602006-03-25 19:31:22 +0000385 gets a pointer to a contiguous area of guest memory, but does not perform
Stefan Weil6f20f552013-09-12 19:57:15 +0200386 any byteswapping. lock_user may return either a pointer to the guest
pbrook53a59602006-03-25 19:31:22 +0000387 memory, or a temporary buffer. */
388
389/* Lock an area of guest memory into the host. If copy is true then the
390 host area will have the same contents as the guest. */
bellard579a97f2007-11-11 14:26:47 +0000391static inline void *lock_user(int type, abi_ulong guest_addr, long len, int copy)
bellardedf779f2004-02-22 13:40:13 +0000392{
bellard579a97f2007-11-11 14:26:47 +0000393 if (!access_ok(type, guest_addr, len))
394 return NULL;
pbrook53a59602006-03-25 19:31:22 +0000395#ifdef DEBUG_REMAP
bellard579a97f2007-11-11 14:26:47 +0000396 {
397 void *addr;
398 addr = malloc(len);
399 if (copy)
400 memcpy(addr, g2h(guest_addr), len);
401 else
402 memset(addr, 0, len);
403 return addr;
404 }
pbrook53a59602006-03-25 19:31:22 +0000405#else
406 return g2h(guest_addr);
407#endif
bellardedf779f2004-02-22 13:40:13 +0000408}
409
bellard579a97f2007-11-11 14:26:47 +0000410/* Unlock an area of guest memory. The first LEN bytes must be
ths1235fc02008-06-03 19:51:57 +0000411 flushed back to guest memory. host_ptr = NULL is explicitly
bellard579a97f2007-11-11 14:26:47 +0000412 allowed and does nothing. */
413static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
blueswir1992f48a2007-10-14 16:27:31 +0000414 long len)
bellardedf779f2004-02-22 13:40:13 +0000415{
bellard579a97f2007-11-11 14:26:47 +0000416
pbrook53a59602006-03-25 19:31:22 +0000417#ifdef DEBUG_REMAP
bellard579a97f2007-11-11 14:26:47 +0000418 if (!host_ptr)
419 return;
420 if (host_ptr == g2h(guest_addr))
pbrook53a59602006-03-25 19:31:22 +0000421 return;
422 if (len > 0)
balrog06177d32007-12-24 13:47:52 +0000423 memcpy(g2h(guest_addr), host_ptr, len);
bellard579a97f2007-11-11 14:26:47 +0000424 free(host_ptr);
pbrook53a59602006-03-25 19:31:22 +0000425#endif
bellardedf779f2004-02-22 13:40:13 +0000426}
427
bellard579a97f2007-11-11 14:26:47 +0000428/* Return the length of a string in target memory or -TARGET_EFAULT if
429 access error. */
430abi_long target_strlen(abi_ulong gaddr);
bellardedf779f2004-02-22 13:40:13 +0000431
pbrook53a59602006-03-25 19:31:22 +0000432/* Like lock_user but for null terminated strings. */
blueswir1992f48a2007-10-14 16:27:31 +0000433static inline void *lock_user_string(abi_ulong guest_addr)
pbrook53a59602006-03-25 19:31:22 +0000434{
bellard579a97f2007-11-11 14:26:47 +0000435 abi_long len;
436 len = target_strlen(guest_addr);
437 if (len < 0)
438 return NULL;
439 return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
pbrook53a59602006-03-25 19:31:22 +0000440}
441
Stefan Weil41d1af42013-09-12 19:57:41 +0200442/* Helper macros for locking/unlocking a target struct. */
bellard579a97f2007-11-11 14:26:47 +0000443#define lock_user_struct(type, host_ptr, guest_addr, copy) \
444 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
445#define unlock_user_struct(host_ptr, guest_addr, copy) \
pbrook53a59602006-03-25 19:31:22 +0000446 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
447
pbrookc8a706f2008-06-02 16:16:42 +0000448#include <pthread.h>
pbrookc8a706f2008-06-02 16:16:42 +0000449
Peter Maydelldfeab062013-07-16 18:44:52 +0100450/* Include target-specific struct and function definitions;
451 * they may need access to the target-independent structures
452 * above, so include them last.
453 */
454#include "target_cpu.h"
455#include "target_signal.h"
Petar Jovanovic55a2b162013-10-30 14:46:31 +0100456#include "target_structs.h"
Peter Maydelldfeab062013-07-16 18:44:52 +0100457
bellarde88de092005-02-07 12:35:39 +0000458#endif /* QEMU_H */