/* $OpenBSD: monotonicrelapse.c,v 1.3 2021/12/13 16:56:49 deraadt Exp $ */
/*
 * Scott Cheloha <scottcheloha@gmail.com>, 2019.  Public Domain.
 */

#include <sys/types.h>
#include <sys/sysctl.h>
#include <sys/time.h>

#include <err.h>
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

void report_relapse(int, struct timespec *, struct timespec *);
void *thread_func(void *);
void thread_spawn(pthread_t **, int, void *(*)(void *));

/*
 * Is the active timecounter monotonic?
 *
 * Spawn the given number of threads and measure the monotonic clock
 * across nanosleep(2) calls.
 *
 * Threads have a tendency to wake up on new CPUs.  If the active
 * timecounter is not synchronized across CPUs this will be detected
 * relatively quickly and the test will fail.
 */

int
main(int argc, char *argv[])
{
        const char *errstr;
        pthread_t *thread;
        int error, i, nthreads;

        if (argc != 2) {
                fprintf(stderr, "usage: %s nthreads\n", getprogname());
                return 1;
        }
        nthreads = strtonum(argv[1], 1, INT_MAX, &errstr);
        if (errstr != NULL)
                errx(1, "nthreads is %s: %s", errstr, argv[1]);

        thread = calloc(nthreads, sizeof(*thread));
        if (thread == NULL)
                err(1, NULL);

        for (i = 0; i < nthreads; i++) {
                error = pthread_create(&thread[i], NULL, thread_func,
                    (void *)((uintptr_t)i + 1));
                if (error)
                        errc(1, error, "pthread_create");
        }

        sleep(10);

        return 0;
}

void
report_relapse(int num, struct timespec *before, struct timespec *after)
{
        static pthread_mutex_t report_mutex = PTHREAD_MUTEX_INITIALIZER;
        struct timespec relapsed;
        int error;

        error = pthread_mutex_lock(&report_mutex);
        if (error)
                errc(1, error, "T%d: pthread_mutex_lock", num);

        timespecsub(before, after, &relapsed);
        errx(1, "T%d: monotonic clock relapsed %.9f seconds: %.9f -> %.9f",
            num, relapsed.tv_sec + relapsed.tv_nsec / 1000000000.0,
            before->tv_sec + before->tv_nsec / 1000000000.0,
            after->tv_sec + after->tv_nsec / 1000000000.0);
}

void *
thread_func(void *arg)
{
        struct timespec after, before, timeout;
        int num;

        timeout.tv_sec = 0;
        timeout.tv_nsec = 1;
        num = (int)arg;

        for (;;) {
                clock_gettime(CLOCK_MONOTONIC, &before);
                if (nanosleep(&timeout, NULL) == -1)
                        err(1, "T%d: nanosleep", num);
                clock_gettime(CLOCK_MONOTONIC, &after);
                if (timespeccmp(&after, &before, <))
                        report_relapse(num, &before, &after);
        }

        return NULL;
}