/*
 * 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 2019 Robert Mustacchi
 * Copyright 2021 Oxide Computer Company
 */

/*
 * Tests for SMBIOS type 44 - SMB_TYPE_PROCESSOR_INFO and the per-CPU type
 * follow ups.
 */

#include "smbios_test.h"

static uint16_t smbios_pinfo_phandle = 0x1;
static uint64_t smbios_pinfo_isa = 0x4010d;
static uint8_t smbios_pinfo_hartid[16];
static uint8_t smbios_pinfo_vendid[16];
static uint8_t smbios_pinfo_archid[16];
static uint8_t smbios_pinfo_machid[16];
static uint8_t smbios_pinfo_metdi[16];
static uint8_t smbios_pinfo_mitdi[16];

boolean_t
smbios_test_pinfo_mktable_amd64(smbios_test_table_t *table)
{
	smb_processor_info_t pi;

	pi.smbpai_hdr.smbh_type = SMB_TYPE_PROCESSOR_INFO;
	pi.smbpai_hdr.smbh_len = sizeof (smb_processor_info_t);
	pi.smbpai_proc = htole16(smbios_pinfo_phandle);
	pi.smbpai_len = 0;
	pi.smbpai_type = SMB_PROCINFO_T_AMD64;

	(void) smbios_test_table_append(table, &pi, sizeof (pi));
	smbios_test_table_append_eot(table);

	return (B_TRUE);
}

boolean_t
smbios_test_pinfo_verify_amd64(smbios_hdl_t *hdl)
{
	smbios_struct_t sp;
	smbios_processor_info_t pinfo;
	smbios_processor_info_riscv_t rv;
	boolean_t ret = B_TRUE;

	if (smbios_lookup_type(hdl, SMB_TYPE_PROCESSOR_INFO, &sp) == -1) {
		warnx("failed to lookup SMBIOS processor additional "
		    "information: %s", smbios_errmsg(smbios_errno(hdl)));
		return (B_FALSE);
	}

	if (smbios_info_processor_info(hdl, sp.smbstr_id, &pinfo) != 0) {

		warnx("failed to get SMBIOS processor additional "
		    "information: %s", smbios_errmsg(smbios_errno(hdl)));
		return (B_FALSE);
	}

	if (pinfo.smbpi_processor != smbios_pinfo_phandle) {
		warnx("processor handle incorrect, found 0x%" _PRIxID,
		    pinfo.smbpi_processor);
		ret = B_FALSE;
	}

	if (pinfo.smbpi_ptype != SMB_PROCINFO_T_AMD64) {
		warnx("processor type incorrect, found 0x%x",
		    pinfo.smbpi_ptype);
		ret = B_FALSE;
	}

	if (strcmp(smbios_processor_info_type_desc(pinfo.smbpi_ptype),
	    "X64 (x86-64, Intel64, AMD64, EMT64)") != 0) {
		warnx("processor type incorrect, found %s",
		    smbios_processor_info_type_desc(pinfo.smbpi_ptype));
		ret = B_FALSE;
	}

	if (smbios_info_processor_riscv(hdl, sp.smbstr_id, &rv) != -1) {
		warnx("accidentally got riscv info on non-riscv handle");
		ret = B_FALSE;
	}

	if (smbios_errno(hdl) != ESMB_TYPE) {
		warnx("encountered wrong errno for RISC-V info, found: 0x%x",
		    smbios_errno(hdl));
		ret = B_FALSE;
	}

	return (ret);
}

