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

/*
 * Test various mutex types to determine whether we properly deadlock or
 * generate an error when attempting to take the lock. Note, that the issues
 * described in 16200 only occur for a single threaded program which this does
 * not test.
 */

#include <err.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include <thread.h>
#include <synch.h>
#include <stdbool.h>
#include <sys/sysmacros.h>
#include <unistd.h>
#include <libproc.h>
#include <string.h>
#include <sys/debug.h>

typedef enum {
	MUTEX_TEST_F_USE_ATTR	= 1 << 0,
	MUTEX_TEST_F_SET_TYPE	= 1 << 1,
	MUTEX_TEST_F_DEADLOCK	= 1 << 2,
	MUTEX_TEST_F_ILLUMOS	= 1 << 3,
	MUTEX_TEST_F_UNLOCK	= 1 << 4
} mutex_test_flags_t;

typedef struct {
	const char *mt_desc;
	mutex_test_flags_t mt_flags;
	int mt_type;
	int mt_ret;
} mutex_test_t;

const mutex_test_t mutex_tests[] = {
	{
		.mt_desc = "pthread attr NULL",
		.mt_flags = MUTEX_TEST_F_DEADLOCK,
		.mt_ret = INT32_MIN
	}, {
		.mt_desc = "pthread attr unset",
		.mt_flags = MUTEX_TEST_F_USE_ATTR | MUTEX_TEST_F_DEADLOCK,
		.mt_ret = INT32_MIN
	}, {
		.mt_desc = "pthrad attr default",
		.mt_flags = MUTEX_TEST_F_USE_ATTR | MUTEX_TEST_F_SET_TYPE |
		    MUTEX_TEST_F_DEADLOCK,
		.mt_type = PTHREAD_MUTEX_DEFAULT,
		.mt_ret = INT32_MIN
	}, {
		.mt_desc = "pthread attr normal",
		.mt_flags = MUTEX_TEST_F_USE_ATTR | MUTEX_TEST_F_SET_TYPE |
		    MUTEX_TEST_F_DEADLOCK,
		.mt_type = PTHREAD_MUTEX_NORMAL,
		/* Set to a value that we should never see or get to */
		.mt_ret = INT32_MIN
	}, {
		.mt_desc = "pthread attr recursive",
		.mt_flags = MUTEX_TEST_F_USE_ATTR | MUTEX_TEST_F_SET_TYPE,
		.mt_type = PTHREAD_MUTEX_RECURSIVE,
		.mt_ret = 0
	}, {
		.mt_desc = "pthread attr errorcheck",
		.mt_flags = MUTEX_TEST_F_USE_ATTR | MUTEX_TEST_F_SET_TYPE,
		.mt_type = PTHREAD_MUTEX_ERRORCHECK,
		.mt_ret = EDEADLK
	}, {
		.mt_desc = "pthread attr recursive unlock",
		.mt_flags = MUTEX_TEST_F_USE_ATTR | MUTEX_TEST_F_SET_TYPE |
		    MUTEX_TEST_F_UNLOCK,
		.mt_type = PTHREAD_MUTEX_RECURSIVE,
		.mt_ret = EPERM
	}, {
		.mt_desc = "pthread attr errorcheck unlock",
		.mt_flags = MUTEX_TEST_F_USE_ATTR | MUTEX_TEST_F_SET_TYPE |
		    MUTEX_TEST_F_UNLOCK,
		.mt_type = PTHREAD_MUTEX_ERRORCHECK,
		.mt_ret = EPERM
	}, {
		.mt_desc = "illumos USYNC_THREAD",
		.mt_flags = MUTEX_TEST_F_DEADLOCK | MUTEX_TEST_F_ILLUMOS,
		.mt_type = USYNC_THREAD,
		.mt_ret = INT32_MAX
	}, {
		.mt_desc = "illumos error check",
		.mt_flags = MUTEX_TEST_F_ILLUMOS,
		.mt_type = USYNC_THREAD | LOCK_ERRORCHECK,
		.mt_ret = EDEADLK
	}, {
		.mt_desc = "illumos recursive",
		.mt_flags = MUTEX_TEST_F_ILLUMOS,
		.mt_type = USYNC_THREAD | LOCK_RECURSIVE,
		.mt_ret = 0
	}, {
		.mt_desc = "illumos recursive error check",
		.mt_flags = MUTEX_TEST_F_ILLUMOS,
		.mt_type = USYNC_THREAD | LOCK_RECURSIVE | LOCK_ERRORCHECK,
		.mt_ret = 0
	}, {
		.mt_desc = "illumos error check unlock",
		.mt_flags = MUTEX_TEST_F_ILLUMOS | MUTEX_TEST_F_UNLOCK,
		.mt_type = USYNC_THREAD | LOCK_ERRORCHECK,
		.mt_ret = EPERM
	}, {
		.mt_desc = "illumos recursive error check unlock",
		.mt_flags = MUTEX_TEST_F_ILLUMOS | MUTEX_TEST_F_UNLOCK,
		.mt_type = USYNC_THREAD | LOCK_RECURSIVE | LOCK_ERRORCHECK,
		.mt_ret = EPERM
	}
};

