[qemu.git] / bsd-user / syscall.c

/*
 *  BSD syscalls
 *
 *  Copyright (c) 2003 - 2008 Fabrice Bellard
 *
 *  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, see <http://www.gnu.org/licenses/>.
 */
#include "qemu/osdep.h"
#include "qemu/cutils.h"
#include "qemu/path.h"
#include <sys/syscall.h>
#include <sys/param.h>
#include <sys/sysctl.h>
#include <utime.h>

#include "qemu.h"
#include "qemu-common.h"

//#define DEBUG

static abi_ulong target_brk;
static abi_ulong target_original_brk;

static inline abi_long get_errno(abi_long ret)
{
    if (ret == -1)
        /* XXX need to translate host -> target errnos here */
        return -(errno);
    else
        return ret;
}

#define target_to_host_bitmask(x, tbl) (x)

static inline int is_error(abi_long ret)
{
    return (abi_ulong)ret >= (abi_ulong)(-4096);
}

void target_set_brk(abi_ulong new_brk)
{
    target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
}

/* do_obreak() must return target errnos. */
static abi_long do_obreak(abi_ulong new_brk)
{
    abi_ulong brk_page;
    abi_long mapped_addr;
    int new_alloc_size;

    if (!new_brk)
        return 0;
    if (new_brk < target_original_brk)
        return -TARGET_EINVAL;

    brk_page = HOST_PAGE_ALIGN(target_brk);

    /* If the new brk is less than this, set it and we're done... */
    if (new_brk < brk_page) {
        target_brk = new_brk;
        return 0;
    }

    /* We need to allocate more memory after the brk... */
    new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);
    mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
                                        PROT_READ|PROT_WRITE,
                                        MAP_ANON|MAP_FIXED|MAP_PRIVATE, -1, 0));

    if (!is_error(mapped_addr))
        target_brk = new_brk;
    else
        return mapped_addr;

    return 0;
}

#if defined(TARGET_I386)
static abi_long do_freebsd_sysarch(CPUX86State *env, int op, abi_ulong parms)
{
    abi_long ret = 0;
    abi_ulong val;
    int idx;

    switch(op) {
#ifdef TARGET_ABI32
    case TARGET_FREEBSD_I386_SET_GSBASE:
    case TARGET_FREEBSD_I386_SET_FSBASE:
        if (op == TARGET_FREEBSD_I386_SET_GSBASE)
#else
    case TARGET_FREEBSD_AMD64_SET_GSBASE:
    case TARGET_FREEBSD_AMD64_SET_FSBASE:
        if (op == TARGET_FREEBSD_AMD64_SET_GSBASE)
#endif
            idx = R_GS;
        else
            idx = R_FS;
        if (get_user(val, parms, abi_ulong))
            return -TARGET_EFAULT;
        cpu_x86_load_seg(env, idx, 0);
        env->segs[idx].base = val;
        break;
#ifdef TARGET_ABI32
    case TARGET_FREEBSD_I386_GET_GSBASE:
    case TARGET_FREEBSD_I386_GET_FSBASE:
        if (op == TARGET_FREEBSD_I386_GET_GSBASE)
#else
    case TARGET_FREEBSD_AMD64_GET_GSBASE:
    case TARGET_FREEBSD_AMD64_GET_FSBASE:
        if (op == TARGET_FREEBSD_AMD64_GET_GSBASE)
#endif
            idx = R_GS;
        else
            idx = R_FS;
        val = env->segs[idx].base;
        if (put_user(val, parms, abi_ulong))
            return -TARGET_EFAULT;
        break;
    /* XXX handle the others... */
    default:
        ret = -TARGET_EINVAL;
        break;
    }
    return ret;
}
#endif

#ifdef TARGET_SPARC
static abi_long do_freebsd_sysarch(void *env, int op, abi_ulong parms)
{
    /* XXX handle
     * TARGET_FREEBSD_SPARC_UTRAP_INSTALL,
     * TARGET_FREEBSD_SPARC_SIGTRAMP_INSTALL
     */
    return -TARGET_EINVAL;
}
#endif

#ifdef __FreeBSD__
/*
 * XXX this uses the undocumented oidfmt interface to find the kind of
 * a requested sysctl, see /sys/kern/kern_sysctl.c:sysctl_sysctl_oidfmt()
 * (this is mostly copied from src/sbin/sysctl/sysctl.c)
 */
static int
oidfmt(int *oid, int len, char *fmt, uint32_t *kind)
{
    int qoid[CTL_MAXNAME+2];
    uint8_t buf[BUFSIZ];
    int i;
    size_t j;

    qoid[0] = 0;
    qoid[1] = 4;
    memcpy(qoid + 2, oid, len * sizeof(int));

    j = sizeof(buf);
    i = sysctl(qoid, len + 2, buf, &j, 0, 0);
    if (i)
        return i;

    if (kind)
        *kind = *(uint32_t *)buf;

    if (fmt)
        strcpy(fmt, (char *)(buf + sizeof(uint32_t)));
    return (0);
}