boolean_t
smbios_test_pinfo_mktable_riscv(smbios_test_table_t *table)
{
	smb_processor_info_t pi;
	smb_processor_info_riscv_t rv;

	pi.smbpai_hdr.smbh_type = SMB_TYPE_PROCESSOR_INFO;
	pi.smbpai_hdr.smbh_len = sizeof (smb_processor_info_t) +
	    sizeof (smb_processor_info_riscv_t);
	pi.smbpai_proc = htole16(smbios_pinfo_phandle);
	pi.smbpai_len = sizeof (smb_processor_info_riscv_t);
	pi.smbpai_type = SMB_PROCINFO_T_RV64;

	(void) smbios_test_table_append(table, &pi, sizeof (pi));

	rv.smbpairv_vers = 1;
	rv.smbpairv_len = sizeof (smb_processor_info_riscv_t);
	arc4random_buf(smbios_pinfo_hartid, sizeof (smbios_pinfo_hartid));
	bcopy(smbios_pinfo_hartid, rv.smbpairv_hartid,
	    sizeof (smbios_pinfo_hartid));
	rv.smbpairv_boot = 1;
	arc4random_buf(smbios_pinfo_vendid, sizeof (smbios_pinfo_vendid));
	bcopy(smbios_pinfo_vendid, rv.smbpairv_vendid,
	    sizeof (smbios_pinfo_vendid));
	arc4random_buf(smbios_pinfo_archid, sizeof (smbios_pinfo_archid));
	bcopy(smbios_pinfo_archid, rv.smbpairv_archid,
	    sizeof (smbios_pinfo_archid));
	arc4random_buf(smbios_pinfo_machid, sizeof (smbios_pinfo_machid));
	bcopy(smbios_pinfo_machid, rv.smbpairv_machid,
	    sizeof (smbios_pinfo_machid));
	rv.smbpairv_boot = 1;
	rv.smbpairv_isa = htole64(smbios_pinfo_isa);
	rv.smbpairv_privlvl = SMB_RV_PRIV_M | SMB_RV_PRIV_S;
	arc4random_buf(smbios_pinfo_metdi, sizeof (smbios_pinfo_metdi));
	bcopy(smbios_pinfo_metdi, rv.smbpairv_metdi,
	    sizeof (smbios_pinfo_metdi));
	arc4random_buf(smbios_pinfo_mitdi, sizeof (smbios_pinfo_mitdi));
	bcopy(smbios_pinfo_mitdi, rv.smbpairv_mitdi,
	    sizeof (smbios_pinfo_mitdi));
	rv.smbpairv_xlen = SMB_RV_WIDTH_64B;
	rv.smbpairv_mxlen = SMB_RV_WIDTH_64B;
	rv.smbpairv_sxlen = SMB_RV_WIDTH_128B;
	rv.smbpairv_uxlen = SMB_RV_WIDTH_32B;

	smbios_test_table_append_raw(table, &rv, sizeof (rv));
	smbios_test_table_append_eot(table);

	return (B_TRUE);
}

static void
smbios_test_pinfo_id_mismatch(uint8_t *act, uint8_t *exp)
{
	uint_t i;
	(void) fprintf(stderr, "found:    ");
	for (i = 0; i < 16; i++) {
		(void) fprintf(stderr, " %02x", act[i]);
	}
	(void) fprintf(stderr, "\nexpected: ");
	for (i = 0; i < 16; i++) {
		(void) fprintf(stderr, " %02x", exp[i]);
	}
	(void) fprintf(stderr, "\n");
}

