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

/*
 * This constructs various failure cases for our SPD parsing logic and ensures
 * that we can catch them.
 */

#include <err.h>
#include <stdlib.h>
#include <sys/sysmacros.h>
#include <libjedec.h>

typedef struct {
	uint8_t lst_data[1024];
	size_t lst_len;
	spd_error_t lst_err;
	const char *lst_desc;
	boolean_t (*lst_check)(nvlist_t *);
} libjedec_spd_test_t;

/*
 * The test in question only specifies 0x10 bytes. This means we should have a
 * valid errors nvl with an incomplete entry.
 */
static boolean_t
spd_check_short_ddr4(nvlist_t *nvl)
{
	int ret;
	uint32_t inc;

	if ((ret = nvlist_lookup_uint32(nvl, SPD_KEY_INCOMPLETE,
	    &inc)) != 0) {
		warnc(ret, "failed to lookup incomplete key");
		return (B_FALSE);
	}

	if (inc != 0x11) {
		warnx("incomplete key has unexpected offset: expected %u, "
		    "found %u", 0x11, inc);
		return (B_FALSE);
	}

	return (B_TRUE);
}

static boolean_t
spd_check_single_err(nvlist_t *nvl, const char *key, spd_error_kind_t kind)
{
	int ret;
	nvlist_t *check;
	uint32_t code;
	char *msg;
	boolean_t pass = B_TRUE;

	if ((ret = nvlist_lookup_nvlist(nvl, key, &check)) != 0) {
		warnc(ret, "failed to lookup key %s in error nvlist", key);
		dump_nvlist(nvl, 4);
		return (B_FALSE);
	}

	if ((ret = nvlist_lookup_string(check, SPD_KEY_ERRS_MSG, &msg)) != 0) {
		warnc(ret, "missing error message for error key %s", key);
		dump_nvlist(check, 6);
		pass = B_FALSE;
	}

	if ((ret = nvlist_lookup_uint32(check, SPD_KEY_ERRS_CODE,
	    &code)) != 0) {
		warnc(ret, "missing error number for error key %s", key);
		dump_nvlist(check, 6);
		pass = B_FALSE;
	} else if (code != kind) {
		warnx("found wrong error kind for error key %s: expected 0x%x, "
		    "found 0x%x", key, kind, code);
		pass = B_FALSE;
	}

	nvlist_free(check);
	return (pass);
}

/*
 * This goes through and checks for a number of error codes being set as
 * expected. Note, we check that the message exists, but we don't validate its
 * contents in any way. Because we're using all zero data, we can expect to find
 * a number of different cases.
 */
static boolean_t
spd_check_misc_errors(nvlist_t *nvl)
{
	int ret;
	nvlist_t *errs;
	boolean_t pass = B_TRUE;

	if ((ret = nvlist_lookup_nvlist(nvl, SPD_KEY_ERRS, &errs)) != 0) {
		warnc(ret, "failed to lookup errors nvlist");
		return (B_FALSE);
	}

	if (!spd_check_single_err(errs, SPD_KEY_MFG_DRAM_MFG_NAME,
	    SPD_ERROR_NO_XLATE) ||
	    !spd_check_single_err(errs, SPD_KEY_CRC_DDR4_BASE,
	    SPD_ERROR_BAD_DATA) ||
	    !spd_check_single_err(errs, SPD_KEY_MFG_MOD_PN,
	    SPD_ERROR_UNPRINT) ||
	    !spd_check_single_err(errs, SPD_KEY_TRCD_MIN, SPD_ERROR_NO_XLATE)) {
		pass = B_FALSE;
	}


	nvlist_free(errs);
	return (pass);
}

