xref: /illumos-gate/usr/src/test/i2c-tests/tests/ioctl/addresses.c (revision 0cbe48189888d02563dba9c90132ac391ba233b6)

/*
 * 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 2025 Oxide Computer Company
 */

/*
 * Test various aspects of creating and removing devices. This operates on the
 * smbussim1/0 port where there are no devices by default. In particular we
 * want to verify a few different properties:
 *
 *  - Invalid nvlists and missing nvlist fields are caught
 *  - The device name and compatible array are correctly populated
 *  - Address allocation across ports is sensible, meaning that something on the
 *    top-level port stops allocations on downstream ports and vice-versa
 *
 * Unlike the i2cadm tests, we care about the specific kernel ioctl return
 * values.
 */

#include <stdlib.h>
#include <unistd.h>
#include <err.h>
#include <sys/debug.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/nvpair.h>
#include <sys/sysmacros.h>
#include <libdevinfo.h>

#include <sys/i2c/ioctl.h>
#include "i2c_ioctl_util.h"

static const char *bad_names[] = {
	"",
	"thisisalongstringthatshouldbetoolongbuthasvalidchars",
	"0nonum",
	"42",
	"help#",
	"!at24c32",
	"at24%c32",
	"at@24xc32",
	"three rings",
	"elven(kings)",
	"ゼルダの伝説"
};

static bool
test_add(int fd, const void *arg, size_t len, i2c_errno_t err, const char *desc)
{
	bool ret = true;
	ui2c_dev_add_t add = {
		.uda_error = {
			/*
			 * We use token values here to make sure that they're
			 * always set by the target.
			 */
			INT32_MIN,
			INT32_MIN
		},
		.uda_nvl = (uintptr_t)arg,
		.uda_nvl_len = len
	};

	if (ioctl(fd, UI2C_IOCTL_DEVICE_ADD, &add) != 0) {
		warnx("TEST FAILED: %s: add ioctl failed unexpectedly with "
		    "errno %s", desc, strerrorname_np(errno));
		return (false);
	}

	if (add.uda_error.i2c_error != err) {
		warnx("TEST FAILED: %s: ioctl failed with I2C error 0x%x, "
		    "expected 0x%x", desc, add.uda_error.i2c_error, err);
		ret = false;
	}

	if (add.uda_error.i2c_ctrl != I2C_CTRL_E_OK) {
		warnx("TEST FAILED: %s: ioctl has unexpected controller "
		    "error 0x%x", desc, add.uda_error.i2c_ctrl);
		ret = false;
	}

	if (ret) {
		if (err == I2C_CORE_E_OK) {
			(void) printf("TEST PASSED: %s correctly created "
			    "device\n", desc);
		} else {
			(void) printf("TEST PASSED: %s correctly failed with "
			    "0x%x\n", desc, err);
		}
	}

	return (ret);
}

static bool
test_add_nvlist(int fd, nvlist_t *nvl, i2c_errno_t err, const char *desc)
{
	size_t len;
	char *data = fnvlist_pack(nvl, &len);
	bool ret = test_add(fd, data, len, err, desc);
	fnvlist_pack_free(data, len);
	return (ret);
}