boolean_t
smbios_test_pinfo_verify_riscv(smbios_hdl_t *hdl)
{
	smbios_struct_t sp;
	smbios_processor_info_t pinfo;
	smbios_processor_info_riscv_t rv;
	boolean_t ret = B_TRUE;

	if (smbios_lookup_type(hdl, SMB_TYPE_PROCESSOR_INFO, &sp) == -1) {
		warnx("failed to lookup SMBIOS processor additional "
		    "information: %s", smbios_errmsg(smbios_errno(hdl)));
		return (B_FALSE);
	}

	if (smbios_info_processor_info(hdl, sp.smbstr_id, &pinfo) != 0) {
		warnx("failed to get SMBIOS processor additional "
		    "information: %s", smbios_errmsg(smbios_errno(hdl)));
		return (B_FALSE);
	}

	if (pinfo.smbpi_processor != smbios_pinfo_phandle) {
		warnx("processor handle incorrect, found 0x%" _PRIxID,
		    pinfo.smbpi_processor);
		ret = B_FALSE;
	}

	if (pinfo.smbpi_ptype != SMB_PROCINFO_T_RV64) {
		warnx("processor type incorrect, found 0x%x",
		    pinfo.smbpi_ptype);
		ret = B_FALSE;
	}

	if (strcmp(smbios_processor_info_type_desc(pinfo.smbpi_ptype),
	    "64-bit RISC-V (RV64)") != 0) {
		warnx("processor type incorrect, found %s",
		    smbios_processor_info_type_desc(pinfo.smbpi_ptype));
		ret = B_FALSE;
	}

	if (smbios_info_processor_riscv(hdl, sp.smbstr_id, &rv) != 0) {

		warnx("failed to get SMBIOS processor additional "
		    "information for RISC-V: %s",
		    smbios_errmsg(smbios_errno(hdl)));
		return (B_FALSE);
	}

	if (bcmp(rv.smbpirv_hartid, smbios_pinfo_hartid,
	    sizeof (smbios_pinfo_hartid)) != 0) {
		warnx("RISC-V hart id's don't match");
		smbios_test_pinfo_id_mismatch(rv.smbpirv_hartid,
		    smbios_pinfo_hartid);
		ret = B_FALSE;
	}

	if (bcmp(rv.smbpirv_vendid, smbios_pinfo_vendid,
	    sizeof (smbios_pinfo_vendid)) != 0) {
		warnx("RISC-V vend id's don't match");
		smbios_test_pinfo_id_mismatch(rv.smbpirv_vendid,
		    smbios_pinfo_vendid);
		ret = B_FALSE;
	}

	if (bcmp(rv.smbpirv_archid, smbios_pinfo_archid,
	    sizeof (smbios_pinfo_archid)) != 0) {
		warnx("RISC-V arch id's don't match");
		smbios_test_pinfo_id_mismatch(rv.smbpirv_archid,
		    smbios_pinfo_archid);
		ret = B_FALSE;
	}

	if (bcmp(rv.smbpirv_machid, smbios_pinfo_machid,
	    sizeof (smbios_pinfo_machid)) != 0) {
		warnx("RISC-V mach id's don't match");
		smbios_test_pinfo_id_mismatch(rv.smbpirv_machid,
		    smbios_pinfo_machid);
		ret = B_FALSE;
	}

	if (bcmp(rv.smbpirv_metdi, smbios_pinfo_metdi,
	    sizeof (smbios_pinfo_metdi)) != 0) {
		warnx("RISC-V METDI don't match");
		smbios_test_pinfo_id_mismatch(rv.smbpirv_metdi,
		    smbios_pinfo_metdi);
		ret = B_FALSE;
	}

	if (bcmp(rv.smbpirv_mitdi, smbios_pinfo_mitdi,
	    sizeof (smbios_pinfo_mitdi)) != 0) {
		warnx("RISC-V METDI don't match");
		smbios_test_pinfo_id_mismatch(rv.smbpirv_mitdi,
		    smbios_pinfo_mitdi);
		ret = B_FALSE;
	}

	if (rv.smbpirv_isa != smbios_pinfo_isa) {
		warnx("RISC-V ISA mismatch");
		ret = B_FALSE;
	}

	if (rv.smbpirv_privlvl != (SMB_RV_PRIV_M | SMB_RV_PRIV_S)) {
		warnx("RISC-V privilege level mismatch, found: 0x%x",
		    rv.smbpirv_privlvl);
		ret = B_FALSE;
	}

	if (rv.smbpirv_xlen != SMB_RV_WIDTH_64B) {
		warnx("RISC-V xlen mismatch, found: 0x%x", rv.smbpirv_xlen);
		ret = B_FALSE;
	}

	if (rv.smbpirv_mxlen != SMB_RV_WIDTH_64B) {
		warnx("RISC-V mxlen mismatch, found: 0x%x", rv.smbpirv_mxlen);
		ret = B_FALSE;
	}

	if (rv.smbpirv_sxlen != SMB_RV_WIDTH_128B) {
		warnx("RISC-V sxlen mismatch, found: 0x%x", rv.smbpirv_sxlen);
		ret = B_FALSE;
	}

	if (rv.smbpirv_uxlen != SMB_RV_WIDTH_32B) {
		warnx("RISC-V uxlen mismatch, found: 0x%x", rv.smbpirv_uxlen);
		ret = B_FALSE;
	}

	/*
	 * Finally, use this to spot check several of the different RISC-V
	 * strings.
	 */
	if (strcmp(smbios_riscv_priv_desc(SMB_RV_PRIV_M), "Machine Mode") !=
	    0) {
		warnx("SMB_RV_PRIV_M string desc mismatch, found %s",
		    smbios_riscv_priv_desc(SMB_RV_PRIV_M));
		ret = B_FALSE;
	}

	if (strcmp(smbios_riscv_priv_name(SMB_RV_PRIV_U), "SMB_RV_PRIV_U") !=
	    0) {
		warnx("SMB_RV_PRIV_U string name mismatch, found %s",
		    smbios_riscv_priv_name(SMB_RV_PRIV_U));
		ret = B_FALSE;
	}

	if (strcmp(smbios_riscv_width_desc(SMB_RV_WIDTH_64B), "64-bit") !=
	    0) {
		warnx("SMB_RV_WIDTH_64B string desc mismatch, found %s",
		    smbios_riscv_width_desc(SMB_RV_WIDTH_64B));
		ret = B_FALSE;
	}

	if (strcmp(smbios_riscv_width_desc(SMB_RV_WIDTH_128B), "128-bit") !=
	    0) {
		warnx("SMB_RV_WIDTH_128B string desc mismatch, found %s",
		    smbios_riscv_width_desc(SMB_RV_WIDTH_128B));
		ret = B_FALSE;
	}

	if (strcmp(smbios_riscv_isa_desc(SMB_RV_ISA_A), "Atomic") != 0) {
		warnx("SMB_RV_ISA_A string desc mismatch, found %s",
		    smbios_riscv_isa_desc(SMB_RV_ISA_A));
		ret = B_FALSE;
	}

	if (strcmp(smbios_riscv_isa_desc(SMB_RV_ISA_C), "Compressed") != 0) {
		warnx("SMB_RV_ISA_C string desc mismatch, found %s",
		    smbios_riscv_isa_desc(SMB_RV_ISA_C));
		ret = B_FALSE;
	}

	if (strcmp(smbios_riscv_isa_desc(SMB_RV_ISA_Q),
	    "Quad-precision floating-point") != 0) {
		warnx("SMB_RV_ISA_Q string desc mismatch, found %s",
		    smbios_riscv_isa_desc(SMB_RV_ISA_Q));
		ret = B_FALSE;
	}

	if (strcmp(smbios_riscv_isa_name(SMB_RV_ISA_A), "SMB_RV_ISA_A") != 0) {
		warnx("SMB_RV_ISA_A string name mismatch, found %s",
		    smbios_riscv_isa_name(SMB_RV_ISA_A));
		ret = B_FALSE;
	}

	if (strcmp(smbios_riscv_isa_name(SMB_RV_ISA_C), "SMB_RV_ISA_C") != 0) {
		warnx("SMB_RV_ISA_Q string name mismatch, found %s",
		    smbios_riscv_isa_name(SMB_RV_ISA_C));
		ret = B_FALSE;
	}

	if (strcmp(smbios_riscv_isa_name(SMB_RV_ISA_Q), "SMB_RV_ISA_Q") != 0) {
		warnx("SMB_RV_ISA_Q string name mismatch, found %s",
		    smbios_riscv_isa_name(SMB_RV_ISA_Q));
		ret = B_FALSE;
	}

	return (ret);
}