/*
 * try and convert sysctl return data for the target.
 * XXX doesn't handle CTLTYPE_OPAQUE and CTLTYPE_STRUCT.
 */
static int sysctl_oldcvt(void *holdp, size_t holdlen, uint32_t kind)
{
    switch (kind & CTLTYPE) {
    case CTLTYPE_INT:
    case CTLTYPE_UINT:
        *(uint32_t *)holdp = tswap32(*(uint32_t *)holdp);
        break;
#ifdef TARGET_ABI32
    case CTLTYPE_LONG:
    case CTLTYPE_ULONG:
        *(uint32_t *)holdp = tswap32(*(long *)holdp);
        break;
#else
    case CTLTYPE_LONG:
        *(uint64_t *)holdp = tswap64(*(long *)holdp);
    case CTLTYPE_ULONG:
        *(uint64_t *)holdp = tswap64(*(unsigned long *)holdp);
        break;
#endif
#ifdef CTLTYPE_U64
    case CTLTYPE_S64:
    case CTLTYPE_U64:
#else
    case CTLTYPE_QUAD:
#endif
        *(uint64_t *)holdp = tswap64(*(uint64_t *)holdp);
        break;
    case CTLTYPE_STRING:
        break;
    default:
        /* XXX unhandled */
        return -1;
    }
    return 0;
}

/* XXX this needs to be emulated on non-FreeBSD hosts... */
static abi_long do_freebsd_sysctl(abi_ulong namep, int32_t namelen, abi_ulong oldp,
                          abi_ulong oldlenp, abi_ulong newp, abi_ulong newlen)
{
    abi_long ret;
    void *hnamep, *holdp, *hnewp = NULL;
    size_t holdlen;
    abi_ulong oldlen = 0;
    int32_t *snamep = g_malloc(sizeof(int32_t) * namelen), *p, *q, i;
    uint32_t kind = 0;

    if (oldlenp)
        get_user_ual(oldlen, oldlenp);
    if (!(hnamep = lock_user(VERIFY_READ, namep, namelen, 1)))
        return -TARGET_EFAULT;
    if (newp && !(hnewp = lock_user(VERIFY_READ, newp, newlen, 1)))
        return -TARGET_EFAULT;
    if (!(holdp = lock_user(VERIFY_WRITE, oldp, oldlen, 0)))
        return -TARGET_EFAULT;
    holdlen = oldlen;
    for (p = hnamep, q = snamep, i = 0; i < namelen; p++, i++)
       *q++ = tswap32(*p);
    oidfmt(snamep, namelen, NULL, &kind);
    /* XXX swap hnewp */
    ret = get_errno(sysctl(snamep, namelen, holdp, &holdlen, hnewp, newlen));
    if (!ret)
        sysctl_oldcvt(holdp, holdlen, kind);
    put_user_ual(holdlen, oldlenp);
    unlock_user(hnamep, namep, 0);
    unlock_user(holdp, oldp, holdlen);
    if (hnewp)
        unlock_user(hnewp, newp, 0);
    g_free(snamep);
    return ret;
}
#endif

/* FIXME
 * lock_iovec()/unlock_iovec() have a return code of 0 for success where
 * other lock functions have a return code of 0 for failure.
 */
static abi_long lock_iovec(int type, struct iovec *vec, abi_ulong target_addr,
                           int count, int copy)
{
    struct target_iovec *target_vec;
    abi_ulong base;
    int i;

    target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
    if (!target_vec)
        return -TARGET_EFAULT;
    for(i = 0;i < count; i++) {
        base = tswapl(target_vec[i].iov_base);
        vec[i].iov_len = tswapl(target_vec[i].iov_len);
        if (vec[i].iov_len != 0) {
            vec[i].iov_base = lock_user(type, base, vec[i].iov_len, copy);
            /* Don't check lock_user return value. We must call writev even
               if a element has invalid base address. */
        } else {
            /* zero length pointer is ignored */
            vec[i].iov_base = NULL;
        }
    }
    unlock_user (target_vec, target_addr, 0);
    return 0;
}

static abi_long unlock_iovec(struct iovec *vec, abi_ulong target_addr,
                             int count, int copy)
{
    struct target_iovec *target_vec;
    abi_ulong base;
    int i;

    target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
    if (!target_vec)
        return -TARGET_EFAULT;
    for(i = 0;i < count; i++) {
        if (target_vec[i].iov_base) {
            base = tswapl(target_vec[i].iov_base);
            unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
        }
    }
    unlock_user (target_vec, target_addr, 0);

    return 0;
}

/* do_syscall() should always have a single exit point at the end so
   that actions, such as logging of syscall results, can be performed.
   All errnos that do_syscall() returns must be -TARGET_<errcode>. */
abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
                            abi_long arg2, abi_long arg3, abi_long arg4,
                            abi_long arg5, abi_long arg6, abi_long arg7,
                            abi_long arg8)
{
    CPUState *cpu = ENV_GET_CPU(cpu_env);
    abi_long ret;
    void *p;

#ifdef DEBUG
    gemu_log("freebsd syscall %d\n", num);
#endif
    trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    if(do_strace)
        print_freebsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);

    switch(num) {
    case TARGET_FREEBSD_NR_exit:
#ifdef TARGET_GPROF
        _mcleanup();
#endif
        gdb_exit(cpu_env, arg1);
        /* XXX: should free thread stack and CPU env */
        _exit(arg1);
        ret = 0; /* avoid warning */
        break;
    case TARGET_FREEBSD_NR_read:
        if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
            goto efault;
        ret = get_errno(read(arg1, p, arg3));
        unlock_user(p, arg2, ret);
        break;
    case TARGET_FREEBSD_NR_write:
        if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
            goto efault;
        ret = get_errno(write(arg1, p, arg3));
        unlock_user(p, arg2, 0);
        break;
    case TARGET_FREEBSD_NR_writev:
        {
            int count = arg3;
            struct iovec *vec;

            vec = alloca(count * sizeof(struct iovec));
            if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
                goto efault;
            ret = get_errno(writev(arg1, vec, count));
            unlock_iovec(vec, arg2, count, 0);
        }
        break;
    case TARGET_FREEBSD_NR_open:
        if (!(p = lock_user_string(arg1)))
            goto efault;
        ret = get_errno(open(path(p),
                             target_to_host_bitmask(arg2, fcntl_flags_tbl),
                             arg3));
        unlock_user(p, arg1, 0);
        break;
    case TARGET_FREEBSD_NR_mmap:
        ret = get_errno(target_mmap(arg1, arg2, arg3,
                                    target_to_host_bitmask(arg4, mmap_flags_tbl),
                                    arg5,
                                    arg6));
        break;
    case TARGET_FREEBSD_NR_mprotect:
        ret = get_errno(target_mprotect(arg1, arg2, arg3));
        break;
    case TARGET_FREEBSD_NR_break:
        ret = do_obreak(arg1);
        break;
#ifdef __FreeBSD__
    case TARGET_FREEBSD_NR___sysctl:
        ret = do_freebsd_sysctl(arg1, arg2, arg3, arg4, arg5, arg6);
        break;
#endif
    case TARGET_FREEBSD_NR_sysarch:
        ret = do_freebsd_sysarch(cpu_env, arg1, arg2);
        break;
    case TARGET_FREEBSD_NR_syscall:
    case TARGET_FREEBSD_NR___syscall:
        ret = do_freebsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,arg7,arg8,0);
        break;
    default:
        ret = get_errno(syscall(num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
        break;
    }
 fail:
#ifdef DEBUG
    gemu_log(" = %ld\n", ret);
#endif
    if (do_strace)
        print_freebsd_syscall_ret(num, ret);
    trace_guest_user_syscall_ret(cpu, num, ret);
    return ret;
 efault:
    ret = -TARGET_EFAULT;
    goto fail;
}

abi_long do_netbsd_syscall(void *cpu_env, int num, abi_long arg1,
                           abi_long arg2, abi_long arg3, abi_long arg4,
                           abi_long arg5, abi_long arg6)
{
    CPUState *cpu = ENV_GET_CPU(cpu_env);
    abi_long ret;
    void *p;

#ifdef DEBUG
    gemu_log("netbsd syscall %d\n", num);
#endif
    trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);
    if(do_strace)
        print_netbsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);

    switch(num) {
    case TARGET_NETBSD_NR_exit:
#ifdef TARGET_GPROF
        _mcleanup();
#endif
        gdb_exit(cpu_env, arg1);
        /* XXX: should free thread stack and CPU env */
        _exit(arg1);
        ret = 0; /* avoid warning */
        break;
    case TARGET_NETBSD_NR_read:
        if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
            goto efault;
        ret = get_errno(read(arg1, p, arg3));
        unlock_user(p, arg2, ret);
        break;
    case TARGET_NETBSD_NR_write:
        if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
            goto efault;
        ret = get_errno(write(arg1, p, arg3));
        unlock_user(p, arg2, 0);
        break;
    case TARGET_NETBSD_NR_open:
        if (!(p = lock_user_string(arg1)))
            goto efault;
        ret = get_errno(open(path(p),
                             target_to_host_bitmask(arg2, fcntl_flags_tbl),
                             arg3));
        unlock_user(p, arg1, 0);
        break;
    case TARGET_NETBSD_NR_mmap:
        ret = get_errno(target_mmap(arg1, arg2, arg3,
                                    target_to_host_bitmask(arg4, mmap_flags_tbl),
                                    arg5,
                                    arg6));
        break;
    case TARGET_NETBSD_NR_mprotect:
        ret = get_errno(target_mprotect(arg1, arg2, arg3));
        break;
    case TARGET_NETBSD_NR_syscall:
    case TARGET_NETBSD_NR___syscall:
        ret = do_netbsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
        break;
    default:
        ret = syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
        break;
    }
 fail:
