/*
 * 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
 */

/*
 * Check that supporting information for a VM_EXITCODE_SUSPENDED exit is correct
 * for a vCPU-specific event (triple-fault).
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <strings.h>
#include <libgen.h>
#include <assert.h>
#include <pthread.h>
#include <errno.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"

#define VCPU0_STACK     (MEM_LOC_STACK)
#define VCPU1_STACK     (MEM_LOC_STACK - 0x1000)

struct vcpu_thread_ctx {
        struct vcpu *vcpu;
        enum vm_suspend_how *howp;
        int *sourcep;
};

static void *
vcpu0_thread(void *arg)
{
        struct vcpu_thread_ctx *vtc = arg;
        struct vcpu *vcpu = vtc->vcpu;

        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:
                        if (vexit.exitcode != VM_EXITCODE_SUSPENDED) {
                                test_fail_vmexit(&vexit);
                        }
                        *vtc->howp = vexit.u.suspended.how;
                        *vtc->sourcep = vexit.u.suspended.source;
                        return (NULL);
                default:
                        test_fail_vmexit(&vexit);
                }
        } while (true);
}

static void
vcpu0_setup(struct vcpu *vcpu)
{
        int err;

        err = test_setup_vcpu(vcpu, MEM_LOC_PAYLOAD, VCPU0_STACK);
        if (err != 0) {
                test_fail_errno(err, "Could not initialize vcpu0");
        }
        err = vm_set_register(vcpu, VM_REG_GUEST_RDI, 0);
        if (err != 0) {
                test_fail_errno(err, "failed to set %rdi");
        }
}

static pthread_t
vcpu0_spawn(struct vcpu_thread_ctx *vtc)
{
        pthread_t tid;
        if (pthread_create(&tid, NULL, vcpu0_thread, (void *)vtc) != 0) {
                test_fail_errno(errno, "could not create thread for vcpu0");
        }

        return (tid);
}

static void
vcpu0_join(pthread_t tid)
{
        void *status = NULL;
        if (pthread_join(tid, &status) != 0) {
                test_fail_errno(errno, "could not join thread for vcpu0");
        }
        assert(status == NULL);
}

static void
test_plain_suspend(struct vmctx *ctx, struct vcpu *vcpu,
    enum vm_suspend_how test_how)
{
        enum vm_suspend_how how;
        int source;
        struct vcpu_thread_ctx vcpu0 = {
                .vcpu = vcpu,
                .howp = &how,
                .sourcep = &source,
        };
        pthread_t tid;
        int err;

        vcpu0_setup(vcpu);
        tid = vcpu0_spawn(&vcpu0);
        err = vm_suspend(ctx, test_how);
        if (err != 0) {
                test_fail_errno(err, "vm_suspend() failure");
        }
        vcpu0_join(tid);

        if (how != test_how) {
                test_fail_msg("Unexpected suspend how %d != %d\n",
                    how, test_how);
        }
        if (source != -1) {
                test_fail_msg("Unexpected suspend source %d != %d\n",
                    source, -1);
        }

        /* Reset VM for another test */
        test_reinitialize(ctx, 0);
}

static void
test_emitted_triplefault(struct vmctx *ctx, struct vcpu *vcpu)
{
        enum vm_suspend_how vcpu0_how;
        int vcpu0_source;
        struct vcpu_thread_ctx vcpu0 = {
                .vcpu = vcpu,
                .howp = &vcpu0_how,
                .sourcep = &vcpu0_source,
        };
        struct vcpu *vcpu1;
        int err;
        pthread_t tid;

        vcpu0_setup(vcpu);

        if ((vcpu1 = vm_vcpu_open(ctx, 1)) == NULL) {
                test_fail_errno(errno, "Could not open vcpu1");
        }

        /* Setup vCPU1 like vCPU0, but with ID of 1 in %rdi */
        err = test_setup_vcpu(vcpu1, MEM_LOC_PAYLOAD, VCPU1_STACK);
        if (err != 0) {
                test_fail_errno(err, "Could not initialize vcpu1");
        }
        err = vm_set_register(vcpu1, VM_REG_GUEST_RDI, 1);
        if (err != 0) {
                test_fail_errno(err, "failed to set %rdi");
        }

        /*
         * Get vcpu0 running on a separate thread, ready to have its day
         * "ruined" by a triple-fault on vcpu1
         */
        tid = vcpu0_spawn(&vcpu0);

        struct vm_entry ventry = { 0 };
        struct vm_exit vexit = { 0 };
        do {
                const enum vm_exit_kind kind =
                    test_run_vcpu(vcpu1, &ventry, &vexit);
                switch (kind) {
                case VEK_REENTR:
                        break;
                case VEK_UNHANDLED: {
                        /* expect immediate triple-fault from ud2a */
                        if (vexit.exitcode != VM_EXITCODE_SUSPENDED) {
                                test_fail_vmexit(&vexit);
                        }
                        vcpu0_join(tid);
                        const enum vm_suspend_how vcpu1_how =
                            vexit.u.suspended.how;
                        const int vcpu1_source = vexit.u.suspended.source;

                        if (vcpu0_how != VM_SUSPEND_TRIPLEFAULT ||
                            vcpu0_how != vcpu1_how) {
                                test_fail_msg("Unexpected 'how' for "
                                    "triple-fault: vcpu0=%d, vcpu1=%d, "
                                    "expected=%d",
                                    vcpu0_how, vcpu1_how,
                                    VM_SUSPEND_TRIPLEFAULT);
                        }
                        if (vcpu0_source != 1 ||
                            vcpu0_source != vcpu1_source) {
                                test_fail_msg("Unexpected 'source' for "
                                    "triple-fault: vcpu0=%d, vcpu1=%d, "
                                    "expected=%d",
                                    vcpu0_source, vcpu1_source, 1);
                        }
                        return;
                }

                default:
                        test_fail_vmexit(&vexit);
                        break;
                }
        } while (true);
}

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

        ctx = test_initialize(test_suite_name);

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

        /*
         * Try injecting the various suspend types, and confirm that vcpu0 exits
         * with the expected details.
         */
        test_plain_suspend(ctx, vcpu, VM_SUSPEND_RESET);
        test_plain_suspend(ctx, vcpu, VM_SUSPEND_POWEROFF);
        test_plain_suspend(ctx, vcpu, VM_SUSPEND_HALT);

        /*
         * Let vCPU1 generate a triple-fault, and confirm that it is emitted by
         * both exiting vCPU threads, with the proper details.
         */
        test_emitted_triplefault(ctx, vcpu);

        test_pass();
}