static const libjedec_spd_test_t spd_tests[] = {
	{ .lst_data = {}, .lst_len = 0, .lst_err = LIBJEDEC_SPD_TOOSHORT,
	    .lst_desc = "Invalid SPD Data (zero length)" },
	{ .lst_data = { 0x00, 0x10, SPD_DT_DDR_SGRAM, 0x00 }, .lst_len = 4,
	    .lst_err = LIBJEDEC_SPD_UNSUP_TYPE, .lst_desc = "Unsupported "
	    "SPD type (DDR SGRAM)" },
	{ .lst_data = { 0x00, 0x10, 0x42, 0x00 }, .lst_len = 4,
	    .lst_err = LIBJEDEC_SPD_UNSUP_TYPE, .lst_desc = "Unknown "
	    "SPD type (0x42)" },
	{ .lst_data = { 0x00, 0x00, SPD_DT_DDR4_SDRAM, 0x00 }, .lst_len = 4,
	    .lst_err = LIBJEDEC_SPD_UNSUP_REV, .lst_desc = "Bad DDR4 "
	    "Revision (0x00)" },
	{ .lst_data = { 0x00, 0x54, SPD_DT_DDR4_SDRAM, 0x00 }, .lst_len = 4,
	    .lst_err = LIBJEDEC_SPD_UNSUP_REV, .lst_desc = "Bad DDR4 "
	    "Revision (0x54)" },
	{ .lst_data = { 0x00, 0x00, SPD_DT_DDR5_SDRAM, 0x00 }, .lst_len = 4,
	    .lst_err = LIBJEDEC_SPD_UNSUP_REV, .lst_desc = "Bad DDR4 "
	    "Revision (0x00)" },
	{ .lst_data = { 0x00, 0xb2, SPD_DT_DDR5_SDRAM, 0x00 }, .lst_len = 4,
	    .lst_err = LIBJEDEC_SPD_UNSUP_REV, .lst_desc = "Bad DDR5 "
	    "Revision (0xb2)" },
	{ .lst_data = { 0x00, 0x10, SPD_DT_DDR5_SDRAM, 0x00 }, .lst_len = 0xc3,
	    .lst_err = LIBJEDEC_SPD_UNSUP_REV, .lst_desc = "Bad DDR5 Common "
	    "Revision (0x00)" },
	{ .lst_data = { 0x00, 0x10, SPD_DT_DDR4_SDRAM, 0x00 }, .lst_len = 0x10,
	    .lst_err = LIBJEDEC_SPD_OK, .lst_desc = "Catch incomplete errors",
	    .lst_check = spd_check_short_ddr4 },
	{ .lst_data = { 0x00, 0x10, SPD_DT_DDR4_SDRAM, 0x00 }, .lst_len = 0x200,
	    .lst_err = LIBJEDEC_SPD_OK, .lst_desc = "Non-fatal parsing errors",
	    .lst_check = spd_check_misc_errors },

};

static boolean_t
libjedec_spd_test(const libjedec_spd_test_t *test)
{
	nvlist_t *nvl;
	spd_error_t err;
	boolean_t pass = B_TRUE;

	nvl = libjedec_spd(test->lst_data, test->lst_len, &err);
	if (err != test->lst_err) {
		warnx("found mismatched error: expected 0x%x, found 0x%x",
		    test->lst_err, err);
		pass = B_FALSE;
	}

	if (nvl != NULL) {
		if (test->lst_err != LIBJEDEC_SPD_OK) {
			warnx("expected fatal error (0x%x), but somehow got "
			    "an nvlist! Contents:", test->lst_err);
			dump_nvlist(nvl, 4);
			pass = B_FALSE;
		}
	} else {
		if (test->lst_err == LIBJEDEC_SPD_OK) {
			warnx("expected an nvlist_t, but didn't get one: "
			    "actual spd_error_t: 0x%x", err);
			pass = B_FALSE;
		}
	}

	if (pass && test->lst_check) {
		pass = test->lst_check(nvl);
	}

	return (pass);
}

int
main(void)
{
	int ret = EXIT_SUCCESS;

	for (size_t i = 0; i < ARRAY_SIZE(spd_tests); i++) {
		const libjedec_spd_test_t *test = &spd_tests[i];

		if (!libjedec_spd_test(test)) {
			(void) fprintf(stderr, "TEST FAILED: %s\n",
			    test->lst_desc);
			ret = EXIT_FAILURE;
		} else {
			(void) printf("TEST PASSED: %s\n", test->lst_desc);
		}
	}

	return (ret);
}