static bool
test_bad_nvlists(int fd)
{
	bool ret = true;
	const char *str = "I promise I'm an nvlist_t";

	if (!test_add(fd, NULL, 4 * 1024 * 1024, I2C_IOCTL_E_NVL_TOO_BIG,
	    "nvlist_t too large to copy in")) {
		ret = false;
	}

	size_t pgsz = (size_t)sysconf(_SC_PAGESIZE);
	void *addr = mmap(NULL, pgsz, PROT_NONE, MAP_PRIVATE | MAP_ANON,
	    -1, 0);
	VERIFY3P(addr, !=, NULL);
	if (!test_add(fd, addr, pgsz, I2C_IOCTL_E_BAD_USER_DATA, "unreadable "
	    "user data")) {
		ret = false;
	}
	VERIFY0(munmap(addr, pgsz));

	if (!test_add(fd, str, strlen(str) + 1, I2C_IOCTL_E_NVL_INVALID,
	    "unparseable nvlist_t")) {
		ret = false;
	}

	/*
	 * Go through and test all of the missing keys cases.
	 */
	nvlist_t *nvl = fnvlist_alloc();
	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_NVL_KEY_MISSING, "missing "
	    "keys (all)")) {
		ret = false;
	}

	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x00);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_NVL_KEY_MISSING, "missing "
	    "keys (name)")) {
		ret = false;
	}
	nvlist_free(nvl);

	nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x00);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "foobar");
	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_NVL_KEY_MISSING, "missing "
	    "keys (type)")) {
		ret = false;
	}
	nvlist_free(nvl);

	nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "foobar");
	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_NVL_KEY_MISSING, "missing "
	    "keys (type)")) {
		ret = false;
	}
	nvlist_free(nvl);

	nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x00);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_NAME, 0x42);
	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_NVL_KEY_BAD_TYPE, "bad key "
	    "type (name)")) {
		ret = false;
	}
	nvlist_free(nvl);

	nvl = fnvlist_alloc();
	fnvlist_add_uint32(nvl, UI2C_IOCTL_NVL_ADDR, 0x00);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "foobar");
	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_NVL_KEY_BAD_TYPE, "bad key "
	    "type (addr)")) {
		ret = false;
	}
	nvlist_free(nvl);

	nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x00);
	fnvlist_add_int64(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "foobar");
	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_NVL_KEY_BAD_TYPE, "bad key "
	    "type (type)")) {
		ret = false;
	}
	nvlist_free(nvl);

	nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x00);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "foobar");
	fnvlist_add_byte_array(nvl, UI2C_IOCTL_NVL_COMPAT, (uchar_t *)str,
	    strlen(str));
	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_NVL_KEY_BAD_TYPE, "bad key "
	    "type (compat)")) {
		ret = false;
	}
	nvlist_free(nvl);

	for (size_t i = 0; i < nbad_addrs; i++) {
		char desc[128];

		(void) snprintf(desc, sizeof (desc), "bad address %zu "
		    "(0x%x,0x%x)", i, bad_addrs[i].ba_type,
		    bad_addrs[i].ba_addr);
		nvl = fnvlist_alloc();
		fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE,
		    bad_addrs[i].ba_type);
		fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR,
		    bad_addrs[i].ba_addr);
		fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "foobar");
		if (!test_add_nvlist(fd, nvl, bad_addrs[i].ba_error, desc)) {
			ret = false;
		}
		fnvlist_free(nvl);
	}

	for (size_t i = 0; i < ARRAY_SIZE(bad_names); i++) {
		char desc[128];

		(void) snprintf(desc, sizeof (desc), "bad names %zu", i);
		nvl = fnvlist_alloc();
		fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
		fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x42);
		fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, bad_names[i]);
		if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_BAD_DEV_NAME, desc)) {
			ret = false;
		}
		fnvlist_free(nvl);
	}

	for (size_t i = 0; i < ARRAY_SIZE(bad_names); i++) {
		char desc[128];

		(void) snprintf(desc, sizeof (desc), "bad compat %zu", i);
		nvl = fnvlist_alloc();
		fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
		fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x42);
		fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "foobar");
		fnvlist_add_string_array(nvl, UI2C_IOCTL_NVL_COMPAT,
		    (char * const *)&bad_names[i], 1);
		if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_BAD_DEV_NAME, desc)) {
			ret = false;
		}
		fnvlist_free(nvl);
	}

	char *compat[42];
	for (size_t i = 0; i < ARRAY_SIZE(compat); i++) {
		compat[i] = "at24c32";
	}

	nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x42);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "foobar");
	fnvlist_add_string_array(nvl, UI2C_IOCTL_NVL_COMPAT, compat,
	    ARRAY_SIZE(compat));
	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_COMPAT_LEN_RANGE,
	    "compat[] too long")) {
		ret = false;
	}
	fnvlist_free(nvl);

	nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x42);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "foobar");
	fnvlist_add_string(nvl, "magicite", "materia");

	if (!test_add_nvlist(fd, nvl, I2C_IOCTL_E_NVL_KEY_UNKNOWN,
	    "extra keys")) {
		ret = false;
	}
	fnvlist_free(nvl);

	return (ret);
}

