OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

Avoid accessing guest memory directly in usermode emulation. 

git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@1790 c046a42c-6fe2-441c-8c8c-71466251a162
This commit is contained in:
pbrook 2006-03-25 19:31:22 +00:00
parent 26f69dc09f
commit 53a5960aad
15 changed files with 1195 additions and 773 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
cpu-all.h
View File

@ -584,22 +584,41 @@ static inline void stfq_be_p(void *ptr, float64 v)
/* MMU memory access macros */ /* MMU memory access macros */
#if defined(CONFIG_USER_ONLY)
/* On some host systems the guest address space is reserved on the host.
* This allows the guest address space to be offset to a convenient location.
*/
//#define GUEST_BASE 0x20000000
#define GUEST_BASE 0
/* All direct uses of g2h and h2g need to go away for usermode softmmu. */
#define g2h(x) ((void *)((unsigned long)(x) + GUEST_BASE))
#define h2g(x) ((target_ulong)(x - GUEST_BASE))
#define saddr(x) g2h(x)
#define laddr(x) g2h(x)
#else /* !CONFIG_USER_ONLY */
/* NOTE: we use double casts if pointers and target_ulong have /* NOTE: we use double casts if pointers and target_ulong have
different sizes */ different sizes */
#define ldub_raw(p) ldub_p((uint8_t *)(long)(p)) #define saddr(x) (uint8_t *)(long)(x)
#define ldsb_raw(p) ldsb_p((uint8_t *)(long)(p)) #define laddr(x) (uint8_t *)(long)(x)
#define lduw_raw(p) lduw_p((uint8_t *)(long)(p)) #endif
#define ldsw_raw(p) ldsw_p((uint8_t *)(long)(p))
#define ldl_raw(p) ldl_p((uint8_t *)(long)(p)) #define ldub_raw(p) ldub_p(laddr((p)))
#define ldq_raw(p) ldq_p((uint8_t *)(long)(p)) #define ldsb_raw(p) ldsb_p(laddr((p)))
#define ldfl_raw(p) ldfl_p((uint8_t *)(long)(p)) #define lduw_raw(p) lduw_p(laddr((p)))
#define ldfq_raw(p) ldfq_p((uint8_t *)(long)(p)) #define ldsw_raw(p) ldsw_p(laddr((p)))
#define stb_raw(p, v) stb_p((uint8_t *)(long)(p), v) #define ldl_raw(p) ldl_p(laddr((p)))
#define stw_raw(p, v) stw_p((uint8_t *)(long)(p), v) #define ldq_raw(p) ldq_p(laddr((p)))
#define stl_raw(p, v) stl_p((uint8_t *)(long)(p), v) #define ldfl_raw(p) ldfl_p(laddr((p)))
#define stq_raw(p, v) stq_p((uint8_t *)(long)(p), v) #define ldfq_raw(p) ldfq_p(laddr((p)))
#define stfl_raw(p, v) stfl_p((uint8_t *)(long)(p), v) #define stb_raw(p, v) stb_p(saddr((p)), v)
#define stfq_raw(p, v) stfq_p((uint8_t *)(long)(p), v) #define stw_raw(p, v) stw_p(saddr((p)), v)
#define stl_raw(p, v) stl_p(saddr((p)), v)
#define stq_raw(p, v) stq_p(saddr((p)), v)
#define stfl_raw(p, v) stfl_p(saddr((p)), v)
#define stfq_raw(p, v) stfq_p(saddr((p)), v)
#if defined(CONFIG_USER_ONLY) #if defined(CONFIG_USER_ONLY)
@ -648,6 +667,7 @@ static inline void stfq_be_p(void *ptr, float64 v)
#define TARGET_PAGE_MASK ~(TARGET_PAGE_SIZE - 1) #define TARGET_PAGE_MASK ~(TARGET_PAGE_SIZE - 1)
#define TARGET_PAGE_ALIGN(addr) (((addr) + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK) #define TARGET_PAGE_ALIGN(addr) (((addr) + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK)
/* ??? These should be the larger of unsigned long and target_ulong. */
extern unsigned long qemu_real_host_page_size; extern unsigned long qemu_real_host_page_size;
extern unsigned long qemu_host_page_bits; extern unsigned long qemu_host_page_bits;
extern unsigned long qemu_host_page_size; extern unsigned long qemu_host_page_size;
@ -666,9 +686,9 @@ extern unsigned long qemu_host_page_mask;
#define PAGE_WRITE_ORG 0x0010 #define PAGE_WRITE_ORG 0x0010
void page_dump(FILE *f); void page_dump(FILE *f);
int page_get_flags(unsigned long address); int page_get_flags(target_ulong address);
void page_set_flags(unsigned long start, unsigned long end, int flags); void page_set_flags(target_ulong start, target_ulong end, int flags);
void page_unprotect_range(uint8_t *data, unsigned long data_size); void page_unprotect_range(target_ulong data, target_ulong data_size);
#define SINGLE_CPU_DEFINES #define SINGLE_CPU_DEFINES
#ifdef SINGLE_CPU_DEFINES #ifdef SINGLE_CPU_DEFINES

10
cpu-exec.c
View File

@ -913,7 +913,7 @@ static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
pc, address, is_write, *(unsigned long *)old_set); pc, address, is_write, *(unsigned long *)old_set);
#endif #endif
/* XXX: locking issue */ /* XXX: locking issue */
if (is_write && page_unprotect(address, pc, puc)) { if (is_write && page_unprotect(h2g(address), pc, puc)) {
return 1; return 1;
} }
@ -964,7 +964,7 @@ static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
pc, address, is_write, *(unsigned long *)old_set); pc, address, is_write, *(unsigned long *)old_set);
#endif #endif
/* XXX: locking issue */ /* XXX: locking issue */
if (is_write && page_unprotect(address, pc, puc)) { if (is_write && page_unprotect(h2g(address), pc, puc)) {
return 1; return 1;
} }
/* see if it is an MMU fault */ /* see if it is an MMU fault */
@ -1000,7 +1000,7 @@ static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
pc, address, is_write, *(unsigned long *)old_set); pc, address, is_write, *(unsigned long *)old_set);
#endif #endif
/* XXX: locking issue */ /* XXX: locking issue */
if (is_write && page_unprotect(address, pc, puc)) { if (is_write && page_unprotect(h2g(address), pc, puc)) {
return 1; return 1;
} }
/* see if it is an MMU fault */ /* see if it is an MMU fault */
@ -1036,7 +1036,7 @@ static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
pc, address, is_write, *(unsigned long *)old_set); pc, address, is_write, *(unsigned long *)old_set);
#endif #endif
/* XXX: locking issue */ /* XXX: locking issue */
if (is_write && page_unprotect(address, pc, puc)) { if (is_write && page_unprotect(h2g(address), pc, puc)) {
return 1; return 1;
} }
@ -1086,7 +1086,7 @@ static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
pc, address, is_write, *(unsigned long *)old_set); pc, address, is_write, *(unsigned long *)old_set);
#endif #endif
/* XXX: locking issue */ /* XXX: locking issue */
if (is_write && page_unprotect(address, pc, puc)) { if (is_write && page_unprotect(h2g(address), pc, puc)) {
return 1; return 1;
} }

2
exec-all.h
View File

@ -93,7 +93,7 @@ int cpu_restore_state_copy(struct TranslationBlock *tb,
void *puc); void *puc);
void cpu_resume_from_signal(CPUState *env1, void *puc); void cpu_resume_from_signal(CPUState *env1, void *puc);
void cpu_exec_init(CPUState *env); void cpu_exec_init(CPUState *env);
int page_unprotect(unsigned long address, unsigned long pc, void *puc); int page_unprotect(target_ulong address, unsigned long pc, void *puc);
void tb_invalidate_phys_page_range(target_ulong start, target_ulong end, void tb_invalidate_phys_page_range(target_ulong start, target_ulong end,
int is_cpu_write_access); int is_cpu_write_access);
void tb_invalidate_page_range(target_ulong start, target_ulong end); void tb_invalidate_page_range(target_ulong start, target_ulong end);

58
exec.c
View File

