/*
 * This file is freeware. You are free to use it and add your own
 * license.
 *
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/module.h>

#include <sys/dtrace.h>

static d_open_t prototype_open;
static int      prototype_unload(void);
static void     prototype_getargdesc(void *, dtrace_id_t, void *, dtrace_argdesc_t *);
static void     prototype_provide(void *, dtrace_probedesc_t *);
static void     prototype_destroy(void *, dtrace_id_t, void *);
static void     prototype_enable(void *, dtrace_id_t, void *);
static void     prototype_disable(void *, dtrace_id_t, void *);
static void     prototype_load(void *);

static struct cdevsw prototype_cdevsw = {
        .d_version      = D_VERSION,
        .d_open         = prototype_open,
        .d_name         = "prototype",
};

static dtrace_pattr_t prototype_attr = {
{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
};

static dtrace_pops_t prototype_pops = {
        .dtps_provide =         prototype_provide,
        .dtps_provide_module =  NULL,
        .dtps_enable =          prototype_enable,
        .dtps_disable =         prototype_disable,
        .dtps_suspend =         NULL,
        .dtps_resume =          NULL,
        .dtps_getargdesc =      prototype_getargdesc,
        .dtps_getargval =       NULL,
        .dtps_usermode =        NULL,
        .dtps_destroy =         prototype_destroy
};

static struct cdev              *prototype_cdev;
static dtrace_provider_id_t     prototype_id;

static void
prototype_getargdesc(void *arg, dtrace_id_t id, void *parg, dtrace_argdesc_t *desc)
{
}

static void
prototype_provide(void *arg, dtrace_probedesc_t *desc)
{
}

static void
prototype_destroy(void *arg, dtrace_id_t id, void *parg)
{
}

static void
prototype_enable(void *arg, dtrace_id_t id, void *parg)
{
}

static void
prototype_disable(void *arg, dtrace_id_t id, void *parg)
{
}

static void
prototype_load(void *dummy)
{
        /*
         * Create the /dev/dtrace/prototype entry.
         * XXX: Remove this if the provider does not need any customs ioctls.
         */
        prototype_cdev = make_dev(&prototype_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
            "dtrace/prototype");

        if (dtrace_register("prototype", &prototype_attr, DTRACE_PRIV_USER,
            NULL, &prototype_pops, NULL, &prototype_id) != 0)
                return;
}


static int
prototype_unload(void)
{
        int error = 0;

        if ((error = dtrace_unregister(prototype_id)) != 0)
                return (error);

        destroy_dev(prototype_cdev);

        return (error);
}

static int
prototype_modevent(module_t mod __unused, int type, void *data __unused)
{
        int error = 0;

        switch (type) {
        case MOD_LOAD:
                break;

        case MOD_UNLOAD:
                break;

        case MOD_SHUTDOWN:
                break;

        default:
                error = EOPNOTSUPP;
                break;

        }

        return (error);
}

static int
prototype_open(struct cdev *dev __unused, int oflags __unused, int devtype __unused, struct thread *td __unused)
{
        return (0);
}

SYSINIT(prototype_load, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, prototype_load, NULL);
SYSUNINIT(prototype_unload, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, prototype_unload, NULL);

DEV_MODULE(prototype, prototype_modevent, NULL);
MODULE_VERSION(prototype, 1);
MODULE_DEPEND(prototype, dtrace, 1, 1, 1);
MODULE_DEPEND(prototype, opensolaris, 1, 1, 1);