X-Git-Url: http://vcs.maemo.org/git/?a=blobdiff_plain;f=arm-semi.c;h=1cf22038872b7219cb5b306074a6885c5148d2fc;hb=d66846a14e191c75f4aa373623dd9a7aaa843ade;hp=4254cba84aefdd31efa7de2a20990a701722072c;hpb=8e71621f784b27ac06c3b6301df161e445132b88;p=qemu diff --git a/arm-semi.c b/arm-semi.c index 4254cba..1cf2203 100644 --- a/arm-semi.c +++ b/arm-semi.c @@ -1,6 +1,6 @@ /* * Arm "Angel" semihosting syscalls - * + * * Copyright (c) 2005, 2007 CodeSourcery. * Written by Paul Brook. * @@ -33,7 +33,9 @@ #define ARM_ANGEL_HEAP_SIZE (128 * 1024 * 1024) #else -#include "vl.h" +#include "qemu-common.h" +#include "sysemu.h" +#include "gdbstub.h" #endif #define SYS_OPEN 0x01 @@ -61,7 +63,30 @@ #define O_BINARY 0 #endif -int open_modeflags[12] = { +#define GDB_O_RDONLY 0x000 +#define GDB_O_WRONLY 0x001 +#define GDB_O_RDWR 0x002 +#define GDB_O_APPEND 0x008 +#define GDB_O_CREAT 0x200 +#define GDB_O_TRUNC 0x400 +#define GDB_O_BINARY 0 + +static int gdb_open_modeflags[12] = { + GDB_O_RDONLY, + GDB_O_RDONLY | GDB_O_BINARY, + GDB_O_RDWR, + GDB_O_RDWR | GDB_O_BINARY, + GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC, + GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY, + GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC, + GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY, + GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND, + GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY, + GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND, + GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY +}; + +static int open_modeflags[12] = { O_RDONLY, O_RDONLY | O_BINARY, O_RDWR, @@ -89,61 +114,67 @@ static inline uint32_t set_swi_errno(CPUState *env, uint32_t code) return code; } -static uint32_t softmmu_tget32(CPUState *env, uint32_t addr) -{ - uint32_t val; +#include "softmmu-semi.h" +#endif - cpu_memory_rw_debug(env, addr, (uint8_t *)&val, 4, 0); - return tswap32(val); -} -static uint32_t softmmu_tget8(CPUState *env, uint32_t addr) -{ - uint8_t val; +static target_ulong arm_semi_syscall_len; - cpu_memory_rw_debug(env, addr, &val, 1, 0); - return val; -} -#define tget32(p) softmmu_tget32(env, p) -#define tget8(p) softmmu_tget8(env, p) +#if !defined(CONFIG_USER_ONLY) +static target_ulong syscall_err; +#endif -static void *softmmu_lock_user(CPUState *env, uint32_t addr, uint32_t len, - int copy) +static void arm_semi_cb(CPUState *env, target_ulong ret, target_ulong err) { - char *p; - /* TODO: Make this something that isn't fixed size. */ - p = malloc(len); - if (copy) - cpu_memory_rw_debug(env, addr, p, len, 0); - return p; -} -#define lock_user(p, len, copy) softmmu_lock_user(env, p, len, copy) -static char *softmmu_lock_user_string(CPUState *env, uint32_t addr) -{ - char *p; - char *s; - uint8_t c; - /* TODO: Make this something that isn't fixed size. */ - s = p = malloc(1024); - do { - cpu_memory_rw_debug(env, addr, &c, 1, 0); - addr++; - *(p++) = c; - } while (c); - return s; +#ifdef CONFIG_USER_ONLY + TaskState *ts = env->opaque; +#endif + + if (ret == (target_ulong)-1) { +#ifdef CONFIG_USER_ONLY + ts->swi_errno = err; +#else + syscall_err = err; +#endif + env->regs[0] = ret; + } else { + /* Fixup syscalls that use nonstardard return conventions. */ + switch (env->regs[0]) { + case SYS_WRITE: + case SYS_READ: + env->regs[0] = arm_semi_syscall_len - ret; + break; + case SYS_SEEK: + env->regs[0] = 0; + break; + default: + env->regs[0] = ret; + break; + } + } } -#define lock_user_string(p) softmmu_lock_user_string(env, p) -static void softmmu_unlock_user(CPUState *env, void *p, target_ulong addr, - target_ulong len) + +static void arm_semi_flen_cb(CPUState *env, target_ulong ret, target_ulong err) { - if (len) - cpu_memory_rw_debug(env, addr, p, len, 1); - free(p); -} -#define unlock_user(s, args, len) softmmu_unlock_user(env, s, args, len) + /* The size is always stored in big-endian order, extract + the value. We assume the size always fit in 32 bits. */ + uint32_t size; + cpu_memory_rw_debug(env, env->regs[13]-64+32, (uint8_t *)&size, 4, 0); + env->regs[0] = be32_to_cpu(size); +#ifdef CONFIG_USER_ONLY + ((TaskState *)env->opaque)->swi_errno = err; +#else + syscall_err = err; #endif +} -#define ARG(n) tget32(args + (n) * 4) -#define SET_ARG(n, val) tput32(args + (n) * 4,val) +#define ARG(n) \ +({ \ + target_ulong __arg; \ + /* FIXME - handle get_user() failure */ \ + get_user_ual(__arg, args + (n) * 4); \ + __arg; \ +}) +#define SET_ARG(n, val) put_user_ual(val, args + (n) * 4) uint32_t do_arm_semihosting(CPUState *env) { target_ulong args; @@ -161,61 +192,121 @@ uint32_t do_arm_semihosting(CPUState *env) args = env->regs[1]; switch (nr) { case SYS_OPEN: - s = lock_user_string(ARG(0)); + if (!(s = lock_user_string(ARG(0)))) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; if (ARG(1) >= 12) - return (uint32_t)-1; + return (uint32_t)-1; if (strcmp(s, ":tt") == 0) { if (ARG(1) < 4) return STDIN_FILENO; else return STDOUT_FILENO; } - ret = set_swi_errno(ts, open(s, open_modeflags[ARG(1)], 0644)); + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_cb, "open,%s,%x,1a4", ARG(0), + (int)ARG(2)+1, gdb_open_modeflags[ARG(1)]); + return env->regs[0]; + } else { + ret = set_swi_errno(ts, open(s, open_modeflags[ARG(1)], 0644)); + } unlock_user(s, ARG(0), 0); return ret; case SYS_CLOSE: - return set_swi_errno(ts, close(ARG(0))); + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_cb, "close,%x", ARG(0)); + return env->regs[0]; + } else { + return set_swi_errno(ts, close(ARG(0))); + } case SYS_WRITEC: { - char c = tget8(args); + char c; + + if (get_user_u8(c, args)) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; /* Write to debug console. stderr is near enough. */ - return write(STDERR_FILENO, &c, 1); + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_cb, "write,2,%x,1", args); + return env->regs[0]; + } else { + return write(STDERR_FILENO, &c, 1); + } } case SYS_WRITE0: - s = lock_user_string(args); - ret = write(STDERR_FILENO, s, strlen(s)); + if (!(s = lock_user_string(args))) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; + len = strlen(s); + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_cb, "write,2,%x,%x\n", args, len); + ret = env->regs[0]; + } else { + ret = write(STDERR_FILENO, s, len); + } unlock_user(s, args, 0); return ret; case SYS_WRITE: len = ARG(2); - s = lock_user(ARG(1), len, 1); - ret = set_swi_errno(ts, write(ARG(0), s, len)); - unlock_user(s, ARG(1), 0); - if (ret == (uint32_t)-1) - return -1; - return ARG(2) - ret; + if (use_gdb_syscalls()) { + arm_semi_syscall_len = len; + gdb_do_syscall(arm_semi_cb, "write,%x,%x,%x", ARG(0), ARG(1), len); + return env->regs[0]; + } else { + if (!(s = lock_user(VERIFY_READ, ARG(1), len, 1))) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; + ret = set_swi_errno(ts, write(ARG(0), s, len)); + unlock_user(s, ARG(1), 0); + if (ret == (uint32_t)-1) + return -1; + return len - ret; + } case SYS_READ: len = ARG(2); - s = lock_user(ARG(1), len, 0); - do - ret = set_swi_errno(ts, read(ARG(0), s, len)); - while (ret == -1 && errno == EINTR); - unlock_user(s, ARG(1), len); - if (ret == (uint32_t)-1) - return -1; - return ARG(2) - ret; + if (use_gdb_syscalls()) { + arm_semi_syscall_len = len; + gdb_do_syscall(arm_semi_cb, "read,%x,%x,%x", ARG(0), ARG(1), len); + return env->regs[0]; + } else { + if (!(s = lock_user(VERIFY_WRITE, ARG(1), len, 0))) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; + do + ret = set_swi_errno(ts, read(ARG(0), s, len)); + while (ret == -1 && errno == EINTR); + unlock_user(s, ARG(1), len); + if (ret == (uint32_t)-1) + return -1; + return len - ret; + } case SYS_READC: /* XXX: Read from debug cosole. Not implemented. */ return 0; case SYS_ISTTY: - return isatty(ARG(0)); + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_cb, "isatty,%x", ARG(0)); + return env->regs[0]; + } else { + return isatty(ARG(0)); + } case SYS_SEEK: - ret = set_swi_errno(ts, lseek(ARG(0), ARG(1), SEEK_SET)); - if (ret == (uint32_t)-1) - return -1; - return 0; + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_cb, "lseek,%x,%x,0", ARG(0), ARG(1)); + return env->regs[0]; + } else { + ret = set_swi_errno(ts, lseek(ARG(0), ARG(1), SEEK_SET)); + if (ret == (uint32_t)-1) + return -1; + return 0; + } case SYS_FLEN: - { + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_flen_cb, "fstat,%x,%x", + ARG(0), env->regs[13]-64); + return env->regs[0]; + } else { struct stat buf; ret = set_swi_errno(ts, fstat(ARG(0), &buf)); if (ret == (uint32_t)-1) @@ -226,18 +317,35 @@ uint32_t do_arm_semihosting(CPUState *env) /* XXX: Not implemented. */ return -1; case SYS_REMOVE: - s = lock_user_string(ARG(0)); - ret = set_swi_errno(ts, remove(s)); - unlock_user(s, ARG(0), 0); + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_cb, "unlink,%s", ARG(0), (int)ARG(1)+1); + ret = env->regs[0]; + } else { + if (!(s = lock_user_string(ARG(0)))) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; + ret = set_swi_errno(ts, remove(s)); + unlock_user(s, ARG(0), 0); + } return ret; case SYS_RENAME: - { + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_cb, "rename,%s,%s", + ARG(0), (int)ARG(1)+1, ARG(2), (int)ARG(3)+1); + return env->regs[0]; + } else { char *s2; s = lock_user_string(ARG(0)); s2 = lock_user_string(ARG(2)); - ret = set_swi_errno(ts, rename(s, s2)); - unlock_user(s2, ARG(2), 0); - unlock_user(s, ARG(0), 0); + if (!s || !s2) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + ret = (uint32_t)-1; + else + ret = set_swi_errno(ts, rename(s, s2)); + if (s2) + unlock_user(s2, ARG(2), 0); + if (s) + unlock_user(s, ARG(0), 0); return ret; } case SYS_CLOCK: @@ -245,14 +353,21 @@ uint32_t do_arm_semihosting(CPUState *env) case SYS_TIME: return set_swi_errno(ts, time(NULL)); case SYS_SYSTEM: - s = lock_user_string(ARG(0)); - ret = set_swi_errno(ts, system(s)); - unlock_user(s, ARG(0), 0); + if (use_gdb_syscalls()) { + gdb_do_syscall(arm_semi_cb, "system,%s", ARG(0), (int)ARG(1)+1); + return env->regs[0]; + } else { + if (!(s = lock_user_string(ARG(0)))) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; + ret = set_swi_errno(ts, system(s)); + unlock_user(s, ARG(0), 0); + } case SYS_ERRNO: #ifdef CONFIG_USER_ONLY return ts->swi_errno; #else - return 0; + return syscall_err; #endif case SYS_GET_CMDLINE: #ifdef CONFIG_USER_ONLY @@ -261,7 +376,11 @@ uint32_t do_arm_semihosting(CPUState *env) char **arg = ts->info->host_argv; int len = ARG(1); /* lock the buffer on the ARM side */ - char *cmdline_buffer = (char*)lock_user(ARG(0), len, 0); + char *cmdline_buffer = (char*)lock_user(VERIFY_WRITE, ARG(0), len, 0); + + if (!cmdline_buffer) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; s = cmdline_buffer; while (*arg && len > 2) { @@ -316,8 +435,10 @@ uint32_t do_arm_semihosting(CPUState *env) } ts->heap_limit = limit; } - - ptr = lock_user(ARG(0), 16, 0); + + if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0))) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; ptr[0] = tswap32(ts->heap_base); ptr[1] = tswap32(ts->heap_limit); ptr[2] = tswap32(ts->stack_base); @@ -325,7 +446,9 @@ uint32_t do_arm_semihosting(CPUState *env) unlock_user(ptr, ARG(0), 16); #else limit = ram_size; - ptr = lock_user(ARG(0), 16, 0); + if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0))) + /* FIXME - should this error code be -TARGET_EFAULT ? */ + return (uint32_t)-1; /* TODO: Make this use the limit of the loaded application. */ ptr[0] = tswap32(limit / 2); ptr[1] = tswap32(limit);