static void *
mutex_test_thr(void *arg)
{
	int ret;
	pthread_mutexattr_t attr, *attrp = NULL;
	const mutex_test_t *test = arg;

	if ((test->mt_flags & MUTEX_TEST_F_USE_ATTR) != 0) {
		VERIFY0(pthread_mutexattr_init(&attr));
		attrp = &attr;

		if ((test->mt_flags & MUTEX_TEST_F_SET_TYPE) != 0) {
			VERIFY0(pthread_mutexattr_settype(&attr,
			    test->mt_type));
		}
	}

	if ((test->mt_flags & MUTEX_TEST_F_UNLOCK) != 0) {
		if ((test->mt_flags & MUTEX_TEST_F_ILLUMOS) != 0) {
			mutex_t m;

			VERIFY0(mutex_init(&m, test->mt_type, NULL));
			ret = mutex_unlock(&m);
		} else {
			pthread_mutex_t pm;

			VERIFY0(pthread_mutex_init(&pm, attrp));
			ret = pthread_mutex_unlock(&pm);
		}

		return ((void *)(uintptr_t)ret);
	}

	if ((test->mt_flags & MUTEX_TEST_F_ILLUMOS) != 0) {
		mutex_t m;

		VERIFY0(mutex_init(&m, test->mt_type, NULL));
		VERIFY0(mutex_lock(&m));
		ret = mutex_lock(&m);
	} else {
		pthread_mutex_t pm;

		VERIFY0(pthread_mutex_init(&pm, attrp));
		VERIFY0(pthread_mutex_lock(&pm));
		ret = pthread_mutex_lock(&pm);
	}

	return ((void *)(uintptr_t)ret);
}


/*
 * Attempt to determine if a thread is still going and we should wait, if it has
 * potentially terminated, or if it is blocked in lwp_park() suggesting it has
 * been deadlocked.
 */
typedef enum {
	THR_STATE_PARKED,
	THR_STATE_DEAD,
	THR_STATE_RUNNING
} thr_state_t;

static thr_state_t
mutex_test_thr_state(thread_t thr)
{
	lwpstatus_t lwp;
	char name[SYS2STR_MAX];

	if (proc_get_lwpstatus(getpid(), (uint_t)thr, &lwp) != 0) {
		int e = errno;
		switch (e) {
		case ENOENT:
			return (THR_STATE_DEAD);
		default:
			errc(EXIT_FAILURE, e, "fatal error: got unexpected "
			    "error while trying to get lwpstatus");
		}
	}

	if ((lwp.pr_flags & PR_ASLEEP) == 0) {
		return (THR_STATE_RUNNING);
	}

	if (proc_sysname(lwp.pr_syscall, name, sizeof (name)) == 0) {
		return (THR_STATE_RUNNING);
	}

	if (strcmp(name, "lwp_park") == 0) {
		return (THR_STATE_PARKED);
	}

	return (THR_STATE_RUNNING);
}

static bool
mutex_test_run_one(const mutex_test_t *test)
{
	int err, lock;
	thread_t thr;
	thr_state_t state;
	void *val;

	err = thr_create(NULL, 0, mutex_test_thr, (void *)test, 0, &thr);
	if (err != 0) {
		errc(EXIT_FAILURE, err, "fatal test error: could not create "
		    "thread for %s", test->mt_desc);
	}

	/*
	 * Wait for the thread to deadlock or exit and then continue.
	 */
	while ((state = mutex_test_thr_state(thr)) == THR_STATE_RUNNING) {
		struct timespec sleep;

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

	if (state == THR_STATE_PARKED) {
		if ((test->mt_flags & MUTEX_TEST_F_DEADLOCK) != 0) {
			(void) printf("TEST PASSED: %s: successfully "
			    "deadlocked\n", test->mt_desc);
			return (true);
		}

		(void) sleep(100000);

		warnx("TEST FAILED: %s: thread deadlocked, but expected return "
		    "value %d", test->mt_desc, test->mt_ret);
		return (false);
	}

	VERIFY0(thr_join(thr, NULL, &val));
	lock = (int)(uintptr_t)val;
	if ((test->mt_flags & MUTEX_TEST_F_DEADLOCK) != 0) {
		warnx("TEST FAILED: %s: expected deadlock, but mutex lock "
		    "returned %d", test->mt_desc, lock);
		return (false);
	} else if (lock != test->mt_ret) {
		warnx("TEST FAILED: %s: found return value %d, expected %d",
		    test->mt_desc, lock, test->mt_ret);
		return (false);
	} else {
		(void) printf("TEST PASSED: %s: got correct lock return value "
		    "(%d)\n", test->mt_desc, test->mt_ret);
		return (true);
	}
}

int
main(void)
{
	int ret = EXIT_SUCCESS;

	if (getenv("_THREAD_ASYNC_SAFE") != NULL) {
		errx(EXIT_FAILURE, "cannot run tests because "
		    "_THREAD_ASYNC_SAFE is set in the environment!");
	}

	for (size_t i = 0; i < ARRAY_SIZE(mutex_tests); i++) {
		if (!mutex_test_run_one(&mutex_tests[i])) {
			ret = EXIT_FAILURE;
		}
	}

	/*
	 * Ensure any lingering threads don't keep us around.
	 */
	exit(ret);
}