/*
 * This shows having an invalid table length.
 */
boolean_t
smbios_test_pinfo_mktable_invlen1(smbios_test_table_t *table)
{
	smb_processor_info_t pi;

	pi.smbpai_hdr.smbh_type = SMB_TYPE_PROCESSOR_INFO;
	pi.smbpai_hdr.smbh_len = 2;
	pi.smbpai_proc = htole16(smbios_pinfo_phandle);
	pi.smbpai_len = 0;
	pi.smbpai_type = SMB_PROCINFO_T_AMD64;

	(void) smbios_test_table_append(table, &pi, sizeof (pi));
	smbios_test_table_append_eot(table);

	return (B_TRUE);
}

/*
 * This sets the internal length of the additional processor information data to
 * go beyond the length of the basic structure.
 */
boolean_t
smbios_test_pinfo_mktable_invlen2(smbios_test_table_t *table)
{
	smb_processor_info_t pi;
	smb_processor_info_riscv_t rv;

	pi.smbpai_hdr.smbh_type = SMB_TYPE_PROCESSOR_INFO;
	pi.smbpai_hdr.smbh_len = sizeof (smb_processor_info_t);
	pi.smbpai_proc = htole16(smbios_pinfo_phandle);
	pi.smbpai_len = sizeof (smb_processor_info_riscv_t);
	pi.smbpai_type = SMB_PROCINFO_T_RV64;

	(void) smbios_test_table_append(table, &pi, sizeof (pi));

	arc4random_buf(&rv, sizeof (rv));
	rv.smbpairv_vers = 1;
	rv.smbpairv_len = sizeof (smb_processor_info_riscv_t);

	smbios_test_table_append_raw(table, &rv, sizeof (rv));
	smbios_test_table_append_eot(table);

	return (B_TRUE);
}

