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

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <strings.h>
#include <libgen.h>
#include <assert.h>
#include <errno.h>
#include <err.h>

#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/debug.h>
#include <sys/vmm.h>
#include <sys/vmm_dev.h>
#include <vmmapi.h>

#include "in_guest.h"

static uint32_t opt_repeat_count = 1000;
static bool opt_summarize = false;

/* Names of the test phases running in guest context */
static const char *test_metric_idents[] = {
        "MSR",
        "PIO",
        "MMIO",
};

/* Track which test phase the guest is executing */
static uint_t current_test = 0;
/* Cache the queried CPU frequency */
static uint64_t cpu_freq = 0;

static uint64_t
query_cpu_freq(struct vmctx *ctx)
{
        const int vmfd = vm_get_device_fd(ctx);
        struct vdi_time_info_v1 time_info;
        struct vm_data_xfer xfer = {
                .vdx_class = VDC_VMM_TIME,
                .vdx_version = 1,
                .vdx_len = sizeof (struct vdi_time_info_v1),
                .vdx_data = &time_info,
        };

        if (ioctl(vmfd, VM_DATA_READ, &xfer) != 0) {
                errx(EXIT_FAILURE, "VMM_DATA_READ of time info failed");
        }
        return (time_info.vt_guest_freq);
}

static double
cycles_to_ns(uint64_t cycles)
{
        return ((cycles * 1000000000.0) / cpu_freq);
}

static void
print_result(struct vmctx *ctx, uintptr_t gpa, uint_t test_idx)
{
        if (test_idx >= ARRAY_SIZE(test_metric_idents)) {
                test_fail_msg("unexpected test iteration");
                return;
        }

        const uint64_t *data =
            vm_map_gpa(ctx, gpa, opt_repeat_count * sizeof (uint64_t));
        assert(data != NULL);

        printf("%s", test_metric_idents[test_idx]);
        if (opt_summarize) {
                double sum = 0.0;
                for (uint32_t i = 0; i < opt_repeat_count; i++) {
                        sum += cycles_to_ns(data[i]);
                }
                printf(",%0.2f", sum / opt_repeat_count);
        } else {
                for (uint32_t i = 0; i < opt_repeat_count; i++) {
                        printf(",%0.2f", cycles_to_ns(data[i]));
                }
        }
        printf("\n");
}

static void
handle_exit(struct vmctx *ctx, const struct vm_exit *vexit,
    struct vm_entry *ventry)
{
        uint32_t outval;

        if (vexit_match_inout(vexit, true, IOP_TEST_PARAM0, 4, NULL)) {
                ventry_fulfill_inout(vexit, ventry, opt_repeat_count);
                return;
        }
        if (vexit_match_inout(vexit, false, IOP_TEST_VALUE, 4, &outval)) {
                ventry_fulfill_inout(vexit, ventry, 0);
                print_result(ctx, (uintptr_t)outval, current_test);
                /* proceed to next test */
                current_test++;
                return;
        }

        test_fail_vmexit(vexit);
}

static void
usage(const char *progname, int status)
{
        char *base = strdup(progname);

        (void) printf("usage: %s [args]\n"
            "\t-n <count>\tNumber of repetitions (default: 1000)\n"
            "\t-s\t\tSummarize (average) results\n"
            "\t-h\t\tPrint this help\n", basename(base));
        exit(status);
}

static void
parse_args(int argc, char *argv[])
{
        int c;
        unsigned long num_parsed;

        while ((c = getopt(argc, argv, ":hsn:")) != -1) {
                switch (c) {
                case 'h':
                        usage(argv[0], EXIT_SUCCESS);
                        break;
                case 's':
                        opt_summarize = true;
                        break;
                case 'n':
                        errno = 0;
                        num_parsed = strtoul(optarg, NULL, 10);
                        if (num_parsed == 0 && errno != 0) {
                                perror("Invalid repeat count");
                                usage(argv[0], EXIT_FAILURE);
                        }
                        if (num_parsed <= 0 || num_parsed > UINT32_MAX) {
                                (void) printf(
                                    "Repeat count must be between 1 - %lu\n",
                                    UINT32_MAX);
                                usage(argv[0], EXIT_FAILURE);
                        }
                        opt_repeat_count = num_parsed;
                        break;
                case ':':
                        (void) printf("Missing argument for option '%c'\n",
                            optopt);
                        usage(argv[0], EXIT_FAILURE);
                        break;
                case '?':
                        (void) printf("Unrecognized option '%c'\n", optopt);
                        usage(argv[0], EXIT_FAILURE);
                        break;
                }
        }
}

int
main(int argc, char *argv[])
{
        const char *test_suite_name = basename(argv[0]);
        struct vmctx *ctx = NULL;
        struct vcpu *vcpu;
        int err;

        parse_args(argc, argv);

        ctx = test_initialize(test_suite_name);

        if ((vcpu = vm_vcpu_open(ctx, 0)) == NULL) {
                test_fail_errno(errno, "Could not open vcpu0");
        }

        err = test_setup_vcpu(vcpu, MEM_LOC_PAYLOAD, MEM_LOC_STACK);
        if (err != 0) {
                test_fail_errno(err, "Could not initialize vcpu0");
        }
        cpu_freq = query_cpu_freq(ctx);

        struct vm_entry ventry = { 0 };
        struct vm_exit vexit = { 0 };

        do {
                const enum vm_exit_kind kind =
                    test_run_vcpu(vcpu, &ventry, &vexit);
                switch (kind) {
                case VEK_REENTR:
                        break;
                case VEK_UNHANDLED:
                        handle_exit(ctx, &vexit, &ventry);
                        break;

                case VEK_TEST_PASS:
                        /*
                         * Skip the normal "PASS" message, since the consumer is
                         * interested in the data itself.
                         */
                        exit(EXIT_SUCCESS);
                        break;
                case VEK_TEST_MSG:
                        test_msg_print(ctx);
                        break;
                case VEK_TEST_FAIL:
                default:
                        test_fail_vmexit(&vexit);
                        break;
                }
        } while (true);
}