xref: /illumos-gate/usr/src/test/nvme-tests/tests/libnvme/ns-lifecycle.c (revision f5f0964ce91892f7482efc86903b0ec7c7b6ba66)

/*
 * 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 2025 Oxide Computer Company
 */

/*
 * This test goes through the lifecycle of a namespace and verifies that when we
 * try to take transitions that it does not support, we can generate the
 * expected errors.
 *
 * This test expects to start from the device-empty profile.
 */

#include <err.h>
#include <stdlib.h>
#include <sys/sysmacros.h>

#include "libnvme_test_common.h"

/*
 * We expect that we should always be issued NSID 1.
 */
#define	NS_LC_NSID	1

/*
 * This is a list of actions we can take in a given state against a namespace.
 * There is no namespace create in this list as there is no way to specify a
 * namespace to take action against.
 */
typedef enum {
	NS_ACT_NS_DELETE,
	NS_ACT_CTRL_ATTACH,
	NS_ACT_CTRL_DETACH,
	NS_ACT_BD_ATTACH,
	NS_ACT_BD_DETACH
} ns_act_t;

#define	NS_LC_NACTS	(NS_ACT_BD_DETACH + 1)

nvme_err_t nvme_unalloc_errs[NS_LC_NACTS] = {
	[NS_ACT_NS_DELETE] = NVME_ERR_NS_UNALLOC,
	[NS_ACT_CTRL_ATTACH] = NVME_ERR_NS_UNALLOC,
	[NS_ACT_CTRL_DETACH] = NVME_ERR_NS_UNALLOC,
	[NS_ACT_BD_ATTACH] = NVME_ERR_NS_UNALLOC,
	[NS_ACT_BD_DETACH] = NVME_ERR_NS_UNALLOC
};

nvme_err_t nvme_alloc_errs[NS_LC_NACTS] = {
	[NS_ACT_NS_DELETE] = NVME_ERR_OK,
	[NS_ACT_CTRL_ATTACH] = NVME_ERR_OK,
	[NS_ACT_CTRL_DETACH] = NVME_ERR_NS_CTRL_NOT_ATTACHED,
	[NS_ACT_BD_ATTACH] = NVME_ERR_NS_CTRL_NOT_ATTACHED,
	[NS_ACT_BD_DETACH] = NVME_ERR_NS_CTRL_NOT_ATTACHED
};

nvme_err_t nvme_attach_errs[NS_LC_NACTS] = {
	[NS_ACT_NS_DELETE] = NVME_ERR_NS_CTRL_ATTACHED,
	[NS_ACT_CTRL_ATTACH] = NVME_ERR_NS_CTRL_ATTACHED,
	[NS_ACT_CTRL_DETACH] = NVME_ERR_OK,
	[NS_ACT_BD_ATTACH] = NVME_ERR_OK,
	[NS_ACT_BD_DETACH] = NVME_ERR_NS_CTRL_ATTACHED
};

nvme_err_t nvme_blkdev_errs[NS_LC_NACTS] = {
	[NS_ACT_NS_DELETE] = NVME_ERR_NS_BLKDEV_ATTACH,
	[NS_ACT_CTRL_ATTACH] = NVME_ERR_NS_BLKDEV_ATTACH,
	[NS_ACT_CTRL_DETACH] = NVME_ERR_NS_BLKDEV_ATTACH,
	[NS_ACT_BD_ATTACH] = NVME_ERR_NS_BLKDEV_ATTACH,
	[NS_ACT_BD_DETACH] = NVME_ERR_OK
};

static bool
ns_life_err_comp(nvme_ctrl_t *ctrl, nvme_err_t exp, nvme_err_t act,
    const char *desc, const char *state)
{
	if (act != exp) {
		warnx("TEST FAILED: %s in state %s returned %s (0x%x), but "
		    "expected %s (0x%x)", desc, state,
		    nvme_ctrl_errtostr(ctrl, act), act,
		    nvme_ctrl_errtostr(ctrl, exp), exp);
	} else {
		(void) printf("TEST PASSED: %s in state %s correctly returned "
		    "%s\n", desc, state, nvme_ctrl_errtostr(ctrl, act));
	}

	return (act == exp);
}

static bool
ns_life_ns_delete(nvme_ctrl_t *ctrl, uint32_t nsid, nvme_err_t exp,
    const char *state)
{
	nvme_err_t act;

	if (!libnvme_test_ns_delete(ctrl, nsid, &act)) {
		return (false);
	}

	return (ns_life_err_comp(ctrl, exp, act, "namespace delete", state));
}

static bool
ns_life_ctrl_attach(nvme_ctrl_t *ctrl, uint32_t nsid, nvme_err_t exp,
    const char *state)
{
	nvme_err_t act;

	if (!libnvme_test_ctrl_attach(ctrl, nsid, NVME_NS_ATTACH_CTRL_ATTACH,
	    &act)) {
		return (false);
	}

	return (ns_life_err_comp(ctrl, exp, act, "controller attach", state));
}

