[qemu.git] / arm-semi.c

/*
 *  Arm "Angel" semihosting syscalls
 * 
 *  Copyright (c) 2005, 2007 CodeSourcery.
 *  Written by Paul Brook.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#include "cpu.h"
#ifdef CONFIG_USER_ONLY
#include "qemu.h"

#define ARM_ANGEL_HEAP_SIZE (128 * 1024 * 1024)
#else
#include "vl.h"
#endif

#define SYS_OPEN        0x01
#define SYS_CLOSE       0x02
#define SYS_WRITEC      0x03
#define SYS_WRITE0      0x04
#define SYS_WRITE       0x05
#define SYS_READ        0x06
#define SYS_READC       0x07
#define SYS_ISTTY       0x09
#define SYS_SEEK        0x0a
#define SYS_FLEN        0x0c
#define SYS_TMPNAM      0x0d
#define SYS_REMOVE      0x0e
#define SYS_RENAME      0x0f
#define SYS_CLOCK       0x10
#define SYS_TIME        0x11
#define SYS_SYSTEM      0x12
#define SYS_ERRNO       0x13
#define SYS_GET_CMDLINE 0x15
#define SYS_HEAPINFO    0x16
#define SYS_EXIT        0x18

#ifndef O_BINARY
#define O_BINARY 0
#endif

#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,
    O_RDWR | O_BINARY,
    O_WRONLY | O_CREAT | O_TRUNC,
    O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
    O_RDWR | O_CREAT | O_TRUNC,
    O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
    O_WRONLY | O_CREAT | O_APPEND,
    O_WRONLY | O_CREAT | O_APPEND | O_BINARY,
    O_RDWR | O_CREAT | O_APPEND,
    O_RDWR | O_CREAT | O_APPEND | O_BINARY
};

#ifdef CONFIG_USER_ONLY
static inline uint32_t set_swi_errno(TaskState *ts, uint32_t code)
{
    if (code == (uint32_t)-1)
        ts->swi_errno = errno;
    return code;
}
#else
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;

    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;

    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)

static void *softmmu_lock_user(CPUState *env, uint32_t addr, uint32_t len,
                               int copy)
{
    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;
}
#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)
{
    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)
#endif

static target_ulong arm_semi_syscall_len;

static void arm_semi_cb(CPUState *env, target_ulong ret, target_ulong err)
{
#ifdef CONFIG_USER_ONLY
    TaskState *ts = env->opaque;
#endif
    if (ret == (target_ulong)-1) {
#ifdef CONFIG_USER_ONLY
        ts->swi_errno = 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 ARG(n) tget32(args + (n) * 4)
#define SET_ARG(n, val) tput32(args + (n) * 4,val)
uint32_t do_arm_semihosting(CPUState *env)
{
    target_ulong args;
    char * s;
    int nr;
    uint32_t ret;
    uint32_t len;
#ifdef CONFIG_USER_ONLY
    TaskState *ts = env->opaque;
#else
    CPUState *ts = env;
#endif

    nr = env->regs[0];
    args = env->regs[1];
    switch (nr) {
    case SYS_OPEN:
        s = lock_user_string(ARG(0));
        if (ARG(1) >= 12)
          return (uint32_t)-1;
        if (strcmp(s, ":tt") == 0) {
            if (ARG(1) < 4)
                return STDIN_FILENO;
            else
                return STDOUT_FILENO;
        }
        if (use_gdb_syscalls()) {
            gdb_do_syscall(arm_semi_cb, "open,%s,%x,1a4", ARG(0), (int)ARG(2),
                           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:
        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);
          /* Write to debug console.  stderr is near enough.  */
          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);
        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);
        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 {
            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 len - ret;
        }
    case SYS_READ:
        len = ARG(2);
        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 {
            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 len - ret;
        }
    case SYS_READC:
       /* XXX: Read from debug cosole. Not implemented.  */
        return 0;
    case SYS_ISTTY:
        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:
        if (use_gdb_syscalls()) {
            gdb_do_syscall(arm_semi_cb, "fseek,%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()) {
            /* TODO: Use stat syscall.  */
            return -1;
        } else {
            struct stat buf;
            ret = set_swi_errno(ts, fstat(ARG(0), &buf));
            if (ret == (uint32_t)-1)
                return -1;
            return buf.st_size;
        }
    case SYS_TMPNAM:
        /* XXX: Not implemented.  */
        return -1;
    case SYS_REMOVE:
        if (use_gdb_syscalls()) {
            gdb_do_syscall(arm_semi_cb, "unlink,%s", ARG(0), (int)ARG(1));
            ret = env->regs[0];
        } else {
            s = lock_user_string(ARG(0));
            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), ARG(2), (int)ARG(3));
            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);
            return ret;
        }
    case SYS_CLOCK:
        return clock() / (CLOCKS_PER_SEC / 100);
    case SYS_TIME:
        return set_swi_errno(ts, time(NULL));
    case SYS_SYSTEM:
        if (use_gdb_syscalls()) {
            gdb_do_syscall(arm_semi_cb, "system,%s", ARG(0), (int)ARG(1));
            return env->regs[0];
        } else {
            s = lock_user_string(ARG(0));
            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;
#endif
    case SYS_GET_CMDLINE:
#ifdef CONFIG_USER_ONLY
        /* Build a commandline from the original argv.  */
        {
            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);

            s = cmdline_buffer;
            while (*arg && len > 2) {
                int n = strlen(*arg);

                if (s != cmdline_buffer) {
                    *(s++) = ' ';
                    len--;
                }
                if (n >= len)
                    n = len - 1;
                memcpy(s, *arg, n);
                s += n;
                len -= n;
                arg++;
            }
            /* Null terminate the string.  */
            *s = 0;
            len = s - cmdline_buffer;

            /* Unlock the buffer on the ARM side.  */
            unlock_user(cmdline_buffer, ARG(0), len);

            /* Adjust the commandline length argument.  */
            SET_ARG(1, len);

            /* Return success if commandline fit into buffer.  */
            return *arg ? -1 : 0;
        }
