[mirror_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"
#include "user/syscall-trace.h"

//#define DEBUG

static abi_ulong target_brk;
static abi_ulong target_original_brk;

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

#define target_to_host_bitmask(x, tbl) (x)

bool 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;
}

#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);
        break;
    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_cpu(cpu_env);
    abi_long ret;
    void *p;

#ifdef DEBUG
    gemu_log("freebsd syscall %d\n", num);
#endif
    record_syscall_start(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);

    if (do_strace)
        print_freebsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);

    switch (num) {
    case TARGET_FREEBSD_NR_exit:
#ifdef CONFIG_GPROF
        _mcleanup();
#endif
        gdb_exit(arg1);
        qemu_plugin_user_exit();
        /* 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);

    record_syscall_return(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_cpu(cpu_env);
    abi_long ret;
    void *p;

#ifdef DEBUG
    gemu_log("netbsd syscall %d\n", num);
#endif

    record_syscall_start(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 CONFIG_GPROF
        _mcleanup();
#endif
        gdb_exit(arg1);
        qemu_plugin_user_exit();
        /* 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);

    record_syscall_return(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_cpu(cpu_env);
    abi_long ret;
    void *p;

#ifdef DEBUG
    gemu_log("openbsd syscall %d\n", num);
#endif

    record_syscall_start(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 CONFIG_GPROF
        _mcleanup();
#endif
        gdb_exit(arg1);
        qemu_plugin_user_exit();
        /* 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);

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