// SPDX-License-Identifier: GPL-2.0
/*
 * vdso_full_test.c: Sample code to test all the timers.
 * Copyright (c) 2019 Arm Ltd.
 *
 * Compile with:
 * gcc -std=gnu99 vdso_full_test.c parse_vdso.c
 *
 */

#include <stdint.h>
#include <elf.h>
#include <stdio.h>
#include <time.h>
#include <sys/auxv.h>
#include <sys/time.h>
#define _GNU_SOURCE
#include <unistd.h>
#include <sys/syscall.h>

#include "kselftest.h"
#include "vdso_config.h"
#include "vdso_call.h"
#include "parse_vdso.h"

static const char *version;
static const char **name;

/* The same as struct __kernel_timespec */
struct vdso_timespec64 {
        uint64_t tv_sec;
        uint64_t tv_nsec;
};

typedef long (*vdso_gettimeofday_t)(struct timeval *tv, struct timezone *tz);
typedef long (*vdso_clock_gettime_t)(clockid_t clk_id, struct timespec *ts);
typedef long (*vdso_clock_gettime64_t)(clockid_t clk_id, struct vdso_timespec64 *ts);
typedef long (*vdso_clock_getres_t)(clockid_t clk_id, struct timespec *ts);
typedef long (*vdso_clock_getres_time64_t)(clockid_t clk_id, struct vdso_timespec64 *ts);
typedef time_t (*vdso_time_t)(time_t *t);

static const char * const vdso_clock_name[] = {
        [CLOCK_REALTIME]                = "CLOCK_REALTIME",
        [CLOCK_MONOTONIC]               = "CLOCK_MONOTONIC",
        [CLOCK_PROCESS_CPUTIME_ID]      = "CLOCK_PROCESS_CPUTIME_ID",
        [CLOCK_THREAD_CPUTIME_ID]       = "CLOCK_THREAD_CPUTIME_ID",
        [CLOCK_MONOTONIC_RAW]           = "CLOCK_MONOTONIC_RAW",
        [CLOCK_REALTIME_COARSE]         = "CLOCK_REALTIME_COARSE",
        [CLOCK_MONOTONIC_COARSE]        = "CLOCK_MONOTONIC_COARSE",
        [CLOCK_BOOTTIME]                = "CLOCK_BOOTTIME",
        [CLOCK_REALTIME_ALARM]          = "CLOCK_REALTIME_ALARM",
        [CLOCK_BOOTTIME_ALARM]          = "CLOCK_BOOTTIME_ALARM",
        [10 /* CLOCK_SGI_CYCLE */]      = "CLOCK_SGI_CYCLE",
        [CLOCK_TAI]                     = "CLOCK_TAI",
};

static void vdso_test_gettimeofday(void)
{
        /* Find gettimeofday. */
        vdso_gettimeofday_t vdso_gettimeofday =
                (vdso_gettimeofday_t)vdso_sym(version, name[0]);

        if (!vdso_gettimeofday) {
                ksft_print_msg("Couldn't find %s\n", name[0]);
                ksft_test_result_skip("%s\n", name[0]);
                return;
        }

        struct timeval tv;
        long ret = VDSO_CALL(vdso_gettimeofday, 2, &tv, 0);

        if (ret == 0) {
                ksft_print_msg("The time is %lld.%06lld\n",
                               (long long)tv.tv_sec, (long long)tv.tv_usec);
                ksft_test_result_pass("%s\n", name[0]);
        } else {
                ksft_test_result_fail("%s\n", name[0]);
        }
}