#else
      return -1;
#endif
    case SYS_HEAPINFO:
        {
            uint32_t *ptr;
            uint32_t limit;

#ifdef CONFIG_USER_ONLY
            /* Some C libraries assume the heap immediately follows .bss, so
               allocate it using sbrk.  */
            if (!ts->heap_limit) {
                long ret;

                ts->heap_base = do_brk(0);
                limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
                /* Try a big heap, and reduce the size if that fails.  */
                for (;;) {
                    ret = do_brk(limit);
                    if (ret != -1)
                        break;
                    limit = (ts->heap_base >> 1) + (limit >> 1);
                }
                ts->heap_limit = limit;
            }
              
            ptr = lock_user(ARG(0), 16, 0);
            ptr[0] = tswap32(ts->heap_base);
            ptr[1] = tswap32(ts->heap_limit);
            ptr[2] = tswap32(ts->stack_base);
            ptr[3] = tswap32(0); /* Stack limit.  */
            unlock_user(ptr, ARG(0), 16);
#else
            limit = ram_size;
            ptr = lock_user(ARG(0), 16, 0);
            /* TODO: Make this use the limit of the loaded application.  */
            ptr[0] = tswap32(limit / 2);
            ptr[1] = tswap32(limit);
            ptr[2] = tswap32(limit); /* Stack base */
            ptr[3] = tswap32(0); /* Stack limit.  */
            unlock_user(ptr, ARG(0), 16);
#endif
            return 0;
        }
    case SYS_EXIT:
        exit(0);
    default:
        fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
        cpu_dump_state(env, stderr, fprintf, 0);
        abort();
    }
}
Commit	Line	Data
a4f81979 FB	1	/*
	2	* Arm "Angel" semihosting syscalls
	3	*
8e71621f PB	4	* Copyright (c) 2005, 2007 CodeSourcery.
8e71621f PB	5	* Written by Paul Brook.
a4f81979 FB	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	20	*/
	21
	22	#include <sys/types.h>
	23	#include <sys/stat.h>
	24	#include <fcntl.h>
	25	#include <unistd.h>
	26	#include <stdlib.h>
	27	#include <stdio.h>
	28	#include <time.h>
	29