static bool
test_add_device(int fd, const char *name, uint8_t addr, i2c_errno_t err,
    const char *desc)
{
	nvlist_t *nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, addr);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, name);
	bool ret = test_add_nvlist(fd, nvl, err, desc);
	fnvlist_free(nvl);
	return (ret);
}

static bool
test_address_conflicts(int fd)
{
	bool ret = true;

	if (!test_add_device(fd, "pca9548", 0x70, I2C_CORE_E_OK, "create "
	    "pca9548")) {
		ret = false;
	}

	if (!test_add_device(fd, "fake-device", 0x70, I2C_CORE_E_ADDR_IN_USE,
	    "address in use fails (0x70)")) {
		ret = false;
	}

	int pfd0 = i2c_ioctl_test_get_fd(I2C_D_PORT, "smbussim1/0/0x70/mux/0",
	    O_RDWR);
	int pfd4 = i2c_ioctl_test_get_fd(I2C_D_PORT, "smbussim1/0/0x70/mux/4",
	    O_RDWR);

	/*
	 * Verify that an address used downstream on the mux cannot be used
	 * upstream of it.
	 */
	if (!test_add_device(pfd0, "fake-device", 0x42, I2C_CORE_E_OK, "create "
	    "fake device (ox42) on mux port 0")) {
		ret = false;
	}

	if (!test_add_device(pfd4, "fake-device", 0x42, I2C_CORE_E_OK, "create "
	    "fake device (ox42) on mux port 4")) {
		ret = false;
	}

	if (!test_add_device(fd, "fake-device", 0x42, I2C_CORE_E_ADDR_IN_USE,
	    "cannot create device on upstream port used on downstream ports")) {
		ret = false;
	}

	/*
	 * Verify that an address used on the top-level port cannot be used
	 * downstream of it.
	 */
	if (test_add_device(fd, "fake-device", 0x23, I2C_CORE_E_OK, "create "
	    "fake device (0x23)")) {
		if (!test_add_device(pfd0, "fake-device", 0x23,
		    I2C_CORE_E_ADDR_IN_USE, "cannot allocate address on "
		    "downstream port when used upstream (1)")) {
			ret = false;
		}

		if (!test_add_device(pfd4, "fake-device", 0x23,
		    I2C_CORE_E_ADDR_IN_USE, "cannot allocate address on "
		    "downstream port when used upstream (2)")) {
			ret = false;
		}
	} else {
		ret = false;
	}

	VERIFY0(close(pfd4));
	VERIFY0(close(pfd0));
	return (ret);
}

typedef struct {
	bool tcc_ret;
	bool tcc_compat0;
	bool tcc_compat1;
	char **tcc_compat;
} test_compat_cb_t;

static int
test_compat_walk_cb(di_node_t di, void *arg)
{
	test_compat_cb_t *cb = arg;
	const char *name = di_node_name(di);
	int exp;

	if (strcmp(name, "fake-compat-0") == 0) {
		cb->tcc_compat0 = true;
		exp = 1;
	} else if (strcmp(name, "fake-compat-1") == 0) {
		cb->tcc_compat1 = true;
		exp = 32;
	} else {
		return (DI_WALK_CONTINUE);
	}

	char *compat;
	int nents = di_prop_lookup_strings(DDI_DEV_T_ANY, di, "compatible",
	    &compat);
	if (nents == exp) {
		bool valid = true;
		for (int i = 0; i < exp; i++) {
			if (strcmp(compat, cb->tcc_compat[i]) != 0) {
				valid = false;
				warnx("TEST FAILED: %s has incorrect "
				    "compatible[%d] entry: expected %s, found "
				    "%s", name, i, compat, cb->tcc_compat[i]);
			}

			compat += strlen(compat) + 1;
		}

		if (valid) {
			(void) printf("TEST PASSED: devi %s has correct "
			    "comaptible[%d]\n", name, nents);
		}
	} else {
		warnx("TEST FAILED: node %s has wrong compatible[] count: "
		    "found %d, expected %d", name, nents, exp);
		cb->tcc_ret = false;
	}

	return (DI_WALK_PRUNECHILD);
}