/*
 * This verifies that we can detect a header length that doesn't properly
 * contain both the risc-v and base structure.
 */
boolean_t
smbios_test_pinfo_mktable_invlen3(smbios_test_table_t *table)
{
	smb_processor_info_t pi;
	smb_processor_info_riscv_t rv;

	pi.smbpai_hdr.smbh_type = SMB_TYPE_PROCESSOR_INFO;
	pi.smbpai_hdr.smbh_len = sizeof (smb_processor_info_t);
	pi.smbpai_proc = htole16(smbios_pinfo_phandle);
	pi.smbpai_len = 0;
	pi.smbpai_type = SMB_PROCINFO_T_RV64;

	(void) smbios_test_table_append(table, &pi, sizeof (pi));

	arc4random_buf(&rv, sizeof (rv));
	rv.smbpairv_vers = 1;
	rv.smbpairv_len = sizeof (smb_processor_info_riscv_t);

	smbios_test_table_append_raw(table, &rv, sizeof (rv));
	smbios_test_table_append_eot(table);

	return (B_TRUE);
}

/*
 * This verifies that we can detect an inner risc-v additional processor
 * information section that declares its size to be beyond the header of the
 * structure.
 */
boolean_t
smbios_test_pinfo_mktable_invlen4(smbios_test_table_t *table)
{
	smb_processor_info_t pi;
	smb_processor_info_riscv_t rv;

	pi.smbpai_hdr.smbh_type = SMB_TYPE_PROCESSOR_INFO;
	pi.smbpai_hdr.smbh_len = sizeof (smb_processor_info_t) +
	    sizeof (smb_processor_info_riscv_t);
	pi.smbpai_proc = htole16(smbios_pinfo_phandle);
	pi.smbpai_len = sizeof (smb_processor_info_riscv_t);
	pi.smbpai_type = SMB_PROCINFO_T_RV64;

	(void) smbios_test_table_append(table, &pi, sizeof (pi));

	arc4random_buf(&rv, sizeof (rv));
	rv.smbpairv_vers = 1;
	rv.smbpairv_len = sizeof (smb_processor_info_riscv_t) * 2;

	smbios_test_table_append_raw(table, &rv, sizeof (rv));
	smbios_test_table_append_eot(table);

	return (B_TRUE);
}
static boolean_t
smbios_test_pinfo_verify_badtable(smbios_hdl_t *hdl, int smberr,
    boolean_t valid_pinfo)
{
	smbios_struct_t sp;
	smbios_processor_info_t pinfo;
	smbios_processor_info_riscv_t rv;
	boolean_t ret = B_TRUE;

	if (smbios_lookup_type(hdl, SMB_TYPE_PROCESSOR_INFO, &sp) == -1) {
		warnx("failed to lookup SMBIOS processor additional "
		    "information: %s", smbios_errmsg(smbios_errno(hdl)));
		return (B_FALSE);
	}

	if (!valid_pinfo) {
		if (smbios_info_processor_info(hdl, sp.smbstr_id, &pinfo) !=
		    -1) {
			warnx("accidentally parsed invalid processor "
			    "additional information as valid");
			ret = B_FALSE;
		}

		if (smbios_errno(hdl) != smberr) {
			warnx("encountered wrong error for processor info, "
			    "found: 0x%x", smbios_errno(hdl));
			ret = B_FALSE;
		}
	} else {
		if (smbios_info_processor_info(hdl, sp.smbstr_id, &pinfo) !=
		    0) {
			warnx("failed to get SMBIOS processor additional "
			    "information: %s",
			    smbios_errmsg(smbios_errno(hdl)));
			ret = B_FALSE;
		}
	}

	if (smbios_info_processor_riscv(hdl, sp.smbstr_id, &rv) != -1) {
		warnx("accidentally got riscv info on invalid handle");
		ret = B_FALSE;
	}

	if (smbios_errno(hdl) != smberr) {
		warnx("encountered wrong error for amd64 info, found: 0x%x",
		    smbios_errno(hdl));
		ret = B_FALSE;
	}

	return (ret);
}