8e71621f PB	30	#include "cpu.h"
8e71621f PB	31	#ifdef CONFIG_USER_ONLY
a4f81979 FB	32	#include "qemu.h"
	33
	34	#define ARM_ANGEL_HEAP_SIZE (128 * 1024 * 1024)
8e71621f PB	35	#else
	36	#include "vl.h"
	37	#endif
a4f81979 FB	38
	39	#define SYS_OPEN 0x01
	40	#define SYS_CLOSE 0x02
	41	#define SYS_WRITEC 0x03
	42	#define SYS_WRITE0 0x04
	43	#define SYS_WRITE 0x05
	44	#define SYS_READ 0x06
	45	#define SYS_READC 0x07
	46	#define SYS_ISTTY 0x09
	47	#define SYS_SEEK 0x0a
	48	#define SYS_FLEN 0x0c
	49	#define SYS_TMPNAM 0x0d
	50	#define SYS_REMOVE 0x0e
	51	#define SYS_RENAME 0x0f
	52	#define SYS_CLOCK 0x10
	53	#define SYS_TIME 0x11
	54	#define SYS_SYSTEM 0x12
	55	#define SYS_ERRNO 0x13
	56	#define SYS_GET_CMDLINE 0x15
	57	#define SYS_HEAPINFO 0x16
	58	#define SYS_EXIT 0x18
	59
	60	#ifndef O_BINARY
	61	#define O_BINARY 0
	62	#endif
	63
a2d1ebaf PB	64	#define GDB_O_RDONLY 0x000
	65	#define GDB_O_WRONLY 0x001
	66	#define GDB_O_RDWR 0x002
	67	#define GDB_O_APPEND 0x008
	68	#define GDB_O_CREAT 0x200
	69	#define GDB_O_TRUNC 0x400
	70	#define GDB_O_BINARY 0
	71
	72	static int gdb_open_modeflags[12] = {
	73	GDB_O_RDONLY,
	74	GDB_O_RDONLY \| GDB_O_BINARY,
	75	GDB_O_RDWR,
	76	GDB_O_RDWR \| GDB_O_BINARY,
	77	GDB_O_WRONLY \| GDB_O_CREAT \| GDB_O_TRUNC,
	78	GDB_O_WRONLY \| GDB_O_CREAT \| GDB_O_TRUNC \| GDB_O_BINARY,
	79	GDB_O_RDWR \| GDB_O_CREAT \| GDB_O_TRUNC,
	80	GDB_O_RDWR \| GDB_O_CREAT \| GDB_O_TRUNC \| GDB_O_BINARY,
	81	GDB_O_WRONLY \| GDB_O_CREAT \| GDB_O_APPEND,
	82	GDB_O_WRONLY \| GDB_O_CREAT \| GDB_O_APPEND \| GDB_O_BINARY,
	83	GDB_O_RDWR \| GDB_O_CREAT \| GDB_O_APPEND,
	84	GDB_O_RDWR \| GDB_O_CREAT \| GDB_O_APPEND \| GDB_O_BINARY
	85	};
	86
	87	static int open_modeflags[12] = {
a4f81979 FB	88	O_RDONLY,
	89	O_RDONLY \| O_BINARY,
	90	O_RDWR,
	91	O_RDWR \| O_BINARY,
	92	O_WRONLY \| O_CREAT \| O_TRUNC,
	93	O_WRONLY \| O_CREAT \| O_TRUNC \| O_BINARY,
	94	O_RDWR \| O_CREAT \| O_TRUNC,
	95	O_RDWR \| O_CREAT \| O_TRUNC \| O_BINARY,
	96	O_WRONLY \| O_CREAT \| O_APPEND,
	97	O_WRONLY \| O_CREAT \| O_APPEND \| O_BINARY,
	98	O_RDWR \| O_CREAT \| O_APPEND,
	99	O_RDWR \| O_CREAT \| O_APPEND \| O_BINARY
	100	};
	101