static bool
test_compat(int fd)
{
	bool ret = true;
	char *compat[32];

	for (size_t i = 0; i < ARRAY_SIZE(compat); i++) {
		if (asprintf(&compat[i], "bad,compat%zu", i) < 0) {
			err(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to "
			    "construct compat entry %zu", i);
		}
	}

	nvlist_t *nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x30);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "fake-compat-0");
	fnvlist_add_string_array(nvl, UI2C_IOCTL_NVL_COMPAT, compat,
	    1);
	if (!test_add_nvlist(fd, nvl, I2C_CORE_E_OK, "1-entry compat[]")) {
		ret = false;
	}
	fnvlist_free(nvl);

	nvl = fnvlist_alloc();
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_TYPE, I2C_ADDR_7BIT);
	fnvlist_add_uint16(nvl, UI2C_IOCTL_NVL_ADDR, 0x31);
	fnvlist_add_string(nvl, UI2C_IOCTL_NVL_NAME, "fake-compat-1");
	fnvlist_add_string_array(nvl, UI2C_IOCTL_NVL_COMPAT, compat,
	    ARRAY_SIZE(compat));
	if (!test_add_nvlist(fd, nvl, I2C_CORE_E_OK, "32-entry compat[]")) {
		ret = false;
	}
	fnvlist_free(nvl);

	test_compat_cb_t cb = {
		.tcc_ret = true,
		.tcc_compat0 = false,
		.tcc_compat1 = false,
		.tcc_compat = compat
	};

	di_node_t root = di_init(i2c_sim_dipath, DINFOCPYALL);
	(void) di_walk_node(root, DI_WALK_CLDFIRST, &cb, test_compat_walk_cb);
	di_fini(root);

	if (!cb.tcc_ret) {
		ret = false;
	}

	if (!cb.tcc_compat0) {
		warnx("TEST FAILED: failed to find devi fake-compat-0");
		ret = false;
	}

	if (!cb.tcc_compat1) {
		warnx("TEST FAILED: failed to find devi fake-compat-1");
		ret = false;
	}

	for (size_t i = 0; i < ARRAY_SIZE(compat); i++) {
		free(compat[i]);
	}

	return (ret);
}

static bool
test_rm(int fd, uint16_t family, uint16_t addr, i2c_errno_t err,
    const char *desc)
{
	bool ret = true;
	ui2c_dev_rem_t rm = {
		.udr_error = {
			/* Token errors to ensure this is set by copyout. */
			INT32_MAX,
			INT32_MAX
		},
		.udr_addr = { family, addr }
	};

	if (ioctl(fd, UI2C_IOCTL_DEVICE_REMOVE, &rm) != 0) {
		warnx("TEST FAILED: %s: removal ioctl failed unexpectedly with "
		    "errno %s", desc, strerrorname_np(errno));
		return (false);
	}

	if (rm.udr_error.i2c_error != err) {
		warnx("TEST FAILED: %s: ioctl failed with I2C error 0x%x, "
		    "expected 0x%x", desc, rm.udr_error.i2c_error, err);
		ret = false;
	}

	if (rm.udr_error.i2c_ctrl != I2C_CTRL_E_OK) {
		warnx("TEST FAILED: %s: ioctl has unexpected controller "
		    "error 0x%x", desc, rm.udr_error.i2c_ctrl);
		ret = false;
	}

	if (ret) {
		if (err == I2C_CORE_E_OK) {
			(void) printf("TEST PASSED: %s correctly removed "
			    "device\n", desc);
		} else {
			(void) printf("TEST PASSED: %s correctly failed with "
			    "0x%x\n", desc, err);
		}
	}

	return (ret);
}

