tests/libnvme/ctrl-disc.c

/*
 * 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.
 */

/*
 * Copyright 2024 Oxide Computer Company
 */

/*
 * Test controller discovery. Because we've been given a controller, we expect
 * to be able to find a controller with the same devi while performing
 * controller discovery. Its minor should point to the same devi that the normal
 * discovery and controller do.
 */

#include <err.h>
#include <string.h>
#include <umem.h>
#include <sys/stat.h>

#include "libnvme_test_common.h"

static bool
ctrl_disc_count_cb(nvme_t *nvme, const nvme_ctrl_disc_t *disc, void *arg)
{
	uint32_t *valp = arg;
	*valp = *valp + 1;
	return (true);
}

static bool
ctrl_check_disc(const nvme_ctrl_disc_t *disc)
{
	bool ret = true;
	di_node_t ctrl_devi, minor_devi;
	di_minor_t minor;
	const char *mname;

	ctrl_devi = nvme_ctrl_disc_devi(disc);
	minor = nvme_ctrl_disc_minor(disc);
	minor_devi = di_minor_devinfo(minor);
	mname = di_minor_name(minor);

	if (di_minor_spectype(minor) != S_IFCHR) {
		warnx("TEST FAILED: %s minor is not a character device, found "
		    "0x%x\n", mname, di_minor_spectype(minor));
		ret = false;
	} else {
		(void) printf("TEST PASSED: %s: minor is a character device\n",
		    mname);
	}

	if (strcmp(di_minor_nodetype(minor), DDI_NT_NVME_NEXUS) != 0) {
		warnx("TEST FAILED: %s minor has wrong node type %s, expected "
		    "%s", mname, di_minor_nodetype(minor), DDI_NT_NVME_NEXUS);
	} else {
		(void) printf("TEST PASSED: %s minor has correct node types\n",
		    mname);
	}

	if (minor_devi != ctrl_devi) {
		warnx("TEST FAILED: %s minor devi does not match the "
		    "controller devi", mname);
		ret = false;
	} else {
		(void) printf("TEST PASSED: %s minor devi matches its "
		    "controller\n", mname);
	}

	return (ret);
}

static bool
ctrl_match(nvme_t *nvme, nvme_ctrl_t *targ)
{
	bool ret = true, match = false;
	nvme_ctrl_iter_t *iter = NULL;
	const nvme_ctrl_disc_t *disc;
	nvme_iter_t iret;
	di_node_t targ_di;

	if (!nvme_ctrl_devi(targ, &targ_di)) {
		libnvme_test_ctrl_warn(targ, "failed to obtain di_node_t from "
		    "controller");
		return (false);
	}

	if (!nvme_ctrl_discover_init(nvme, &iter)) {
		libnvme_test_hdl_warn(nvme, "failed to initialize controller "
		    "discovery");
		return (false);
	}

	while ((iret = nvme_ctrl_discover_step(iter, &disc)) ==
	    NVME_ITER_VALID) {
		if (!ctrl_check_disc(disc)) {
			ret = false;
		}

		if (nvme_ctrl_disc_devi(disc) == targ_di) {
			match = true;
		}
	}

	if (iret != NVME_ITER_DONE) {
		libnvme_test_hdl_warn(nvme, "failed to iterate controllers");
		ret = false;
	}

	if (!match) {
		warnx("TEST FAILED: failed to find matching controller");
		ret = false;
	} else {
		(void) printf("TEST PASSED: found matching controller in "
		    "discovery for device %s\n", getenv(NVME_TEST_DEV_ENVVAR));
	}

	nvme_ctrl_discover_fini(iter);
	return (ret);
}

static bool
ctrl_disc_nop_cb(nvme_t *nvme, const nvme_ctrl_disc_t *disc, void *arg)
{
	return (true);
}

static bool
ctrl_disc_bad_disc_init(nvme_t *nvme, nvme_ctrl_iter_t **iterp,
    nvme_err_t exp_err, const char *desc)
{
	if (nvme_ctrl_discover_init(nvme, iterp)) {
		warnx("TEST FAILED: nvme_ctrl_discover_init() erroneously "
		    "passed despite %s\n", desc);
		return (false);
	} else if (nvme_err(nvme) != exp_err) {
		warnx("TEST FAILED: nvme_ctrl_discover_init() returned "
		    "wrong error %s (0x%x), not %s (0x%x)",
		    nvme_errtostr(nvme, nvme_err(nvme)), nvme_err(nvme),
		    nvme_errtostr(nvme, exp_err), exp_err);
		return (false);
	} else {
		(void) printf("TEST PASSED: nvme_ctrl_discover_init() failed "
		    "correctly for %s\n", desc);
		return (true);
	}
}

static bool
ctrl_disc_bad_disc(nvme_t *nvme, nvme_ctrl_disc_f func, nvme_err_t exp_err,
    const char *desc)
{
	if (nvme_ctrl_discover(nvme, func, NULL)) {
		warnx("TEST FAILED: nvme_ctrl_discover() erroneously "
		    "passed despite %s\n", desc);
		return (false);
	} else if (nvme_err(nvme) != exp_err) {
		warnx("TEST FAILED: nvme_ctrl_discover() returned "
		    "wrong error %s (0x%x), not %s (0x%x)",
		    nvme_errtostr(nvme, nvme_err(nvme)), nvme_err(nvme),
		    nvme_errtostr(nvme, exp_err), exp_err);
		return (false);
	} else {
		(void) printf("TEST PASSED: nvme_ctrl_discover() failed "
		    "correctly for %s\n", desc);
		return (true);
	}
}

int
main(void)
{
	int ret = EXIT_SUCCESS;
	nvme_t *nvme;
	nvme_ctrl_t *ctrl;
	uint32_t nctrl = 0;
	nvme_ctrl_iter_t *iter;

	libnvme_test_init(&nvme, &ctrl);

	if (!nvme_ctrl_discover(nvme, ctrl_disc_count_cb, &nctrl)) {
		libnvme_test_hdl_warn(nvme, "failed to discover controllers");
		ret = EXIT_FAILURE;
	} else if (nctrl == 0) {
		warnx("TEST FAILED: discovered zero controllers somehow!");
		ret = EXIT_FAILURE;
	} else {
		(void) printf("TEST PASSED: discovered some number of "
		    "controllers");
	}

	if (!ctrl_match(nvme, ctrl)) {
		ret = EXIT_FAILURE;
	}

	if (!ctrl_disc_bad_disc_init(nvme, NULL, NVME_ERR_BAD_PTR,
	    "invalid iter pointer")) {
		ret = EXIT_FAILURE;
	}

	if (!ctrl_disc_bad_disc(nvme, NULL, NVME_ERR_BAD_PTR,
	    "invalid function pointer")) {
		ret = EXIT_FAILURE;
	}

	umem_setmtbf(1);
	if (!ctrl_disc_bad_disc_init(nvme, &iter, NVME_ERR_NO_MEM,
	    "no memory")) {
		ret = EXIT_FAILURE;
	}

	if (!ctrl_disc_bad_disc(nvme, ctrl_disc_nop_cb, NVME_ERR_NO_MEM,
	    "no memory")) {
		ret = EXIT_FAILURE;
	}
	umem_setmtbf(0);

	if (ret == EXIT_SUCCESS) {
		(void) printf("All tests passed successfully\n");
	}

	nvme_ctrl_fini(ctrl);
	nvme_fini(nvme);
	return (ret);
}