8e71621f	102	#ifdef CONFIG_USER_ONLY
a4f81979 FB	103	static inline uint32_t set_swi_errno(TaskState *ts, uint32_t code)
a4f81979 FB	104	{
8e71621f PB	105	if (code == (uint32_t)-1)
	106	ts->swi_errno = errno;
	107	return code;
	108	}
	109	#else
	110	static inline uint32_t set_swi_errno(CPUState *env, uint32_t code)
	111	{
	112	return code;
	113	}
	114
	115	static uint32_t softmmu_tget32(CPUState *env, uint32_t addr)
	116	{
	117	uint32_t val;
	118
	119	cpu_memory_rw_debug(env, addr, (uint8_t *)&val, 4, 0);
	120	return tswap32(val);
a4f81979	121	}
8e71621f PB	122	static uint32_t softmmu_tget8(CPUState *env, uint32_t addr)
	123	{
	124	uint8_t val;
	125
	126	cpu_memory_rw_debug(env, addr, &val, 1, 0);
	127	return val;
	128	}
	129	#define tget32(p) softmmu_tget32(env, p)
	130	#define tget8(p) softmmu_tget8(env, p)
	131
	132	static void softmmu_lock_user(CPUState env, uint32_t addr, uint32_t len,
	133	int copy)
	134	{
	135	char *p;
	136	/* TODO: Make this something that isn't fixed size. */
	137	p = malloc(len);
	138	if (copy)
	139	cpu_memory_rw_debug(env, addr, p, len, 0);
	140	return p;
	141	}
	142	#define lock_user(p, len, copy) softmmu_lock_user(env, p, len, copy)
	143	static char softmmu_lock_user_string(CPUState env, uint32_t addr)
	144	{
	145	char *p;
	146	char *s;
	147	uint8_t c;
	148	/* TODO: Make this something that isn't fixed size. */
	149	s = p = malloc(1024);
	150	do {
	151	cpu_memory_rw_debug(env, addr, &c, 1, 0);
	152	addr++;
	153	*(p++) = c;
	154	} while (c);
	155	return s;
	156	}
	157	#define lock_user_string(p) softmmu_lock_user_string(env, p)
	158	static void softmmu_unlock_user(CPUState env, void p, target_ulong addr,
	159	target_ulong len)
	160	{
	161	if (len)
	162	cpu_memory_rw_debug(env, addr, p, len, 1);
	163	free(p);
	164	}
	165	#define unlock_user(s, args, len) softmmu_unlock_user(env, s, args, len)
	166	#endif
a4f81979	167
a2d1ebaf PB	168	static target_ulong arm_semi_syscall_len;
	169
	170	static void arm_semi_cb(CPUState *env, target_ulong ret, target_ulong err)
	171	{
	172	#ifdef CONFIG_USER_ONLY
	173	TaskState *ts = env->opaque;
	174	#endif
	175	if (ret == (target_ulong)-1) {
	176	#ifdef CONFIG_USER_ONLY
	177	ts->swi_errno = err;
	178	#endif
	179	env->regs[0] = ret;
	180	} else {
	181	/* Fixup syscalls that use nonstardard return conventions. */
	182	switch (env->regs[0]) {
	183	case SYS_WRITE:
	184	case SYS_READ:
	185	env->regs[0] = arm_semi_syscall_len - ret;
	186	break;
	187	case SYS_SEEK:
	188	env->regs[0] = 0;
	189	break;
	190	default:
	191	env->regs[0] = ret;
	192	break;
	193	}
	194	}
	195	}
	196