static bool
test_teardown(int fd)
{
	bool ret = true;

	for (size_t i = 0; i < nbad_addrs; i++) {
		char desc[128];

		(void) snprintf(desc, sizeof (desc), "remove bad address %zu",
		    i);
		if (!test_rm(fd, bad_addrs[i].ba_type, bad_addrs[i].ba_addr,
		    bad_addrs[i].ba_error, desc)) {
			ret = false;
		}
	}

	if (!test_rm(fd, I2C_ADDR_7BIT, 0x70, I2C_IOCTL_E_NEXUS,
	    "cannot tear down mux with devices under it")) {
		ret = false;
	}

	if (!test_rm(fd, I2C_ADDR_7BIT, 0x30, I2C_CORE_E_OK, "tear down device "
	    "unrelated to mux (0x30)")) {
		ret = false;
	}

	if (!test_rm(fd, I2C_ADDR_7BIT, 0x31, I2C_CORE_E_OK, "tear down device "
	    "unrelated to mux (0x31)")) {
		ret = false;
	}

	int pfd0 = i2c_ioctl_test_get_fd(I2C_D_PORT, "smbussim1/0/0x70/mux/0",
	    O_RDWR);
	if (!test_rm(pfd0, I2C_ADDR_7BIT, 0x42, I2C_CORE_E_OK, "tear down "
	    "device under mux (0/0x42)")) {
		ret = false;
	}

	if (!test_rm(pfd0, I2C_ADDR_7BIT, 0x42, I2C_CORE_E_UNKNOWN_ADDR,
	    "cannot remove 0/0x42 a second time on same port")) {
		ret = false;
	}
	VERIFY0(close(pfd0));

	int pfd2 = i2c_ioctl_test_get_fd(I2C_D_PORT, "smbussim1/0/0x70/mux/2",
	    O_RDWR);
	if (!test_rm(pfd2, I2C_ADDR_7BIT, 0x42, I2C_CORE_E_UNKNOWN_ADDR,
	    "cannot remove non-existent 2/0x42")) {
		ret = false;
	}
	VERIFY0(close(pfd2));

	int pdf4 = i2c_ioctl_test_get_fd(I2C_D_PORT, "smbussim1/0/0x70/mux/4",
	    O_RDWR);
	if (!test_rm(pdf4, I2C_ADDR_7BIT, 0x42, I2C_CORE_E_OK, "tear down "
	    "device under mux (4/0x42)")) {
		ret = false;
	}

	if (!test_rm(pdf4, I2C_ADDR_7BIT, 0x42, I2C_CORE_E_UNKNOWN_ADDR,
	    "cannot remove 4/0x42 a second time on same port")) {
		ret = false;
	}
	VERIFY0(close(pdf4));

	if (!test_rm(fd, I2C_ADDR_7BIT, 0x70, I2C_CORE_E_OK, "tear down empty "
	    "mux")) {
		ret = false;
	}

	if (!test_rm(fd, I2C_ADDR_7BIT, 0x23, I2C_CORE_E_OK, "tear down device "
	    "(0x23)")) {
		ret = false;
	}
	return (ret);
}

int
main(void)
{
	int ret = EXIT_SUCCESS;
	int fd = i2c_ioctl_test_get_fd(I2C_D_PORT, "smbussim1/0", O_RDWR);

	if (!test_bad_nvlists(fd)) {
		ret = EXIT_FAILURE;
	}

	if (!test_address_conflicts(fd)) {
		ret = EXIT_FAILURE;
	}

	if (!test_compat(fd)) {
		ret = EXIT_FAILURE;
	}

	if (!test_teardown(fd)) {
		ret = EXIT_FAILURE;
	}

	VERIFY0(close(fd));
	if (ret == EXIT_SUCCESS) {
		(void) printf("All tests passed successfully\n");
	}
	return (ret);
}