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

/*
 * The purpose of this test is to verify that multiple readers can all grab the
 * same lock. In this case, we will use a mix of namespace and controller locks,
 * but only one lock per fd. Specifically we want to ensure that all three of
 * these classes can simultaneously hold the lock:
 *
 * o Controller fd, controller lock
 * o Controller fd, namespace lock
 * o Namespace fd, namespace lock
 *
 * This also is testing that multiple instances of the same type can hold the fd
 * as well. In addition, We want to ensure that this happens regardless of
 * whomever does the first lock. In particular we want to test the following
 * orders:
 *
 * 1) All controller read locks, then all ctrl ns, then all ns
 * 2) All ns fd read locks, then all ctrl fd ns locks, then all ctrl ctrl
 * 3) All ctrl fd ns locks, then all ctrl ctrl locks, then all ns fd
 *
 * Then we repeat the above but swizzling with one fd from each.
 */

#include <err.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdbool.h>

#include "nvme_ioctl_util.h"

/*
 * Number of readers of each type.
 */
#define	NREADERS	10

static bool
multi_lock_one(int fd, const nvme_ioctl_lock_t *tmpl, const char *desc,
    size_t iter)
{
	nvme_ioctl_lock_t lock = *tmpl;

	if (ioctl(fd, NVME_IOC_LOCK, &lock) != 0) {
		warn("TEST FAILED: %s %zu: failed to issue lock ioctl",
		    desc, iter);
		return (false);
	} else if (lock.nil_common.nioc_drv_err != NVME_IOCTL_E_OK) {
		warnx("TEST FAILED: %s %zu: lock ioctl failed with driver "
		    "error 0x%x", desc, iter, lock.nil_common.nioc_drv_err);
		return (false);
	} else {
		return (true);
	}
}

static bool
multi_unlock_one(int fd, const nvme_ioctl_unlock_t *tmpl, const char *desc,
    size_t iter)
{
	nvme_ioctl_unlock_t unlock = *tmpl;
	if (ioctl(fd, NVME_IOC_UNLOCK, &unlock) != 0) {
		warn("TEST FAILED: %s %zu: failed to issue unlock ioctl",
		    desc, iter);
		return (false);
	} else if (unlock.niu_common.nioc_drv_err != NVME_IOCTL_E_OK) {
		warnx("TEST FAILED: %s %zu: unlock ioctl failed with driver "
		    "error 0x%x", desc, iter, unlock.niu_common.nioc_drv_err);
		return (false);
	} else {
		return (true);
	}
}

static bool
multi_unlock_all(int ctrl_ctrl[NREADERS], int ctrl_ns[NREADERS],
    int ns_ns[NREADERS])
{
	bool ret = true;
	for (uint32_t i = 0; i < NREADERS; i++) {
		if (!multi_unlock_one(ctrl_ctrl[i], &nvme_test_ctrl_unlock,
		    "ctrl fd ctrl lock", i)) {
			ret = false;
		}

		if (!multi_unlock_one(ctrl_ns[i], &nvme_test_ns_unlock,
		    "ctrl fd ns lock", i)) {
			ret = false;
		}

		if (!multi_unlock_one(ns_ns[i], &nvme_test_ns_unlock,
		    "ns fd ns lock", i)) {
			ret = false;
		}
	}

	return (ret);
}

