/*
 * Copyright (c) 2011 Alex Hornung <alex@alexhornung.com>.
 * 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 COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/conf.h>
#include <sys/malloc.h>
#include <machine/md_var.h>
#include <sys/ctype.h>
#include <sys/kthread.h>
#include <sys/device.h>
#include <sys/fcntl.h>
#include <sys/module.h>
#include <libprop/proplib.h>
#include <sys/tbridge.h>

static cdev_t           tbridge_dev;
static d_open_t         tbridge_dev_open;
static d_close_t        tbridge_dev_close;
static d_ioctl_t        tbridge_dev_ioctl;


static struct dev_ops tbridge_dev_ops = {
        { "tbridge", 0, 0 },
        .d_open = tbridge_dev_open,
        .d_close = tbridge_dev_close,
        .d_ioctl = tbridge_dev_ioctl
};

static struct tbridge_testcase *tbridge_curtest = NULL;
static prop_dictionary_t tbridge_testcase = NULL;
static int tbridge_result_ready = 0;
static char tbridge_msgbuf[131072]; /* 128 kB message buffer */
static char *tbridge_msgbuf_ptr;
size_t tbridge_msgbuf_remsz;

static prop_dictionary_t
testcase_get_result_dict(prop_dictionary_t testcase)
{
        prop_dictionary_t result_dict;
        int r;

        result_dict = prop_dictionary_get(testcase, "result");
        if (result_dict == NULL) {
                result_dict = prop_dictionary_create();
                if (result_dict == NULL) {
                        kprintf("could not allocate new result dict");
                        return NULL;
                }

                r = prop_dictionary_set(testcase, "result", result_dict);
                if (r == 0) {
                        kprintf("prop_dictionary operation failed");
                        return NULL;
                }
        }

        return result_dict;
}

static int
testcase_get_timeout(prop_dictionary_t testcase)
{
        int32_t val;
        int r;

        r = prop_dictionary_get_int32(prop_dictionary_get(testcase, "opts"),
            "timeout_in_secs", &val);
        if (r == 0)
                val = 600/* default timeout = 10min */;
                
        return val;
}

static int
testcase_set_stdout_buf(prop_dictionary_t testcase, const char *buf)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_cstring(dict, "stdout_buf", buf);
}

static int
testcase_set_result(prop_dictionary_t testcase, int result)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_int32(dict, "result", result);
}

static const char *
testcase_get_name(prop_dictionary_t testcase)
{
        const char *str;
        int r;

        r = prop_dictionary_get_cstring_nocopy(testcase, "name", &str);
        if (r == 0)
                str = "???";

        return str;
}

int
tbridge_printf(const char *fmt, ...)
{
        __va_list args;
        int i;

        __va_start(args,fmt);
        i = kvsnprintf(tbridge_msgbuf_ptr, tbridge_msgbuf_remsz, fmt, args);
        __va_end(args);

        tbridge_msgbuf_ptr += i;
        tbridge_msgbuf_remsz -= i;

        return i;
}

static int
tbridge_register(struct tbridge_testcase *test)
{
        if (tbridge_curtest != NULL)
                return EBUSY;

        tbridge_curtest = test;

        return 0;
}

static int
tbridge_unregister(void)
{
        tbridge_curtest = NULL;

        return 0;
}

int
tbridge_testcase_modhandler(module_t mod, int type, void *arg)
{
        struct tbridge_testcase *tcase = (struct tbridge_testcase *)arg;
        int error = 0;

        switch (type) {
        case MOD_LOAD:
                error = tbridge_register(tcase);
                break;

        case MOD_UNLOAD:
                if (tcase->tb_abort != NULL)
                        error = tcase->tb_abort();

                if (!error)
                        tbridge_unregister();
                break;

        default:
                break;
        }

        return error;
}

void
tbridge_test_done(int result)
{
        KKASSERT(tbridge_testcase != NULL);

        kprintf("testcase '%s' called test_done with result=%d\n",
            testcase_get_name(tbridge_testcase), result);

        testcase_set_result(tbridge_testcase, result);
        testcase_set_stdout_buf(tbridge_testcase, tbridge_msgbuf);

        tbridge_result_ready = 1;
        wakeup(&tbridge_result_ready);
}

static void
tbridge_reset(void)
{
        tbridge_msgbuf_ptr = tbridge_msgbuf;
        tbridge_msgbuf_remsz = sizeof(tbridge_msgbuf);

        if (tbridge_testcase != NULL) {
                prop_object_release(tbridge_testcase);
                tbridge_testcase = NULL;
        }

        safemem_reset_error_count();
        tbridge_result_ready = 0;
}


/*
 * dev stuff
 */
static int
tbridge_dev_open(struct dev_open_args *ap)
{
        return 0;
}

static int
tbridge_dev_close(struct dev_close_args *ap)
{
        return 0;
}

static int
tbridge_dev_ioctl(struct dev_ioctl_args *ap)
{
        struct plistref *pref;
        struct thread *td;
        int error, r;

        error = 0;

        /* Use proplib(3) for userspace/kernel communication */
        pref = (struct plistref *)ap->a_data;

        switch(ap->a_cmd) {
        case TBRIDGE_LOADTEST:
                tbridge_reset();

                if (tbridge_curtest == NULL)
                        return EINVAL;

                error = prop_dictionary_copyin_ioctl(pref, ap->a_cmd,
                    &tbridge_testcase);
                if (error)
                        return error;

                break;

        case TBRIDGE_GETRESULT:
                error = kthread_create(tbridge_curtest->tb_run, NULL, &td,
                    "testrunner");
                if (error)
                        tbridge_test_done(RESULT_PREFAIL);

                /* The following won't be called if the thread wasn't created */
                if (!tbridge_result_ready) {
                        r = tsleep(&tbridge_result_ready, 0, "tbridgeres",
                            hz * testcase_get_timeout(tbridge_testcase));
                        if (r != 0) {
                                if (tbridge_curtest->tb_abort != NULL)
                                        tbridge_curtest->tb_abort();

                                tbridge_test_done(RESULT_TIMEOUT);
                        }
                }

                if (safemem_get_error_count() != 0) {
                        /*
                         * If there were any double-frees or buffer over- or
                         * underflows, we mark the result as 'signalled', i.e.
                         * the equivalent of a SIGSEGV/SIGBUS in userland.
                         */
                        testcase_set_result(tbridge_testcase, RESULT_SIGNALLED);
                }

                error = prop_dictionary_copyout_ioctl(pref, ap->a_cmd,
                    tbridge_testcase);
                if (error)
                        return error;

                break;
        default:
                error = ENOTTY; /* Inappropriate ioctl for device */
                break;
        }

        return(error);
}


static int
testbridge_modevent(module_t mod, int type, void *unused)
{
        switch (type) {
        case MOD_LOAD:
                tbridge_dev = make_dev(&tbridge_dev_ops,
                    0,
                    UID_ROOT,
                    GID_WHEEL,
                    0600,
                    "tbridge");

                tbridge_testcase = NULL;
                tbridge_reset();

                kprintf("dfregress kernel test bridge ready!\n");
                return 0;

        case MOD_UNLOAD:
                destroy_dev(tbridge_dev);
                kprintf("dfregress kernel test bridge unloaded.\n");
                return 0;
        }

        return EINVAL;
}

static moduledata_t testbridge_mod = {
        "testbridge",
        testbridge_modevent,
        0
};

DECLARE_MODULE(testbridge, testbridge_mod, SI_SUB_DRIVERS, SI_ORDER_ANY);
MODULE_VERSION(testbridge, 1);