/*
 * 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 test covers the following aspects of the locking behavior:
 *
 *  o A controller write lock blocks controller read/write locks
 *  o A controller write lock blocks namespace read/write locks
 *  o A controller read lock blocks controller write locks
 *  o A controller read lock does not block namespace write locks
 *  o A namespace write lock blocks namespace read/write locks
 *  o A namespace write lock blocks controller write locks, but not read locks
 *  o A namespace read lock blocks namespace write locks
 *  o A namespace read lock blocks controller write locks
 *
 * The interaction of various read locks is tested in multi-reader-lock.c.
 */

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

#include "nvme_ioctl_util.h"

typedef enum {
	CBF_FD_CTRL,
	CBF_FD_NS
} ctrl_block_fd_t;

/*
 * This structure describes a given test case. We expect to always succeed in
 * locking fd0 and then we will expect the return value in cbt_ret1 when we try
 * to take lock1.
 */
typedef struct {
	const char *cbt_desc;
	ctrl_block_fd_t cbt_fd0;
	ctrl_block_fd_t cbt_fd1;
	const nvme_ioctl_lock_t *cbt_lock0;
	const nvme_ioctl_lock_t *cbt_lock1;
	nvme_ioctl_errno_t cbt_ret1;
} ctrl_block_test_t;

static const ctrl_block_test_t ctrl_block_tests[] = { {
	.cbt_desc = "controller write blocks controller read",
	.cbt_fd0 = CBF_FD_CTRL,
	.cbt_fd1 = CBF_FD_CTRL,
	.cbt_lock0 = &nvme_test_ctrl_wrlock,
	.cbt_lock1 = &nvme_test_ctrl_rdlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "controller write blocks controller write",
	.cbt_fd0 = CBF_FD_CTRL,
	.cbt_fd1 = CBF_FD_CTRL,
	.cbt_lock0 = &nvme_test_ctrl_wrlock,
	.cbt_lock1 = &nvme_test_ctrl_wrlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "controller write blocks namespace read",
	.cbt_fd0 = CBF_FD_CTRL,
	.cbt_fd1 = CBF_FD_NS,
	.cbt_lock0 = &nvme_test_ctrl_wrlock,
	.cbt_lock1 = &nvme_test_ns_rdlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "controller write blocks namespace write",
	.cbt_fd0 = CBF_FD_CTRL,
	.cbt_fd1 = CBF_FD_NS,
	.cbt_lock0 = &nvme_test_ctrl_wrlock,
	.cbt_lock1 = &nvme_test_ns_wrlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "controller read blocks controller write",
	.cbt_fd0 = CBF_FD_CTRL,
	.cbt_fd1 = CBF_FD_CTRL,
	.cbt_lock0 = &nvme_test_ctrl_rdlock,
	.cbt_lock1 = &nvme_test_ctrl_wrlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "controller read does not block namespace write",
	.cbt_fd0 = CBF_FD_CTRL,
	.cbt_fd1 = CBF_FD_NS,
	.cbt_lock0 = &nvme_test_ctrl_rdlock,
	.cbt_lock1 = &nvme_test_ns_wrlock,
	.cbt_ret1 = NVME_IOCTL_E_OK
}, {
	.cbt_desc = "namespace write blocks namespace read",
	.cbt_fd0 = CBF_FD_NS,
	.cbt_fd1 = CBF_FD_NS,
	.cbt_lock0 = &nvme_test_ns_wrlock,
	.cbt_lock1 = &nvme_test_ns_rdlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "namespace write blocks namespace read",
	.cbt_fd0 = CBF_FD_NS,
	.cbt_fd1 = CBF_FD_NS,
	.cbt_lock0 = &nvme_test_ns_wrlock,
	.cbt_lock1 = &nvme_test_ns_rdlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "namespace write blocks namespace write",
	.cbt_fd0 = CBF_FD_NS,
	.cbt_fd1 = CBF_FD_NS,
	.cbt_lock0 = &nvme_test_ns_wrlock,
	.cbt_lock1 = &nvme_test_ns_wrlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "namespace write blocks controller write",
	.cbt_fd0 = CBF_FD_NS,
	.cbt_fd1 = CBF_FD_CTRL,
	.cbt_lock0 = &nvme_test_ns_wrlock,
	.cbt_lock1 = &nvme_test_ctrl_wrlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "namespace write does not block controller read",
	.cbt_fd0 = CBF_FD_NS,
	.cbt_fd1 = CBF_FD_CTRL,
	.cbt_lock0 = &nvme_test_ns_wrlock,
	.cbt_lock1 = &nvme_test_ctrl_rdlock,
	.cbt_ret1 = NVME_IOCTL_E_OK
}, {
	.cbt_desc = "namespace read blocks namespace write",
	.cbt_fd0 = CBF_FD_NS,
	.cbt_fd1 = CBF_FD_NS,
	.cbt_lock0 = &nvme_test_ns_rdlock,
	.cbt_lock1 = &nvme_test_ns_wrlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
}, {
	.cbt_desc = "namespace read blocks controller write",
	.cbt_fd0 = CBF_FD_NS,
	.cbt_fd1 = CBF_FD_CTRL,
	.cbt_lock0 = &nvme_test_ns_rdlock,
	.cbt_lock1 = &nvme_test_ctrl_wrlock,
	.cbt_ret1 = NVME_IOCTL_E_LOCK_WOULD_BLOCK
} };

