12 #endif /* DEBUG_REMAP */
14 #include "exec/user/abitypes.h"
16 #include "exec/user/thunk.h"
17 #include "syscall_defs.h"
19 #include "exec/gdbstub.h"
20 #include "qemu/queue.h"
22 #if defined(CONFIG_USE_NPTL)
23 #define THREAD __thread
28 /* This struct is used to hold certain information about the image.
29 * Basically, it replicates in user space what would be certain
30 * task_struct fields in the kernel
44 abi_ulong start_stack
;
45 abi_ulong stack_limit
;
47 abi_ulong code_offset
;
48 abi_ulong data_offset
;
55 #ifdef CONFIG_USE_FDPIC
56 abi_ulong loadmap_addr
;
59 abi_ulong pt_dynamic_addr
;
60 struct image_info
*other_info
;
65 /* Information about the current linux thread */
66 struct vm86_saved_state
{
67 uint32_t eax
; /* return code */
77 uint16_t cs
, ss
, ds
, es
, fs
, gs
;
83 #include "nwfpe/fpa11.h"
86 #define MAX_SIGQUEUE_SIZE 1024
89 struct sigqueue
*next
;
90 target_siginfo_t info
;
93 struct emulated_sigtable
{
94 int pending
; /* true if signal is pending */
95 struct sigqueue
*first
;
96 struct sigqueue info
; /* in order to always have memory for the
97 first signal, we put it here */
100 /* NOTE: we force a big alignment so that the stack stored after is
102 typedef struct TaskState
{
103 pid_t ts_tid
; /* tid (or pid) of this task */
109 #ifdef TARGET_UNICORE32
112 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
113 abi_ulong target_v86
;
114 struct vm86_saved_state vm86_saved_regs
;
115 struct target_vm86plus_struct vm86plus
;
119 #ifdef CONFIG_USE_NPTL
120 abi_ulong child_tidptr
;
125 #if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32)
126 /* Extra fields for semihosted binaries. */
131 int used
; /* non zero if used */
132 struct image_info
*info
;
133 struct linux_binprm
*bprm
;
135 struct emulated_sigtable sigtab
[TARGET_NSIG
];
136 struct sigqueue sigqueue_table
[MAX_SIGQUEUE_SIZE
]; /* siginfo queue */
137 struct sigqueue
*first_free
; /* first free siginfo queue entry */
138 int signal_pending
; /* non zero if a signal may be pending */
139 } __attribute__((aligned(16))) TaskState
;
141 extern char *exec_path
;
142 void init_task_state(TaskState
*ts
);
143 void task_settid(TaskState
*);
144 void stop_all_tasks(void);
145 extern const char *qemu_uname_release
;
146 extern unsigned long mmap_min_addr
;
148 /* ??? See if we can avoid exposing so much of the loader internals. */
150 * MAX_ARG_PAGES defines the number of pages allocated for arguments
151 * and envelope for the new program. 32 should suffice, this gives
152 * a maximum env+arg of 128kB w/4KB pages!
154 #define MAX_ARG_PAGES 33
156 /* Read a good amount of data initially, to hopefully get all the
157 program headers loaded. */
158 #define BPRM_BUF_SIZE 1024
161 * This structure is used to hold the arguments that are
162 * used when loading binaries.
164 struct linux_binprm
{
165 char buf
[BPRM_BUF_SIZE
] __attribute__((aligned
));
166 void *page
[MAX_ARG_PAGES
];
173 char * filename
; /* Name of binary */
174 int (*core_dump
)(int, const CPUArchState
*); /* coredump routine */
177 void do_init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
);
178 abi_ulong
loader_build_argptr(int envc
, int argc
, abi_ulong sp
,
179 abi_ulong stringp
, int push_ptr
);
180 int loader_exec(const char * filename
, char ** argv
, char ** envp
,
181 struct target_pt_regs
* regs
, struct image_info
*infop
,
182 struct linux_binprm
*);
184 int load_elf_binary(struct linux_binprm
* bprm
, struct target_pt_regs
* regs
,
185 struct image_info
* info
);
186 int load_flt_binary(struct linux_binprm
* bprm
, struct target_pt_regs
* regs
,
187 struct image_info
* info
);
189 abi_long
memcpy_to_target(abi_ulong dest
, const void *src
,
191 void target_set_brk(abi_ulong new_brk
);
192 abi_long
do_brk(abi_ulong new_brk
);
193 void syscall_init(void);
194 abi_long
do_syscall(void *cpu_env
, int num
, abi_long arg1
,
195 abi_long arg2
, abi_long arg3
, abi_long arg4
,
196 abi_long arg5
, abi_long arg6
, abi_long arg7
,
198 void gemu_log(const char *fmt
, ...) GCC_FMT_ATTR(1, 2);
199 extern THREAD CPUState
*thread_cpu
;
200 void cpu_loop(CPUArchState
*env
);
201 char *target_strerror(int err
);
202 int get_osversion(void);
203 void fork_start(void);
204 void fork_end(int child
);
206 /* Creates the initial guest address space in the host memory space using
207 * the given host start address hint and size. The guest_start parameter
208 * specifies the start address of the guest space. guest_base will be the
209 * difference between the host start address computed by this function and
210 * guest_start. If fixed is specified, then the mapped address space must
211 * start at host_start. The real start address of the mapped memory space is
212 * returned or -1 if there was an error.
214 unsigned long init_guest_space(unsigned long host_start
,
215 unsigned long host_size
,
216 unsigned long guest_start
,
219 #include "qemu/log.h"
222 int host_to_target_waitstatus(int status
);
225 void print_syscall(int num
,
226 abi_long arg1
, abi_long arg2
, abi_long arg3
,
227 abi_long arg4
, abi_long arg5
, abi_long arg6
);
228 void print_syscall_ret(int num
, abi_long arg1
);
229 extern int do_strace
;
232 void process_pending_signals(CPUArchState
*cpu_env
);
233 void signal_init(void);
234 int queue_signal(CPUArchState
*env
, int sig
, target_siginfo_t
*info
);
235 void host_to_target_siginfo(target_siginfo_t
*tinfo
, const siginfo_t
*info
);
236 void target_to_host_siginfo(siginfo_t
*info
, const target_siginfo_t
*tinfo
);
237 int target_to_host_signal(int sig
);
238 int host_to_target_signal(int sig
);
239 long do_sigreturn(CPUArchState
*env
);
240 long do_rt_sigreturn(CPUArchState
*env
);
241 abi_long
do_sigaltstack(abi_ulong uss_addr
, abi_ulong uoss_addr
, abi_ulong sp
);
245 void save_v86_state(CPUX86State
*env
);
246 void handle_vm86_trap(CPUX86State
*env
, int trapno
);
247 void handle_vm86_fault(CPUX86State
*env
);
248 int do_vm86(CPUX86State
*env
, long subfunction
, abi_ulong v86_addr
);
249 #elif defined(TARGET_SPARC64)
250 void sparc64_set_context(CPUSPARCState
*env
);
251 void sparc64_get_context(CPUSPARCState
*env
);
255 int target_mprotect(abi_ulong start
, abi_ulong len
, int prot
);
256 abi_long
target_mmap(abi_ulong start
, abi_ulong len
, int prot
,
257 int flags
, int fd
, abi_ulong offset
);
258 int target_munmap(abi_ulong start
, abi_ulong len
);
259 abi_long
target_mremap(abi_ulong old_addr
, abi_ulong old_size
,
260 abi_ulong new_size
, unsigned long flags
,
262 int target_msync(abi_ulong start
, abi_ulong len
, int flags
);
263 extern unsigned long last_brk
;
264 extern abi_ulong mmap_next_start
;
265 void mmap_lock(void);
266 void mmap_unlock(void);
267 abi_ulong
mmap_find_vma(abi_ulong
, abi_ulong
);
268 void cpu_list_lock(void);
269 void cpu_list_unlock(void);
270 #if defined(CONFIG_USE_NPTL)
271 void mmap_fork_start(void);
272 void mmap_fork_end(int child
);
276 extern unsigned long guest_stack_size
;
280 #define VERIFY_READ 0
281 #define VERIFY_WRITE 1 /* implies read access */
283 static inline int access_ok(int type
, abi_ulong addr
, abi_ulong size
)
285 return page_check_range((target_ulong
)addr
, size
,
286 (type
== VERIFY_READ
) ? PAGE_READ
: (PAGE_READ
| PAGE_WRITE
)) == 0;
289 /* NOTE __get_user and __put_user use host pointers and don't check access.
290 These are usually used to access struct data members once the struct has
291 been locked - usually with lock_user_struct. */
294 - Use __builtin_choose_expr to avoid type promotion from ?:,
295 - Invalid sizes result in a compile time error stemming from
296 the fact that abort has no parameters.
297 - It's easier to use the endian-specific unaligned load/store
298 functions than host-endian unaligned load/store plus tswapN. */
300 #define __put_user_e(x, hptr, e) \
301 (__builtin_choose_expr(sizeof(*(hptr)) == 1, stb_p, \
302 __builtin_choose_expr(sizeof(*(hptr)) == 2, stw_##e##_p, \
303 __builtin_choose_expr(sizeof(*(hptr)) == 4, stl_##e##_p, \
304 __builtin_choose_expr(sizeof(*(hptr)) == 8, stq_##e##_p, abort)))) \
307 #define __get_user_e(x, hptr, e) \
308 ((x) = (typeof(*hptr))( \
309 __builtin_choose_expr(sizeof(*(hptr)) == 1, ldub_p, \
310 __builtin_choose_expr(sizeof(*(hptr)) == 2, lduw_##e##_p, \
311 __builtin_choose_expr(sizeof(*(hptr)) == 4, ldl_##e##_p, \
312 __builtin_choose_expr(sizeof(*(hptr)) == 8, ldq_##e##_p, abort)))) \
315 #ifdef TARGET_WORDS_BIGENDIAN
316 # define __put_user(x, hptr) __put_user_e(x, hptr, be)
317 # define __get_user(x, hptr) __get_user_e(x, hptr, be)
319 # define __put_user(x, hptr) __put_user_e(x, hptr, le)
320 # define __get_user(x, hptr) __get_user_e(x, hptr, le)
323 /* put_user()/get_user() take a guest address and check access */
324 /* These are usually used to access an atomic data type, such as an int,
325 * that has been passed by address. These internally perform locking
326 * and unlocking on the data type.
328 #define put_user(x, gaddr, target_type) \
330 abi_ulong __gaddr = (gaddr); \
331 target_type *__hptr; \
333 if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
334 __ret = __put_user((x), __hptr); \
335 unlock_user(__hptr, __gaddr, sizeof(target_type)); \
337 __ret = -TARGET_EFAULT; \
341 #define get_user(x, gaddr, target_type) \
343 abi_ulong __gaddr = (gaddr); \
344 target_type *__hptr; \
346 if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
347 __ret = __get_user((x), __hptr); \
348 unlock_user(__hptr, __gaddr, 0); \
350 /* avoid warning */ \
352 __ret = -TARGET_EFAULT; \
357 #define put_user_ual(x, gaddr) put_user((x), (gaddr), abi_ulong)
358 #define put_user_sal(x, gaddr) put_user((x), (gaddr), abi_long)
359 #define put_user_u64(x, gaddr) put_user((x), (gaddr), uint64_t)
360 #define put_user_s64(x, gaddr) put_user((x), (gaddr), int64_t)
361 #define put_user_u32(x, gaddr) put_user((x), (gaddr), uint32_t)
362 #define put_user_s32(x, gaddr) put_user((x), (gaddr), int32_t)
363 #define put_user_u16(x, gaddr) put_user((x), (gaddr), uint16_t)
364 #define put_user_s16(x, gaddr) put_user((x), (gaddr), int16_t)
365 #define put_user_u8(x, gaddr) put_user((x), (gaddr), uint8_t)
366 #define put_user_s8(x, gaddr) put_user((x), (gaddr), int8_t)
368 #define get_user_ual(x, gaddr) get_user((x), (gaddr), abi_ulong)
369 #define get_user_sal(x, gaddr) get_user((x), (gaddr), abi_long)
370 #define get_user_u64(x, gaddr) get_user((x), (gaddr), uint64_t)
371 #define get_user_s64(x, gaddr) get_user((x), (gaddr), int64_t)
372 #define get_user_u32(x, gaddr) get_user((x), (gaddr), uint32_t)
373 #define get_user_s32(x, gaddr) get_user((x), (gaddr), int32_t)
374 #define get_user_u16(x, gaddr) get_user((x), (gaddr), uint16_t)
375 #define get_user_s16(x, gaddr) get_user((x), (gaddr), int16_t)
376 #define get_user_u8(x, gaddr) get_user((x), (gaddr), uint8_t)
377 #define get_user_s8(x, gaddr) get_user((x), (gaddr), int8_t)
379 /* copy_from_user() and copy_to_user() are usually used to copy data
380 * buffers between the target and host. These internally perform
381 * locking/unlocking of the memory.
383 abi_long
copy_from_user(void *hptr
, abi_ulong gaddr
, size_t len
);
384 abi_long
copy_to_user(abi_ulong gaddr
, void *hptr
, size_t len
);
386 /* Functions for accessing guest memory. The tget and tput functions
387 read/write single values, byteswapping as necessary. The lock_user
388 gets a pointer to a contiguous area of guest memory, but does not perform
389 and byteswapping. lock_user may return either a pointer to the guest
390 memory, or a temporary buffer. */
392 /* Lock an area of guest memory into the host. If copy is true then the
393 host area will have the same contents as the guest. */
394 static inline void *lock_user(int type
, abi_ulong guest_addr
, long len
, int copy
)
396 if (!access_ok(type
, guest_addr
, len
))
403 memcpy(addr
, g2h(guest_addr
), len
);
405 memset(addr
, 0, len
);
409 return g2h(guest_addr
);
413 /* Unlock an area of guest memory. The first LEN bytes must be
414 flushed back to guest memory. host_ptr = NULL is explicitly
415 allowed and does nothing. */
416 static inline void unlock_user(void *host_ptr
, abi_ulong guest_addr
,
423 if (host_ptr
== g2h(guest_addr
))
426 memcpy(g2h(guest_addr
), host_ptr
, len
);
431 /* Return the length of a string in target memory or -TARGET_EFAULT if
433 abi_long
target_strlen(abi_ulong gaddr
);
435 /* Like lock_user but for null terminated strings. */
436 static inline void *lock_user_string(abi_ulong guest_addr
)
439 len
= target_strlen(guest_addr
);
442 return lock_user(VERIFY_READ
, guest_addr
, (long)(len
+ 1), 1);
445 /* Helper macros for locking/ulocking a target struct. */
446 #define lock_user_struct(type, host_ptr, guest_addr, copy) \
447 (host_ptr = lock_user(type, guest_addr, sizeof(*host_ptr), copy))
448 #define unlock_user_struct(host_ptr, guest_addr, copy) \
449 unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
451 #if defined(CONFIG_USE_NPTL)
455 /* Include target-specific struct and function definitions;
456 * they may need access to the target-independent structures
457 * above, so include them last.
459 #include "target_cpu.h"
460 #include "target_signal.h"