/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2023 Chelsio Communications, Inc.
 * Written by: John Baldwin <jhb@FreeBSD.org>
 */

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/malloc.h>
#include <sys/nv.h>
#include <dev/nvme/nvme.h>
#include <dev/nvmf/nvmf.h>
#include <dev/nvmf/nvmf_transport.h>
#include <dev/nvmf/host/nvmf_var.h>

static struct cdev *nvmf_cdev;

static int
nvmf_handoff_host(struct nvmf_ioc_nv *nv)
{
	nvlist_t *nvl;
	device_t dev;
	int error;

	error = nvmf_copyin_handoff(nv, &nvl);
	if (error != 0)
		return (error);

	bus_topo_lock();
	dev = device_add_child(root_bus, "nvme", DEVICE_UNIT_ANY);
	if (dev == NULL) {
		bus_topo_unlock();
		error = ENXIO;
		goto out;
	}

	device_set_ivars(dev, nvl);
	error = device_probe_and_attach(dev);
	device_set_ivars(dev, NULL);
	if (error != 0)
		device_delete_child(root_bus, dev);
	bus_topo_unlock();

out:
	nvlist_destroy(nvl);
	return (error);
}

static bool
nvmf_matches(device_t dev, char *name)
{
	struct nvmf_softc *sc = device_get_softc(dev);

	if (strcmp(device_get_nameunit(dev), name) == 0)
		return (true);
	if (strcmp(sc->cdata->subnqn, name) == 0)
		return (true);
	return (false);
}

static int
nvmf_disconnect_by_name(char *name)
{
	devclass_t dc;
	device_t dev;
	int error, unit;
	bool found;

	found = false;
	error = 0;
	bus_topo_lock();
	dc = devclass_find("nvme");
	if (dc == NULL)
		goto out;

	for (unit = 0; unit < devclass_get_maxunit(dc); unit++) {
		dev = devclass_get_device(dc, unit);
		if (dev == NULL)
			continue;
		if (device_get_driver(dev) != &nvme_nvmf_driver)
			continue;
		if (device_get_parent(dev) != root_bus)
			continue;
		if (name != NULL && !nvmf_matches(dev, name))
			continue;

		error = device_delete_child(root_bus, dev);
		if (error != 0)
			break;
		found = true;
	}
out:
	bus_topo_unlock();
	if (error == 0 && !found)
		error = ENOENT;
	return (error);
}

static int
nvmf_disconnect_host(const char **namep)
{
	char *name;
	int error;

	name = malloc(PATH_MAX, M_NVMF, M_WAITOK);
	error = copyinstr(*namep, name, PATH_MAX, NULL);
	if (error == 0)
		error = nvmf_disconnect_by_name(name);
	free(name, M_NVMF);
	return (error);
}

static int
nvmf_ctl_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag,
    struct thread *td)
{
	switch (cmd) {
	case NVMF_HANDOFF_HOST:
		return (nvmf_handoff_host((struct nvmf_ioc_nv *)arg));
	case NVMF_DISCONNECT_HOST:
		return (nvmf_disconnect_host((const char **)arg));
	case NVMF_DISCONNECT_ALL:
		return (nvmf_disconnect_by_name(NULL));
	default:
		return (ENOTTY);
	}
}

static struct cdevsw nvmf_ctl_cdevsw = {
	.d_version = D_VERSION,
	.d_ioctl = nvmf_ctl_ioctl
};

int
nvmf_ctl_load(void)
{
	struct make_dev_args mda;
	int error;

	make_dev_args_init(&mda);
	mda.mda_devsw = &nvmf_ctl_cdevsw;
	mda.mda_uid = UID_ROOT;
	mda.mda_gid = GID_WHEEL;
	mda.mda_mode = 0600;
	error = make_dev_s(&mda, &nvmf_cdev, "nvmf");
	if (error != 0)
		nvmf_cdev = NULL;
	return (error);
}

void
nvmf_ctl_unload(void)
{
	if (nvmf_cdev != NULL) {
		destroy_dev(nvmf_cdev);
		nvmf_cdev = NULL;
	}
}