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

/*
 * Create a thread that blocks on a lock and then once we know it is blocked,
 * signal it. Verify that it errored out with EINTR. Once we do that, we ensure
 * we can take all four basic locks in turn to verify that our state isn't bad.
 */

#include <err.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include <sys/sysmacros.h>
#include <sys/debug.h>
#include <thread.h>
#include <synch.h>
#include <strings.h>
#include <signal.h>

#include "nvme_ioctl_util.h"

static volatile int lock_sig_ret = EXIT_SUCCESS;
static volatile uint32_t lock_sig_nsignals = 0;
static volatile thread_t lock_sig_thrid;

typedef struct {
	const char *lss_desc;
	const nvme_ioctl_lock_t *lss_lock;
} lock_sig_test_t;

static const lock_sig_test_t lock_sig_tests[] = {
	{ "controller write lock", &nvme_test_ctrl_wrlock },
	{ "controller read lock", &nvme_test_ctrl_wrlock },
	{ "namespace write lock", &nvme_test_ns_wrlock },
	{ "namespace read lock", &nvme_test_ns_wrlock }
};

static void
lock_signal_hdlr(int sig)
{
	VERIFY3U(sig, ==, SIGINFO);
	VERIFY3U(thr_self(), ==, lock_sig_thrid);
	lock_sig_nsignals++;
}

static void *
lock_signal_thr(void *arg)
{
	int fd = nvme_ioctl_test_get_fd(0);
	const lock_sig_test_t *test = arg;
	nvme_ioctl_lock_t lock = *test->lss_lock;
	sigset_t set;
	int ret;

	VERIFY0(sigemptyset(&set));
	VERIFY0(sigaddset(&set, SIGINFO));
	lock_sig_thrid = thr_self();

	if ((ret = thr_sigsetmask(SIG_UNBLOCK, &set, NULL)) != 0) {
		errc(EXIT_FAILURE, ret, "failed to unblock SIGINFO");
	}


	lock.nil_flags &= ~NVME_LOCK_F_DONT_BLOCK;
	if (ioctl(fd, NVME_IOC_LOCK, &lock) != 0) {
		err(EXIT_FAILURE, "TEST FAILED: unable to continue test "
		    "execution due to lock ioctl failure");
	}

	if (lock.nil_common.nioc_drv_err != NVME_IOCTL_E_LOCK_WAIT_SIGNAL) {
		warnx("TEST FAILED: %s: lock thread didn't error with "
		    "NVME_IOCTL_E_LOCK_WAIT_SIGNAL (%u), but found instead %u",
		    test->lss_desc, NVME_IOCTL_E_LOCK_WAIT_SIGNAL,
		    lock.nil_common.nioc_drv_err);
		lock_sig_ret = EXIT_FAILURE;
	} else {
		(void) printf("TEST PASSED: %s: thread successfully "
		    "interrupted\n", test->lss_desc);
	}

	thr_exit(NULL);
}

static void
lock_signal_one(const lock_sig_test_t *test)
{
	int fd = nvme_ioctl_test_get_fd(0);
	int ret;
	thread_t thr;

	nvme_ioctl_test_lock(fd, &nvme_test_ctrl_wrlock);
	ret = thr_create(NULL, 0, lock_signal_thr, (void *)test, 0, &thr);
	if (ret != 0) {
		errc(EXIT_FAILURE, ret, "TEST FAILED: %s: cannot continue "
		    "because we failed to create the thread to signal",
		    test->lss_desc);
	}

	while (!nvme_ioctl_test_thr_blocked(thr)) {
		struct timespec sleep;

		sleep.tv_sec = 0;
		sleep.tv_nsec = MSEC2NSEC(10);
		(void) nanosleep(&sleep, NULL);
	}

	ret = thr_kill(thr, SIGINFO);
	if (ret != 0) {
		errc(EXIT_FAILURE, ret, "TEST FAILED: %s: cannot continue "
		    "because we failed to send SIGINFO to tid %u",
		    test->lss_desc, thr);
	}

	ret = thr_join(thr, NULL, NULL);
	if (ret != 0) {
		errc(EXIT_FAILURE, ret, "TEST FAILED: %s: cannot continue "
		    "because we failed to join thread %u", test->lss_desc, thr);
	}

	VERIFY0(close(fd));
	fd = nvme_ioctl_test_get_fd(0);
	nvme_ioctl_test_lock(fd, test->lss_lock);
	(void) printf("TEST PASSED: %s: successfully grabbed follow up lock\n",
	    test->lss_desc);
	VERIFY0(close(fd));
}

int
main(void)
{
	int ret;
	sigset_t set;
	struct sigaction act;

	VERIFY0(sigfillset(&set));
	if ((ret = thr_sigsetmask(SIG_BLOCK, &set, NULL)) != 0) {
		errc(EXIT_FAILURE, ret, "failed to block signals");
	}

	act.sa_handler = lock_signal_hdlr;
	VERIFY0(sigemptyset(&act.sa_mask));
	act.sa_flags = 0;
	VERIFY0(sigaction(SIGINFO, &act, NULL));

	for (size_t i = 0; i < ARRAY_SIZE(lock_sig_tests); i++) {
		lock_signal_one(&lock_sig_tests[i]);
	}

	if (lock_sig_nsignals != ARRAY_SIZE(lock_sig_tests)) {
		lock_sig_ret = EXIT_FAILURE;
		warnx("TEST FAILED: Didn't get %zu SIGINFO handlers, instead "
		    "got %u", ARRAY_SIZE(lock_sig_tests), lock_sig_nsignals);
	} else {
		(void) printf("TEST PASSED: Successfully ran SIGINFO "
		    "handlers\n");
	}

	return (lock_sig_ret);
}