/* $NetBSD: syscallemu.c,v 1.1 2012/01/05 13:26:51 jmcneill Exp $ */

/*-
 * Copyright (c) 2012 Jared D. McNeill <jmcneill@invisible.ca>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: syscallemu.c,v 1.1 2012/01/05 13:26:51 jmcneill Exp $");

#include <sys/param.h>
#include <sys/proc.h>
#include <sys/systm.h>
#include <sys/module.h>
#include <sys/atomic.h>
#include <sys/syscallvar.h>

#include "syscallemu.h"

#if !defined(__HAVE_SYSCALL_INTERN)
#error syscallemu requires __HAVE_SYSCALL_INTERN
#endif

static specificdata_key_t syscallemu_data_key;
static unsigned int syscallemu_refcnt;

static const struct syscall_package syscallemu_syscalls[] = {
	{ SYS_syscallemu,	0, (sy_call_t *)sys_syscallemu	},
	{ 0, 0, NULL },
};

struct syscallemu_data *
syscallemu_getsce(struct proc *p)
{
	return proc_getspecific(p, syscallemu_data_key);
}

void
syscallemu_setsce(struct proc *p, struct syscallemu_data *sce)
{
	proc_setspecific(p, syscallemu_data_key, sce);
}

/*
 * specificdata destructor
 */
static void
syscallemu_dtor(void *priv)
{
	struct syscallemu_data *sce = priv;

	kmem_free(sce, sizeof(*sce));
	atomic_dec_uint(&syscallemu_refcnt);
}

/*
 * Allocate private storage for the syscallemu parameters and stash it
 * in process specificdata. This can only be called once per process.
 *
 * Returns EINVAL if the specified start address falls after the end.
 * Returns EACCESS if syscallemu has already been configured for this process.
 */
int
sys_syscallemu(lwp_t *l, const struct sys_syscallemu_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(uintptr_t) user_start;
		syscallarg(uintptr_t) user_end;
	} */
	vaddr_t user_start = (vaddr_t)SCARG(uap, user_start);
	vaddr_t user_end = (vaddr_t)SCARG(uap, user_end);
	struct syscallemu_data *sce;
	struct proc *p = l->l_proc;

	if (syscallemu_getsce(p) != NULL)
		return EACCES;
	if (user_start >= user_end)
		return EINVAL;

	sce = kmem_alloc(sizeof(*sce), KM_SLEEP);
	sce->sce_user_start = user_start;
	sce->sce_user_end = user_end;
	sce->sce_md_syscall = md_syscallemu(p);
	KASSERT(sce->sce_md_syscall != NULL);

	atomic_inc_uint(&syscallemu_refcnt);
	syscallemu_setsce(p, sce);

#ifdef DEBUG
	printf("syscallemu: enabled for pid %d\n", p->p_pid);
#endif

	return 0;
}

/*
 * Initialize the syscallemu module
 */
static int
syscallemu_init(void)
{
	int error;

	syscallemu_refcnt = 0;

	/* XXX workaround for kern/45781 */
	if (emul_netbsd.e_sysent[SYS_syscallemu].sy_call == sys_nosys) {
		printf("syscallemu: applying workaround for kern/45781\n");
		emul_netbsd.e_sysent[SYS_syscallemu].sy_call = sys_nomodule;
	}
	emul_netbsd.e_sysent[SYS_syscallemu].sy_narg =
	    sizeof(struct sys_syscallemu_args) / sizeof(register_t);
	emul_netbsd.e_sysent[SYS_syscallemu].sy_argsize =
	    sizeof(struct sys_syscallemu_args);

	error = proc_specific_key_create(&syscallemu_data_key, syscallemu_dtor);
	if (error) {
		printf("syscallemu: couldn't create proc specific key (%d)\n",
		    error);
		return error;
	}

	error = syscall_establish(NULL, syscallemu_syscalls);
	if (error) {
		printf("syscallemu: couldn't establish syscalls\n");
		proc_specific_key_delete(syscallemu_data_key);
		return ENXIO;
	}

	return 0;
}

/*
 * Finalize the syscallemu module
 */
static int
syscallemu_fini(void)
{
	if (syscallemu_refcnt > 0)
		return EBUSY;

	syscall_disestablish(NULL, syscallemu_syscalls);
	proc_specific_key_delete(syscallemu_data_key);
	return 0;
}

/*
 * Module glue
 */
MODULE(MODULE_CLASS_MISC, syscallemu, NULL);

static int
syscallemu_modcmd(modcmd_t cmd, void *arg)
{
	switch (cmd) {
	case MODULE_CMD_INIT:
		return syscallemu_init();	
	case MODULE_CMD_FINI:
		return syscallemu_fini();
	case MODULE_CMD_AUTOUNLOAD:
		return EBUSY;
	default:
		return ENOTTY;
	}
}