static bool
ctrl_block_test_one(int fd0, int fd1, const ctrl_block_test_t *test)
{
	nvme_ioctl_lock_t lock0 = *test->cbt_lock0;
	nvme_ioctl_lock_t lock1 = *test->cbt_lock1;

	if (ioctl(fd0, NVME_IOC_LOCK, &lock0) != 0) {
		warn("TEST FAILED: %s: failed to issue lock ioctl for fd0",
		    test->cbt_desc);
		return (false);
	} else if (lock0.nil_common.nioc_drv_err != NVME_IOCTL_E_OK) {
		warnx("TEST FAILED: %s: fd0 lock ioctl failed with 0x%x, "
		    "expected success", test->cbt_desc,
		    lock0.nil_common.nioc_drv_err);
		return (false);
	}

	if (ioctl(fd1, NVME_IOC_LOCK, &lock1) != 0) {
		warn("TEST FAILED: %s: failed to issue lock ioctl for fd1",
		    test->cbt_desc);
		return (false);
	} else if (lock1.nil_common.nioc_drv_err != test->cbt_ret1) {
		warnx("TEST FAILED: %s: fd1 lock ioctl returned with 0x%x, "
		    "expected 0x%x", test->cbt_desc,
		    lock1.nil_common.nioc_drv_err, test->cbt_ret1);
		return (false);
	}

	(void) printf("TEST PASSED: %s\n", test->cbt_desc);
	return (true);
}

int
main(void)
{
	int ret = EXIT_SUCCESS;

	/*
	 * We purposefully open and close the fds every iteration of this loop
	 * so we don't have to explicitly issue conditional unlocks.
	 */
	for (size_t i = 0; i < ARRAY_SIZE(ctrl_block_tests); i++) {
		int fd0, fd1;

		if (ctrl_block_tests[i].cbt_fd0 == CBF_FD_CTRL) {
			fd0 = nvme_ioctl_test_get_fd(0);
		} else {
			fd0 = nvme_ioctl_test_get_fd(1);
		}

		if (ctrl_block_tests[i].cbt_fd1 == CBF_FD_CTRL) {
			fd1 = nvme_ioctl_test_get_fd(0);
		} else {
			fd1 = nvme_ioctl_test_get_fd(1);
		}

		if (!ctrl_block_test_one(fd0, fd1, &ctrl_block_tests[i])) {
			ret = EXIT_FAILURE;
		}

		VERIFY0(close(fd0));
		VERIFY0(close(fd1));
	}

	return (ret);
}