#ifdef DEBUG
    gemu_log(" = %ld\n", ret);
#endif
    if (do_strace)
        print_netbsd_syscall_ret(num, ret);
    trace_guest_user_syscall_ret(cpu, num, ret);
    return ret;
 efault:
    ret = -TARGET_EFAULT;
    goto fail;
}

abi_long do_openbsd_syscall(void *cpu_env, int num, abi_long arg1,
                            abi_long arg2, abi_long arg3, abi_long arg4,
                            abi_long arg5, abi_long arg6)
{
    CPUState *cpu = ENV_GET_CPU(cpu_env);
    abi_long ret;
    void *p;

#ifdef DEBUG
    gemu_log("openbsd syscall %d\n", num);
#endif
    trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);
    if(do_strace)
        print_openbsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);

    switch(num) {
    case TARGET_OPENBSD_NR_exit:
#ifdef TARGET_GPROF
        _mcleanup();
#endif
        gdb_exit(cpu_env, arg1);
        /* XXX: should free thread stack and CPU env */
        _exit(arg1);
        ret = 0; /* avoid warning */
        break;
    case TARGET_OPENBSD_NR_read:
        if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
            goto efault;
        ret = get_errno(read(arg1, p, arg3));
        unlock_user(p, arg2, ret);
        break;
    case TARGET_OPENBSD_NR_write:
        if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
            goto efault;
        ret = get_errno(write(arg1, p, arg3));
        unlock_user(p, arg2, 0);
        break;
    case TARGET_OPENBSD_NR_open:
        if (!(p = lock_user_string(arg1)))
            goto efault;
        ret = get_errno(open(path(p),
                             target_to_host_bitmask(arg2, fcntl_flags_tbl),
                             arg3));
        unlock_user(p, arg1, 0);
        break;
    case TARGET_OPENBSD_NR_mmap:
        ret = get_errno(target_mmap(arg1, arg2, arg3,
                                    target_to_host_bitmask(arg4, mmap_flags_tbl),
                                    arg5,
                                    arg6));
        break;
    case TARGET_OPENBSD_NR_mprotect:
        ret = get_errno(target_mprotect(arg1, arg2, arg3));
        break;
    case TARGET_OPENBSD_NR_syscall:
    case TARGET_OPENBSD_NR___syscall:
        ret = do_openbsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
        break;
    default:
        ret = syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
        break;
    }
 fail:
#ifdef DEBUG
    gemu_log(" = %ld\n", ret);
#endif
    if (do_strace)
        print_openbsd_syscall_ret(num, ret);
    trace_guest_user_syscall_ret(cpu, num, ret);
    return ret;
 efault:
    ret = -TARGET_EFAULT;
    goto fail;
}

void syscall_init(void)
{
}
Commit	Line	Data
84778508 BS	1	/*
	2	* BSD syscalls
	3	*
	4	* Copyright (c) 2003 - 2008 Fabrice Bellard
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
8167ee88	17	* along with this program; if not, see <http://www.gnu.org/licenses/>.
84778508	18	*/
2231197c	19	#include "qemu/osdep.h"
c40e13e1 EM	20	#include "qemu/cutils.h"
c40e13e1 EM	21	#include "qemu/path.h"
84778508	22	#include <sys/syscall.h>
544f4f0b	23	#include <sys/param.h>
78cfb07f	24	#include <sys/sysctl.h>
84778508 BS	25	#include <utime.h>
	26
	27	#include "qemu.h"
	28	#include "qemu-common.h"
	29
	30	//#define DEBUG
	31
	32	static abi_ulong target_brk;
	33	static abi_ulong target_original_brk;
	34
78cfb07f JL	35	static inline abi_long get_errno(abi_long ret)
	36	{
	37	if (ret == -1)
	38	/* XXX need to translate host -> target errnos here */
	39	return -(errno);
	40	else
	41	return ret;
	42	}
	43
84778508 BS	44	#define target_to_host_bitmask(x, tbl) (x)
84778508 BS	45
78cfb07f JL	46	static inline int is_error(abi_long ret)
	47	{
	48	return (abi_ulong)ret >= (abi_ulong)(-4096);
	49	}
	50
84778508 BS	51	void target_set_brk(abi_ulong new_brk)
	52	{
	53	target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
	54	}
	55