38d0662a PB	197	#define ARG(n) tget32(args + (n) * 4)
38d0662a PB	198	#define SET_ARG(n, val) tput32(args + (n) * 4,val)
a4f81979 FB	199	uint32_t do_arm_semihosting(CPUState *env)
a4f81979 FB	200	{
53a5960a	201	target_ulong args;
a4f81979 FB	202	char * s;
	203	int nr;
	204	uint32_t ret;
8e71621f PB	205	uint32_t len;
8e71621f PB	206	#ifdef CONFIG_USER_ONLY
a4f81979	207	TaskState *ts = env->opaque;
8e71621f PB	208	#else
	209	CPUState *ts = env;
	210	#endif
a4f81979 FB	211
a4f81979 FB	212	nr = env->regs[0];
53a5960a	213	args = env->regs[1];
a4f81979 FB	214	switch (nr) {
a4f81979 FB	215	case SYS_OPEN:
8e71621f	216	s = lock_user_string(ARG(0));
a4f81979 FB	217	if (ARG(1) >= 12)
	218	return (uint32_t)-1;
	219	if (strcmp(s, ":tt") == 0) {
	220	if (ARG(1) < 4)
	221	return STDIN_FILENO;
	222	else
	223	return STDOUT_FILENO;
	224	}
a2d1ebaf PB	225	if (use_gdb_syscalls()) {
	226	gdb_do_syscall(arm_semi_cb, "open,%s,%x,1a4", ARG(0), (int)ARG(2),
	227	gdb_open_modeflags[ARG(1)]);
	228	return env->regs[0];
	229	} else {
	230	ret = set_swi_errno(ts, open(s, open_modeflags[ARG(1)], 0644));
	231	}
8e71621f PB	232	unlock_user(s, ARG(0), 0);
8e71621f PB	233	return ret;
a4f81979	234	case SYS_CLOSE:
a2d1ebaf PB	235	if (use_gdb_syscalls()) {
	236	gdb_do_syscall(arm_semi_cb, "close,%x", ARG(0));
	237	return env->regs[0];
	238	} else {
	239	return set_swi_errno(ts, close(ARG(0)));
	240	}
a4f81979	241	case SYS_WRITEC:
53a5960a PB	242	{
	243	char c = tget8(args);
	244	/* Write to debug console. stderr is near enough. */
a2d1ebaf PB	245	if (use_gdb_syscalls()) {
	246	gdb_do_syscall(arm_semi_cb, "write,2,%x,1", args);
	247	return env->regs[0];
	248	} else {
	249	return write(STDERR_FILENO, &c, 1);
	250	}
53a5960a	251	}
a4f81979	252	case SYS_WRITE0:
53a5960a	253	s = lock_user_string(args);
a2d1ebaf PB	254	len = strlen(s);
	255	if (use_gdb_syscalls()) {
	256	gdb_do_syscall(arm_semi_cb, "write,2,%x,%x\n", args, len);
	257	ret = env->regs[0];
	258	} else {
	259	ret = write(STDERR_FILENO, s, len);
	260	}
53a5960a PB	261	unlock_user(s, args, 0);
53a5960a PB	262	return ret;
a4f81979	263	case SYS_WRITE:
8e71621f	264	len = ARG(2);
a2d1ebaf PB	265	if (use_gdb_syscalls()) {
	266	arm_semi_syscall_len = len;
	267	gdb_do_syscall(arm_semi_cb, "write,%x,%x,%x", ARG(0), ARG(1), len);
	268	return env->regs[0];
	269	} else {
	270	s = lock_user(ARG(1), len, 1);
	271	ret = set_swi_errno(ts, write(ARG(0), s, len));
	272	unlock_user(s, ARG(1), 0);
	273	if (ret == (uint32_t)-1)
	274	return -1;
	275	return len - ret;
	276	}
a4f81979	277	case SYS_READ:
8e71621f	278	len = ARG(2);
a2d1ebaf PB	279	if (use_gdb_syscalls()) {
	280	arm_semi_syscall_len = len;
	281	gdb_do_syscall(arm_semi_cb, "read,%x,%x,%x", ARG(0), ARG(1), len);
	282	return env->regs[0];
	283	} else {
	284	s = lock_user(ARG(1), len, 0);
	285	do
	286	ret = set_swi_errno(ts, read(ARG(0), s, len));
	287	while (ret == -1 && errno == EINTR);
	288	unlock_user(s, ARG(1), len);
	289	if (ret == (uint32_t)-1)
	290	return -1;
	291	return len - ret;
	292	}
a4f81979 FB	293	case SYS_READC:
	294	/* XXX: Read from debug cosole. Not implemented. */
	295	return 0;
	296	case SYS_ISTTY:
a2d1ebaf PB	297	if (use_gdb_syscalls()) {
	298	gdb_do_syscall(arm_semi_cb, "isatty,%x", ARG(0));
	299	return env->regs[0];
	300	} else {
	301	return isatty(ARG(0));
	302	}
a4f81979	303	case SYS_SEEK:
a2d1ebaf PB	304	if (use_gdb_syscalls()) {
	305	gdb_do_syscall(arm_semi_cb, "fseek,%x,%x,0", ARG(0), ARG(1));
	306	return env->regs[0];
	307	} else {
	308	ret = set_swi_errno(ts, lseek(ARG(0), ARG(1), SEEK_SET));
	309	if (ret == (uint32_t)-1)
	310	return -1;
	311	return 0;
	312	}
a4f81979	313	case SYS_FLEN:
a2d1ebaf PB	314	if (use_gdb_syscalls()) {
	315	/* TODO: Use stat syscall. */
	316	return -1;
	317	} else {
a4f81979 FB	318	struct stat buf;
	319	ret = set_swi_errno(ts, fstat(ARG(0), &buf));
	320	if (ret == (uint32_t)-1)
	321	return -1;
	322	return buf.st_size;
	323	}
	324	case SYS_TMPNAM:
	325	/* XXX: Not implemented. */
	326	return -1;
	327	case SYS_REMOVE:
a2d1ebaf PB	328	if (use_gdb_syscalls()) {
	329	gdb_do_syscall(arm_semi_cb, "unlink,%s", ARG(0), (int)ARG(1));
	330	ret = env->regs[0];
	331	} else {
	332	s = lock_user_string(ARG(0));
	333	ret = set_swi_errno(ts, remove(s));
	334	unlock_user(s, ARG(0), 0);
	335	}
8e71621f	336	return ret;
a4f81979	337	case SYS_RENAME:
a2d1ebaf PB	338	if (use_gdb_syscalls()) {
	339	gdb_do_syscall(arm_semi_cb, "rename,%s,%s",
	340	ARG(0), (int)ARG(1), ARG(2), (int)ARG(3));
	341	return env->regs[0];
	342	} else {
8e71621f PB	343	char *s2;
	344	s = lock_user_string(ARG(0));
	345	s2 = lock_user_string(ARG(2));
	346	ret = set_swi_errno(ts, rename(s, s2));
	347	unlock_user(s2, ARG(2), 0);
	348	unlock_user(s, ARG(0), 0);
	349	return ret;
	350	}
a4f81979 FB	351	case SYS_CLOCK:
	352	return clock() / (CLOCKS_PER_SEC / 100);
	353	case SYS_TIME:
	354	return set_swi_errno(ts, time(NULL));
	355	case SYS_SYSTEM:
a2d1ebaf PB	356	if (use_gdb_syscalls()) {
	357	gdb_do_syscall(arm_semi_cb, "system,%s", ARG(0), (int)ARG(1));
	358	return env->regs[0];
	359	} else {
	360	s = lock_user_string(ARG(0));
	361	ret = set_swi_errno(ts, system(s));
	362	unlock_user(s, ARG(0), 0);
	363	}
a4f81979	364	case SYS_ERRNO:
8e71621f	365	#ifdef CONFIG_USER_ONLY
a4f81979	366	return ts->swi_errno;
8e71621f PB	367	#else
	368	return 0;
	369	#endif
a4f81979	370	case SYS_GET_CMDLINE:
8e71621f	371	#ifdef CONFIG_USER_ONLY
38d0662a PB	372	/* Build a commandline from the original argv. */
	373	{
	374	char **arg = ts->info->host_argv;
	375	int len = ARG(1);
	376	/* lock the buffer on the ARM side */
	377	char cmdline_buffer = (char)lock_user(ARG(0), len, 0);
	378
	379	s = cmdline_buffer;
	380	while (*arg && len > 2) {
	381	int n = strlen(*arg);
	382
	383	if (s != cmdline_buffer) {
	384	*(s++) = ' ';
	385	len--;
	386	}
	387	if (n >= len)
	388	n = len - 1;
	389	memcpy(s, *arg, n);
	390	s += n;
	391	len -= n;
	392	arg++;
	393	}
	394	/* Null terminate the string. */
	395	*s = 0;
	396	len = s - cmdline_buffer;
	397
	398	/* Unlock the buffer on the ARM side. */
	399	unlock_user(cmdline_buffer, ARG(0), len);
	400
	401	/* Adjust the commandline length argument. */
	402	SET_ARG(1, len);
	403
	404	/* Return success if commandline fit into buffer. */
	405	return *arg ? -1 : 0;
	406	}
8e71621f PB	407	#else
	408	return -1;
	409	#endif
a4f81979 FB	410	case SYS_HEAPINFO:
	411	{
	412	uint32_t *ptr;
	413	uint32_t limit;
	414
8e71621f PB	415	#ifdef CONFIG_USER_ONLY
8e71621f PB	416	/* Some C libraries assume the heap immediately follows .bss, so
a4f81979 FB	417	allocate it using sbrk. */
	418	if (!ts->heap_limit) {
	419	long ret;
	420
53a5960a	421	ts->heap_base = do_brk(0);
a4f81979 FB	422	limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
	423	/* Try a big heap, and reduce the size if that fails. */
	424	for (;;) {
53a5960a	425	ret = do_brk(limit);
a4f81979 FB	426	if (ret != -1)
	427	break;
	428	limit = (ts->heap_base >> 1) + (limit >> 1);
	429	}
	430	ts->heap_limit = limit;
	431	}
	432
8e71621f	433	ptr = lock_user(ARG(0), 16, 0);
a4f81979 FB	434	ptr[0] = tswap32(ts->heap_base);
	435	ptr[1] = tswap32(ts->heap_limit);
	436	ptr[2] = tswap32(ts->stack_base);
	437	ptr[3] = tswap32(0); /* Stack limit. */
8e71621f PB	438	unlock_user(ptr, ARG(0), 16);
	439	#else
	440	limit = ram_size;
	441	ptr = lock_user(ARG(0), 16, 0);
	442	/* TODO: Make this use the limit of the loaded application. */
	443	ptr[0] = tswap32(limit / 2);
	444	ptr[1] = tswap32(limit);
	445	ptr[2] = tswap32(limit); /* Stack base */
	446	ptr[3] = tswap32(0); /* Stack limit. */
	447	unlock_user(ptr, ARG(0), 16);
	448	#endif
a4f81979 FB	449	return 0;
	450	}
	451	case SYS_EXIT:
	452	exit(0);
	453	default:
	454	fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
	455	cpu_dump_state(env, stderr, fprintf, 0);
	456	abort();
	457	}
	458	}