/*
 * 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 the various pthreads related clock based locking routines. These all
 * attempt to take some form of lock and utilize a timeout that can be specified
 * in terms of a given clock (i.e. CLOCK_REALTIME and CLOCK_HIGHRES). In
 * particular we want to cover:
 *
 *  - Invalid clock sources
 *  - Invalid timeouts ignored when acquired
 *  - Invalid timeouts caught when used
 *  - We can successfully get an ETIMEDOUT and that time has advanced at least
 *    that much
 */

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

#include "clock_lock.h"

/*
 * This is a generic 100ms timeout that we can use. We use it for some tests
 * that require an absolute timeout that is in the future but we don't want to
 * bother computing.
 */
const struct timespec clock_to_100ms = { 0, MSEC2NSEC(100) };

/*
 * A series of invalid clocks. The first is usable for both relative and
 * absolute operations. The others which use negative times should only fail for
 * the relative operations at this time.
 */
const struct timespec clock_to_invns = { 0, NANOSEC * 2 };
const struct timespec clock_to_invnegs = { -12345, 0 };
const struct timespec clock_to_invnegns = { 100, -0x23 };

void
clock_rel_to_abs(clockid_t clock, const struct timespec *restrict rel,
    struct timespec *restrict abs)
{
        if (clock_gettime(clock, abs) != 0) {
                err(EXIT_FAILURE, "failed to get absolute time for clock %d",
                    clock);
        }

        abs->tv_nsec += rel->tv_nsec;
        abs->tv_sec += rel->tv_sec;
        if (abs->tv_nsec > NANOSEC) {
                abs->tv_sec += abs->tv_nsec / NANOSEC;
                abs->tv_nsec %= NANOSEC;
        }
}

bool
clock_abs_after(clockid_t clock, const struct timespec *to)
{
        struct timespec now;

        if (clock_gettime(clock, &now) != 0) {
                err(EXIT_FAILURE, "failed to get absolute time for clock %d",
                    clock);
        }

        if (now.tv_sec > to->tv_sec)
                return (true);

        return (now.tv_sec == to->tv_sec && now.tv_nsec > to->tv_nsec);
}

bool
clock_rel_after(clockid_t clock, const struct timespec *start,
    const struct timespec *to)
{
        struct timespec now, absto;

        if (clock_gettime(clock, &now) != 0) {
                err(EXIT_FAILURE, "failed to get absolute time for clock %d",
                    clock);
        }

        absto.tv_nsec = start->tv_nsec + to->tv_nsec;
        absto.tv_sec = start->tv_sec + to->tv_sec;
        if (absto.tv_nsec > NANOSEC) {
                absto.tv_sec += absto.tv_nsec / NANOSEC;
                absto.tv_nsec %= NANOSEC;
        }

        if (now.tv_sec > absto.tv_sec)
                return (true);

        return (now.tv_sec == absto.tv_sec && now.tv_nsec > absto.tv_nsec);
}

typedef struct {
        const clock_test_t *cthr_test;
        void *cthr_prim;
        bool cthr_ret;
} clock_test_thr_t;

static void *
clock_test_thr(void *arg)
{
        clock_test_thr_t *thr = arg;
        thr->cthr_ret = thr->cthr_test->ct_test(thr->cthr_test,
            thr->cthr_prim);
        return (NULL);
}

static bool
clock_test_one(const clock_test_t *test)
{
        void *prim;
        bool ret;

        test->ct_ops->lo_create(test->ct_desc, &prim);

        /*
         * If the test requires that the lock be held in some way, then we spawn
         * the test to run in another thread to avoid any issues with recursive
         * actions. Otherwise we let it run locally.
         */
        if (test->ct_enter) {
                clock_test_thr_t thr_test;
                pthread_t thr;
                int pret;

                test->ct_ops->lo_lock(prim);
                thr_test.cthr_test = test;
                thr_test.cthr_prim = prim;
                thr_test.cthr_ret = false;

                if ((pret = pthread_create(&thr, NULL, clock_test_thr,
                    &thr_test)) != 0) {
                        errc(EXIT_FAILURE, pret, "TEST FAILED: %s: internal "
                            "error creating test thread", test->ct_desc);
                }

                if ((pret = pthread_join(thr, NULL)) != 0) {
                        errc(EXIT_FAILURE, pret, "TEST FAILED: %s: internal "
                            "error joining test thread", test->ct_desc);
                }
                ret = thr_test.cthr_ret;
                test->ct_ops->lo_unlock(prim);
        } else {
                ret = test->ct_test(test, prim);
        }

        test->ct_ops->lo_destroy(prim);

        if (ret) {
                (void) printf("TEST PASSED: %s\n", test->ct_desc);
        }

        return (ret);
}

int
main(void)
{
        int ret = EXIT_SUCCESS;

        for (size_t i = 0; i < clock_mutex_ntests; i++) {
                if (!clock_test_one(&clock_mutex_tests[i])) {
                        ret = EXIT_FAILURE;
                }
        }

        for (size_t i = 0; i < clock_rwlock_ntests; i++) {
                if (!clock_test_one(&clock_rwlock_tests[i])) {
                        ret = EXIT_FAILURE;
                }
        }

        for (size_t i = 0; i < clock_sem_ntests; i++) {
                if (!clock_test_one(&clock_sem_tests[i])) {
                        ret = EXIT_FAILURE;
                }
        }

        for (size_t i = 0; i < clock_cond_ntests; i++) {
                if (!clock_test_one(&clock_cond_tests[i])) {
                        ret = EXIT_FAILURE;
                }
        }


        return (ret);
}