/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */
/* This file is dual-licensed; see usr/src/contrib/bhyve/LICENSE */

/*
 * Copyright 2022 Oxide Computer Company
 */

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/mkdev.h>
#include <sys/sunddi.h>
#include <sys/id_space.h>
#include <sys/stat.h>

#include <sys/vmm_drv.h>
#include <sys/vmm_drv_test.h>

#define	VDT_CTL_NAME	"vmm_drv_test"
#define	VDT_CTL_MINOR	0

static dev_info_t	*vdt_dip;
static void		*vdt_state;
static id_space_t	*vdt_minors;

typedef struct vdt_soft_state {
	kmutex_t	vss_lock;
	vmm_hold_t	*vss_hold;
} vdt_soft_state_t;


static int
vdt_open(dev_t *devp, int flag, int otype, cred_t *cr)
{
	id_t minor;

	if (otype != OTYP_CHR) {
		return (EINVAL);
	}
	if (getminor(*devp) != VDT_CTL_MINOR) {
		return (ENXIO);
	}

	minor = id_alloc_nosleep(vdt_minors);
	if (minor == -1) {
		return (EBUSY);
	}
	if (ddi_soft_state_zalloc(vdt_state, minor) != DDI_SUCCESS) {
		id_free(vdt_minors, minor);
		return (ENOMEM);
	}

	vdt_soft_state_t *ss;
	ss = ddi_get_soft_state(vdt_state, minor);
	mutex_init(&ss->vss_lock, NULL, MUTEX_DEFAULT, NULL);
	*devp = makedevice(getmajor(*devp), minor);

	return (0);
}

static int
vdt_close(dev_t dev, int flag, int otype, cred_t *cr)
{
	if (otype != OTYP_CHR) {
		return (EINVAL);
	}

	id_t minor = getminor(dev);
	vdt_soft_state_t *ss = ddi_get_soft_state(vdt_state, minor);
	if (ss == NULL) {
		return (ENXIO);
	}

	if (ss->vss_hold != NULL) {
		vmm_drv_rele(ss->vss_hold);
		ss->vss_hold = NULL;
	}
	mutex_destroy(&ss->vss_lock);
	ddi_soft_state_free(vdt_state, minor);
	id_free(vdt_minors, minor);

	return (0);
}

static int
vdt_ioc_hold(vdt_soft_state_t *ss, cred_t *cr, int vmm_fd)
{
	mutex_enter(&ss->vss_lock);
	if (ss->vss_hold != NULL) {
		mutex_exit(&ss->vss_lock);
		return (EEXIST);
	}

	file_t *fp = getf(vmm_fd);
	if (fp == NULL) {
		mutex_exit(&ss->vss_lock);
		return (EBADF);
	}

	int err = vmm_drv_hold(fp, cr, &ss->vss_hold);
	releasef(vmm_fd);
	mutex_exit(&ss->vss_lock);
	return (err);
}

static int
vdt_ioc_rele(vdt_soft_state_t *ss)
{
	mutex_enter(&ss->vss_lock);
	if (ss->vss_hold == NULL) {
		mutex_exit(&ss->vss_lock);
		return (ENODEV);
	}

	vmm_drv_rele(ss->vss_hold);
	ss->vss_hold = NULL;
	mutex_exit(&ss->vss_lock);
	return (0);
}

static int
vdt_ioctl(dev_t dev, int cmd, intptr_t data, int md, cred_t *cr, int *rv)
{
	vdt_soft_state_t *ss = ddi_get_soft_state(vdt_state, getminor(dev));
	if (ss == NULL) {
		return (ENXIO);
	}

	int err = 0;
	*rv = 0;
	switch (cmd) {
	case VDT_IOC_HOLD:
		err = vdt_ioc_hold(ss, cr, (int)data);
		break;
	case VDT_IOC_RELE:
		err = vdt_ioc_rele(ss);
		break;
	default:
		err = ENOTTY;
		break;
	}

	return (err);
}

static int
vdt_info(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
	switch (cmd) {
	case DDI_INFO_DEVT2DEVINFO:
		*result = (void *)vdt_dip;
		return (DDI_SUCCESS);
	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)0;
		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}
}

static int
vdt_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	if (cmd != DDI_ATTACH) {
		return (DDI_FAILURE);
	}

	if (vdt_dip != NULL) {
		return (DDI_FAILURE);
	}

	/* Create "control" node from which other instances are spawned */
	if (ddi_create_minor_node(dip, VDT_CTL_NAME, S_IFCHR, VDT_CTL_MINOR,
	    DDI_PSEUDO, 0) != 0) {
		return (DDI_FAILURE);
	}

	ddi_report_dev(dip);
	vdt_dip = dip;
	return (DDI_SUCCESS);
}

static int
vdt_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	if (cmd != DDI_DETACH) {
		return (DDI_FAILURE);
	}

	ddi_remove_minor_node(vdt_dip, NULL);
	vdt_dip = NULL;

	return (DDI_SUCCESS);
}

static struct cb_ops vdt_cb_ops = {
	.cb_open	= vdt_open,
	.cb_close	= vdt_close,
	.cb_strategy	= nodev,
	.cb_print	= nodev,
	.cb_dump	= nodev,
	.cb_read	= nodev,
	.cb_write	= nodev,
	.cb_ioctl	= vdt_ioctl,
	.cb_devmap	= nodev,
	.cb_mmap	= nodev,
	.cb_segmap	= nodev,
	.cb_chpoll	= nochpoll,
	.cb_prop_op	= ddi_prop_op,

	.cb_str		= NULL,

	.cb_flag	= D_NEW | D_MP | D_DEVMAP,
	.cb_rev		= CB_REV,
	.cb_aread	= nodev,
	.cb_awrite	= nodev,
};

static struct dev_ops vdt_ops = {
	.devo_rev	= DEVO_REV,
	.devo_refcnt	= 0,

	.devo_getinfo	= vdt_info,
	.devo_identify	= nulldev,
	.devo_probe	= nulldev,
	.devo_attach	= vdt_attach,
	.devo_detach	= vdt_detach,
	.devo_reset	= nodev,
	.devo_cb_ops	= &vdt_cb_ops,

	.devo_bus_ops	= NULL,
	.devo_power	= ddi_power,
	.devo_quiesce	= ddi_quiesce_not_needed,
};

static struct modldrv modldrv = {
	&mod_driverops,
	"bhyve vmm drv test",
	&vdt_ops
};

static struct modlinkage modlinkage = {
	MODREV_1,
	&modldrv,
	NULL
};

int
_init(void)
{
	int err;

	vdt_minors = id_space_create("vmm_drv_test_minors",
	    VDT_CTL_MINOR + 1, MAXMIN32);

	err = ddi_soft_state_init(&vdt_state, sizeof (vdt_soft_state_t), 0);
	if (err != 0) {
		return (err);
	}

	err = mod_install(&modlinkage);
	if (err != 0) {
		ddi_soft_state_fini(&vdt_state);
	}

	return (0);
}

int
_fini(void)
{
	int err = mod_remove(&modlinkage);
	if (err != 0) {
		return (err);
	}

	ddi_soft_state_fini(&vdt_state);

	id_space_destroy(vdt_minors);

	return (0);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}