boolean_t
smbios_test_pinfo_verify_invlen1(smbios_hdl_t *hdl)
{
	return (smbios_test_pinfo_verify_badtable(hdl, ESMB_SHORT, B_FALSE));
}

boolean_t
smbios_test_pinfo_verify_invlen2(smbios_hdl_t *hdl)
{
	return (smbios_test_pinfo_verify_badtable(hdl, ESMB_CORRUPT, B_FALSE));
}

boolean_t
smbios_test_pinfo_verify_invlen3(smbios_hdl_t *hdl)
{
	return (smbios_test_pinfo_verify_badtable(hdl, ESMB_SHORT, B_TRUE));
}

boolean_t
smbios_test_pinfo_verify_invlen4(smbios_hdl_t *hdl)
{
	return (smbios_test_pinfo_verify_badtable(hdl, ESMB_CORRUPT, B_TRUE));
}

boolean_t
smbios_test_pinfo_verify_badtype(smbios_hdl_t *hdl)
{
	smbios_struct_t sp;
	smbios_processor_info_t pinfo;
	smbios_processor_info_riscv_t rv;
	boolean_t ret = B_TRUE;

	if (smbios_lookup_type(hdl, SMB_TYPE_MEMDEVICE, &sp) == -1) {
		warnx("failed to lookup SMBIOS memory device information: %s",
		    smbios_errmsg(smbios_errno(hdl)));
		return (B_FALSE);
	}

	if (smbios_info_processor_info(hdl, sp.smbstr_id, &pinfo) != -1) {
		warnx("accidentally parsed invalid processor additional "
		    "information as valid");
		ret = B_FALSE;
	}

	if (smbios_errno(hdl) != ESMB_TYPE) {
		warnx("encountered wrong error for processor info, found: 0x%x",
		    smbios_errno(hdl));
		ret = B_FALSE;
	}

	if (smbios_info_processor_riscv(hdl, sp.smbstr_id, &rv) != -1) {
		warnx("accidentally got riscv info on invalid handle");
		ret = B_FALSE;
	}

	if (smbios_errno(hdl) != ESMB_TYPE) {
		warnx("encountered wrong error for processor info, found: 0x%x",
		    smbios_errno(hdl));
		ret = B_FALSE;
	}

	return (ret);
}