xref: /illumos-gate/usr/src/cmd/pcieadm/pcieadm_link.c (revision eed8d5db49a4734bebcc457f1f146a474d020fdf)

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

/*
 * Implement logic related to the state of PCIe links. These operate on a PCIe
 * bridge (e.g. a root port) by way of the private ioctls implemented by the
 * 'pcieb' driver.
 */

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
#include <ofmt.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <strings.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/debug.h>

#include <pcieb_ioctl.h>

#include "pcieadm.h"

/*
 * Go through and initialize the common logic for most of the link related
 * commands that need to use the pcieb ioctls. This includes:
 *
 *  - Verifying it makes sense
 *  - Setting privileges
 *  - Opening the actual devctl file
 *  - Finding the dip
 */
static int
pcieadm_link_pcieb_open(pcieadm_t *pcip, const char *device, bool write)
{
	const char *drv;

	/*
	 * We retain FILE_DAC_READ and FILE_DAC_SEARCH to find and open the
	 * device file and SYS_DEVICES for the ioctls themselves. To open it for
	 * writing (some bridge ioctls, such as retrain, mutate link state) we
	 * also need FILE_DAC_WRITE to override the node's permissions, and
	 * FILE_WRITE because, unlike FILE_READ, it is stripped from our minimal
	 * privilege set.
	 */
	VERIFY0(priv_addset(pcip->pia_priv_eff, PRIV_SYS_DEVICES));
	VERIFY0(priv_addset(pcip->pia_priv_eff, PRIV_FILE_DAC_READ));
	VERIFY0(priv_addset(pcip->pia_priv_eff, PRIV_FILE_DAC_SEARCH));
	if (write) {
		VERIFY0(priv_addset(pcip->pia_priv_eff, PRIV_FILE_WRITE));
		VERIFY0(priv_addset(pcip->pia_priv_eff, PRIV_FILE_DAC_WRITE));
	}
	pcieadm_init_privs(pcip);

	pcieadm_find_dip(pcip, device);
	drv = di_driver_name(pcip->pia_devi);
	if (drv == NULL || strcmp(drv, "pcieb") != 0) {
		errx(EXIT_FAILURE, "device %s is not a PCIe bridge: found "
		    "driver %s, but expected pcieb", device,
		    drv == NULL ? "<none>" : drv);
	}

	for (di_minor_t m = di_minor_next(pcip->pia_devi, DI_MINOR_NIL);
	    m != NULL; m = di_minor_next(pcip->pia_devi, m)) {
		if (strcmp(di_minor_name(m), "devctl") == 0) {
			char buf[PATH_MAX], *mp;
			int fd;

			mp = di_devfs_minor_path(m);
			if (mp == NULL) {
				err(EXIT_FAILURE, "failed to get devfs path "
				    "for %s devctl minor", device);
			}

			if (snprintf(buf, sizeof (buf), "/devices%s", mp) >=
			    sizeof (buf)) {
				errx(EXIT_FAILURE, "failed to construct devfs "
				    "minor path for %s devctl minor: internal "
				    "path buffer would have overflowed",
				    device);
			}
			di_devfs_path_free(mp);

			if (setppriv(PRIV_SET, PRIV_EFFECTIVE,
			    pcip->pia_priv_eff) != 0) {
				err(EXIT_FAILURE, "failed to raise privileges");
			}

			fd = open(buf, write ? O_RDWR : O_RDONLY);
			if (fd < 0) {
				err(EXIT_FAILURE,
				    "failed to open %s devctl minor %s",
				    device, buf);
			}

			if (setppriv(PRIV_SET, PRIV_EFFECTIVE,
			    pcip->pia_priv_min) != 0) {
				err(EXIT_FAILURE,
				    "failed to reduce privileges");
			}

			return (fd);
		}
	}

	errx(EXIT_FAILURE, "failed to find devctl minor for %s", device);
}

static void
pcieadm_link_limit_usage(FILE *f)
{
	(void) fprintf(f, "\tlink limit\t[-s speed] -d device\n");
}

