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

/*
 * This validates the simplest form of locking functionality:
 *
 * o On a controller fd we can take controller read and write locks.
 * o On a controller fd we can take namespace read and write locks.
 * o On a namespace fd we can take namespace read and write locks with nsid = 0
 *   to get our nsid.
 * o On a namespace fd we can specify our nsid still.
 * o A namespace fd cannot take a controller lock with either nsid.
 */

#include <err.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdbool.h>
#include <sys/sysmacros.h>
#include <sys/debug.h>

#include "nvme_ioctl_util.h"

/*
 * Loop for multiple times on each lock just to make sure this isn't a one off.
 */
#define	BASIC_LOCK_NITERS	3

typedef struct {
	const char *blt_desc;
	nvme_lock_ent_t blt_ent;
	nvme_lock_level_t blt_level;
	uint32_t blt_nsid;
} basic_lock_test_t;

static const basic_lock_test_t basic_lock_tests[] = {
	{ "ctrl fd ctrl write lock", NVME_LOCK_E_CTRL, NVME_LOCK_L_WRITE, 0 },
	{ "ctrl fd ctrl read lock", NVME_LOCK_E_CTRL, NVME_LOCK_L_READ, 0 },
	{ "ctrl fd ns write lock", NVME_LOCK_E_NS, NVME_LOCK_L_WRITE, 1 },
	{ "ctrl fd ns read lock", NVME_LOCK_E_NS, NVME_LOCK_L_READ, 1 }
};

static const basic_lock_test_t basic_ns_lock_tests[] = {
	{ "ns fd ns write lock (nsid=0)", NVME_LOCK_E_NS, NVME_LOCK_L_WRITE,
	    0 },
	{ "ns fd ns read lock (nsid=0)", NVME_LOCK_E_NS, NVME_LOCK_L_READ, 0 },
	{ "ns fd ns write lock (nsid=1)", NVME_LOCK_E_NS, NVME_LOCK_L_WRITE,
	    1 },
	{ "ns fd ns read lock (nsid=1)", NVME_LOCK_E_NS, NVME_LOCK_L_READ, 1 }
};

static const basic_lock_test_t basic_ns_ctrl_lock_tests[] = {
	{ "ns fd ctrl write lock (nsid=0)", NVME_LOCK_E_CTRL, NVME_LOCK_L_WRITE,
	    0 },
	{ "ns fd ctrl read lock (nsid=0)", NVME_LOCK_E_CTRL, NVME_LOCK_L_READ,
	    0 },
	{ "ns fd ctrl write lock (nsid=1)", NVME_LOCK_E_CTRL, NVME_LOCK_L_WRITE,
	    1 },
	{ "ns fd ctrl read lock (nsid=1)", NVME_LOCK_E_CTRL, NVME_LOCK_L_READ,
	    1 }
};


static bool
basic_lock_test(const basic_lock_test_t *test, int fd)
{
	nvme_ioctl_lock_t lock;
	nvme_ioctl_unlock_t unlock;

	(void) memset(&lock, 0, sizeof (lock));
	lock.nil_common.nioc_nsid = test->blt_nsid;
	lock.nil_ent = test->blt_ent;
	lock.nil_level = test->blt_level;
	lock.nil_flags = NVME_LOCK_F_DONT_BLOCK;

	(void) memset(&unlock, 0, sizeof (unlock));
	unlock.niu_common.nioc_nsid = test->blt_nsid;
	unlock.niu_ent = test->blt_ent;

	for (uint32_t i = 0; i < BASIC_LOCK_NITERS; i++) {
		if (ioctl(fd, NVME_IOC_LOCK, &lock) != 0) {
			warn("TEST FAILED: %s %u: failed to issue lock ioctl",
			    test->blt_desc, i);
			return (false);
		} else if (lock.nil_common.nioc_drv_err != NVME_IOCTL_E_OK) {
			warnx("TEST FAILED: %s %u: lock ioctl failed with "
			    "driver error 0x%x", test->blt_desc, i,
			    lock.nil_common.nioc_drv_err);
			return (false);
		} else {
			(void) printf("TEST PASSED: %s %u: lock acquired\n",
			    test->blt_desc, i);
		}

		if (ioctl(fd, NVME_IOC_UNLOCK, &unlock) != 0) {
			return (false);
		} else if (lock.nil_common.nioc_drv_err != NVME_IOCTL_E_OK) {
			return (false);
		} else {
			(void) printf("TEST PASSED: %s %u: lock released\n",
			    test->blt_desc, i);
		}
	}

	return (true);
}

/*
 * Verify that attempting to grab these locks fails with
 * NVME_IOCTL_E_NS_CANNOT_LOCK_CTRL. We don't bother with multiple repetitions
 * here.
 */
static bool
basic_lock_test_no_ns_ctrl(const basic_lock_test_t *test, int fd)
{
	nvme_ioctl_lock_t lock;
	bool ret = true;

	(void) memset(&lock, 0, sizeof (lock));
	lock.nil_common.nioc_nsid = test->blt_nsid;
	lock.nil_ent = test->blt_ent;
	lock.nil_level = test->blt_level;
	lock.nil_flags = NVME_LOCK_F_DONT_BLOCK;

	if (ioctl(fd, NVME_IOC_LOCK, &lock) != 0) {
		warn("TEST FAILED: %s: failed to issue lock ioctl",
		    test->blt_desc);
		return (false);
	} else if (lock.nil_common.nioc_drv_err == NVME_IOCTL_E_OK) {
		errx(EXIT_FAILURE, "TEST FAILED: %s: lock erroneously "
		    "acquired: cannot continue test", test->blt_desc);
	} else if (lock.nil_common.nioc_drv_err !=
	    NVME_IOCTL_E_NS_CANNOT_LOCK_CTRL) {
		warnx("TEST FAILED: %s: lock ioctl failed with "
		    "driver error 0x%x, expected 0x%x "
		    "(NVME_IOCTL_E_NS_CANNOT_LOCK_CTRL)", test->blt_desc,
		    lock.nil_common.nioc_drv_err,
		    NVME_IOCTL_E_NS_CANNOT_LOCK_CTRL);
		return (false);
	} else {
		(void) printf("TEST PASSED: %s: lock denied\n", test->blt_desc);
	}

	return (ret);
}

int
main(void)
{
	int fd = nvme_ioctl_test_get_fd(0);
	int ret = EXIT_SUCCESS;

	for (size_t i = 0; i < ARRAY_SIZE(basic_lock_tests); i++) {
		if (!basic_lock_test(&basic_lock_tests[i], fd)) {
			ret = EXIT_FAILURE;
		}
	}

	VERIFY0(close(fd));

	fd = nvme_ioctl_test_get_fd(1);
	for (size_t i = 0; i < ARRAY_SIZE(basic_ns_lock_tests); i++) {
		if (!basic_lock_test(&basic_ns_lock_tests[i], fd)) {
			ret = EXIT_FAILURE;
		}
	}

	for (size_t i = 0; i < ARRAY_SIZE(basic_ns_ctrl_lock_tests); i++) {
		if (!basic_lock_test_no_ns_ctrl(&basic_ns_ctrl_lock_tests[i],
		    fd)) {
			ret = EXIT_FAILURE;
		}
	}

	return (ret);
}