2005-02-07 15:35:39 +03:00
|
|
|
#ifndef QEMU_H
|
|
|
|
#define QEMU_H
|
2003-02-19 01:55:36 +03:00
|
|
|
|
2003-10-01 01:04:53 +04:00
|
|
|
#include "cpu.h"
|
2014-03-28 22:42:10 +04:00
|
|
|
#include "exec/cpu_ldst.h"
|
2007-10-14 20:27:31 +04:00
|
|
|
|
2007-12-24 16:47:52 +03:00
|
|
|
#undef DEBUG_REMAP
|
|
|
|
|
2012-12-17 21:19:49 +04:00
|
|
|
#include "exec/user/abitypes.h"
|
2007-10-14 20:27:31 +04:00
|
|
|
|
|
|
|
#include "syscall_defs.h"
|
2016-02-01 21:38:42 +03:00
|
|
|
#include "target_syscall.h"
|
2003-03-23 04:06:05 +03:00
|
|
|
|
2021-09-08 18:43:57 +03:00
|
|
|
/*
|
|
|
|
* This is the size of the host kernel's sigset_t, needed where we make
|
2016-06-14 14:49:18 +03:00
|
|
|
* direct system calls that take a sigset_t pointer and a size.
|
|
|
|
*/
|
|
|
|
#define SIGSET_T_SIZE (_NSIG / 8)
|
|
|
|
|
2021-09-08 18:43:57 +03:00
|
|
|
/*
|
|
|
|
* This struct is used to hold certain information about the image.
|
2003-02-19 01:55:36 +03:00
|
|
|
* Basically, it replicates in user space what would be certain
|
|
|
|
* task_struct fields in the kernel
|
|
|
|
*/
|
|
|
|
struct image_info {
|
2010-07-27 21:25:30 +04:00
|
|
|
abi_ulong load_bias;
|
2007-10-14 20:27:31 +04:00
|
|
|
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;
|
2020-01-18 02:02:45 +03:00
|
|
|
abi_ulong reserve_brk;
|
2007-10-14 20:27:31 +04:00
|
|
|
abi_ulong start_mmap;
|
|
|
|
abi_ulong start_stack;
|
2010-06-16 16:03:51 +04:00
|
|
|
abi_ulong stack_limit;
|
2007-10-14 20:27:31 +04:00
|
|
|
abi_ulong entry;
|
|
|
|
abi_ulong code_offset;
|
|
|
|
abi_ulong data_offset;
|
2009-04-07 10:57:11 +04:00
|
|
|
abi_ulong saved_auxv;
|
2012-01-28 23:12:14 +04:00
|
|
|
abi_ulong auxv_len;
|
2022-04-27 05:51:29 +03:00
|
|
|
abi_ulong argc;
|
|
|
|
abi_ulong argv;
|
|
|
|
abi_ulong envc;
|
|
|
|
abi_ulong envp;
|
2016-12-15 20:38:11 +03:00
|
|
|
abi_ulong file_string;
|
2012-03-30 21:02:50 +04:00
|
|
|
uint32_t elf_flags;
|
2021-09-08 18:43:57 +03:00
|
|
|
int personality;
|
linux-user: fix ELF load alignment error
When we try to use some targets on ppc64, it can happen the target
doesn't support the host page size to align ELF load sections and
fails with:
ELF load command alignment not page-aligned
Since commit a70daba3771 ("linux-user: Tell guest about big host
page sizes") the host page size is used to align ELF sections, but
this doesn't work if the alignment required by the load section is
smaller than the host one. For these cases, we continue to use the
TARGET_PAGE_SIZE instead of the host one.
I have tested this change on ppc64, and it fixes qemu linux-user for:
s390x, m68k, i386, arm, aarch64, hppa
and I have tested it doesn't break the following targets:
x86_64, mips64el, sh4
mips and mipsel abort, but I think for another reason.
Signed-off-by: Laurent Vivier <laurent@vivier.eu>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
[lv: fixed "info->alignment = 0"]
Message-Id: <20180716195349.29959-1-laurent@vivier.eu>
2018-07-16 22:53:49 +03:00
|
|
|
abi_ulong alignment;
|
2018-04-30 11:03:41 +03:00
|
|
|
|
2022-04-27 05:51:29 +03:00
|
|
|
/* Generic semihosting knows about these pointers. */
|
|
|
|
abi_ulong arg_strings; /* strings for argv */
|
|
|
|
abi_ulong env_strings; /* strings for envp; ends arg_strings */
|
|
|
|
|
2018-04-30 11:03:41 +03:00
|
|
|
/* The fields below are used in FDPIC mode. */
|
2011-02-07 09:05:50 +03:00
|
|
|
abi_ulong loadmap_addr;
|
|
|
|
uint16_t nsegs;
|
2021-09-08 18:43:57 +03:00
|
|
|
void *loadsegs;
|
2011-02-07 09:05:50 +03:00
|
|
|
abi_ulong pt_dynamic_addr;
|
2018-04-30 11:03:43 +03:00
|
|
|
abi_ulong interpreter_loadmap_addr;
|
|
|
|
abi_ulong interpreter_pt_dynamic_addr;
|
2011-02-07 09:05:50 +03:00
|
|
|
struct image_info *other_info;
|
2020-10-21 20:37:47 +03:00
|
|
|
|
|
|
|
/* For target-specific processing of NT_GNU_PROPERTY_TYPE_0. */
|
|
|
|
uint32_t note_flags;
|
|
|
|
|
2018-10-22 17:43:40 +03:00
|
|
|
#ifdef TARGET_MIPS
|
|
|
|
int fp_abi;
|
|
|
|
int interp_fp_abi;
|
|
|
|
#endif
|
2003-02-19 01:55:36 +03:00
|
|
|
};
|
|
|
|
|
2003-06-16 00:05:50 +04:00
|
|
|
#ifdef TARGET_I386
|
2003-03-29 19:53:14 +03:00
|
|
|
/* 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;
|
|
|
|
};
|
2003-06-16 00:05:50 +04:00
|
|
|
#endif
|
2003-03-29 19:53:14 +03:00
|
|
|
|
2013-09-03 23:12:17 +04:00
|
|
|
#if defined(TARGET_ARM) && defined(TARGET_ABI32)
|
2004-02-17 00:47:43 +03:00
|
|
|
/* FPU emulator */
|
|
|
|
#include "nwfpe/fpa11.h"
|
|
|
|
#endif
|
|
|
|
|
2008-05-31 20:11:38 +04:00
|
|
|
struct emulated_sigtable {
|
|
|
|
int pending; /* true if signal is pending */
|
2016-05-27 17:51:52 +03:00
|
|
|
target_siginfo_t info;
|
2008-05-31 20:11:38 +04:00
|
|
|
};
|
|
|
|
|
2003-03-29 19:53:14 +03:00
|
|
|
typedef struct TaskState {
|
2009-04-07 10:57:11 +04:00
|
|
|
pid_t ts_tid; /* tid (or pid) of this task */
|
2004-02-17 00:47:43 +03:00
|
|
|
#ifdef TARGET_ARM
|
2013-09-03 23:12:17 +04:00
|
|
|
# ifdef TARGET_ABI32
|
2004-02-17 00:47:43 +03:00
|
|
|
/* FPA state */
|
|
|
|
FPA11 fpa;
|
2013-09-03 23:12:17 +04:00
|
|
|
# endif
|
2021-01-09 01:42:52 +03:00
|
|
|
#endif
|
|
|
|
#if defined(TARGET_ARM) || defined(TARGET_RISCV)
|
2005-04-23 22:25:41 +04:00
|
|
|
int swi_errno;
|
2004-02-17 00:47:43 +03:00
|
|
|
#endif
|
2007-04-06 12:56:50 +04:00
|
|
|
#if defined(TARGET_I386) && !defined(TARGET_X86_64)
|
2007-10-14 20:27:31 +04:00
|
|
|
abi_ulong target_v86;
|
2003-03-29 19:53:14 +03:00
|
|
|
struct vm86_saved_state vm86_saved_regs;
|
2003-05-15 01:48:51 +04:00
|
|
|
struct target_vm86plus_struct vm86plus;
|
2003-05-10 17:14:52 +04:00
|
|
|
uint32_t v86flags;
|
|
|
|
uint32_t v86mask;
|
2006-10-22 04:18:54 +04:00
|
|
|
#endif
|
2009-03-07 18:24:59 +03:00
|
|
|
abi_ulong child_tidptr;
|
2006-10-22 04:18:54 +04:00
|
|
|
#ifdef TARGET_M68K
|
2013-07-16 21:44:55 +04:00
|
|
|
abi_ulong tp_value;
|
2007-05-26 19:09:38 +04:00
|
|
|
#endif
|
2021-01-09 01:42:52 +03:00
|
|
|
#if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_RISCV)
|
2007-05-26 19:09:38 +04:00
|
|
|
/* Extra fields for semihosted binaries. */
|
2016-07-04 15:06:35 +03:00
|
|
|
abi_ulong heap_base;
|
|
|
|
abi_ulong heap_limit;
|
2003-06-16 00:05:50 +04:00
|
|
|
#endif
|
2016-07-04 15:06:35 +03:00
|
|
|
abi_ulong stack_base;
|
2003-03-29 19:53:14 +03:00
|
|
|
int used; /* non zero if used */
|
2006-06-17 22:30:42 +04:00
|
|
|
struct image_info *info;
|
2009-04-07 10:57:11 +04:00
|
|
|
struct linux_binprm *bprm;
|
2008-05-31 20:11:38 +04:00
|
|
|
|
2016-05-27 17:51:53 +03:00
|
|
|
struct emulated_sigtable sync_signal;
|
2008-05-31 20:11:38 +04:00
|
|
|
struct emulated_sigtable sigtab[TARGET_NSIG];
|
2021-09-08 18:43:57 +03:00
|
|
|
/*
|
|
|
|
* This thread's signal mask, as requested by the guest program.
|
2016-05-27 17:51:49 +03:00
|
|
|
* The actual signal mask of this thread may differ:
|
|
|
|
* + we don't let SIGSEGV and SIGBUS be blocked while running guest code
|
|
|
|
* + sometimes we block all signals to avoid races
|
|
|
|
*/
|
|
|
|
sigset_t signal_mask;
|
2021-09-08 18:43:57 +03:00
|
|
|
/*
|
|
|
|
* The signal mask imposed by a guest sigsuspend syscall, if we are
|
2016-05-27 17:51:49 +03:00
|
|
|
* currently in the middle of such a syscall
|
|
|
|
*/
|
|
|
|
sigset_t sigsuspend_mask;
|
|
|
|
/* Nonzero if we're leaving a sigsuspend and sigsuspend_mask is valid. */
|
|
|
|
int in_sigsuspend;
|
|
|
|
|
2021-09-08 18:43:57 +03:00
|
|
|
/*
|
|
|
|
* Nonzero if process_pending_signals() needs to do something (either
|
2016-05-27 17:51:49 +03:00
|
|
|
* handle a pending signal or unblock signals).
|
|
|
|
* This flag is written from a signal handler so should be accessed via
|
2020-09-23 13:56:46 +03:00
|
|
|
* the qatomic_read() and qatomic_set() functions. (It is not accessed
|
2016-05-27 17:51:49 +03:00
|
|
|
* from multiple threads.)
|
|
|
|
*/
|
|
|
|
int signal_pending;
|
|
|
|
|
2019-07-25 16:16:45 +03:00
|
|
|
/* This thread's sigaltstack, if it has one */
|
|
|
|
struct target_sigaltstack sigaltstack_used;
|
2022-01-28 03:12:51 +03:00
|
|
|
|
|
|
|
/* Start time of task after system boot in clock ticks */
|
|
|
|
uint64_t start_boottime;
|
2022-01-14 18:37:30 +03:00
|
|
|
} TaskState;
|
2003-03-29 19:53:14 +03:00
|
|
|
|
2021-09-08 18:44:03 +03:00
|
|
|
abi_long do_brk(abi_ulong new_brk);
|
2003-05-10 17:14:52 +04:00
|
|
|
|
2004-02-22 16:40:13 +03:00
|
|
|
/* user access */
|
|
|
|
|
2021-02-12 21:48:38 +03:00
|
|
|
#define VERIFY_READ PAGE_READ
|
|
|
|
#define VERIFY_WRITE (PAGE_READ | PAGE_WRITE)
|
2004-02-22 16:40:13 +03:00
|
|
|
|
2021-02-12 21:48:47 +03:00
|
|
|
static inline bool access_ok_untagged(int type, abi_ulong addr, abi_ulong size)
|
2007-11-14 13:51:00 +03:00
|
|
|
{
|
2021-02-12 21:48:45 +03:00
|
|
|
if (size == 0
|
2021-02-12 21:48:46 +03:00
|
|
|
? !guest_addr_valid_untagged(addr)
|
|
|
|
: !guest_range_valid_untagged(addr, size)) {
|
2021-02-12 21:48:37 +03:00
|
|
|
return false;
|
|
|
|
}
|
2021-02-12 21:48:38 +03:00
|
|
|
return page_check_range((target_ulong)addr, size, type) == 0;
|
2007-11-14 13:51:00 +03:00
|
|
|
}
|
2004-02-22 16:40:13 +03:00
|
|
|
|
2021-02-12 21:48:47 +03:00
|
|
|
static inline bool access_ok(CPUState *cpu, int type,
|
|
|
|
abi_ulong addr, abi_ulong size)
|
|
|
|
{
|
|
|
|
return access_ok_untagged(type, cpu_untagged_addr(cpu, addr), size);
|
|
|
|
}
|
|
|
|
|
2013-01-05 04:39:31 +04:00
|
|
|
/* 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. */
|
|
|
|
|
2018-10-09 19:18:14 +03:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
* - The pragmas are necessary only to silence a clang false-positive
|
|
|
|
* warning: see https://bugs.llvm.org/show_bug.cgi?id=39113 .
|
|
|
|
* - gcc has bugs in its _Pragma() support in some versions, eg
|
|
|
|
* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83256 -- so we only
|
|
|
|
* include the warning-suppression pragmas for clang
|
|
|
|
*/
|
2018-11-30 11:23:16 +03:00
|
|
|
#if defined(__clang__) && __has_warning("-Waddress-of-packed-member")
|
2018-10-09 19:18:14 +03:00
|
|
|
#define PRAGMA_DISABLE_PACKED_WARNING \
|
|
|
|
_Pragma("GCC diagnostic push"); \
|
|
|
|
_Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\"")
|
|
|
|
|
|
|
|
#define PRAGMA_REENABLE_PACKED_WARNING \
|
|
|
|
_Pragma("GCC diagnostic pop")
|
|
|
|
|
|
|
|
#else
|
|
|
|
#define PRAGMA_DISABLE_PACKED_WARNING
|
|
|
|
#define PRAGMA_REENABLE_PACKED_WARNING
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define __put_user_e(x, hptr, e) \
|
|
|
|
do { \
|
|
|
|
PRAGMA_DISABLE_PACKED_WARNING; \
|
|
|
|
(__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)), (void)0); \
|
|
|
|
PRAGMA_REENABLE_PACKED_WARNING; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define __get_user_e(x, hptr, e) \
|
|
|
|
do { \
|
|
|
|
PRAGMA_DISABLE_PACKED_WARNING; \
|
|
|
|
((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)), (void)0); \
|
|
|
|
PRAGMA_REENABLE_PACKED_WARNING; \
|
|
|
|
} while (0)
|
|
|
|
|
2013-01-05 04:39:31 +04:00
|
|
|
|
2022-03-23 18:57:18 +03:00
|
|
|
#if TARGET_BIG_ENDIAN
|
2013-01-05 04:39:31 +04:00
|
|
|
# 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
|
2004-02-22 16:40:13 +03:00
|
|
|
|
2007-11-11 17:26:47 +03:00
|
|
|
/* 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; \
|
2014-04-22 16:40:50 +04:00
|
|
|
abi_long __ret = 0; \
|
2007-11-11 17:26:47 +03:00
|
|
|
if ((__hptr = lock_user(VERIFY_WRITE, __gaddr, sizeof(target_type), 0))) { \
|
2014-04-22 16:40:50 +04:00
|
|
|
__put_user((x), __hptr); \
|
2007-11-11 17:26:47 +03:00
|
|
|
unlock_user(__hptr, __gaddr, sizeof(target_type)); \
|
|
|
|
} else \
|
|
|
|
__ret = -TARGET_EFAULT; \
|
|
|
|
__ret; \
|
2004-02-22 16:40:13 +03:00
|
|
|
})
|
|
|
|
|
2007-11-11 17:26:47 +03:00
|
|
|
#define get_user(x, gaddr, target_type) \
|
|
|
|
({ \
|
|
|
|
abi_ulong __gaddr = (gaddr); \
|
|
|
|
target_type *__hptr; \
|
2014-04-22 16:40:50 +04:00
|
|
|
abi_long __ret = 0; \
|
2007-11-11 17:26:47 +03:00
|
|
|
if ((__hptr = lock_user(VERIFY_READ, __gaddr, sizeof(target_type), 1))) { \
|
2014-04-22 16:40:50 +04:00
|
|
|
__get_user((x), __hptr); \
|
2007-11-11 17:26:47 +03:00
|
|
|
unlock_user(__hptr, __gaddr, 0); \
|
2007-11-16 13:46:05 +03:00
|
|
|
} else { \
|
|
|
|
/* avoid warning */ \
|
|
|
|
(x) = 0; \
|
2007-11-11 17:26:47 +03:00
|
|
|
__ret = -TARGET_EFAULT; \
|
2007-11-16 13:46:05 +03:00
|
|
|
} \
|
2007-11-11 17:26:47 +03:00
|
|
|
__ret; \
|
2004-02-22 16:40:13 +03:00
|
|
|
})
|
|
|
|
|
2007-11-16 13:46:05 +03:00
|
|
|
#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)
|
|
|
|
|
2007-11-11 17:26:47 +03:00
|
|
|
/* 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.
|
|
|
|
*/
|
2021-03-15 23:40:04 +03:00
|
|
|
int copy_from_user(void *hptr, abi_ulong gaddr, ssize_t len);
|
|
|
|
int copy_to_user(abi_ulong gaddr, void *hptr, ssize_t len);
|
2007-11-11 17:26:47 +03:00
|
|
|
|
2006-03-25 22:31:22 +03:00
|
|
|
/* Functions for accessing guest memory. The tget and tput functions
|
2013-09-12 21:57:15 +04:00
|
|
|
read/write single values, byteswapping as necessary. The lock_user function
|
2006-03-25 22:31:22 +03:00
|
|
|
gets a pointer to a contiguous area of guest memory, but does not perform
|
2013-09-12 21:57:15 +04:00
|
|
|
any byteswapping. lock_user may return either a pointer to the guest
|
2006-03-25 22:31:22 +03:00
|
|
|
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. */
|
2021-03-15 23:40:04 +03:00
|
|
|
void *lock_user(int type, abi_ulong guest_addr, ssize_t len, bool copy);
|
2004-02-22 16:40:13 +03:00
|
|
|
|
2007-11-11 17:26:47 +03:00
|
|
|
/* Unlock an area of guest memory. The first LEN bytes must be
|
2008-06-03 23:51:57 +04:00
|
|
|
flushed back to guest memory. host_ptr = NULL is explicitly
|
2007-11-11 17:26:47 +03:00
|
|
|
allowed and does nothing. */
|
2021-02-12 21:48:48 +03:00
|
|
|
#ifndef DEBUG_REMAP
|
2021-03-15 23:40:04 +03:00
|
|
|
static inline void unlock_user(void *host_ptr, abi_ulong guest_addr,
|
|
|
|
ssize_t len)
|
|
|
|
{
|
|
|
|
/* no-op */
|
|
|
|
}
|
2021-02-12 21:48:48 +03:00
|
|
|
#else
|
2021-03-15 23:40:04 +03:00
|
|
|
void unlock_user(void *host_ptr, abi_ulong guest_addr, ssize_t len);
|
2006-03-25 22:31:22 +03:00
|
|
|
#endif
|
2004-02-22 16:40:13 +03:00
|
|
|
|
2007-11-11 17:26:47 +03:00
|
|
|
/* Return the length of a string in target memory or -TARGET_EFAULT if
|
|
|
|
access error. */
|
2021-02-12 21:48:49 +03:00
|
|
|
ssize_t target_strlen(abi_ulong gaddr);
|
2006-03-25 22:31:22 +03:00
|
|
|
|
|
|
|
/* Like lock_user but for null terminated strings. */
|
2021-02-12 21:48:48 +03:00
|
|
|
void *lock_user_string(abi_ulong guest_addr);
|
2004-02-22 16:40:13 +03:00
|
|
|
|
2013-09-12 21:57:41 +04:00
|
|
|
/* Helper macros for locking/unlocking a target struct. */
|
2007-11-11 17:26:47 +03:00
|
|
|
#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) \
|
2006-03-25 22:31:22 +03:00
|
|
|
unlock_user(host_ptr, guest_addr, (copy) ? sizeof(*host_ptr) : 0)
|
|
|
|
|
2005-02-07 15:35:39 +03:00
|
|
|
#endif /* QEMU_H */
|