78cfb07f JL	56	/* do_obreak() must return target errnos. */
	57	static abi_long do_obreak(abi_ulong new_brk)
	58	{
	59	abi_ulong brk_page;
	60	abi_long mapped_addr;
	61	int new_alloc_size;
	62
	63	if (!new_brk)
	64	return 0;
	65	if (new_brk < target_original_brk)
	66	return -TARGET_EINVAL;
	67
	68	brk_page = HOST_PAGE_ALIGN(target_brk);
	69
	70	/* If the new brk is less than this, set it and we're done... */
	71	if (new_brk < brk_page) {
	72	target_brk = new_brk;
	73	return 0;
	74	}
	75
	76	/* We need to allocate more memory after the brk... */
	77	new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);
	78	mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
	79	PROT_READ\|PROT_WRITE,
	80	MAP_ANON\|MAP_FIXED\|MAP_PRIVATE, -1, 0));
	81
	82	if (!is_error(mapped_addr))
	83	target_brk = new_brk;
	84	else
	85	return mapped_addr;
	86
	87	return 0;
	88	}
	89
	90	#if defined(TARGET_I386)
	91	static abi_long do_freebsd_sysarch(CPUX86State *env, int op, abi_ulong parms)
	92	{
	93	abi_long ret = 0;
	94	abi_ulong val;
	95	int idx;
	96
	97	switch(op) {
	98	#ifdef TARGET_ABI32
	99	case TARGET_FREEBSD_I386_SET_GSBASE:
	100	case TARGET_FREEBSD_I386_SET_FSBASE:
	101	if (op == TARGET_FREEBSD_I386_SET_GSBASE)
	102	#else
	103	case TARGET_FREEBSD_AMD64_SET_GSBASE:
	104	case TARGET_FREEBSD_AMD64_SET_FSBASE:
	105	if (op == TARGET_FREEBSD_AMD64_SET_GSBASE)
	106	#endif
	107	idx = R_GS;
	108	else
	109	idx = R_FS;
	110	if (get_user(val, parms, abi_ulong))
	111	return -TARGET_EFAULT;
	112	cpu_x86_load_seg(env, idx, 0);
	113	env->segs[idx].base = val;
	114	break;
	115	#ifdef TARGET_ABI32
	116	case TARGET_FREEBSD_I386_GET_GSBASE:
	117	case TARGET_FREEBSD_I386_GET_FSBASE:
	118	if (op == TARGET_FREEBSD_I386_GET_GSBASE)
	119	#else
120	case TARGET_FREEBSD_AMD64_GET_GSBASE:
121	case TARGET_FREEBSD_AMD64_GET_FSBASE:
122	if (op == TARGET_FREEBSD_AMD64_GET_GSBASE)
123	#endif
124	idx = R_GS;
125	else
126	idx = R_FS;
127	val = env->segs[idx].base;
128	if (put_user(val, parms, abi_ulong))
129	return -TARGET_EFAULT;
130	break;
131	/* XXX handle the others... */
132	default:
133	ret = -TARGET_EINVAL;
134	break;
135	}
136	return ret;
137	}
138	#endif
139
140	#ifdef TARGET_SPARC
141	static abi_long do_freebsd_sysarch(void *env, int op, abi_ulong parms)
142	{
143	/* XXX handle
144	* TARGET_FREEBSD_SPARC_UTRAP_INSTALL,
145	* TARGET_FREEBSD_SPARC_SIGTRAMP_INSTALL
146	*/
147	return -TARGET_EINVAL;
148	}
149	#endif
150
151	#ifdef __FreeBSD__
152	/*
153	* XXX this uses the undocumented oidfmt interface to find the kind of
154	* a requested sysctl, see /sys/kern/kern_sysctl.c:sysctl_sysctl_oidfmt()
155	* (this is mostly copied from src/sbin/sysctl/sysctl.c)
156	*/
157	static int
158	oidfmt(int oid, int len, char fmt, uint32_t *kind)
159	{
160	int qoid[CTL_MAXNAME+2];
161	uint8_t buf[BUFSIZ];
162	int i;
163	size_t j;
164
165	qoid[0] = 0;
166	qoid[1] = 4;
167	memcpy(qoid + 2, oid, len * sizeof(int));
168
169	j = sizeof(buf);
170	i = sysctl(qoid, len + 2, buf, &j, 0, 0);
171	if (i)
172	return i;
173
174	if (kind)
175	kind = (uint32_t *)buf;
176
177	if (fmt)
178	strcpy(fmt, (char *)(buf + sizeof(uint32_t)));
179	return (0);
180	}
181
182	/*
183	* try and convert sysctl return data for the target.
184	* XXX doesn't handle CTLTYPE_OPAQUE and CTLTYPE_STRUCT.
185	*/
186	static int sysctl_oldcvt(void *holdp, size_t holdlen, uint32_t kind)
187	{
188	switch (kind & CTLTYPE) {
189	case CTLTYPE_INT:
190	case CTLTYPE_UINT:
191	(uint32_t )holdp = tswap32((uint32_t )holdp);
192	break;
193	#ifdef TARGET_ABI32
194	case CTLTYPE_LONG:
195	case CTLTYPE_ULONG:
196	(uint32_t )holdp = tswap32((long )holdp);
197	break;
198	#else
199	case CTLTYPE_LONG:
200	(uint64_t )holdp = tswap64((long )holdp);
201	case CTLTYPE_ULONG:
202	(uint64_t )holdp = tswap64((unsigned long )holdp);
203	break;
204	#endif
e6a3ee5f EM	205	#ifdef CTLTYPE_U64
e6a3ee5f EM	206	case CTLTYPE_S64:
6ea8430d	207	case CTLTYPE_U64:
e6a3ee5f EM	208	#else
e6a3ee5f EM	209	case CTLTYPE_QUAD:
6ea8430d	210	#endif
78cfb07f JL	211	(uint64_t )holdp = tswap64((uint64_t )holdp);
	212	break;
	213	case CTLTYPE_STRING:
	214	break;
	215	default:
	216	/* XXX unhandled */
	217	return -1;
	218	}
	219	return 0;
	220	}
	221
	222	/* XXX this needs to be emulated on non-FreeBSD hosts... */
	223	static abi_long do_freebsd_sysctl(abi_ulong namep, int32_t namelen, abi_ulong oldp,
	224	abi_ulong oldlenp, abi_ulong newp, abi_ulong newlen)
	225	{
	226	abi_long ret;
	227	void hnamep, holdp, *hnewp = NULL;
	228	size_t holdlen;
	229	abi_ulong oldlen = 0;
7267c094	230	int32_t snamep = g_malloc(sizeof(int32_t) namelen), p, q, i;
78cfb07f JL	231	uint32_t kind = 0;
	232
	233	if (oldlenp)
	234	get_user_ual(oldlen, oldlenp);
	235	if (!(hnamep = lock_user(VERIFY_READ, namep, namelen, 1)))
	236	return -TARGET_EFAULT;
	237	if (newp && !(hnewp = lock_user(VERIFY_READ, newp, newlen, 1)))
	238	return -TARGET_EFAULT;
	239	if (!(holdp = lock_user(VERIFY_WRITE, oldp, oldlen, 0)))
	240	return -TARGET_EFAULT;
	241	holdlen = oldlen;
	242	for (p = hnamep, q = snamep, i = 0; i < namelen; p++, i++)
	243	q++ = tswap32(p);
	244	oidfmt(snamep, namelen, NULL, &kind);
	245	/* XXX swap hnewp */
	246	ret = get_errno(sysctl(snamep, namelen, holdp, &holdlen, hnewp, newlen));
	247	if (!ret)
	248	sysctl_oldcvt(holdp, holdlen, kind);
	249	put_user_ual(holdlen, oldlenp);
	250	unlock_user(hnamep, namep, 0);
	251	unlock_user(holdp, oldp, holdlen);
	252	if (hnewp)
	253	unlock_user(hnewp, newp, 0);
7267c094	254	g_free(snamep);
78cfb07f JL	255	return ret;
	256	}
	257	#endif
	258
	259	/* FIXME
	260	* lock_iovec()/unlock_iovec() have a return code of 0 for success where
	261	* other lock functions have a return code of 0 for failure.
	262	*/
	263	static abi_long lock_iovec(int type, struct iovec *vec, abi_ulong target_addr,
	264	int count, int copy)
	265	{
	266	struct target_iovec *target_vec;
	267	abi_ulong base;
	268	int i;
	269
	270	target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
	271	if (!target_vec)
	272	return -TARGET_EFAULT;
	273	for(i = 0;i < count; i++) {
	274	base = tswapl(target_vec[i].iov_base);
	275	vec[i].iov_len = tswapl(target_vec[i].iov_len);
	276	if (vec[i].iov_len != 0) {
	277	vec[i].iov_base = lock_user(type, base, vec[i].iov_len, copy);
	278	/* Don't check lock_user return value. We must call writev even
	279	if a element has invalid base address. */
	280	} else {
	281	/* zero length pointer is ignored */
	282	vec[i].iov_base = NULL;
	283	}
	284	}
	285	unlock_user (target_vec, target_addr, 0);
	286	return 0;
	287	}
	288
	289	static abi_long unlock_iovec(struct iovec *vec, abi_ulong target_addr,
	290	int count, int copy)
	291	{
	292	struct target_iovec *target_vec;
	293	abi_ulong base;
	294	int i;
	295
	296	target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
	297	if (!target_vec)
	298	return -TARGET_EFAULT;
	299	for(i = 0;i < count; i++) {
	300	if (target_vec[i].iov_base) {
	301	base = tswapl(target_vec[i].iov_base);
	302	unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
	303	}
	304	}
	305	unlock_user (target_vec, target_addr, 0);
	306
	307	return 0;
	308	}
	309