static void vdso_test_clock_gettime64(clockid_t clk_id)
{
        /* Find clock_gettime64. */
        vdso_clock_gettime64_t vdso_clock_gettime64 =
                (vdso_clock_gettime64_t)vdso_sym(version, name[5]);

        if (!vdso_clock_gettime64) {
                ksft_print_msg("Couldn't find %s\n", name[5]);
                ksft_test_result_skip("%s %s\n", name[5],
                                      vdso_clock_name[clk_id]);
                return;
        }

        struct vdso_timespec64 ts;
        long ret = VDSO_CALL(vdso_clock_gettime64, 2, clk_id, &ts);

        if (ret == 0) {
                ksft_print_msg("The time is %lld.%06lld\n",
                               (long long)ts.tv_sec, (long long)ts.tv_nsec);
                ksft_test_result_pass("%s %s\n", name[5],
                                      vdso_clock_name[clk_id]);
        } else {
                ksft_test_result_fail("%s %s\n", name[5],
                                      vdso_clock_name[clk_id]);
        }
}

static void vdso_test_clock_gettime(clockid_t clk_id)
{
        /* Find clock_gettime. */
        vdso_clock_gettime_t vdso_clock_gettime =
                (vdso_clock_gettime_t)vdso_sym(version, name[1]);

        if (!vdso_clock_gettime) {
                ksft_print_msg("Couldn't find %s\n", name[1]);
                ksft_test_result_skip("%s %s\n", name[1],
                                      vdso_clock_name[clk_id]);
                return;
        }

        struct timespec ts;
        long ret = VDSO_CALL(vdso_clock_gettime, 2, clk_id, &ts);

        if (ret == 0) {
                ksft_print_msg("The time is %lld.%06lld\n",
                               (long long)ts.tv_sec, (long long)ts.tv_nsec);
                ksft_test_result_pass("%s %s\n", name[1],
                                      vdso_clock_name[clk_id]);
        } else {
                ksft_test_result_fail("%s %s\n", name[1],
                                      vdso_clock_name[clk_id]);
        }
}

static void vdso_test_time(void)
{
        /* Find time. */
        vdso_time_t vdso_time =
                (vdso_time_t)vdso_sym(version, name[2]);

        if (!vdso_time) {
                ksft_print_msg("Couldn't find %s\n", name[2]);
                ksft_test_result_skip("%s\n", name[2]);
                return;
        }

        long ret = VDSO_CALL(vdso_time, 1, NULL);

        if (ret > 0) {
                ksft_print_msg("The time in hours since January 1, 1970 is %lld\n",
                                (long long)(ret / 3600));
                ksft_test_result_pass("%s\n", name[2]);
        } else {
                ksft_test_result_fail("%s\n", name[2]);
        }
}

static void vdso_test_clock_getres(clockid_t clk_id)
{
        int clock_getres_fail = 0;

        /* Find clock_getres. */
        vdso_clock_getres_t vdso_clock_getres =
                (vdso_clock_getres_t)vdso_sym(version, name[3]);

        if (!vdso_clock_getres) {
                ksft_print_msg("Couldn't find %s\n", name[3]);
                ksft_test_result_skip("%s %s\n", name[3],
                                      vdso_clock_name[clk_id]);
                return;
        }

        struct timespec ts, sys_ts;
        long ret = VDSO_CALL(vdso_clock_getres, 2, clk_id, &ts);

        if (ret == 0) {
                ksft_print_msg("The vdso resolution is %lld %lld\n",
                               (long long)ts.tv_sec, (long long)ts.tv_nsec);
        } else {
                clock_getres_fail++;
        }

        ret = syscall(__NR_clock_getres, clk_id, &sys_ts);

        ksft_print_msg("The syscall resolution is %lld %lld\n",
                        (long long)sys_ts.tv_sec, (long long)sys_ts.tv_nsec);

        if ((sys_ts.tv_sec != ts.tv_sec) || (sys_ts.tv_nsec != ts.tv_nsec))
                clock_getres_fail++;

        if (clock_getres_fail > 0) {
                ksft_test_result_fail("%s %s\n", name[3],
                                      vdso_clock_name[clk_id]);
        } else {
                ksft_test_result_pass("%s %s\n", name[3],
                                      vdso_clock_name[clk_id]);
        }
}

