xref: /illumos-gate/usr/src/cmd/amdzen/amdzen_common.c (revision dde6d5134333279b60915f237b5c04f4472bb385)

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

/*
 * Utility functions common to amdzen commands.
 */

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <libdevinfo.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "amdzen_common.h"

/*
 * Traditionally we expected to be given the path to a character device file
 * somewhere under /devices, where the device minor referred to a specific
 * data fabric (DF) instance. It is often more convenient to be able to give
 * a higher-level identifier instead, such as a DF number, optionally
 * prefixed with the driver name. This function distinguishes between the
 * two cases by attempting to parse the argument as a DF identifier. If that
 * succeeds, we map it to the corresponding minor of the named driver and
 * open that, otherwise the argument is treated as a device path and opened
 * directly. Either way the caller receives an open file descriptor, or -1
 * after a warning has been issued.
 */
int
amdzen_open_device(const char *driver, const char *arg, int oflag)
{
	struct stat st;
	di_node_t root, node;
	di_minor_t minor;
	const char *errstr, *id;
	char mname[64];
	char *bpath, *path;
	size_t drvlen;
	int df, fd;

	/* If there is a driver prefix provided, accept and remove it */
	id = arg;
	drvlen = strlen(driver);
	if (strncmp(id, driver, drvlen) == 0)
		id += drvlen;

	df = (int)strtonumx(id, 0, INT_MAX, &errstr, 0);
	if (errstr != NULL) {
		/* Not a DF identifier, so treat it as a device path */
		if ((fd = open(arg, oflag)) < 0) {
			warn("failed to open %s", arg);
			return (-1);
		}
		if (fstat(fd, &st) != 0) {
			warn("failed to stat %s", arg);
			(void) close(fd);
			return (-1);
		}
		if (!S_ISCHR(st.st_mode)) {
			warnx("%s is not a character device", arg);
			(void) close(fd);
			return (-1);
		}
		return (fd);
	}

	root = di_init_driver(driver, DINFOSUBTREE | DINFOMINOR);
	if (root == DI_NODE_NIL) {
		warn("failed to take a devinfo snapshot with %s attached",
		    driver);
		return (-1);
	}

	/* These are all single-instance drivers with one minor per DF */
	node = di_drv_first_node(driver, root);
	if (node == DI_NODE_NIL) {
		warnx("failed to find a devinfo node for %s", driver);
		di_fini(root);
		return (-1);
	}

	(void) snprintf(mname, sizeof (mname), "%s.%d", driver, df);
	minor = DI_MINOR_NIL;
	while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {
		if (strcmp(di_minor_name(minor), mname) == 0)
			break;
	}
	if (minor == DI_MINOR_NIL) {
		warnx("failed to find minor %s on %s%d -- no such DF?",
		    mname, di_driver_name(node), di_instance(node));
		di_fini(root);
		return (-1);
	}

	bpath = di_devfs_minor_path(minor);
	if (bpath == NULL) {
		warn("failed to get minor path for %s%d:%s",
		    di_driver_name(node), di_instance(node),
		    di_minor_name(minor));
		di_fini(root);
		return (-1);
	}
	if (asprintf(&path, "/devices%s", bpath) < 0) {
		warn("failed to construct full path for %s", bpath);
		di_devfs_path_free(bpath);
		di_fini(root);
		return (-1);
	}
	di_devfs_path_free(bpath);
	di_fini(root);

	if ((fd = open(path, oflag)) < 0)
		warn("failed to open %s", path);
	free(path);

	return (fd);
}