static bool
ns_life_ctrl_detach(nvme_ctrl_t *ctrl, uint32_t nsid, nvme_err_t exp,
    const char *state)
{
	nvme_err_t act;

	if (!libnvme_test_ctrl_attach(ctrl, nsid, NVME_NS_ATTACH_CTRL_DETACH,
	    &act)) {
		return (false);
	}

	return (ns_life_err_comp(ctrl, exp, act, "controller detach", state));
}

static bool
ns_life_blkdev_attach(nvme_ctrl_t *ctrl, uint32_t nsid, nvme_err_t exp,
    const char *state)
{
	nvme_err_t act;

	if (!libnvme_test_ns_blkdev(ctrl, nsid, true, &act)) {
		return (false);
	}

	return (ns_life_err_comp(ctrl, exp, act, "blkdev attach", state));
}

static bool
ns_life_blkdev_detach(nvme_ctrl_t *ctrl, uint32_t nsid, nvme_err_t exp,
    const char *state)
{
	nvme_err_t act;

	if (!libnvme_test_ns_blkdev(ctrl, nsid, false, &act)) {
		return (false);
	}

	return (ns_life_err_comp(ctrl, exp, act, "blkdev detach", state));
}

typedef bool (*ns_life_f)(nvme_ctrl_t *, uint32_t, nvme_err_t,
    const char *);

static const ns_life_f ns_lf_funcs[NS_LC_NACTS] = {
	[NS_ACT_NS_DELETE] = ns_life_ns_delete,
	[NS_ACT_CTRL_ATTACH] = ns_life_ctrl_attach,
	[NS_ACT_CTRL_DETACH] = ns_life_ctrl_detach,
	[NS_ACT_BD_ATTACH] = ns_life_blkdev_attach,
	[NS_ACT_BD_DETACH] = ns_life_blkdev_detach
};

typedef struct ns_life_test {
	nvme_ns_disc_level_t nlt_disc;
	const char *nlt_desc;
	nvme_err_t *nlt_errs;
	size_t nlt_nerrs;
} ns_life_test_t;

static const ns_life_test_t ns_life_tests[] = { {
	.nlt_disc = NVME_NS_DISC_F_ALL,
	.nlt_desc = "unallocated",
	.nlt_errs = nvme_unalloc_errs,
	.nlt_nerrs = ARRAY_SIZE(nvme_unalloc_errs)
}, {
	.nlt_disc = NVME_NS_DISC_F_ALLOCATED,
	.nlt_desc = "allocated",
	.nlt_errs = nvme_alloc_errs,
	.nlt_nerrs = ARRAY_SIZE(nvme_alloc_errs)
}, {
	.nlt_disc = NVME_NS_DISC_F_NOT_IGNORED,
	.nlt_desc = "active",
	.nlt_errs = nvme_attach_errs,
	.nlt_nerrs = ARRAY_SIZE(nvme_attach_errs)
}, {
	.nlt_disc = NVME_NS_DISC_F_BLKDEV,
	.nlt_desc = "blkdev",
	.nlt_errs = nvme_blkdev_errs,
	.nlt_nerrs = ARRAY_SIZE(nvme_blkdev_errs)
} };

static bool
ns_life_run_one(nvme_ctrl_t *ctrl, uint32_t lbaf, const ns_life_test_t *test)
{
	bool ret = true;

	for (size_t i = 0; i < test->nlt_nerrs; i++) {
		if (!libnvme_test_setup_ns(ctrl, test->nlt_disc, NS_LC_NSID,
		    lbaf)) {
			warnx("TEST FAILED: failed to transition ns to %s",
			    test->nlt_desc);
			ret = false;
		}

		if (!ns_lf_funcs[i](ctrl, NS_LC_NSID, test->nlt_errs[i],
		    test->nlt_desc)) {
			ret = false;
		}
	}

	return (ret);
}

int
main(void)
{
	int ret = EXIT_SUCCESS;
	nvme_t *nvme;
	nvme_ctrl_t *ctrl;
	nvme_ctrl_info_t *info;
	uint32_t lbaf;

	libnvme_test_init(&nvme, &ctrl);
	if (!nvme_ctrl_lock(ctrl, NVME_LOCK_L_WRITE, NVME_LOCK_F_DONT_BLOCK)) {
		libnvme_test_ctrl_fatal(ctrl, "failed to obtain write lock");
	}

	if (!nvme_ctrl_info_snap(ctrl, &info)) {
		libnvme_test_ctrl_fatal(ctrl, "failed to get info snapshot");
	}

	if (!libnvme_test_lbaf(info, NVME_TEST_LBA_SIZE, &lbaf)) {
		errx(EXIT_FAILURE, "failed to find 4K LBA format, cannot "
		    "continue");
	}

	for (size_t i = 0; i < ARRAY_SIZE(ns_life_tests); i++) {
		if (!ns_life_run_one(ctrl, lbaf, &ns_life_tests[i]))
			ret = EXIT_FAILURE;
	}

	nvme_ctrl_info_free(info);
	nvme_ctrl_unlock(ctrl);
	nvme_ctrl_fini(ctrl);
	nvme_fini(nvme);

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

	return (ret);
}