static void
pcieadm_link_limit_help(const char *fmt, ...)
{
	if (fmt != NULL) {
		va_list ap;

		va_start(ap, fmt);
		vwarnx(fmt, ap);
		va_end(ap);
		(void) fprintf(stderr, "\n");
	}

	(void) fprintf(stderr, "Usage:  %s link limit [-s speed] -d device\n",
	    pcieadm_progname);
	(void) fprintf(stderr, "Print or set the administrative limit on the "
	    "corresponding PCIe link\n\n"
	    "\t-d device\tthe PCIe bridge to operate on (driver instance,"
	    "\n\t\t\t/devices path, or b/d/f)\n"
	    "\t-s speed\tlimit the device to the specified PCIe gen/speed "
	    "(e.g.\n\t\t\t2.5, 32, gen2, gen3, etc.)\n");
}

typedef struct {
	uint32_t	pls_speed;
	const char	*pls_gts;
	const char	*pls_gen;
	const char	*pls_alt;
} pcieadm_link_speed_t;

static const pcieadm_link_speed_t pcieadm_link_speeds[] = {
	{ PCIEB_LINK_SPEED_GEN1, "2.5",  "gen1", NULL },
	{ PCIEB_LINK_SPEED_GEN2, "5.0",  "gen2", "5" },
	{ PCIEB_LINK_SPEED_GEN3, "8.0",  "gen3", "8" },
	{ PCIEB_LINK_SPEED_GEN4, "16.0", "gen4", "16" },
	{ PCIEB_LINK_SPEED_GEN5, "32.0", "gen5", "32" },
	{ PCIEB_LINK_SPEED_GEN6, "64.0", "gen6", "64" }
};

static uint32_t
pcieadm_parse_pcieb_speed(const char *str)
{
	for (uint_t i = 0; i < ARRAY_SIZE(pcieadm_link_speeds); i++) {
		const pcieadm_link_speed_t *pls = &pcieadm_link_speeds[i];

		if (strcasecmp(str, pls->pls_gts) == 0 ||
		    strcasecmp(str, pls->pls_gen) == 0 ||
		    (pls->pls_alt != NULL &&
		    strcasecmp(str, pls->pls_alt) == 0)) {
			return (pls->pls_speed);
		}
	}

	errx(EXIT_FAILURE, "failed to parse speed: %s", str);
}

static const pcieadm_link_speed_t *
pcieadm_link_speed_lookup(uint32_t speed)
{
	for (uint_t i = 0; i < ARRAY_SIZE(pcieadm_link_speeds); i++) {
		if (pcieadm_link_speeds[i].pls_speed == speed)
			return (&pcieadm_link_speeds[i]);
	}

	return (NULL);
}

static int
pcieadm_link_limit(pcieadm_t *pcip, int argc, char *argv[])
{
	int c, ret = EXIT_SUCCESS;
	const char *device = NULL, *speed = NULL;
	pcieb_ioctl_target_speed_t pits;

	while ((c = getopt(argc, argv, ":d:s:")) != -1) {
		switch (c) {
		case 'd':
			device = optarg;
			break;
		case 's':
			speed = optarg;
			break;
		case ':':
			pcieadm_link_limit_help("Option -%c requires an "
			    "argument", optopt);
			exit(EXIT_USAGE);
		case '?':
		default:
			pcieadm_link_limit_help("unknown option: -%c",
			    optopt);
			exit(EXIT_USAGE);
		}

	}

	if (device == NULL) {
		pcieadm_link_limit_help("missing required device argument "
		    "(-d)");
		exit(EXIT_USAGE);
	}

	argc -= optind;
	argv += optind;
	if (argc != 0) {
		errx(EXIT_USAGE, "encountered extraneous arguments starting "
		    "with %s", argv[0]);
	}

	int fd = pcieadm_link_pcieb_open(pcip, device, speed != NULL);
	bzero(&pits, sizeof (pits));

	if (speed != NULL) {
		pits.pits_speed = pcieadm_parse_pcieb_speed(speed);

		if (setppriv(PRIV_SET, PRIV_EFFECTIVE, pcip->pia_priv_eff) != 0)
			err(EXIT_FAILURE, "failed to raise privileges");

		if (ioctl(fd, PCIEB_IOCTL_SET_TARGET_SPEED, &pits) != 0) {
			err(EXIT_FAILURE, "failed to set %s target speed",
			    device);
		}

		if (setppriv(PRIV_SET, PRIV_EFFECTIVE, pcip->pia_priv_min) != 0)
			err(EXIT_FAILURE, "failed to reduce privileges");
	} else {
		const pcieadm_link_speed_t *pls;

		if (setppriv(PRIV_SET, PRIV_EFFECTIVE, pcip->pia_priv_eff) != 0)
			err(EXIT_FAILURE, "failed to raise privileges");

		if (ioctl(fd, PCIEB_IOCTL_GET_TARGET_SPEED, &pits) != 0) {
			err(EXIT_FAILURE, "failed to get %s target speed",
			    device);
		}

		if (setppriv(PRIV_SET, PRIV_EFFECTIVE, pcip->pia_priv_min) != 0)
			err(EXIT_FAILURE, "failed to reduce privileges");

		pls = pcieadm_link_speed_lookup(pits.pits_speed);
		if (pls != NULL) {
			(void) printf("Target speed: %s GT/s (%s)\n",
			    pls->pls_gts, pls->pls_gen);
		} else {
			(void) printf("Target speed: unknown speed value: "
			    "0x%x\n", pits.pits_speed);
		}

		if ((pits.pits_flags & ~PCIEB_FLAGS_ADMIN_SET) != 0) {
			(void) printf("Unknown flags: 0x%x\n", pits.pits_flags);
		} else if ((pits.pits_flags & PCIEB_FLAGS_ADMIN_SET) != 0) {
			(void) printf("Flags: Admin Set Speed\n");
		}
	}

	VERIFY0(close(fd));
	return (ret);
}