#ifdef __NR_clock_getres_time64
static void vdso_test_clock_getres_time64(clockid_t clk_id)
{
        int clock_getres_fail = 0;

        /* Find clock_getres. */
        vdso_clock_getres_time64_t vdso_clock_getres_time64 =
                (vdso_clock_getres_time64_t)vdso_sym(version, name[7]);

        if (!vdso_clock_getres_time64) {
                ksft_print_msg("Couldn't find %s\n", name[7]);
                ksft_test_result_skip("%s %s\n", name[7],
                                      vdso_clock_name[clk_id]);
                return;
        }

        struct vdso_timespec64 ts, sys_ts;
        long ret = VDSO_CALL(vdso_clock_getres_time64, 2, clk_id, &ts);

        if (ret == 0) {
                ksft_print_msg("The vdso resolution is %lld %lld\n",
                               (long long)ts.tv_sec, (long long)ts.tv_nsec);
        } else {
                clock_getres_fail++;
        }

        ret = syscall(__NR_clock_getres_time64, clk_id, &sys_ts);

        ksft_print_msg("The syscall resolution is %lld %lld\n",
                        (long long)sys_ts.tv_sec, (long long)sys_ts.tv_nsec);

        if ((sys_ts.tv_sec != ts.tv_sec) || (sys_ts.tv_nsec != ts.tv_nsec))
                clock_getres_fail++;

        if (clock_getres_fail > 0) {
                ksft_test_result_fail("%s %s\n", name[7],
                                      vdso_clock_name[clk_id]);
        } else {
                ksft_test_result_pass("%s %s\n", name[7],
                                      vdso_clock_name[clk_id]);
        }
}
#else /* !__NR_clock_getres_time64 */
static void vdso_test_clock_getres_time64(clockid_t clk_id)
{
        ksft_test_result_skip("%s %s\n", name[7], vdso_clock_name[clk_id]);
}
#endif /* __NR_clock_getres_time64 */

/*
 * This function calls vdso_test_clock_gettime and vdso_test_clock_getres
 * with different values for clock_id.
 */
static inline void vdso_test_clock(clockid_t clock_id)
{
        ksft_print_msg("clock_id: %s\n", vdso_clock_name[clock_id]);

        vdso_test_clock_gettime(clock_id);
        vdso_test_clock_gettime64(clock_id);

        vdso_test_clock_getres(clock_id);
        vdso_test_clock_getres_time64(clock_id);
}

#define VDSO_TEST_PLAN  38

int main(int argc, char **argv)
{
        unsigned long sysinfo_ehdr = getauxval(AT_SYSINFO_EHDR);

        ksft_print_header();

        if (!sysinfo_ehdr)
                ksft_exit_skip("AT_SYSINFO_EHDR is not present!\n");

        ksft_set_plan(VDSO_TEST_PLAN);

        version = versions[VDSO_VERSION];
        name = (const char **)&names[VDSO_NAMES];

        ksft_print_msg("[vDSO kselftest] VDSO_VERSION: %s\n", version);

        vdso_init_from_sysinfo_ehdr(getauxval(AT_SYSINFO_EHDR));

        vdso_test_gettimeofday();

        vdso_test_clock(CLOCK_REALTIME);
        vdso_test_clock(CLOCK_BOOTTIME);
        vdso_test_clock(CLOCK_TAI);
        vdso_test_clock(CLOCK_REALTIME_COARSE);
        vdso_test_clock(CLOCK_MONOTONIC);
        vdso_test_clock(CLOCK_MONOTONIC_RAW);
        vdso_test_clock(CLOCK_MONOTONIC_COARSE);
        vdso_test_clock(CLOCK_PROCESS_CPUTIME_ID);
        vdso_test_clock(CLOCK_THREAD_CPUTIME_ID);

        vdso_test_time();

        ksft_finished();
}