84778508 BS	310	/* do_syscall() should always have a single exit point at the end so
	311	that actions, such as logging of syscall results, can be performed.
	312	All errnos that do_syscall() returns must be -TARGET_<errcode>. */
	313	abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
	314	abi_long arg2, abi_long arg3, abi_long arg4,
78cfb07f JL	315	abi_long arg5, abi_long arg6, abi_long arg7,
78cfb07f JL	316	abi_long arg8)
84778508	317	{
9c15e700	318	CPUState *cpu = ENV_GET_CPU(cpu_env);
84778508 BS	319	abi_long ret;
	320	void *p;
	321
	322	#ifdef DEBUG
	323	gemu_log("freebsd syscall %d\n", num);
	324	#endif
9c15e700	325	trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
84778508 BS	326	if(do_strace)
	327	print_freebsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
	328
	329	switch(num) {
	330	case TARGET_FREEBSD_NR_exit:
9788c9ca	331	#ifdef TARGET_GPROF
84778508 BS	332	_mcleanup();
	333	#endif
	334	gdb_exit(cpu_env, arg1);
	335	/* XXX: should free thread stack and CPU env */
	336	_exit(arg1);
	337	ret = 0; /* avoid warning */
	338	break;
	339	case TARGET_FREEBSD_NR_read:
	340	if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
	341	goto efault;
	342	ret = get_errno(read(arg1, p, arg3));
	343	unlock_user(p, arg2, ret);
	344	break;
	345	case TARGET_FREEBSD_NR_write:
	346	if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
	347	goto efault;
	348	ret = get_errno(write(arg1, p, arg3));
	349	unlock_user(p, arg2, 0);
	350	break;
78cfb07f JL	351	case TARGET_FREEBSD_NR_writev:
	352	{
	353	int count = arg3;
	354	struct iovec *vec;
	355
	356	vec = alloca(count * sizeof(struct iovec));
	357	if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
	358	goto efault;
	359	ret = get_errno(writev(arg1, vec, count));
	360	unlock_iovec(vec, arg2, count, 0);
	361	}
	362	break;
84778508 BS	363	case TARGET_FREEBSD_NR_open:
	364	if (!(p = lock_user_string(arg1)))
	365	goto efault;
	366	ret = get_errno(open(path(p),
	367	target_to_host_bitmask(arg2, fcntl_flags_tbl),
	368	arg3));
	369	unlock_user(p, arg1, 0);
	370	break;
	371	case TARGET_FREEBSD_NR_mmap:
	372	ret = get_errno(target_mmap(arg1, arg2, arg3,
	373	target_to_host_bitmask(arg4, mmap_flags_tbl),
	374	arg5,
	375	arg6));
	376	break;
	377	case TARGET_FREEBSD_NR_mprotect:
	378	ret = get_errno(target_mprotect(arg1, arg2, arg3));
	379	break;
78cfb07f JL	380	case TARGET_FREEBSD_NR_break:
	381	ret = do_obreak(arg1);
	382	break;
	383	#ifdef __FreeBSD__
	384	case TARGET_FREEBSD_NR___sysctl:
	385	ret = do_freebsd_sysctl(arg1, arg2, arg3, arg4, arg5, arg6);
	386	break;
	387	#endif
	388	case TARGET_FREEBSD_NR_sysarch:
	389	ret = do_freebsd_sysarch(cpu_env, arg1, arg2);
	390	break;
84778508 BS	391	case TARGET_FREEBSD_NR_syscall:
84778508 BS	392	case TARGET_FREEBSD_NR___syscall:
78cfb07f	393	ret = do_freebsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,arg7,arg8,0);
84778508 BS	394	break;
84778508 BS	395	default:
78cfb07f	396	ret = get_errno(syscall(num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
84778508 BS	397	break;
	398	}
	399	fail:
	400	#ifdef DEBUG
	401	gemu_log(" = %ld\n", ret);
	402	#endif
	403	if (do_strace)
	404	print_freebsd_syscall_ret(num, ret);
9c15e700	405	trace_guest_user_syscall_ret(cpu, num, ret);
84778508 BS	406	return ret;
	407	efault:
	408	ret = -TARGET_EFAULT;
	409	goto fail;
	410	}
	411
	412	abi_long do_netbsd_syscall(void *cpu_env, int num, abi_long arg1,
	413	abi_long arg2, abi_long arg3, abi_long arg4,
	414	abi_long arg5, abi_long arg6)
	415	{
9c15e700	416	CPUState *cpu = ENV_GET_CPU(cpu_env);
84778508 BS	417	abi_long ret;
	418	void *p;
	419
	420	#ifdef DEBUG
	421	gemu_log("netbsd syscall %d\n", num);
	422	#endif
9c15e700	423	trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);
84778508 BS	424	if(do_strace)
	425	print_netbsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
	426
	427	switch(num) {
	428	case TARGET_NETBSD_NR_exit:
9788c9ca	429	#ifdef TARGET_GPROF
84778508 BS	430	_mcleanup();
	431	#endif
	432	gdb_exit(cpu_env, arg1);
	433	/* XXX: should free thread stack and CPU env */
	434	_exit(arg1);
	435	ret = 0; /* avoid warning */
	436	break;
	437	case TARGET_NETBSD_NR_read:
	438	if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
	439	goto efault;
	440	ret = get_errno(read(arg1, p, arg3));
	441	unlock_user(p, arg2, ret);
	442	break;
	443	case TARGET_NETBSD_NR_write:
	444	if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
	445	goto efault;
	446	ret = get_errno(write(arg1, p, arg3));
	447	unlock_user(p, arg2, 0);
	448	break;
	449	case TARGET_NETBSD_NR_open:
	450	if (!(p = lock_user_string(arg1)))
	451	goto efault;
	452	ret = get_errno(open(path(p),
	453	target_to_host_bitmask(arg2, fcntl_flags_tbl),
	454	arg3));
	455	unlock_user(p, arg1, 0);
	456	break;
	457	case TARGET_NETBSD_NR_mmap:
	458	ret = get_errno(target_mmap(arg1, arg2, arg3,
	459	target_to_host_bitmask(arg4, mmap_flags_tbl),
	460	arg5,
	461	arg6));
	462	break;
	463	case TARGET_NETBSD_NR_mprotect:
	464	ret = get_errno(target_mprotect(arg1, arg2, arg3));
	465	break;
	466	case TARGET_NETBSD_NR_syscall:
	467	case TARGET_NETBSD_NR___syscall:
	468	ret = do_netbsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
	469	break;
	470	default:
	471	ret = syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
	472	break;
	473	}
	474	fail:
	475	#ifdef DEBUG
	476	gemu_log(" = %ld\n", ret);
	477	#endif
	478	if (do_strace)
	479	print_netbsd_syscall_ret(num, ret);
9c15e700	480	trace_guest_user_syscall_ret(cpu, num, ret);
84778508 BS	481	return ret;
	482	efault:
	483	ret = -TARGET_EFAULT;
	484	goto fail;
	485	}
	486
	487	abi_long do_openbsd_syscall(void *cpu_env, int num, abi_long arg1,
	488	abi_long arg2, abi_long arg3, abi_long arg4,
	489	abi_long arg5, abi_long arg6)
	490	{
9c15e700	491	CPUState *cpu = ENV_GET_CPU(cpu_env);
84778508 BS	492	abi_long ret;
	493	void *p;
	494
	495	#ifdef DEBUG
	496	gemu_log("openbsd syscall %d\n", num);
	497	#endif
9c15e700	498	trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);
84778508 BS	499	if(do_strace)
	500	print_openbsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
	501
	502	switch(num) {
	503	case TARGET_OPENBSD_NR_exit:
9788c9ca	504	#ifdef TARGET_GPROF
84778508 BS	505	_mcleanup();
	506	#endif
	507	gdb_exit(cpu_env, arg1);
	508	/* XXX: should free thread stack and CPU env */
	509	_exit(arg1);
	510	ret = 0; /* avoid warning */
	511	break;
	512	case TARGET_OPENBSD_NR_read:
	513	if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
	514	goto efault;
	515	ret = get_errno(read(arg1, p, arg3));
	516	unlock_user(p, arg2, ret);
	517	break;
	518	case TARGET_OPENBSD_NR_write:
	519	if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
	520	goto efault;
	521	ret = get_errno(write(arg1, p, arg3));
	522	unlock_user(p, arg2, 0);
	523	break;
	524	case TARGET_OPENBSD_NR_open:
	525	if (!(p = lock_user_string(arg1)))
	526	goto efault;
	527	ret = get_errno(open(path(p),
	528	target_to_host_bitmask(arg2, fcntl_flags_tbl),
	529	arg3));
	530	unlock_user(p, arg1, 0);
	531	break;
	532	case TARGET_OPENBSD_NR_mmap:
	533	ret = get_errno(target_mmap(arg1, arg2, arg3,
	534	target_to_host_bitmask(arg4, mmap_flags_tbl),
	535	arg5,
	536	arg6));
	537	break;
	538	case TARGET_OPENBSD_NR_mprotect:
	539	ret = get_errno(target_mprotect(arg1, arg2, arg3));
	540	break;
	541	case TARGET_OPENBSD_NR_syscall:
	542	case TARGET_OPENBSD_NR___syscall:
	543	ret = do_openbsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
	544	break;
	545	default:
	546	ret = syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
	547	break;
	548	}
	549	fail:
	550	#ifdef DEBUG
	551	gemu_log(" = %ld\n", ret);
	552	#endif
	553	if (do_strace)
	554	print_openbsd_syscall_ret(num, ret);
9c15e700	555	trace_guest_user_syscall_ret(cpu, num, ret);
84778508 BS	556	return ret;
	557	efault:
	558	ret = -TARGET_EFAULT;
	559	goto fail;
	560	}
	561
	562	void syscall_init(void)
	563	{
	564	}