/*
 * 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 "payload_common.h"
#include "payload_utils.h"

/* Arbitrary 2MB limit to keep heap away from stack */
#define	HEAP_LIMIT	0x200000

#define	MSR_APICBASE		0x01b
#define	IOP_ICU1		0x20
#define	ADDR_IOAPIC_BASE	0xfec00000

typedef struct test_data {
	uint32_t count;
	uint64_t *data;
} test_data_t;

static void
zero_data(const test_data_t *td)
{
	for (uint32_t i = 0; i < td->count; i++) {
		td->data[i] = 0;
	}
}

static void
output_data(const test_data_t *td, uint64_t tsc_start)
{
	for (uint32_t i = td->count - 1; i > 0; i--) {
		td->data[i] -= td->data[i - 1];
	}
	td->data[0] -= tsc_start;

	/*
	 * Output the low 32-bits of the data pointers, since that is adequate
	 * while the test resides wholly in lowmem.
	 */
	outl(IOP_TEST_VALUE, (uint32_t)(uintptr_t)td->data);
}

static uint32_t
mmio_read4(volatile uint32_t *ptr)
{
	return (*ptr);
}

/*
 * For a relatively cheap exit, rdmsr(APICBASE) should be suitable, since its
 * emulation is dead simple and LAPIC-related MSR operations are handled within
 * the tight confines of the SVM/VMX vmrun loop.
 */
static void
do_test_rdmsr(const test_data_t *td)
{
	zero_data(td);

	const uint64_t tsc_start = rdtsc();
	for (uint32_t i = 0; i < td->count; i++) {
		(void) rdmsr(MSR_APICBASE);
		td->data[i] = rdtsc();
	}

	output_data(td, tsc_start);
}

/*
 * For a moderately priced exit, an IO port read from the ATPIC should suffice.
 * This will take us out of the SVM/VMX vmrun loop and into the instruction
 * emulation, but the instruction fetch/decode should already be taken care of
 * by the hardware, and no further memory (guest) accesses are required.
 */
static void
do_test_inb(const test_data_t *td)
{
	zero_data(td);

	const uint64_t tsc_start = rdtsc();
	for (uint32_t i = 0; i < td->count; i++) {
		(void) inb(IOP_ICU1);
		td->data[i] = rdtsc();
	}

	output_data(td, tsc_start);
}

/*
 * For a more expensive exit, read from the selector register in the IOAPIC.
 * The device emulation is handled in-kernel, but the instruction will need to
 * (potentially) fetched and decoded.
 */
static void
do_test_mmio_cheap(const test_data_t *td)
{
	zero_data(td);
	volatile uint32_t *ioapic_regsel = (void *)(uintptr_t)ADDR_IOAPIC_BASE;

	const uint64_t tsc_start = rdtsc();
	for (uint32_t i = 0; i < td->count; i++) {
		(void) mmio_read4(ioapic_regsel);
		td->data[i] = rdtsc();
	}

	output_data(td, tsc_start);
}

void
start(void)
{

	/* Get the number of repetitions per test */
	const uint32_t count = inl(IOP_TEST_PARAM0);

	if (count * sizeof (uint64_t) > HEAP_LIMIT) {
		test_msg("excessive test count for memory sz");
		test_result_fail();
		return;
	}

	test_data_t td = {
		.count = count,
		.data = (uint64_t *)(uintptr_t)MEM_LOC_HEAP,
	};

	do_test_rdmsr(&td);
	do_test_inb(&td);
	do_test_mmio_cheap(&td);

	test_result_pass();
}