@ -34,6 +34,9 @@
#include "cpu.h" #include "cpu.h"
#include "exec-all.h" #include "exec-all.h"
#if defined(CONFIG_USER_ONLY)
#include <qemu.h>
#endif
//#define DEBUG_TB_INVALIDATE //#define DEBUG_TB_INVALIDATE
//#define DEBUG_FLUSH //#define DEBUG_FLUSH
@ -810,7 +813,7 @@ static void tb_invalidate_phys_page(target_ulong addr,
/* add the tb in the target page and protect it if necessary */ /* add the tb in the target page and protect it if necessary */
static inline void tb_alloc_page(TranslationBlock *tb, static inline void tb_alloc_page(TranslationBlock *tb,
unsigned int n, unsigned int page_addr) unsigned int n, target_ulong page_addr)
{ {
PageDesc *p; PageDesc *p;
TranslationBlock *last_first_tb; TranslationBlock *last_first_tb;
@ -826,23 +829,30 @@ static inline void tb_alloc_page(TranslationBlock *tb,
#if defined(CONFIG_USER_ONLY) #if defined(CONFIG_USER_ONLY)
if (p->flags & PAGE_WRITE) { if (p->flags & PAGE_WRITE) {
unsigned long host_start, host_end, addr; target_ulong addr;
PageDesc *p2;
int prot; int prot;
/* force the host page as non writable (writes will have a /* force the host page as non writable (writes will have a
page fault + mprotect overhead) */ page fault + mprotect overhead) */
host_start = page_addr & qemu_host_page_mask; page_addr &= qemu_host_page_mask;
host_end = host_start + qemu_host_page_size;
prot = 0; prot = 0;
for(addr = host_start; addr < host_end; addr += TARGET_PAGE_SIZE) for(addr = page_addr; addr < page_addr + qemu_host_page_size;
prot |= page_get_flags(addr); addr += TARGET_PAGE_SIZE) {
mprotect((void *)host_start, qemu_host_page_size,
p2 = page_find (addr >> TARGET_PAGE_BITS);
if (!p2)
continue;
prot |= p2->flags;
p2->flags &= ~PAGE_WRITE;
page_get_flags(addr);
}
mprotect(g2h(page_addr), qemu_host_page_size,
(prot & PAGE_BITS) & ~PAGE_WRITE); (prot & PAGE_BITS) & ~PAGE_WRITE);
#ifdef DEBUG_TB_INVALIDATE #ifdef DEBUG_TB_INVALIDATE
printf("protecting code page: 0x%08lx\n", printf("protecting code page: 0x%08lx\n",
host_start); page_addr);
#endif #endif
p->flags &= ~PAGE_WRITE;
} }
#else #else
/* if some code is already present, then the pages are already /* if some code is already present, then the pages are already
@ -1546,7 +1556,7 @@ int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
/* called from signal handler: invalidate the code and unprotect the /* called from signal handler: invalidate the code and unprotect the
page. Return TRUE if the fault was succesfully handled. */ page. Return TRUE if the fault was succesfully handled. */
int page_unprotect(unsigned long addr, unsigned long pc, void *puc) int page_unprotect(target_ulong addr, unsigned long pc, void *puc)
{ {
#if !defined(CONFIG_SOFTMMU) #if !defined(CONFIG_SOFTMMU)
VirtPageDesc *vp; VirtPageDesc *vp;
@ -1645,7 +1655,7 @@ void page_dump(FILE *f)
} }
} }
int page_get_flags(unsigned long address) int page_get_flags(target_ulong address)
{ {
PageDesc *p; PageDesc *p;
@ -1658,10 +1668,10 @@ int page_get_flags(unsigned long address)
/* modify the flags of a page and invalidate the code if /* modify the flags of a page and invalidate the code if
necessary. The flag PAGE_WRITE_ORG is positionned automatically necessary. The flag PAGE_WRITE_ORG is positionned automatically
depending on PAGE_WRITE */ depending on PAGE_WRITE */
void page_set_flags(unsigned long start, unsigned long end, int flags) void page_set_flags(target_ulong start, target_ulong end, int flags)
{ {
PageDesc *p; PageDesc *p;
unsigned long addr; target_ulong addr;
start = start & TARGET_PAGE_MASK; start = start & TARGET_PAGE_MASK;
end = TARGET_PAGE_ALIGN(end); end = TARGET_PAGE_ALIGN(end);
@ -1684,11 +1694,11 @@ void page_set_flags(unsigned long start, unsigned long end, int flags)
/* called from signal handler: invalidate the code and unprotect the /* called from signal handler: invalidate the code and unprotect the
page. Return TRUE if the fault was succesfully handled. */ page. Return TRUE if the fault was succesfully handled. */
int page_unprotect(unsigned long address, unsigned long pc, void *puc) int page_unprotect(target_ulong address, unsigned long pc, void *puc)
{ {
unsigned int page_index, prot, pindex; unsigned int page_index, prot, pindex;
PageDesc *p, *p1; PageDesc *p, *p1;
unsigned long host_start, host_end, addr; target_ulong host_start, host_end, addr;
host_start = address & qemu_host_page_mask; host_start = address & qemu_host_page_mask;
page_index = host_start >> TARGET_PAGE_BITS; page_index = host_start >> TARGET_PAGE_BITS;
@ -1707,7 +1717,7 @@ int page_unprotect(unsigned long address, unsigned long pc, void *puc)
if (prot & PAGE_WRITE_ORG) { if (prot & PAGE_WRITE_ORG) {
pindex = (address - host_start) >> TARGET_PAGE_BITS; pindex = (address - host_start) >> TARGET_PAGE_BITS;
if (!(p1[pindex].flags & PAGE_WRITE)) { if (!(p1[pindex].flags & PAGE_WRITE)) {
mprotect((void *)host_start, qemu_host_page_size, mprotect((void *)g2h(host_start), qemu_host_page_size,
(prot & PAGE_BITS) | PAGE_WRITE); (prot & PAGE_BITS) | PAGE_WRITE);
p1[pindex].flags |= PAGE_WRITE; p1[pindex].flags |= PAGE_WRITE;
/* and since the content will be modified, we must invalidate /* and since the content will be modified, we must invalidate
@ -1723,11 +1733,12 @@ int page_unprotect(unsigned long address, unsigned long pc, void *puc)
} }
/* call this function when system calls directly modify a memory area */ /* call this function when system calls directly modify a memory area */
void page_unprotect_range(uint8_t *data, unsigned long data_size) /* ??? This should be redundant now we have lock_user. */
void page_unprotect_range(target_ulong data, target_ulong data_size)
{ {
unsigned long start, end, addr; target_ulong start, end, addr;
start = (unsigned long)data; start = data;
end = start + data_size; end = start + data_size;
start &= TARGET_PAGE_MASK; start &= TARGET_PAGE_MASK;
end = TARGET_PAGE_ALIGN(end); end = TARGET_PAGE_ALIGN(end);
@ -1932,6 +1943,7 @@ void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
{ {
int l, flags; int l, flags;
target_ulong page; target_ulong page;
void * p;
while (len > 0) { while (len > 0) {
page = addr & TARGET_PAGE_MASK; page = addr & TARGET_PAGE_MASK;
@ -1944,11 +1956,15 @@ void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
if (is_write) { if (is_write) {
if (!(flags & PAGE_WRITE)) if (!(flags & PAGE_WRITE))
return; return;
memcpy((uint8_t *)addr, buf, len); p = lock_user(addr, len, 0);
memcpy(p, buf, len);
unlock_user(p, addr, len);
} else { } else {
if (!(flags & PAGE_READ)) if (!(flags & PAGE_READ))
return; return;
memcpy(buf, (uint8_t *)addr, len); p = lock_user(addr, len, 1);
memcpy(buf, p, len);
unlock_user(p, addr, 0);
} }
len -= l; len -= l;
buf += l; buf += l;

41
linux-user/arm-semi.c
View File

@ -77,20 +77,20 @@ static inline uint32_t set_swi_errno(TaskState *ts, uint32_t code)
return code; return code;
} }
#define ARG(x) tswap32(args[x]) #define ARG(n) tget32(args + n * 4)
uint32_t do_arm_semihosting(CPUState *env) uint32_t do_arm_semihosting(CPUState *env)
{ {
uint32_t *args; target_ulong args;
char * s; char * s;
int nr; int nr;
uint32_t ret; uint32_t ret;
TaskState *ts = env->opaque; TaskState *ts = env->opaque;
nr = env->regs[0]; nr = env->regs[0];
args = (uint32_t *)env->regs[1]; args = env->regs[1];
switch (nr) { switch (nr) {
case SYS_OPEN: case SYS_OPEN:
s = (char *)ARG(0); s = (char *)g2h(ARG(0));
if (ARG(1) >= 12) if (ARG(1) >= 12)
return (uint32_t)-1; return (uint32_t)-1;
if (strcmp(s, ":tt") == 0) { if (strcmp(s, ":tt") == 0) {
@ -103,18 +103,23 @@ uint32_t do_arm_semihosting(CPUState *env)
case SYS_CLOSE: case SYS_CLOSE:
return set_swi_errno(ts, close(ARG(0))); return set_swi_errno(ts, close(ARG(0)));
case SYS_WRITEC: case SYS_WRITEC:
/* Write to debug console. stderr is near enough. */ {
return write(STDERR_FILENO, args, 1); char c = tget8(args);
/* Write to debug console. stderr is near enough. */
return write(STDERR_FILENO, &c, 1);
}
case SYS_WRITE0: case SYS_WRITE0:
s = (char *)args; s = lock_user_string(args);
return write(STDERR_FILENO, s, strlen(s)); ret = write(STDERR_FILENO, s, strlen(s));
unlock_user(s, args, 0);
return ret;
case SYS_WRITE: case SYS_WRITE:
ret = set_swi_errno(ts, write(ARG(0), (void *)ARG(1), ARG(2))); ret = set_swi_errno(ts, write(ARG(0), g2h(ARG(1)), ARG(2)));
if (ret == (uint32_t)-1) if (ret == (uint32_t)-1)
return -1; return -1;
return ARG(2) - ret; return ARG(2) - ret;
case SYS_READ: case SYS_READ:
ret = set_swi_errno(ts, read(ARG(0), (void *)ARG(1), ARG(2))); ret = set_swi_errno(ts, read(ARG(0), g2h(ARG(1)), ARG(2)));
if (ret == (uint32_t)-1) if (ret == (uint32_t)-1)
return -1; return -1;
return ARG(2) - ret; return ARG(2) - ret;
@ -140,20 +145,21 @@ uint32_t do_arm_semihosting(CPUState *env)
/* XXX: Not implemented. */ /* XXX: Not implemented. */
return -1; return -1;
case SYS_REMOVE: case SYS_REMOVE:
return set_swi_errno(ts, remove((char *)ARG(0))); return set_swi_errno(ts, remove((char *)g2h(ARG(0))));
case SYS_RENAME: case SYS_RENAME:
return set_swi_errno(ts, rename((char *)ARG(0), (char *)ARG(2))); return set_swi_errno(ts, rename((char *)g2h(ARG(0)),
(char *)g2h(ARG(2))));
case SYS_CLOCK: case SYS_CLOCK:
return clock() / (CLOCKS_PER_SEC / 100); return clock() / (CLOCKS_PER_SEC / 100);
case SYS_TIME: case SYS_TIME:
return set_swi_errno(ts, time(NULL)); return set_swi_errno(ts, time(NULL));
case SYS_SYSTEM: case SYS_SYSTEM:
return set_swi_errno(ts, system((char *)ARG(0))); return set_swi_errno(ts, system((char *)g2h(ARG(0))));
case SYS_ERRNO: case SYS_ERRNO:
return ts->swi_errno; return ts->swi_errno;
case SYS_GET_CMDLINE: case SYS_GET_CMDLINE:
/* XXX: Not implemented. */ /* XXX: Not implemented. */
s = (char *)ARG(0); s = (char *)g2h(ARG(0));
*s = 0; *s = 0;
return -1; return -1;
case SYS_HEAPINFO: case SYS_HEAPINFO:
@ -166,11 +172,11 @@ uint32_t do_arm_semihosting(CPUState *env)
if (!ts->heap_limit) { if (!ts->heap_limit) {
long ret; long ret;
ts->heap_base = do_brk(NULL); ts->heap_base = do_brk(0);
limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE; limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
/* Try a big heap, and reduce the size if that fails. */ /* Try a big heap, and reduce the size if that fails. */
for (;;) { for (;;) {
ret = do_brk((char *)limit); ret = do_brk(limit);
if (ret != -1) if (ret != -1)
break; break;
limit = (ts->heap_base >> 1) + (limit >> 1); limit = (ts->heap_base >> 1) + (limit >> 1);
@ -178,7 +184,8 @@ uint32_t do_arm_semihosting(CPUState *env)
ts->heap_limit = limit; ts->heap_limit = limit;
} }
ptr = (uint32_t *)ARG(0); page_unprotect_range (ARG(0), 32);
ptr = (uint32_t *)g2h(ARG(0));
ptr[0] = tswap32(ts->heap_base); ptr[0] = tswap32(ts->heap_base);
ptr[1] = tswap32(ts->heap_limit); ptr[1] = tswap32(ts->heap_limit);
ptr[2] = tswap32(ts->stack_base); ptr[2] = tswap32(ts->stack_base);

182
linux-user/elfload.c
View File

@ -97,17 +97,17 @@ static inline void init_thread(struct target_pt_regs *regs, struct image_info *i
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop) static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
{ {
target_long *stack = (void *)infop->start_stack; target_long stack = infop->start_stack;
memset(regs, 0, sizeof(*regs)); memset(regs, 0, sizeof(*regs));
regs->ARM_cpsr = 0x10; regs->ARM_cpsr = 0x10;
if (infop->entry & 1) if (infop->entry & 1)
regs->ARM_cpsr |= CPSR_T; regs->ARM_cpsr |= CPSR_T;
regs->ARM_pc = infop->entry & 0xfffffffe; regs->ARM_pc = infop->entry & 0xfffffffe;
regs->ARM_sp = infop->start_stack; regs->ARM_sp = infop->start_stack;
regs->ARM_r2 = tswapl(stack[2]); /* envp */ regs->ARM_r2 = tgetl(stack + 8); /* envp */
regs->ARM_r1 = tswapl(stack[1]); /* argv */ regs->ARM_r1 = tgetl(stack + 4); /* envp */
/* XXX: it seems that r0 is zeroed after ! */ /* XXX: it seems that r0 is zeroed after ! */
// regs->ARM_r0 = tswapl(stack[0]); /* argc */ // regs->ARM_r0 = tgetl(stack); /* argc */
} }
#define USE_ELF_CORE_DUMP #define USE_ELF_CORE_DUMP
@ -202,7 +202,7 @@ do { \
_r->gpr[3] = bprm->argc; \ _r->gpr[3] = bprm->argc; \
_r->gpr[4] = (unsigned long)++pos; \ _r->gpr[4] = (unsigned long)++pos; \
for (; tmp != 0; pos++) \ for (; tmp != 0; pos++) \
tmp = *pos; \ tmp = ldl(pos); \
_r->gpr[5] = (unsigned long)pos; \ _r->gpr[5] = (unsigned long)pos; \
} while (0) } while (0)
@ -297,7 +297,7 @@ static inline void init_thread(struct target_pt_regs *regs, struct image_info *i
*/ */
struct linux_binprm { struct linux_binprm {
char buf[128]; char buf[128];
unsigned long page[MAX_ARG_PAGES]; void *page[MAX_ARG_PAGES];
unsigned long p; unsigned long p;
int sh_bang; int sh_bang;
int fd; int fd;
@ -427,37 +427,13 @@ static void bswap_sym(Elf32_Sym *sym)
} }
#endif #endif
static void * get_free_page(void)
{
void * retval;
/* User-space version of kernel get_free_page. Returns a page-aligned
* page-sized chunk of memory.
*/
retval = (void *)target_mmap(0, qemu_host_page_size, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
if((long)retval == -1) {
perror("get_free_page");
exit(-1);
}
else {
return(retval);
}
}
static void free_page(void * pageaddr)
{
target_munmap((unsigned long)pageaddr, qemu_host_page_size);
}
/* /*
* 'copy_string()' copies argument/envelope strings from user * 'copy_string()' copies argument/envelope strings from user
* memory to free pages in kernel mem. These are in a format ready * memory to free pages in kernel mem. These are in a format ready
* to be put directly into the top of new user memory. * to be put directly into the top of new user memory.
* *
*/ */
static unsigned long copy_strings(int argc,char ** argv,unsigned long *page, static unsigned long copy_strings(int argc,char ** argv, void **page,
unsigned long p) unsigned long p)
{ {
char *tmp, *tmp1, *pag = NULL; char *tmp, *tmp1, *pag = NULL;
@ -482,10 +458,10 @@ static unsigned long copy_strings(int argc,char ** argv,unsigned long *page,
--p; --tmp; --len; --p; --tmp; --len;
if (--offset < 0) { if (--offset < 0) {
offset = p % TARGET_PAGE_SIZE; offset = p % TARGET_PAGE_SIZE;
pag = (char *) page[p/TARGET_PAGE_SIZE]; pag = (char *)page[p/TARGET_PAGE_SIZE];
if (!pag) { if (!pag) {
pag = (char *)get_free_page(); pag = (char *)malloc(TARGET_PAGE_SIZE);
page[p/TARGET_PAGE_SIZE] = (unsigned long)pag; page[p/TARGET_PAGE_SIZE] = pag;
if (!pag) if (!pag)
return 0; return 0;
} }
@ -591,10 +567,20 @@ static int prepare_binprm(struct linux_binprm *bprm)
} }
} }
unsigned long setup_arg_pages(unsigned long p, struct linux_binprm * bprm, static inline void memcpy_to_target(target_ulong dest, const void *src,
struct image_info * info) unsigned long len)
{ {
unsigned long stack_base, size, error; void *host_ptr;
host_ptr = lock_user(dest, len, 0);
memcpy(host_ptr, src, len);
unlock_user(host_ptr, dest, 1);
}
unsigned long setup_arg_pages(target_ulong p, struct linux_binprm * bprm,
struct image_info * info)
{
target_ulong stack_base, size, error;
int i; int i;
/* Create enough stack to hold everything. If we don't use /* Create enough stack to hold everything. If we don't use
@ -627,10 +613,10 @@ unsigned long setup_arg_pages(unsigned long p, struct linux_binprm * bprm,
if (bprm->page[i]) { if (bprm->page[i]) {
info->rss++; info->rss++;
memcpy((void *)stack_base, (void *)bprm->page[i], TARGET_PAGE_SIZE); memcpy_to_target(stack_base, bprm->page[i], TARGET_PAGE_SIZE);
free_page((void *)bprm->page[i]); free(bprm->page[i]);
} }
stack_base += TARGET_PAGE_SIZE; stack_base += TARGET_PAGE_SIZE;
} }
return p; return p;
} }
@ -657,7 +643,6 @@ static void set_brk(unsigned long start, unsigned long end)
static void padzero(unsigned long elf_bss) static void padzero(unsigned long elf_bss)
{ {
unsigned long nbyte; unsigned long nbyte;
char * fpnt;
/* XXX: this is really a hack : if the real host page size is /* XXX: this is really a hack : if the real host page size is
smaller than the target page size, some pages after the end smaller than the target page size, some pages after the end
@ -679,55 +664,57 @@ static void padzero(unsigned long elf_bss)
nbyte = elf_bss & (qemu_host_page_size-1); nbyte = elf_bss & (qemu_host_page_size-1);
if (nbyte) { if (nbyte) {
nbyte = qemu_host_page_size - nbyte; nbyte = qemu_host_page_size - nbyte;
fpnt = (char *) elf_bss;
do { do {
*fpnt++ = 0; tput8(elf_bss, 0);
elf_bss++;
} while (--nbyte); } while (--nbyte);
} }
} }
static unsigned int * create_elf_tables(char *p, int argc, int envc,
struct elfhdr * exec,
unsigned long load_addr,
unsigned long load_bias,
unsigned long interp_load_addr, int ibcs,
struct image_info *info)
{
target_ulong *argv, *envp;
target_ulong *sp, *csp;
target_ulong *u_platform;
const char *k_platform;
int v;
/* static unsigned long create_elf_tables(target_ulong p, int argc, int envc,
* Force 16 byte _final_ alignment here for generality. struct elfhdr * exec,
*/ unsigned long load_addr,
sp = (unsigned int *) (~15UL & (unsigned long) p); unsigned long load_bias,
u_platform = NULL; unsigned long interp_load_addr, int ibcs,
struct image_info *info)
{
target_ulong argv, envp;
target_ulong sp;
int size;
target_ulong u_platform;
const char *k_platform;
const int n = sizeof(target_ulong);
sp = p;
u_platform = 0;
k_platform = ELF_PLATFORM; k_platform = ELF_PLATFORM;
if (k_platform) { if (k_platform) {
size_t len = strlen(k_platform) + 1; size_t len = strlen(k_platform) + 1;
sp -= (len + sizeof(target_ulong) - 1) / sizeof(target_ulong); sp -= (len + n - 1) & ~(n - 1);
u_platform = (target_ulong *)sp; u_platform = sp;
__copy_to_user(u_platform, k_platform, len); memcpy_to_target(sp, k_platform, len);
} }
csp = sp; /*
csp -= (DLINFO_ITEMS + 1) * 2; * Force 16 byte _final_ alignment here for generality.
*/
sp = sp &~ (target_ulong)15;
size = (DLINFO_ITEMS + 1) * 2;
if (k_platform) if (k_platform)
csp -= 2; size += 2;
#ifdef DLINFO_ARCH_ITEMS #ifdef DLINFO_ARCH_ITEMS
csp -= DLINFO_ARCH_ITEMS*2; size += DLINFO_ARCH_ITEMS * 2;
#endif #endif
csp -= envc+1; size += envc + argc + 2;
csp -= argc+1; size += (!ibcs ? 3 : 1); /* argc itself */
csp -= (!ibcs ? 3 : 1); /* argc itself */ size *= n;
if ((unsigned long)csp & 15UL) if (size & 15)
sp -= ((unsigned long)csp & 15UL) / sizeof(*sp); sp -= 16 - (size & 15);
#define NEW_AUX_ENT(id, val) \ #define NEW_AUX_ENT(id, val) do { \
sp -= 2; \ sp -= n; tputl(sp, val); \
put_user (id, sp); \ sp -= n; tputl(sp, id); \
put_user (val, sp + 1) } while(0)
NEW_AUX_ENT (AT_NULL, 0); NEW_AUX_ENT (AT_NULL, 0);
/* There must be exactly DLINFO_ITEMS entries here. */ /* There must be exactly DLINFO_ITEMS entries here. */
@ -744,7 +731,7 @@ static unsigned int * create_elf_tables(char *p, int argc, int envc,
NEW_AUX_ENT(AT_EGID, (target_ulong) getegid()); NEW_AUX_ENT(AT_EGID, (target_ulong) getegid());
NEW_AUX_ENT(AT_HWCAP, (target_ulong) ELF_HWCAP); NEW_AUX_ENT(AT_HWCAP, (target_ulong) ELF_HWCAP);
if (k_platform) if (k_platform)
NEW_AUX_ENT(AT_PLATFORM, (target_ulong) u_platform); NEW_AUX_ENT(AT_PLATFORM, u_platform);
#ifdef ARCH_DLINFO #ifdef ARCH_DLINFO
/* /*
* ARCH_DLINFO must come last so platform specific code can enforce * ARCH_DLINFO must come last so platform specific code can enforce
@ -754,39 +741,32 @@ static unsigned int * create_elf_tables(char *p, int argc, int envc,
#endif #endif
#undef NEW_AUX_ENT #undef NEW_AUX_ENT
sp -= envc+1; sp -= (envc + 1) * n;
envp = sp; envp = sp;
sp -= argc+1; sp -= (argc + 1) * n;
argv = sp; argv = sp;
if (!ibcs) { if (!ibcs) {
put_user((target_ulong)envp,--sp); sp -= n; tputl(sp, envp);
put_user((target_ulong)argv,--sp); sp -= n; tputl(sp, argv);
} }
put_user(argc,--sp); sp -= n; tputl(sp, argc);
info->arg_start = (unsigned int)((unsigned long)p & 0xffffffff); info->arg_start = p;
while (argc-->0) { while (argc-->0) {
put_user((target_ulong)p,argv++); tputl(argv, p); argv += n;
do { p += target_strlen(p) + 1;
get_user(v, p);
p++;
} while (v != 0);
} }
put_user(0,argv); tputl(argv, 0);
info->arg_end = info->env_start = (unsigned int)((unsigned long)p & 0xffffffff); info->arg_end = info->env_start = p;
while (envc-->0) { while (envc-->0) {
put_user((target_ulong)p,envp++); tputl(envp, p); envp += n;
do { p += target_strlen(p) + 1;
get_user(v, p);
p++;
} while (v != 0);
} }
put_user(0,envp); tputl(envp, 0);
info->env_end = (unsigned int)((unsigned long)p & 0xffffffff); info->env_end = p;
return sp; return sp;
} }
static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex, static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
int interpreter_fd, int interpreter_fd,
unsigned long *interp_load_addr) unsigned long *interp_load_addr)
@ -1335,8 +1315,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * r
#ifdef LOW_ELF_STACK #ifdef LOW_ELF_STACK
info->start_stack = bprm->p = elf_stack - 4; info->start_stack = bprm->p = elf_stack - 4;
#endif #endif
bprm->p = (unsigned long) bprm->p = create_elf_tables(bprm->p,
create_elf_tables((char *)bprm->p,
bprm->argc, bprm->argc,
bprm->envc, bprm->envc,
&elf_ex, &elf_ex,
@ -1432,6 +1411,7 @@ int elf_exec(const char * filename, char ** argv, char ** envp,
if(retval>=0) { if(retval>=0) {
retval = load_elf_binary(&bprm,regs,infop); retval = load_elf_binary(&bprm,regs,infop);
} }
if(retval>=0) { if(retval>=0) {
/* success. Initialize important registers */ /* success. Initialize important registers */
init_thread(regs, infop); init_thread(regs, infop);
@ -1440,7 +1420,7 @@ int elf_exec(const char * filename, char ** argv, char ** envp,
/* Something went wrong, return the inode and free the argument pages*/ /* Something went wrong, return the inode and free the argument pages*/
for (i=0 ; i<MAX_ARG_PAGES ; i++) { for (i=0 ; i<MAX_ARG_PAGES ; i++) {
free_page((void *)bprm.page[i]); free(bprm.page[i]);
} }
return(retval); return(retval);
} }

2
linux-user/ioctls.h
View File

@ -55,7 +55,7 @@
IOCTL(KDMKTONE, 0, TYPE_INT) IOCTL(KDMKTONE, 0, TYPE_INT)
IOCTL(KDGKBTYPE, IOC_R, MK_PTR(TYPE_CHAR)) IOCTL(KDGKBTYPE, IOC_R, MK_PTR(TYPE_CHAR))
IOCTL(KDGKBENT, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_kbentry))) IOCTL(KDGKBENT, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_kbentry)))
IOCTL(KDGKBSENT, IOC_RW, TYPE_PTRVOID) IOCTL(KDGKBSENT, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_kbsentry)))
IOCTL(BLKROSET, IOC_W, MK_PTR(TYPE_INT)) IOCTL(BLKROSET, IOC_W, MK_PTR(TYPE_INT))
IOCTL(BLKROGET, IOC_R, MK_PTR(TYPE_INT)) IOCTL(BLKROGET, IOC_R, MK_PTR(TYPE_INT))

58
linux-user/main.c
View File

@ -152,21 +152,25 @@ static void write_dt(void *ptr, unsigned long addr, unsigned long limit,
int flags) int flags)
{ {
unsigned int e1, e2; unsigned int e1, e2;
uint32_t *p;
e1 = (addr << 16) | (limit & 0xffff); e1 = (addr << 16) | (limit & 0xffff);
e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000); e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
e2 |= flags; e2 |= flags;
stl((uint8_t *)ptr, e1); p = ptr;
stl((uint8_t *)ptr + 4, e2); p[0] = tswapl(e1);
p[1] = tswapl(e2);
} }
static void set_gate(void *ptr, unsigned int type, unsigned int dpl, static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
unsigned long addr, unsigned int sel) unsigned long addr, unsigned int sel)
{ {
unsigned int e1, e2; unsigned int e1, e2;
uint32_t *p;
e1 = (addr & 0xffff) | (sel << 16); e1 = (addr & 0xffff) | (sel << 16);
e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8); e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
stl((uint8_t *)ptr, e1); p = ptr;
stl((uint8_t *)ptr + 4, e2); p[0] = tswapl(e1);
p[1] = tswapl(e2);
} }
uint64_t gdt_table[6]; uint64_t gdt_table[6];
@ -343,7 +347,7 @@ void cpu_loop(CPUARMState *env)
/* we handle the FPU emulation here, as Linux */ /* we handle the FPU emulation here, as Linux */
/* we get the opcode */ /* we get the opcode */
opcode = ldl_raw((uint8_t *)env->regs[15]); opcode = tget32(env->regs[15]);
if (EmulateAll(opcode, &ts->fpa, env) == 0) { if (EmulateAll(opcode, &ts->fpa, env) == 0) {
info.si_signo = SIGILL; info.si_signo = SIGILL;
@ -364,20 +368,20 @@ void cpu_loop(CPUARMState *env)
/* system call */ /* system call */
if (trapnr == EXCP_BKPT) { if (trapnr == EXCP_BKPT) {
if (env->thumb) { if (env->thumb) {
insn = lduw((void *)(env->regs[15])); insn = tget16(env->regs[15]);
n = insn & 0xff; n = insn & 0xff;
env->regs[15] += 2; env->regs[15] += 2;
} else { } else {
insn = ldl((void *)(env->regs[15])); insn = tget32(env->regs[15]);
n = (insn & 0xf) | ((insn >> 4) & 0xff0); n = (insn & 0xf) | ((insn >> 4) & 0xff0);
env->regs[15] += 4; env->regs[15] += 4;
} }
} else { } else {
if (env->thumb) { if (env->thumb) {
insn = lduw((void *)(env->regs[15] - 2)); insn = tget16(env->regs[15] - 2);
n = insn & 0xff; n = insn & 0xff;
} else { } else {
insn = ldl((void *)(env->regs[15] - 4)); insn = tget32(env->regs[15] - 4);
n = insn & 0xffffff; n = insn & 0xffffff;
} }
} }
@ -475,16 +479,16 @@ static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
static inline void save_window_offset(CPUSPARCState *env, int cwp1) static inline void save_window_offset(CPUSPARCState *env, int cwp1)
{ {
unsigned int i; unsigned int i;
uint32_t *sp_ptr; target_ulong sp_ptr;
sp_ptr = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]); sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
#if defined(DEBUG_WIN) #if defined(DEBUG_WIN)
printf("win_overflow: sp_ptr=0x%x save_cwp=%d\n", printf("win_overflow: sp_ptr=0x%x save_cwp=%d\n",
(int)sp_ptr, cwp1); (int)sp_ptr, cwp1);
#endif #endif
for(i = 0; i < 16; i++) { for(i = 0; i < 16; i++) {
put_user(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); tputl(sp_ptr, env->regbase[get_reg_index(env, cwp1, 8 + i)]);
sp_ptr++; sp_ptr += sizeof(target_ulong);
} }
} }
@ -500,22 +504,21 @@ static void save_window(CPUSPARCState *env)
static void restore_window(CPUSPARCState *env) static void restore_window(CPUSPARCState *env)
{ {
unsigned int new_wim, i, cwp1; unsigned int new_wim, i, cwp1;
uint32_t *sp_ptr, reg; target_ulong sp_ptr;
new_wim = ((env->wim << 1) | (env->wim >> (NWINDOWS - 1))) & new_wim = ((env->wim << 1) | (env->wim >> (NWINDOWS - 1))) &
((1LL << NWINDOWS) - 1); ((1LL << NWINDOWS) - 1);
/* restore the invalid window */ /* restore the invalid window */
cwp1 = (env->cwp + 1) & (NWINDOWS - 1); cwp1 = (env->cwp + 1) & (NWINDOWS - 1);
sp_ptr = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]); sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
#if defined(DEBUG_WIN) #if defined(DEBUG_WIN)
printf("win_underflow: sp_ptr=0x%x load_cwp=%d\n", printf("win_underflow: sp_ptr=0x%x load_cwp=%d\n",
(int)sp_ptr, cwp1); (int)sp_ptr, cwp1);
#endif #endif
for(i = 0; i < 16; i++) { for(i = 0; i < 16; i++) {
get_user(reg, sp_ptr); env->regbase[get_reg_index(env, cwp1, 8 + i)] = tgetl(sp_ptr);
env->regbase[get_reg_index(env, cwp1, 8 + i)] = reg; sp_ptr += sizeof(target_ulong);
sp_ptr++;
} }
env->wim = new_wim; env->wim = new_wim;
} }
@ -1304,15 +1307,9 @@ void cpu_loop(CPUMIPSState *env)
if (nb_args >= 5) { if (nb_args >= 5) {
sp_reg = env->gpr[29]; sp_reg = env->gpr[29];
/* these arguments are taken from the stack */ /* these arguments are taken from the stack */
if (get_user(arg5, (target_ulong *)(sp_reg + 16))) { arg5 = tgetl(sp_reg + 16);
ret = -EFAULT;
goto fail;
}
if (nb_args >= 6) { if (nb_args >= 6) {
if (get_user(arg6, (target_ulong *)(sp_reg + 20))) { arg6 = tgetl(sp_reg + 20);
ret = -EFAULT;
goto fail;
}
} else { } else {
arg6 = 0; arg6 = 0;
} }
@ -1347,8 +1344,7 @@ void cpu_loop(CPUMIPSState *env)
{ {
uint32_t insn, op; uint32_t insn, op;
if (get_user(insn, (uint32_t *)env->PC) < 0) insn = tget32(env->PC);
goto sigill;
op = insn >> 26; op = insn >> 26;
// printf("insn=%08x op=%02x\n", insn, op); // printf("insn=%08x op=%02x\n", insn, op);
/* XXX: totally dummy FP ops just to be able to launch /* XXX: totally dummy FP ops just to be able to launch
@ -1531,7 +1527,7 @@ int main(int argc, char **argv)
fprintf(logfile, "entry 0x%08lx\n" , info->entry); fprintf(logfile, "entry 0x%08lx\n" , info->entry);
} }
target_set_brk((char *)info->brk); target_set_brk(info->brk);
syscall_init(); syscall_init();
signal_init(); signal_init();
@ -1566,7 +1562,7 @@ int main(int argc, char **argv)
env->eip = regs->eip; env->eip = regs->eip;
/* linux interrupt setup */ /* linux interrupt setup */
env->idt.base = (long)idt_table; env->idt.base = h2g(idt_table);
env->idt.limit = sizeof(idt_table) - 1; env->idt.limit = sizeof(idt_table) - 1;
set_idt(0, 0); set_idt(0, 0);
set_idt(1, 0); set_idt(1, 0);
@ -1591,7 +1587,7 @@ int main(int argc, char **argv)
set_idt(0x80, 3); set_idt(0x80, 3);
/* linux segment setup */ /* linux segment setup */
env->gdt.base = (long)gdt_table; env->gdt.base = h2g(gdt_table);
env->gdt.limit = sizeof(gdt_table) - 1; env->gdt.limit = sizeof(gdt_table) - 1;
write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff, write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |

164
linux-user/mmap.c
View File

@ -29,10 +29,10 @@
//#define DEBUG_MMAP //#define DEBUG_MMAP
/* NOTE: all the constants are the HOST ones */ /* NOTE: all the constants are the HOST ones, but addresses are target. */
int target_mprotect(unsigned long start, unsigned long len, int prot) int target_mprotect(target_ulong start, target_ulong len, int prot)
{ {
unsigned long end, host_start, host_end, addr; target_ulong end, host_start, host_end, addr;
int prot1, ret; int prot1, ret;
#ifdef DEBUG_MMAP #ifdef DEBUG_MMAP
@ -67,7 +67,7 @@ int target_mprotect(unsigned long start, unsigned long len, int prot)
} }
end = host_end; end = host_end;
} }
ret = mprotect((void *)host_start, qemu_host_page_size, prot1 & PAGE_BITS); ret = mprotect(g2h(host_start), qemu_host_page_size, prot1 & PAGE_BITS);
if (ret != 0) if (ret != 0)
return ret; return ret;
host_start += qemu_host_page_size; host_start += qemu_host_page_size;
@ -77,7 +77,7 @@ int target_mprotect(unsigned long start, unsigned long len, int prot)
for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) { for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
prot1 |= page_get_flags(addr); prot1 |= page_get_flags(addr);
} }
ret = mprotect((void *)(host_end - qemu_host_page_size), qemu_host_page_size, ret = mprotect(g2h(host_end - qemu_host_page_size), qemu_host_page_size,
prot1 & PAGE_BITS); prot1 & PAGE_BITS);
if (ret != 0) if (ret != 0)
return ret; return ret;
@ -86,7 +86,7 @@ int target_mprotect(unsigned long start, unsigned long len, int prot)
/* handle the pages in the middle */ /* handle the pages in the middle */
if (host_start < host_end) { if (host_start < host_end) {
ret = mprotect((void *)host_start, host_end - host_start, prot); ret = mprotect(g2h(host_start), host_end - host_start, prot);
if (ret != 0) if (ret != 0)
return ret; return ret;
} }
@ -95,28 +95,31 @@ int target_mprotect(unsigned long start, unsigned long len, int prot)
} }
/* map an incomplete host page */ /* map an incomplete host page */
int mmap_frag(unsigned long host_start, static int mmap_frag(target_ulong real_start,
unsigned long start, unsigned long end, target_ulong start, target_ulong end,
int prot, int flags, int fd, unsigned long offset) int prot, int flags, int fd, target_ulong offset)
{ {
unsigned long host_end, ret, addr; target_ulong real_end, ret, addr;
void *host_start;
int prot1, prot_new; int prot1, prot_new;
host_end = host_start + qemu_host_page_size; real_end = real_start + qemu_host_page_size;
host_start = g2h(real_start);
/* get the protection of the target pages outside the mapping */ /* get the protection of the target pages outside the mapping */
prot1 = 0; prot1 = 0;
for(addr = host_start; addr < host_end; addr++) { for(addr = real_start; addr < real_end; addr++) {
if (addr < start || addr >= end) if (addr < start || addr >= end)
prot1 |= page_get_flags(addr); prot1 |= page_get_flags(addr);
} }
if (prot1 == 0) { if (prot1 == 0) {
/* no page was there, so we allocate one */ /* no page was there, so we allocate one */
ret = (long)mmap((void *)host_start, qemu_host_page_size, prot, ret = (long)mmap(host_start, qemu_host_page_size, prot,
flags | MAP_ANONYMOUS, -1, 0); flags | MAP_ANONYMOUS, -1, 0);
if (ret == -1) if (ret == -1)
return ret; return ret;
prot1 = prot;
} }
prot1 &= PAGE_BITS; prot1 &= PAGE_BITS;
@ -130,31 +133,35 @@ int mmap_frag(unsigned long host_start,
/* adjust protection to be able to read */ /* adjust protection to be able to read */
if (!(prot1 & PROT_WRITE)) if (!(prot1 & PROT_WRITE))
mprotect((void *)host_start, qemu_host_page_size, prot1 | PROT_WRITE); mprotect(host_start, qemu_host_page_size, prot1 | PROT_WRITE);
/* read the corresponding file data */ /* read the corresponding file data */
pread(fd, (void *)start, end - start, offset); pread(fd, g2h(start), end - start, offset);
/* put final protection */ /* put final protection */
if (prot_new != (prot1 | PROT_WRITE)) if (prot_new != (prot1 | PROT_WRITE))
mprotect((void *)host_start, qemu_host_page_size, prot_new); mprotect(host_start, qemu_host_page_size, prot_new);
} else { } else {
/* just update the protection */ /* just update the protection */
if (prot_new != prot1) { if (prot_new != prot1) {
mprotect((void *)host_start, qemu_host_page_size, prot_new); mprotect(host_start, qemu_host_page_size, prot_new);
} }
} }
return 0; return 0;
} }
/* NOTE: all the constants are the HOST ones */ /* NOTE: all the constants are the HOST ones */
long target_mmap(unsigned long start, unsigned long len, int prot, long target_mmap(target_ulong start, target_ulong len, int prot,
int flags, int fd, unsigned long offset) int flags, int fd, target_ulong offset)
{ {
unsigned long ret, end, host_start, host_end, retaddr, host_offset, host_len; target_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len;
long host_start;
#if defined(__alpha__) || defined(__sparc__) || defined(__x86_64__) || \ #if defined(__alpha__) || defined(__sparc__) || defined(__x86_64__) || \
defined(__ia64) defined(__ia64)
static unsigned long last_start = 0x40000000; static target_ulong last_start = 0x40000000;
#elif defined(__CYGWIN__)
/* Cygwin doesn't have a whole lot of address space. */
static target_ulong last_start = 0x18000000;
#endif #endif
#ifdef DEBUG_MMAP #ifdef DEBUG_MMAP
@ -191,45 +198,49 @@ long target_mmap(unsigned long start, unsigned long len, int prot,
len = TARGET_PAGE_ALIGN(len); len = TARGET_PAGE_ALIGN(len);
if (len == 0) if (len == 0)
return start; return start;
host_start = start & qemu_host_page_mask; real_start = start & qemu_host_page_mask;
if (!(flags & MAP_FIXED)) { if (!(flags & MAP_FIXED)) {
#if defined(__alpha__) || defined(__sparc__) || defined(__x86_64__) || \ #if defined(__alpha__) || defined(__sparc__) || defined(__x86_64__) || \
defined(__ia64) defined(__ia64) || defined(__CYGWIN__)
/* tell the kenel to search at the same place as i386 */ /* tell the kenel to search at the same place as i386 */
if (host_start == 0) { if (real_start == 0) {
host_start = last_start; real_start = last_start;
last_start += HOST_PAGE_ALIGN(len); last_start += HOST_PAGE_ALIGN(len);
} }
#endif #endif
if (qemu_host_page_size != qemu_real_host_page_size) { if (qemu_host_page_size != qemu_real_host_page_size) {
/* NOTE: this code is only for debugging with '-p' option */ /* NOTE: this code is only for debugging with '-p' option */
/* ??? Can also occur when TARGET_PAGE_SIZE > host page size. */
/* reserve a memory area */ /* reserve a memory area */
/* ??? This needs fixing for remapping. */
abort();
host_len = HOST_PAGE_ALIGN(len) + qemu_host_page_size - TARGET_PAGE_SIZE; host_len = HOST_PAGE_ALIGN(len) + qemu_host_page_size - TARGET_PAGE_SIZE;
host_start = (long)mmap((void *)host_start, host_len, PROT_NONE, real_start = (long)mmap(g2h(real_start), host_len, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (host_start == -1) if (real_start == -1)
return host_start; return real_start;
host_end = host_start + host_len; real_end = real_start + host_len;
start = HOST_PAGE_ALIGN(host_start); start = HOST_PAGE_ALIGN(real_start);
end = start + HOST_PAGE_ALIGN(len); end = start + HOST_PAGE_ALIGN(len);
if (start > host_start) if (start > real_start)
munmap((void *)host_start, start - host_start); munmap((void *)real_start, start - real_start);
if (end < host_end) if (end < real_end)
munmap((void *)end, host_end - end); munmap((void *)end, real_end - end);
/* use it as a fixed mapping */ /* use it as a fixed mapping */
flags |= MAP_FIXED; flags |= MAP_FIXED;
} else { } else {
/* if not fixed, no need to do anything */ /* if not fixed, no need to do anything */
host_offset = offset & qemu_host_page_mask; host_offset = offset & qemu_host_page_mask;
host_len = len + offset - host_offset; host_len = len + offset - host_offset;
start = (long)mmap((void *)host_start, host_len, host_start = (long)mmap(real_start ? g2h(real_start) : NULL,
prot, flags, fd, host_offset); host_len, prot, flags, fd, host_offset);
if (start == -1) if (host_start == -1)
return start; return host_start;
/* update start so that it points to the file position at 'offset' */ /* update start so that it points to the file position at 'offset' */
if (!(flags & MAP_ANONYMOUS)) if (!(flags & MAP_ANONYMOUS))
start += offset - host_offset; host_start += offset - host_offset;
start = h2g(host_start);
goto the_end1; goto the_end1;
} }
} }
@ -239,7 +250,7 @@ long target_mmap(unsigned long start, unsigned long len, int prot,
return -1; return -1;
} }
end = start + len; end = start + len;
host_end = HOST_PAGE_ALIGN(end); real_end = HOST_PAGE_ALIGN(end);
/* worst case: we cannot map the file because the offset is not /* worst case: we cannot map the file because the offset is not
aligned, so we read it */ aligned, so we read it */
@ -257,7 +268,7 @@ long target_mmap(unsigned long start, unsigned long len, int prot,
-1, 0); -1, 0);
if (retaddr == -1) if (retaddr == -1)
return retaddr; return retaddr;
pread(fd, (void *)start, len, offset); pread(fd, g2h(start), len, offset);
if (!(prot & PROT_WRITE)) { if (!(prot & PROT_WRITE)) {
ret = target_mprotect(start, len, prot); ret = target_mprotect(start, len, prot);
if (ret != 0) if (ret != 0)
@ -267,40 +278,40 @@ long target_mmap(unsigned long start, unsigned long len, int prot,
} }
/* handle the start of the mapping */ /* handle the start of the mapping */
if (start > host_start) { if (start > real_start) {
if (host_end == host_start + qemu_host_page_size) { if (real_end == real_start + qemu_host_page_size) {
/* one single host page */ /* one single host page */
ret = mmap_frag(host_start, start, end, ret = mmap_frag(real_start, start, end,
prot, flags, fd, offset); prot, flags, fd, offset);
if (ret == -1) if (ret == -1)
return ret; return ret;
goto the_end1; goto the_end1;
} }
ret = mmap_frag(host_start, start, host_start + qemu_host_page_size, ret = mmap_frag(real_start, start, real_start + qemu_host_page_size,
prot, flags, fd, offset); prot, flags, fd, offset);
if (ret == -1) if (ret == -1)
return ret; return ret;
host_start += qemu_host_page_size; real_start += qemu_host_page_size;
} }
/* handle the end of the mapping */ /* handle the end of the mapping */
if (end < host_end) { if (end < real_end) {
ret = mmap_frag(host_end - qemu_host_page_size, ret = mmap_frag(real_end - qemu_host_page_size,
host_end - qemu_host_page_size, host_end, real_end - qemu_host_page_size, real_end,
prot, flags, fd, prot, flags, fd,
offset + host_end - qemu_host_page_size - start); offset + real_end - qemu_host_page_size - start);
if (ret == -1) if (ret == -1)
return ret; return ret;
host_end -= qemu_host_page_size; real_end -= qemu_host_page_size;
} }
/* map the middle (easier) */ /* map the middle (easier) */
if (host_start < host_end) { if (real_start < real_end) {
unsigned long offset1; unsigned long offset1;
if (flags & MAP_ANONYMOUS) if (flags & MAP_ANONYMOUS)
offset1 = 0; offset1 = 0;
else else
offset1 = offset + host_start - start; offset1 = offset + real_start - start;
ret = (long)mmap((void *)host_start, host_end - host_start, ret = (long)mmap(g2h(real_start), real_end - real_start,
prot, flags, fd, offset1); prot, flags, fd, offset1);
if (ret == -1) if (ret == -1)
return ret; return ret;
@ -316,9 +327,9 @@ long target_mmap(unsigned long start, unsigned long len, int prot,
return start; return start;
} }
int target_munmap(unsigned long start, unsigned long len) int target_munmap(target_ulong start, target_ulong len)
{ {
unsigned long end, host_start, host_end, addr; target_ulong end, real_start, real_end, addr;
int prot, ret; int prot, ret;
#ifdef DEBUG_MMAP #ifdef DEBUG_MMAP
@ -330,36 +341,36 @@ int target_munmap(unsigned long start, unsigned long len)
if (len == 0) if (len == 0)
return -EINVAL; return -EINVAL;
end = start + len; end = start + len;
host_start = start & qemu_host_page_mask; real_start = start & qemu_host_page_mask;
host_end = HOST_PAGE_ALIGN(end); real_end = HOST_PAGE_ALIGN(end);
if (start > host_start) { if (start > real_start) {
/* handle host page containing start */ /* handle host page containing start */
prot = 0; prot = 0;
for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) { for(addr = real_start; addr < start; addr += TARGET_PAGE_SIZE) {
prot |= page_get_flags(addr); prot |= page_get_flags(addr);
} }
if (host_end == host_start + qemu_host_page_size) { if (real_end == real_start + qemu_host_page_size) {
for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) { for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
prot |= page_get_flags(addr); prot |= page_get_flags(addr);
} }
end = host_end; end = real_end;
} }
if (prot != 0) if (prot != 0)
host_start += qemu_host_page_size; real_start += qemu_host_page_size;
} }
if (end < host_end) { if (end < real_end) {
prot = 0; prot = 0;
for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) { for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
prot |= page_get_flags(addr); prot |= page_get_flags(addr);
} }
if (prot != 0) if (prot != 0)
host_end -= qemu_host_page_size; real_end -= qemu_host_page_size;
} }
/* unmap what we can */ /* unmap what we can */
if (host_start < host_end) { if (real_start < real_end) {
ret = munmap((void *)host_start, host_end - host_start); ret = munmap((void *)real_start, real_end - real_start);
if (ret != 0) if (ret != 0)
return ret; return ret;
} }
@ -370,25 +381,26 @@ int target_munmap(unsigned long start, unsigned long len)
/* XXX: currently, we only handle MAP_ANONYMOUS and not MAP_FIXED /* XXX: currently, we only handle MAP_ANONYMOUS and not MAP_FIXED
blocks which have been allocated starting on a host page */ blocks which have been allocated starting on a host page */
long target_mremap(unsigned long old_addr, unsigned long old_size, long target_mremap(target_ulong old_addr, target_ulong old_size,
unsigned long new_size, unsigned long flags, target_ulong new_size, unsigned long flags,
unsigned long new_addr) target_ulong new_addr)
{ {
int prot; int prot;
/* XXX: use 5 args syscall */ /* XXX: use 5 args syscall */
new_addr = (long)mremap((void *)old_addr, old_size, new_size, flags); new_addr = (long)mremap(g2h(old_addr), old_size, new_size, flags);
if (new_addr == -1) if (new_addr == -1)
return new_addr; return new_addr;
new_addr = h2g(new_addr);
prot = page_get_flags(old_addr); prot = page_get_flags(old_addr);
page_set_flags(old_addr, old_addr + old_size, 0); page_set_flags(old_addr, old_addr + old_size, 0);
page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID); page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID);
return new_addr; return new_addr;
} }
int target_msync(unsigned long start, unsigned long len, int flags) int target_msync(target_ulong start, target_ulong len, int flags)
{ {
unsigned long end; target_ulong end;
if (start & ~TARGET_PAGE_MASK) if (start & ~TARGET_PAGE_MASK)
return -EINVAL; return -EINVAL;
@ -400,6 +412,6 @@ int target_msync(unsigned long start, unsigned long len, int flags)
return 0; return 0;
start &= qemu_host_page_mask; start &= qemu_host_page_mask;
return msync((void *)start, end - start, flags); return msync(g2h(start), end - start, flags);
} }

141
linux-user/qemu.h
View File

@ -69,7 +69,7 @@ typedef struct TaskState {
int swi_errno; int swi_errno;
#endif #endif
#ifdef TARGET_I386 #ifdef TARGET_I386
struct target_vm86plus_struct *target_v86; target_ulong target_v86;
struct vm86_saved_state vm86_saved_regs; struct vm86_saved_state vm86_saved_regs;
struct target_vm86plus_struct vm86plus; struct target_vm86plus_struct vm86plus;
uint32_t v86flags; uint32_t v86flags;
@ -84,8 +84,8 @@ extern TaskState *first_task_state;
int elf_exec(const char * filename, char ** argv, char ** envp, int elf_exec(const char * filename, char ** argv, char ** envp,
struct target_pt_regs * regs, struct image_info *infop); struct target_pt_regs * regs, struct image_info *infop);
void target_set_brk(char *new_brk); void target_set_brk(target_ulong new_brk);
long do_brk(char *new_brk); long do_brk(target_ulong new_brk);
void syscall_init(void); void syscall_init(void);
long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3, long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3,
long arg4, long arg5, long arg6); long arg4, long arg5, long arg6);
@ -112,19 +112,18 @@ long do_rt_sigreturn(CPUState *env);
void save_v86_state(CPUX86State *env); void save_v86_state(CPUX86State *env);
void handle_vm86_trap(CPUX86State *env, int trapno); void handle_vm86_trap(CPUX86State *env, int trapno);
void handle_vm86_fault(CPUX86State *env); void handle_vm86_fault(CPUX86State *env);
int do_vm86(CPUX86State *env, long subfunction, int do_vm86(CPUX86State *env, long subfunction, target_ulong v86_addr);
struct target_vm86plus_struct * target_v86);
#endif #endif
/* mmap.c */ /* mmap.c */
int target_mprotect(unsigned long start, unsigned long len, int prot); int target_mprotect(target_ulong start, target_ulong len, int prot);
long target_mmap(unsigned long start, unsigned long len, int prot, long target_mmap(target_ulong start, target_ulong len, int prot,
int flags, int fd, unsigned long offset); int flags, int fd, target_ulong offset);
int target_munmap(unsigned long start, unsigned long len); int target_munmap(target_ulong start, target_ulong len);
long target_mremap(unsigned long old_addr, unsigned long old_size, long target_mremap(target_ulong old_addr, target_ulong old_size,
unsigned long new_size, unsigned long flags, target_ulong new_size, unsigned long flags,
unsigned long new_addr); target_ulong new_addr);
int target_msync(unsigned long start, unsigned long len, int flags); int target_msync(target_ulong start, target_ulong len, int flags);
/* user access */ /* user access */
@ -133,21 +132,22 @@ int target_msync(unsigned long start, unsigned long len, int flags);
#define access_ok(type,addr,size) (1) #define access_ok(type,addr,size) (1)
/* NOTE get_user and put_user use host addresses. */
#define __put_user(x,ptr)\ #define __put_user(x,ptr)\
({\ ({\
int size = sizeof(*ptr);\ int size = sizeof(*ptr);\
switch(size) {\ switch(size) {\
case 1:\ case 1:\
stb(ptr, (typeof(*ptr))(x));\ *(uint8_t *)(ptr) = (typeof(*ptr))(x);\
break;\ break;\
case 2:\ case 2:\
stw(ptr, (typeof(*ptr))(x));\ *(uint16_t *)(ptr) = tswap16((typeof(*ptr))(x));\
break;\ break;\
case 4:\ case 4:\
stl(ptr, (typeof(*ptr))(x));\ *(uint32_t *)(ptr) = tswap32((typeof(*ptr))(x));\
break;\ break;\
case 8:\ case 8:\
stq(ptr, (typeof(*ptr))(x));\ *(uint64_t *)(ptr) = tswap64((typeof(*ptr))(x));\
break;\ break;\
default:\ default:\
abort();\ abort();\
@ -160,16 +160,16 @@ int target_msync(unsigned long start, unsigned long len, int flags);
int size = sizeof(*ptr);\ int size = sizeof(*ptr);\
switch(size) {\ switch(size) {\
case 1:\ case 1:\
x = (typeof(*ptr))ldub((void *)ptr);\ x = (typeof(*ptr))*(uint8_t *)(ptr);\
break;\ break;\
case 2:\ case 2:\
x = (typeof(*ptr))lduw((void *)ptr);\ x = (typeof(*ptr))tswap16(*(uint16_t *)(ptr));\
break;\ break;\
case 4:\ case 4:\
x = (typeof(*ptr))ldl((void *)ptr);\ x = (typeof(*ptr))tswap32(*(uint32_t *)(ptr));\
break;\ break;\
case 8:\ case 8:\
x = (typeof(*ptr))ldq((void *)ptr);\ x = (typeof(*ptr))tswap64(*(uint64_t *)(ptr));\
break;\ break;\
default:\ default:\
abort();\ abort();\
@ -177,26 +177,6 @@ int target_msync(unsigned long start, unsigned long len, int flags);
0;\ 0;\
}) })
static inline unsigned long __copy_to_user(void *dst, const void *src,
unsigned long size)
{
memcpy(dst, src, size);
return 0;
}
static inline unsigned long __copy_from_user(void *dst, const void *src,
unsigned long size)
{
memcpy(dst, src, size);
return 0;
}
static inline unsigned long __clear_user(void *dst, unsigned long size)
{
memset(dst, 0, size);
return 0;
}
#define put_user(x,ptr)\ #define put_user(x,ptr)\
({\ ({\
int __ret;\ int __ret;\
@ -217,30 +197,77 @@ static inline unsigned long __clear_user(void *dst, unsigned long size)
__ret;\ __ret;\
}) })
static inline unsigned long copy_to_user(void *dst, const void *src, /* Functions for accessing guest memory. The tget and tput functions
unsigned long size) read/write single values, byteswapping as neccessary. 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(target_ulong guest_addr, long len, int copy)
{ {
if (access_ok(VERIFY_WRITE, dst, size)) #ifdef DEBUG_REMAP
return __copy_to_user(dst, src, size); void *addr;
addr = malloc(len);
if (copy)
memcpy(addr, g2h(guest_addr), len);
else else
return size; memset(addr, 0, len);
return addr;
#else
return g2h(guest_addr);
#endif
} }
static inline unsigned long copy_from_user(void *dst, const void *src, /* Unlock an area of guest memory. The first LEN bytes must be flushed back
unsigned long size) to guest memory. */
static inline void unlock_user(void *host_addr, target_ulong guest_addr,
long len)
{ {
if (access_ok(VERIFY_READ, src, size)) #ifdef DEBUG_REMAP
return __copy_from_user(dst, src, size); if (host_addr == g2h(guest_addr))
else return;
return size; if (len > 0)
memcpy(g2h(guest_addr), host_addr, len);
free(host_addr);
#endif
} }
static inline unsigned long clear_user(void *dst, unsigned long size) /* Return the length of a string in target memory. */
static inline int target_strlen(target_ulong ptr)
{ {
if (access_ok(VERIFY_WRITE, dst, size)) return strlen(g2h(ptr));
return __clear_user(dst, size);
else
return size;
} }
/* Like lock_user but for null terminated strings. */
static inline void *lock_user_string(target_ulong guest_addr)
{
long len;
len = target_strlen(guest_addr) + 1;
return lock_user(guest_addr, len, 1);
}
/* Helper macros for locking/ulocking a target struct. */
#define lock_user_struct(host_ptr, guest_addr, copy) \
host_ptr = lock_user(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)
#define tget8(addr) ldub(addr)
#define tput8(addr, val) stb(addr, val)
#define tget16(addr) lduw(addr)
#define tput16(addr, val) stw(addr, val)
#define tget32(addr) ldl(addr)
#define tput32(addr, val) stl(addr, val)
#define tget64(addr) ldq(addr)
#define tput64(addr, val) stq(addr, val)
#if TARGET_LONG_BITS == 64
#define tgetl(addr) ldq(addr)
#define tputl(addr, val) stq(addr, val)
#else
#define tgetl(addr) ldl(addr)
#define tputl(addr, val) stl(addr, val)
#endif
#endif /* QEMU_H */ #endif /* QEMU_H */

32
linux-user/signal.c
View File

@ -135,7 +135,7 @@ void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
host_to_target_sigset_internal(&d1, s); host_to_target_sigset_internal(&d1, s);
for(i = 0;i < TARGET_NSIG_WORDS; i++) for(i = 0;i < TARGET_NSIG_WORDS; i++)
__put_user(d1.sig[i], &d->sig[i]); d->sig[i] = tswapl(d1.sig[i]);
} }
void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s) void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s)
@ -168,7 +168,7 @@ void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
int i; int i;
for(i = 0;i < TARGET_NSIG_WORDS; i++) for(i = 0;i < TARGET_NSIG_WORDS; i++)
__get_user(s1.sig[i], &s->sig[i]); s1.sig[i] = tswapl(s->sig[i]);
target_to_host_sigset_internal(d, &s1); target_to_host_sigset_internal(d, &s1);
} }
@ -647,7 +647,7 @@ get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
ka->sa.sa_restorer) { ka->sa.sa_restorer) {
esp = (unsigned long) ka->sa.sa_restorer; esp = (unsigned long) ka->sa.sa_restorer;
} }
return (void *)((esp - frame_size) & -8ul); return g2h((esp - frame_size) & -8ul);
} }
static void setup_frame(int sig, struct emulated_sigaction *ka, static void setup_frame(int sig, struct emulated_sigaction *ka,
@ -694,7 +694,7 @@ static void setup_frame(int sig, struct emulated_sigaction *ka,
goto give_sigsegv; goto give_sigsegv;
/* Set up registers for signal handler */ /* Set up registers for signal handler */
env->regs[R_ESP] = (unsigned long) frame; env->regs[R_ESP] = h2g(frame);
env->eip = (unsigned long) ka->sa._sa_handler; env->eip = (unsigned long) ka->sa._sa_handler;
cpu_x86_load_seg(env, R_DS, __USER_DS); cpu_x86_load_seg(env, R_DS, __USER_DS);
@ -835,7 +835,7 @@ badframe:
long do_sigreturn(CPUX86State *env) long do_sigreturn(CPUX86State *env)
{ {
struct sigframe *frame = (struct sigframe *)(env->regs[R_ESP] - 8); struct sigframe *frame = (struct sigframe *)g2h(env->regs[R_ESP] - 8);
target_sigset_t target_set; target_sigset_t target_set;
sigset_t set; sigset_t set;
int eax, i; int eax, i;
@ -866,7 +866,7 @@ badframe:
long do_rt_sigreturn(CPUX86State *env) long do_rt_sigreturn(CPUX86State *env)
{ {
struct rt_sigframe *frame = (struct rt_sigframe *)(env->regs[R_ESP] - 4); struct rt_sigframe *frame = (struct rt_sigframe *)g2h(env->regs[R_ESP] - 4);
sigset_t set; sigset_t set;
// stack_t st; // stack_t st;
int eax; int eax;
@ -1029,7 +1029,7 @@ get_sigframe(struct emulated_sigaction *ka, CPUState *regs, int framesize)
/* /*
* ATPCS B01 mandates 8-byte alignment * ATPCS B01 mandates 8-byte alignment
*/ */
return (void *)((sp - framesize) & ~7); return g2h((sp - framesize) & ~7);
} }
static int static int
@ -1084,7 +1084,7 @@ setup_return(CPUState *env, struct emulated_sigaction *ka,
} }
env->regs[0] = usig; env->regs[0] = usig;
env->regs[13] = (target_ulong)frame; env->regs[13] = h2g(frame);
env->regs[14] = retcode; env->regs[14] = retcode;
env->regs[15] = handler & (thumb ? ~1 : ~3); env->regs[15] = handler & (thumb ? ~1 : ~3);
@ -1130,7 +1130,7 @@ static void setup_rt_frame(int usig, struct emulated_sigaction *ka,
err |= copy_siginfo_to_user(&frame->info, info); err |= copy_siginfo_to_user(&frame->info, info);
/* Clear all the bits of the ucontext we don't use. */ /* Clear all the bits of the ucontext we don't use. */
err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext)); memset(&frame->uc, 0, offsetof(struct target_ucontext, tuc_mcontext));
err |= setup_sigcontext(&frame->uc.tuc_mcontext, /*&frame->fpstate,*/ err |= setup_sigcontext(&frame->uc.tuc_mcontext, /*&frame->fpstate,*/
env, set->sig[0]); env, set->sig[0]);
@ -1202,7 +1202,7 @@ long do_sigreturn(CPUState *env)
if (env->regs[13] & 7) if (env->regs[13] & 7)
goto badframe; goto badframe;
frame = (struct sigframe *)env->regs[13]; frame = (struct sigframe *)g2h(env->regs[13]);
#if 0 #if 0
if (verify_area(VERIFY_READ, frame, sizeof (*frame))) if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
@ -1378,7 +1378,7 @@ static inline void *get_sigframe(struct emulated_sigaction *sa, CPUState *env, u
sp = current->sas_ss_sp + current->sas_ss_size; sp = current->sas_ss_sp + current->sas_ss_size;
} }
#endif #endif
return (void *)(sp - framesize); return g2h(sp - framesize);
} }
static int static int
@ -1461,10 +1461,10 @@ static void setup_frame(int sig, struct emulated_sigaction *ka,
goto sigsegv; goto sigsegv;
/* 3. signal handler back-trampoline and parameters */ /* 3. signal handler back-trampoline and parameters */
env->regwptr[UREG_FP] = (target_ulong) sf; env->regwptr[UREG_FP] = h2g(sf);
env->regwptr[UREG_I0] = sig; env->regwptr[UREG_I0] = sig;
env->regwptr[UREG_I1] = (target_ulong) &sf->info; env->regwptr[UREG_I1] = h2g(&sf->info);
env->regwptr[UREG_I2] = (target_ulong) &sf->info; env->regwptr[UREG_I2] = h2g(&sf->info);
/* 4. signal handler */ /* 4. signal handler */
env->pc = (unsigned long) ka->sa._sa_handler; env->pc = (unsigned long) ka->sa._sa_handler;
@ -1473,7 +1473,7 @@ static void setup_frame(int sig, struct emulated_sigaction *ka,
if (ka->sa.sa_restorer) if (ka->sa.sa_restorer)
env->regwptr[UREG_I7] = (unsigned long)ka->sa.sa_restorer; env->regwptr[UREG_I7] = (unsigned long)ka->sa.sa_restorer;
else { else {
env->regwptr[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2); env->regwptr[UREG_I7] = h2g(&(sf->insns[0]) - 2);
/* mov __NR_sigreturn, %g1 */ /* mov __NR_sigreturn, %g1 */
err |= __put_user(0x821020d8, &sf->insns[0]); err |= __put_user(0x821020d8, &sf->insns[0]);
@ -1548,7 +1548,7 @@ long do_sigreturn(CPUState *env)
target_ulong fpu_save; target_ulong fpu_save;
int err, i; int err, i;
sf = (struct target_signal_frame *) env->regwptr[UREG_FP]; sf = (struct target_signal_frame *)g2h(env->regwptr[UREG_FP]);
#if 0 #if 0
fprintf(stderr, "sigreturn\n"); fprintf(stderr, "sigreturn\n");
fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]); fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);

1116
linux-user/syscall.c
View File

File diff suppressed because it is too large Load Diff

3
linux-user/syscall_types.h
View File

@ -68,6 +68,9 @@ STRUCT(dirent,
STRUCT(kbentry, STRUCT(kbentry,
TYPE_CHAR, TYPE_CHAR, TYPE_SHORT) TYPE_CHAR, TYPE_CHAR, TYPE_SHORT)
STRUCT(kbsentry,
TYPE_CHAR, MK_ARRAY(TYPE_CHAR, 512))
STRUCT(audio_buf_info, STRUCT(audio_buf_info,
TYPE_INT, TYPE_INT, TYPE_INT, TYPE_INT) TYPE_INT, TYPE_INT, TYPE_INT, TYPE_INT)

43
linux-user/vm86.c
View File

@ -62,25 +62,28 @@ static inline unsigned int vm_getl(uint8_t *segptr, unsigned int reg16)
void save_v86_state(CPUX86State *env) void save_v86_state(CPUX86State *env)
{ {
TaskState *ts = env->opaque; TaskState *ts = env->opaque;
struct target_vm86plus_struct * target_v86;
lock_user_struct(target_v86, ts->target_v86, 0);
/* put the VM86 registers in the userspace register structure */ /* put the VM86 registers in the userspace register structure */
ts->target_v86->regs.eax = tswap32(env->regs[R_EAX]); target_v86->regs.eax = tswap32(env->regs[R_EAX]);
ts->target_v86->regs.ebx = tswap32(env->regs[R_EBX]); target_v86->regs.ebx = tswap32(env->regs[R_EBX]);
ts->target_v86->regs.ecx = tswap32(env->regs[R_ECX]); target_v86->regs.ecx = tswap32(env->regs[R_ECX]);
ts->target_v86->regs.edx = tswap32(env->regs[R_EDX]); target_v86->regs.edx = tswap32(env->regs[R_EDX]);
ts->target_v86->regs.esi = tswap32(env->regs[R_ESI]); target_v86->regs.esi = tswap32(env->regs[R_ESI]);
ts->target_v86->regs.edi = tswap32(env->regs[R_EDI]); target_v86->regs.edi = tswap32(env->regs[R_EDI]);
ts->target_v86->regs.ebp = tswap32(env->regs[R_EBP]); target_v86->regs.ebp = tswap32(env->regs[R_EBP]);
ts->target_v86->regs.esp = tswap32(env->regs[R_ESP]); target_v86->regs.esp = tswap32(env->regs[R_ESP]);
ts->target_v86->regs.eip = tswap32(env->eip); target_v86->regs.eip = tswap32(env->eip);
ts->target_v86->regs.cs = tswap16(env->segs[R_CS].selector); target_v86->regs.cs = tswap16(env->segs[R_CS].selector);
ts->target_v86->regs.ss = tswap16(env->segs[R_SS].selector); target_v86->regs.ss = tswap16(env->segs[R_SS].selector);
ts->target_v86->regs.ds = tswap16(env->segs[R_DS].selector); target_v86->regs.ds = tswap16(env->segs[R_DS].selector);
ts->target_v86->regs.es = tswap16(env->segs[R_ES].selector); target_v86->regs.es = tswap16(env->segs[R_ES].selector);
ts->target_v86->regs.fs = tswap16(env->segs[R_FS].selector); target_v86->regs.fs = tswap16(env->segs[R_FS].selector);
ts->target_v86->regs.gs = tswap16(env->segs[R_GS].selector); target_v86->regs.gs = tswap16(env->segs[R_GS].selector);
set_flags(env->eflags, ts->v86flags, VIF_MASK | ts->v86mask); set_flags(env->eflags, ts->v86flags, VIF_MASK | ts->v86mask);
ts->target_v86->regs.eflags = tswap32(env->eflags); target_v86->regs.eflags = tswap32(env->eflags);
unlock_user_struct(target_v86, ts->target_v86, 1);
#ifdef DEBUG_VM86 #ifdef DEBUG_VM86
fprintf(logfile, "save_v86_state: eflags=%08x cs:ip=%04x:%04x\n", fprintf(logfile, "save_v86_state: eflags=%08x cs:ip=%04x:%04x\n",
env->eflags, env->segs[R_CS].selector, env->eip); env->eflags, env->segs[R_CS].selector, env->eip);
@ -378,10 +381,10 @@ void handle_vm86_fault(CPUX86State *env)
} }
} }
int do_vm86(CPUX86State *env, long subfunction, int do_vm86(CPUX86State *env, long subfunction, target_ulong vm86_addr)
struct target_vm86plus_struct * target_v86)
{ {
TaskState *ts = env->opaque; TaskState *ts = env->opaque;
struct target_vm86plus_struct * target_v86;
int ret; int ret;
switch (subfunction) { switch (subfunction) {
@ -402,7 +405,6 @@ int do_vm86(CPUX86State *env, long subfunction,
goto out; goto out;
} }
ts->target_v86 = target_v86;
/* save current CPU regs */ /* save current CPU regs */
ts->vm86_saved_regs.eax = 0; /* default vm86 syscall return code */ ts->vm86_saved_regs.eax = 0; /* default vm86 syscall return code */
ts->vm86_saved_regs.ebx = env->regs[R_EBX]; ts->vm86_saved_regs.ebx = env->regs[R_EBX];
@ -421,6 +423,8 @@ int do_vm86(CPUX86State *env, long subfunction,
ts->vm86_saved_regs.fs = env->segs[R_FS].selector; ts->vm86_saved_regs.fs = env->segs[R_FS].selector;
ts->vm86_saved_regs.gs = env->segs[R_GS].selector; ts->vm86_saved_regs.gs = env->segs[R_GS].selector;
ts->target_v86 = vm86_addr;
lock_user_struct(target_v86, vm86_addr, 1);
/* build vm86 CPU state */ /* build vm86 CPU state */
ts->v86flags = tswap32(target_v86->regs.eflags); ts->v86flags = tswap32(target_v86->regs.eflags);
env->eflags = (env->eflags & ~SAFE_MASK) | env->eflags = (env->eflags & ~SAFE_MASK) |
@ -465,6 +469,7 @@ int do_vm86(CPUX86State *env, long subfunction,
ts->vm86plus.vm86plus.flags = tswapl(target_v86->vm86plus.flags); ts->vm86plus.vm86plus.flags = tswapl(target_v86->vm86plus.flags);
memcpy(&ts->vm86plus.vm86plus.vm86dbg_intxxtab, memcpy(&ts->vm86plus.vm86plus.vm86dbg_intxxtab,
target_v86->vm86plus.vm86dbg_intxxtab, 32); target_v86->vm86plus.vm86dbg_intxxtab, 32);
unlock_user_struct(target_v86, vm86_addr, 0);
#ifdef DEBUG_VM86 #ifdef DEBUG_VM86
fprintf(logfile, "do_vm86: cs:ip=%04x:%04x\n", fprintf(logfile, "do_vm86: cs:ip=%04x:%04x\n",

62
target-arm/nwfpe/fpa11_cpdt.c
View File

@ -31,48 +31,52 @@
static inline static inline
void loadSingle(const unsigned int Fn,const unsigned int *pMem) void loadSingle(const unsigned int Fn,const unsigned int *pMem)
{ {
target_ulong addr = (target_ulong)(long)pMem;
FPA11 *fpa11 = GET_FPA11(); FPA11 *fpa11 = GET_FPA11();
fpa11->fType[Fn] = typeSingle; fpa11->fType[Fn] = typeSingle;
get_user(fpa11->fpreg[Fn].fSingle, pMem); fpa11->fpreg[Fn].fSingle = tget32(addr);
} }
static inline static inline
void loadDouble(const unsigned int Fn,const unsigned int *pMem) void loadDouble(const unsigned int Fn,const unsigned int *pMem)
{ {
target_ulong addr = (target_ulong)(long)pMem;
FPA11 *fpa11 = GET_FPA11(); FPA11 *fpa11 = GET_FPA11();
unsigned int *p; unsigned int *p;
p = (unsigned int*)&fpa11->fpreg[Fn].fDouble; p = (unsigned int*)&fpa11->fpreg[Fn].fDouble;
fpa11->fType[Fn] = typeDouble; fpa11->fType[Fn] = typeDouble;
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
get_user(p[0], &pMem[0]); /* sign & exponent */ p[0] = tget32(addr); /* sign & exponent */
get_user(p[1], &pMem[1]); p[1] = tget32(addr + 4);
#else #else
get_user(p[0], &pMem[1]); p[0] = tget32(addr + 4);
get_user(p[1], &pMem[0]); /* sign & exponent */ p[1] = tget32(addr); /* sign & exponent */
#endif #endif
} }
static inline static inline
void loadExtended(const unsigned int Fn,const unsigned int *pMem) void loadExtended(const unsigned int Fn,const unsigned int *pMem)
{ {
target_ulong addr = (target_ulong)(long)pMem;
FPA11 *fpa11 = GET_FPA11(); FPA11 *fpa11 = GET_FPA11();
unsigned int *p; unsigned int *p;
p = (unsigned int*)&fpa11->fpreg[Fn].fExtended; p = (unsigned int*)&fpa11->fpreg[Fn].fExtended;
fpa11->fType[Fn] = typeExtended; fpa11->fType[Fn] = typeExtended;
get_user(p[0], &pMem[0]); /* sign & exponent */ p[0] = tget32(addr); /* sign & exponent */
get_user(p[1], &pMem[2]); /* ls bits */ p[1] = tget32(addr + 8); /* ls bits */
get_user(p[2], &pMem[1]); /* ms bits */ p[2] = tget32(addr + 4); /* ms bits */
} }
static inline static inline
void loadMultiple(const unsigned int Fn,const unsigned int *pMem) void loadMultiple(const unsigned int Fn,const unsigned int *pMem)
{ {
target_ulong addr = (target_ulong)(long)pMem;
FPA11 *fpa11 = GET_FPA11(); FPA11 *fpa11 = GET_FPA11();
register unsigned int *p; register unsigned int *p;
unsigned long x; unsigned long x;
p = (unsigned int*)&(fpa11->fpreg[Fn]); p = (unsigned int*)&(fpa11->fpreg[Fn]);
get_user(x, &pMem[0]); x = tget32(addr);
fpa11->fType[Fn] = (x >> 14) & 0x00000003; fpa11->fType[Fn] = (x >> 14) & 0x00000003;
switch (fpa11->fType[Fn]) switch (fpa11->fType[Fn])
@ -80,16 +84,16 @@ void loadMultiple(const unsigned int Fn,const unsigned int *pMem)
case typeSingle: case typeSingle:
case typeDouble: case typeDouble:
{ {
get_user(p[0], &pMem[2]); /* Single */ p[0] = tget32(addr + 8); /* Single */
get_user(p[1], &pMem[1]); /* double msw */ p[1] = tget32(addr + 4); /* double msw */
p[2] = 0; /* empty */ p[2] = 0; /* empty */
} }
break; break;
case typeExtended: case typeExtended:
{ {
get_user(p[1], &pMem[2]); p[1] = tget32(addr + 8);
get_user(p[2], &pMem[1]); /* msw */ p[2] = tget32(addr + 4); /* msw */
p[0] = (x & 0x80003fff); p[0] = (x & 0x80003fff);
} }
break; break;
@ -99,6 +103,7 @@ void loadMultiple(const unsigned int Fn,const unsigned int *pMem)
static inline static inline
void storeSingle(const unsigned int Fn,unsigned int *pMem) void storeSingle(const unsigned int Fn,unsigned int *pMem)
{ {
target_ulong addr = (target_ulong)(long)pMem;
FPA11 *fpa11 = GET_FPA11(); FPA11 *fpa11 = GET_FPA11();
float32 val; float32 val;
register unsigned int *p = (unsigned int*)&val; register unsigned int *p = (unsigned int*)&val;
@ -116,12 +121,13 @@ void storeSingle(const unsigned int Fn,unsigned int *pMem)
default: val = fpa11->fpreg[Fn].fSingle; default: val = fpa11->fpreg[Fn].fSingle;
} }
put_user(p[0], pMem); tput32(addr, p[0]);
} }
static inline static inline
void storeDouble(const unsigned int Fn,unsigned int *pMem) void storeDouble(const unsigned int Fn,unsigned int *pMem)
{ {
target_ulong addr = (target_ulong)(long)pMem;
FPA11 *fpa11 = GET_FPA11(); FPA11 *fpa11 = GET_FPA11();
float64 val; float64 val;
register unsigned int *p = (unsigned int*)&val; register unsigned int *p = (unsigned int*)&val;
@ -139,17 +145,18 @@ void storeDouble(const unsigned int Fn,unsigned int *pMem)
default: val = fpa11->fpreg[Fn].fDouble; default: val = fpa11->fpreg[Fn].fDouble;
} }
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
put_user(p[0], &pMem[0]); /* msw */ tput32(addr, p[0]); /* msw */
put_user(p[1], &pMem[1]); /* lsw */ tput32(addr + 4, p[1]); /* lsw */
#else #else
put_user(p[1], &pMem[0]); /* msw */ tput32(addr, p[1]); /* msw */
put_user(p[0], &pMem[1]); /* lsw */ tput32(addr + 4, p[0]); /* lsw */
#endif #endif
} }
static inline static inline
void storeExtended(const unsigned int Fn,unsigned int *pMem) void storeExtended(const unsigned int Fn,unsigned int *pMem)
{ {
target_ulong addr = (target_ulong)(long)pMem;
FPA11 *fpa11 = GET_FPA11(); FPA11 *fpa11 = GET_FPA11();
floatx80 val; floatx80 val;
register unsigned int *p = (unsigned int*)&val; register unsigned int *p = (unsigned int*)&val;
@ -167,14 +174,15 @@ void storeExtended(const unsigned int Fn,unsigned int *pMem)
default: val = fpa11->fpreg[Fn].fExtended; default: val = fpa11->fpreg[Fn].fExtended;
} }
put_user(p[0], &pMem[0]); /* sign & exp */ tput32(addr, p[0]); /* sign & exp */
put_user(p[1], &pMem[2]); tput32(addr + 8, p[1]);
put_user(p[2], &pMem[1]); /* msw */ tput32(addr + 4, p[2]); /* msw */
} }
static inline static inline
void storeMultiple(const unsigned int Fn,unsigned int *pMem) void storeMultiple(const unsigned int Fn,unsigned int *pMem)
{ {
target_ulong addr = (target_ulong)(long)pMem;
FPA11 *fpa11 = GET_FPA11(); FPA11 *fpa11 = GET_FPA11();
register unsigned int nType, *p; register unsigned int nType, *p;
@ -186,17 +194,17 @@ void storeMultiple(const unsigned int Fn,unsigned int *pMem)
case typeSingle: case typeSingle:
case typeDouble: case typeDouble:
{ {
put_user(p[0], &pMem[2]); /* single */ tput32(addr + 8, p[0]); /* single */
put_user(p[1], &pMem[1]); /* double msw */ tput32(addr + 4, p[1]); /* double msw */
put_user(nType << 14, &pMem[0]); tput32(addr, nType << 14);
} }
break; break;
case typeExtended: case typeExtended:
{ {
put_user(p[2], &pMem[1]); /* msw */ tput32(addr + 4, p[2]); /* msw */
put_user(p[1], &pMem[2]); tput32(addr + 8, p[1]);
put_user((p[0] & 0x80003fff) | (nType << 14), &pMem[0]); tput32(addr, (p[0] & 0x80003fff) | (nType << 14));
} }
break; break;
} }