int
main(void)
{
	int ret = EXIT_SUCCESS;
	int ctrl_ctrl[NREADERS];
	int ctrl_ns[NREADERS];
	int ns_ns[NREADERS];
	bool test;

	for (size_t i = 0; i < NREADERS; i++) {
		ctrl_ctrl[i] = nvme_ioctl_test_get_fd(0);
		ctrl_ns[i] = nvme_ioctl_test_get_fd(0);
		ns_ns[i] = nvme_ioctl_test_get_fd(1);
	}

	/*
	 * Order 1
	 */
	test = true;
	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ctrl_ctrl[i], &nvme_test_ctrl_rdlock,
		    "ctrl fd ctrl lock", i)) {
			test = false;
		}
	}

	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ctrl_ns[i], &nvme_test_ns_rdlock,
		    "ctrl fd ns lock", i)) {
			test = false;
		}
	}

	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ns_ns[i], &nvme_test_ns_rdlock,
		    "ns fd ns lock", i)) {
			test = false;
		}
	}

	if (test) {
		(void) printf("TEST PASSED: all read locks taken: order 1\n");
	} else {
		warnx("TEST FAILED: failed to take all read locks following "
		    "order 1");
		ret = EXIT_FAILURE;
	}
	if (!multi_unlock_all(ctrl_ctrl, ctrl_ns, ns_ns)) {
		ret = EXIT_FAILURE;
	}

	/*
	 * Order 2
	 */
	test = true;
	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ns_ns[i], &nvme_test_ns_rdlock,
		    "ns fd ns lock", i)) {
			test = false;
		}
	}

	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ctrl_ns[i], &nvme_test_ns_rdlock,
		    "ctrl fd ns lock", i)) {
			test = false;
		}
	}

	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ctrl_ctrl[i], &nvme_test_ctrl_rdlock,
		    "ctrl fd ctrl lock", i)) {
			test = false;
		}
	}

	if (test) {
		(void) printf("TEST PASSED: all read locks taken: order 2\n");
	} else {
		warnx("TEST FAILED: failed to take all read locks following "
		    "order 2");
		ret = EXIT_FAILURE;
	}
	if (!multi_unlock_all(ctrl_ctrl, ctrl_ns, ns_ns)) {
		ret = EXIT_FAILURE;
	}

	/*
	 * Order 3
	 */
	test = true;
	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ctrl_ns[i], &nvme_test_ns_rdlock,
		    "ctrl fd ns lock", i)) {
			test = false;
		}
	}

	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ns_ns[i], &nvme_test_ns_rdlock,
		    "ns fd ns lock", i)) {
			test = false;
		}
	}

	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ctrl_ctrl[i], &nvme_test_ctrl_rdlock,
		    "ctrl fd ctrl lock", i)) {
			test = false;
		}
	}

	if (test) {
		(void) printf("TEST PASSED: all read locks taken: order 3\n");
	} else {
		warnx("TEST FAILED: failed to take all read locks following "
		    "order 3");
		ret = EXIT_FAILURE;
	}
	if (!multi_unlock_all(ctrl_ctrl, ctrl_ns, ns_ns)) {
		ret = EXIT_FAILURE;
	}
	/*
	 * Swizzle 1.
	 */
	test = true;
	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ctrl_ctrl[i], &nvme_test_ctrl_rdlock,
		    "ctrl fd ctrl lock", i)) {
			test = false;
		}

		if (!multi_lock_one(ctrl_ns[i], &nvme_test_ns_rdlock,
		    "ctrl fd ns lock", i)) {
			test = false;
		}

		if (!multi_lock_one(ns_ns[i], &nvme_test_ns_rdlock,
		    "ns fd ns lock", i)) {
			test = false;
		}
	}

	if (test) {
		(void) printf("TEST PASSED: all read locks taken: swizzle 1\n");
	} else {
		warnx("TEST FAILED: failed to take all read locks following "
		    "swizzle 1");
		ret = EXIT_FAILURE;
	}
	if (!multi_unlock_all(ctrl_ctrl, ctrl_ns, ns_ns)) {
		ret = EXIT_FAILURE;
	}

	/*
	 * Swizzle 2.
	 */
	test = true;
	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ns_ns[i], &nvme_test_ns_rdlock,
		    "ns fd ns lock", i)) {
			test = false;
		}

		if (!multi_lock_one(ctrl_ns[i], &nvme_test_ns_rdlock,
		    "ctrl fd ns lock", i)) {
			test = false;
		}

		if (!multi_lock_one(ctrl_ctrl[i], &nvme_test_ctrl_rdlock,
		    "ctrl fd ctrl lock", i)) {
			test = false;
		}
	}

	if (test) {
		(void) printf("TEST PASSED: all read locks taken: swizzle 2\n");
	} else {
		warnx("TEST FAILED: failed to take all read locks following "
		    "swizzle 2");
		ret = EXIT_FAILURE;
	}
	if (!multi_unlock_all(ctrl_ctrl, ctrl_ns, ns_ns)) {
		ret = EXIT_FAILURE;
	}

	/*
	 * Swizzle 3.
	 */
	test = true;
	for (size_t i = 0; i < NREADERS; i++) {
		if (!multi_lock_one(ctrl_ns[i], &nvme_test_ns_rdlock,
		    "ctrl fd ns lock", i)) {
			test = false;
		}

		if (!multi_lock_one(ns_ns[i], &nvme_test_ns_rdlock,
		    "ns fd ns lock", i)) {
			test = false;
		}

		if (!multi_lock_one(ctrl_ctrl[i], &nvme_test_ctrl_rdlock,
		    "ctrl fd ctrl lock", i)) {
			test = false;
		}
	}

	if (test) {
		(void) printf("TEST PASSED: all read locks taken: swizzle 3\n");
	} else {
		warnx("TEST FAILED: failed to take all read locks following "
		    "swizzle 3");
		ret = EXIT_FAILURE;
	}
	if (!multi_unlock_all(ctrl_ctrl, ctrl_ns, ns_ns)) {
		ret = EXIT_FAILURE;
	}

	return (ret);
}