/*
 * 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 2025 Oxide Computer Company
 */

/*
 * Verify we can set and obtain various mutex attributes in the structure. This
 * is also a regression test for illumos#17334 where we did not get the type
 * correctly. This does not validate that a mutex can be successfully created
 * with these attributes.
 */

#include <stdlib.h>
#include <err.h>
#include <pthread.h>
#include <sys/sysmacros.h>
#include <stdbool.h>
#include <errno.h>
#include <string.h>

typedef int (*attr_set_f)(pthread_mutexattr_t *, int);
typedef int (*attr_get_f)(const pthread_mutexattr_t *, int *);

static const int check_types[] = { PTHREAD_MUTEX_NORMAL,
    PTHREAD_MUTEX_ERRORCHECK, PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_DEFAULT };
static const int check_shared[] = { PTHREAD_PROCESS_SHARED,
    PTHREAD_PROCESS_PRIVATE };
static const int check_prioceil[] = { 0, 1, 2 };
static const int check_protocol[] = { PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT,
    PTHREAD_PRIO_PROTECT };
static const int check_robust[] = { PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_ROBUST,
    PTHREAD_MUTEX_STALL_NP, PTHREAD_MUTEX_ROBUST_NP };

static bool
check_field(const char *desc, pthread_mutexattr_t *attr, attr_get_f get_f,
    attr_set_f set_f, int def, const int *vals, size_t nvals, int err_code)
{
        bool ret = true;
        int r, v;

        if ((r = get_f(attr, NULL)) != EINVAL) {
                warnx("TEST FAILED: expected getting %s attribute with invalid "
                    "attr structure to return EINVAL, found %s", desc,
                    strerrorname_np(r));
                ret = false;
        } else {
                (void) printf("TEST PASSED: getting attribute %s with invalid "
                    "attributes returned EINVAL\n");
        }

        if ((r = get_f(attr, &v)) != 0) {
                warnc(r, "TEST FAILED: failed to get default value for mutex "
                    "%s", desc);
                ret = false;
        } else if (v != def) {
                warnx("TEST FAILED: mutex %s has wrong default value: expected "
                    "0x%x, found 0x%x", desc, def, v);
                ret = false;
        } else {
                (void) printf("TEST PASSED: mutex %s default value is the "
                    "expected value\n", desc);
        }

        for (size_t i = 0; i < nvals; i++) {
                if ((r = set_f(attr, vals[i])) != 0) {
                        warnc(r, "TEST FAILED: failed to set mutex %s "
                            "attribute to 0x%x", desc, vals[i]);
                        ret = false;
                        continue;
                }

                if ((r = get_f(attr, &v)) != 0) {
                        warnc(r, "TEST FAILED: failed to get value for mutex "
                            "%s", desc);
                        ret = false;
                } else if (v != vals[i]) {
                        warnx("TEST FAILED: mutex %s has wrong value: expected "
                            "0x%x, found 0x%x", desc, vals[i], v);
                        ret = false;
                } else {
                        (void) printf("TEST PASSED: mutex %s value matches "
                            "what we just set (0x%x)\n", desc, vals[i]);
                }
        }

        if ((r = set_f(attr, INT32_MAX)) != err_code) {
                warnx("TEST FAILED: expected setting mutex %s to INT32_MAX to "
                    "fail with %s, got %s (0x%x)", desc,
                    strerrorname_np(err_code), strerrorname_np(r), r);
                ret = false;
        } else {
                (void) printf("TEST PASSED: Setting mutex %s to invalid value "
                    "(INT32_MAX) correctly failed with %s\n", desc,
                    strerrorname_np(err_code));
        }

        if ((r = set_f(attr, INT32_MIN)) != err_code) {
                warnx("TEST FAILED: expected setting mutex %s to INT32_MIN to "
                    "fail with %s, got %s (0x%x)", desc,
                    strerrorname_np(err_code), strerrorname_np(r), r);
                ret = false;
        } else {
                (void) printf("TEST PASSED: Setting mutex %s to invalid value "
                    "(INT32_MIN) correctly failed with %s\n", desc,
                    strerrorname_np(err_code));
        }

        return (ret);
}

int
main(void)
{
        int ret = EXIT_SUCCESS, r;
        pthread_mutexattr_t attr;

        if ((r = pthread_mutexattr_init(&attr)) != 0) {
                errc(EXIT_FAILURE, r, "TEST FAILED: failed to initialize "
                    "mutex attributes");
        }

        if (!check_field("type", &attr, pthread_mutexattr_gettype,
            pthread_mutexattr_settype, PTHREAD_MUTEX_DEFAULT, check_types,
            ARRAY_SIZE(check_types), EINVAL)) {
                ret = EXIT_FAILURE;
        }

        if (!check_field("shared", &attr, pthread_mutexattr_getpshared,
            pthread_mutexattr_setpshared, PTHREAD_PROCESS_PRIVATE, check_shared,
            ARRAY_SIZE(check_shared), EINVAL)) {
                ret = EXIT_FAILURE;
        }

        if (!check_field("priority ceiling", &attr,
            pthread_mutexattr_getprioceiling, pthread_mutexattr_setprioceiling,
            0, check_prioceil, ARRAY_SIZE(check_prioceil), EINVAL)) {
                ret = EXIT_FAILURE;
        }

        if (!check_field("protocol", &attr, pthread_mutexattr_getprotocol,
            pthread_mutexattr_setprotocol, PTHREAD_PRIO_NONE, check_protocol,
            ARRAY_SIZE(check_protocol), ENOTSUP)) {
                ret = EXIT_FAILURE;
        }

        if (!check_field("robust", &attr, pthread_mutexattr_getrobust,
            pthread_mutexattr_setrobust, PTHREAD_MUTEX_STALLED, check_robust,
            ARRAY_SIZE(check_robust), EINVAL)) {
                ret = EXIT_FAILURE;
        }

        if ((r = pthread_mutexattr_destroy(&attr)) != 0) {
                warnc(r, "TEST FAILED: failed to destroy mutex attributes");
                ret = EXIT_FAILURE;
        }

        if (ret == EXIT_SUCCESS) {
                (void) printf("All tests passed successfully\n");
        }

        return (ret);
}