static void
pcieadm_link_retrain_usage(FILE *f)
{
	(void) fprintf(f, "\tlink retrain\t-d device\n");
}

static void
pcieadm_link_retrain_help(const char *fmt, ...)
{
	if (fmt != NULL) {
		va_list ap;

		va_start(ap, fmt);
		vwarnx(fmt, ap);
		va_end(ap);
		(void) fprintf(stderr, "\n");
	}

	(void) fprintf(stderr, "Usage:  %s link retrain -d device\n",
	    pcieadm_progname);
	(void) fprintf(stderr,
	    "Retrain the link on the specified upstream port by requesting\n"
	    "it via the PCIe Link Control register.\n\n"
	    "\t-d device\tthe PCIe bridge to operate on (driver instance,\n"
	    "\t\t\t/devices path, or b/d/f)\n");
}

static int
pcieadm_link_retrain(pcieadm_t *pcip, int argc, char *argv[])
{
	int c, ret = EXIT_SUCCESS;
	const char *device = NULL;

	while ((c = getopt(argc, argv, ":d:")) != -1) {
		switch (c) {
		case 'd':
			device = optarg;
			break;
		case ':':
			pcieadm_link_retrain_help("Option -%c requires an "
			    "argument", optopt);
			exit(EXIT_USAGE);
		case '?':
		default:
			pcieadm_link_retrain_help("unknown option: -%c",
			    optopt);
			exit(EXIT_USAGE);
		}
	}

	if (device == NULL) {
		pcieadm_link_retrain_help("missing required device argument "
		    "(-d)");
		exit(EXIT_USAGE);
	}

	argc -= optind;
	argv += optind;
	if (argc != 0) {
		errx(EXIT_USAGE, "encountered extraneous arguments starting "
		    "with %s", argv[0]);
	}

	int fd = pcieadm_link_pcieb_open(pcip, device, true);

	if (setppriv(PRIV_SET, PRIV_EFFECTIVE, pcip->pia_priv_eff) != 0)
		err(EXIT_FAILURE, "failed to raise privileges");

	if (ioctl(fd, PCIEB_IOCTL_RETRAIN) != 0) {
		err(EXIT_FAILURE, "failed to retrain link %s", device);
	}

	if (setppriv(PRIV_SET, PRIV_EFFECTIVE, pcip->pia_priv_min) != 0)
		err(EXIT_FAILURE, "failed to reduce privileges");

	VERIFY0(close(fd));
	return (ret);
}

static const pcieadm_cmdtab_t pcieadm_cmds_link[] = {
	{ "limit", pcieadm_link_limit, pcieadm_link_limit_usage },
	{ "retrain", pcieadm_link_retrain, pcieadm_link_retrain_usage },
	{ NULL }
};

int
pcieadm_link(pcieadm_t *pcip, int argc, char *argv[])
{
	return (pcieadm_walk_tab(pcip, pcieadm_cmds_link, argc, argv));
}

void
pcieadm_link_usage(FILE *f)
{
	pcieadm_walk_usage(pcieadm_cmds_link, f);
}