/*
 * 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 <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 void
run_until_unhandled(struct vcpu *vcpu, struct vm_entry *ventry,
    struct vm_exit *vexit)
{
	do {
		const enum vm_exit_kind kind =
		    test_run_vcpu(vcpu, ventry, vexit);
		switch (kind) {
		case VEK_REENTR:
			break;
		case VEK_UNHANDLED:
			return;
		default:
			/*
			 * We are not expecting the payload to use any of the
			 * pass/fail/messaging facilities during this test.
			 */
			test_fail_vmexit(vexit);
			break;
		}
	} while (true);
}

static void
repeat_consistent_exit(struct vcpu *vcpu, struct vm_entry *ventry,
    struct vm_exit *vexit, uint64_t expected_rip)
{
	ventry->cmd = VEC_DEFAULT | VEC_FLAG_EXIT_CONSISTENT;
	if (vm_run(vcpu, ventry, vexit) != 0) {
		test_fail_errno(errno, "Failure during vcpu entry");
	}
	if (vexit->rip != expected_rip) {
		test_fail_msg(
		    "Unexpected forward progress when vCPU already consistent");
	}
}

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

	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");
	}

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

	/*
	 * Let the payload run until it reaches the first userspace exit which
	 * requires actual handling
	 */
	run_until_unhandled(vcpu, &ventry, &vexit);
	if (vexit.exitcode != VM_EXITCODE_RDMSR) {
		test_fail_vmexit(&vexit);
	}
	uint64_t rcx = 0, rip = 0;
	if (vm_get_register(vcpu, VM_REG_GUEST_RCX, &rcx) != 0) {
		test_fail_errno(errno, "Could not read guest %rcx");
	}
	if (vm_get_register(vcpu, VM_REG_GUEST_RIP, &rip) != 0) {
		test_fail_errno(errno, "Could not read guest %rip");
	}
	/* Paranoia: confirm that in-register %rip matches vm_exit data */
	if (rip != vexit.rip) {
		test_fail_msg(
		    "vm_exit`rip does not match in-kernel %rip: %lx != %lx",
		    rip, vexit.rip);
	}

	/* Request a consistent exit */
	ventry.cmd = VEC_DEFAULT | VEC_FLAG_EXIT_CONSISTENT;
	if (vm_run(vcpu, &ventry, &vexit) != 0) {
		test_fail_errno(errno, "Failure during vcpu entry");
	}

	/*
	 * We expect the consistent exit to have completed the instruction
	 * emulation for the rdmsr (just move the %rip forward, since its left
	 * to userspace to update %rax:%rdx) and emit the BOGUS exitcode.
	 */
	if (vexit.exitcode != VM_EXITCODE_BOGUS) {
		test_fail_msg("Unexpected exitcode: %d != %d",
		    vexit.exitcode, VM_EXITCODE_BOGUS);
	}

	/*
	 * Check that the %rip moved forward only the 2 bytes expected for a
	 * rdmsr opcode.
	 */
	if (vexit.rip != (rip + 2)) {
		test_fail_msg("Exited at unexpected %rip: %lx != %lx",
		    vexit.rip, rip + 2);
	}

	/*
	 * Repeat entry with consistency request.  This should not make any
	 * forward progress since the vCPU is already in a consistent state.
	 */
	repeat_consistent_exit(vcpu, &ventry, &vexit, vexit.rip);

	/* Let the vCPU continue on to the next exit condition */
	ventry.cmd = VEC_DEFAULT;
	run_until_unhandled(vcpu, &ventry, &vexit);

	const uint64_t read_addr = 0xc0000000;
	const uint_t read_len = 4;
	if (!vexit_match_mmio(&vexit, true, read_addr, read_len, NULL)) {
		test_fail_vmexit(&vexit);
	}
	rip = vexit.rip;

	/*
	 * An attempt to push the vCPU to a consistent state without first
	 * fulfilling the MMIO should just result in the same MMIO exit.
	 */
	ventry.cmd = VEC_DEFAULT | VEC_FLAG_EXIT_CONSISTENT;
	if (vm_run(vcpu, &ventry, &vexit) != 0) {
		test_fail_errno(errno, "Failure during vcpu entry");
	}
	if (vexit.rip != rip ||
	    !vexit_match_mmio(&vexit, true, read_addr, read_len, NULL)) {
		test_fail_msg(
		    "Unexpected forward progress during MMIO emulation");
	}

	/* Fulfill the MMIO and attempt another consistent exit */
	ventry_fulfill_mmio(&vexit, &ventry, 0);
	ventry.cmd |= VEC_FLAG_EXIT_CONSISTENT;
	if (vm_run(vcpu, &ventry, &vexit) != 0) {
		test_fail_errno(errno, "Failure during vcpu entry");
	}

	/* With current payload, we expect a 3-byte mov instruction */
	if (vexit.rip != (rip + 3)) {
		test_fail_msg("Exited at unexpected %rip: %lx != %lx",
		    vexit.rip, rip + 3);
	}

	/*
	 * And again, check that vCPU remains at that %rip once its state has
	 * been made consistent.
	 */
	repeat_consistent_exit(vcpu, &ventry, &vexit, vexit.rip);

	test_pass();
}