xref: /illumos-gate/usr/src/lib/fm/topo/libtopo/common/pcie.c (revision 84ceaea936ebcf122d4f0756d298adf307fd491d)

/*
 * 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 provides the basic mechanisms for dealing with the pcie schema. A pcie
 * FMRI has the form:
 *
 *     pcie:///cpu=C[/root-complex=R[function=F[...]]]
 *
 * That is to say that the top level nodes represent physical CPUs in the
 * system and their PCIe root complexes are enumerated directly under that.
 *
 * Each node inherits the FMRI of its parent, and then appends a new
 * '/<type>=<instance>' part, for example:
 *
 *     pcie:///cpu=0
 *     pcie:///cpu=0/root-complex=0
 *     pcie:///cpu=0/root-complex=0/function=0
 *     pcie:///cpu=0/root-complex=0/function=0/port=0
 *
 * Types used in the scheme are:
 *	cpu
 *	root-complex
 *	device
 *	function
 *	port
 *	link
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdbool.h>
#include <ctype.h>
#include <alloca.h>
#include <limits.h>
#include <fm/topo_mod.h>
#include <sys/param.h>
#include <sys/systeminfo.h>
#include <sys/fm/protocol.h>
#include <sys/stat.h>

#include <topo_method.h>
#include <topo_subr.h>
#include <pthread.h>

#include <pcie.h>

static size_t
fmri_nvl2str(nvlist_t *nvl, char *buf, size_t buflen)
{
	size_t size = 0;
	uint8_t version;
	nvlist_t **plist;
	uint_t nplist;
	int err;

	if (nvlist_lookup_uint8(nvl, FM_VERSION, &version) != 0 ||
	    version > FM_PCIE_SCHEME_VERSION) {
		return (0);
	}

	if (!topo_fmristr_build(&size, buf, buflen, FM_FMRI_SCHEME_PCIE, NULL,
	    ":///")) {
		return (0);
	}

	err = nvlist_lookup_nvlist_array(nvl, FM_FMRI_PCIE_LIST,
	    &plist, &nplist);
	if (err != 0 || plist == NULL)
		return (0);

	for (uint_t i = 0; i < nplist; i++) {
		char *name = NULL;
		char *id = NULL;

		if (i > 0) {
			if (!topo_fmristr_build(&size, buf, buflen, "/", NULL,
			    NULL)) {
				return (0);
			}
		}
		if (nvlist_lookup_string(plist[i],
		    FM_FMRI_PCIE_NAME, &name) != 0 ||
		    nvlist_lookup_string(plist[i],
		    FM_FMRI_PCIE_ID, &id) != 0) {
			return (0);
		}
		if (name == NULL || id == NULL)
			return (0);
		if (!topo_fmristr_build(&size, buf, buflen, "=", name, id))
			return (0);
	}

	return (size);
}

static int
pcie_fmri_nvl2str(topo_mod_t *mod, tnode_t *node, topo_version_t version,
    nvlist_t *nvl, nvlist_t **out)
{
	size_t len;
	char *name = NULL;
	nvlist_t *fmristr;

	if (version > TOPO_METH_NVL2STR_VERSION)
		return (topo_mod_seterrno(mod, EMOD_VER_NEW));

	if ((len = fmri_nvl2str(nvl, NULL, 0)) == 0)
		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));

	if ((name = topo_mod_alloc(mod, len + 1)) == NULL)
		return (topo_mod_seterrno(mod, EMOD_NOMEM));

	if (fmri_nvl2str(nvl, name, len + 1) == 0) {
		topo_mod_free(mod, name, len + 1);
		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
	}

	if (topo_mod_nvalloc(mod, &fmristr, NV_UNIQUE_NAME) != 0) {
		topo_mod_free(mod, name, len + 1);
		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
	}
	if (nvlist_add_string(fmristr, "fmri-string", name) != 0) {
		topo_mod_free(mod, name, len + 1);
		nvlist_free(fmristr);
		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
	}
	topo_mod_free(mod, name, len + 1);
	*out = fmristr;

	return (0);
}

static nvlist_t *
fmri_create_err(topo_mod_t *mod, nvlist_t **list, uint_t elems,
    nvlist_t *fmri, int err)
{
	if (list != NULL) {
		for (uint_t i = 0; i < elems; i++)
			nvlist_free(list[i]);

		topo_mod_free(mod, list, sizeof (nvlist_t *) * elems);
	}

	nvlist_free(fmri);

	(void) topo_mod_seterrno(mod, err);

	topo_mod_dprintf(mod, "unable to create pcie FMRI: %s\n",
	    topo_mod_errmsg(mod));

	return (NULL);
}

static nvlist_t *
fmri_create_component(topo_mod_t *mod, const char *name, topo_instance_t inst)
{
	char str[21]; /* decimal representation of UINT64_MAX + '\0' */
	nvlist_t *comp;

	if (topo_mod_nvalloc(mod, &comp, NV_UNIQUE_NAME) != 0)
		return (NULL);

	(void) snprintf(str, sizeof (str), "%" PRIu64, inst);

	if (nvlist_add_string(comp, FM_FMRI_PCIE_NAME, name) != 0 ||
	    nvlist_add_string(comp, FM_FMRI_PCIE_ID, str) != 0) {
		nvlist_free(comp);
		return (NULL);
	}

	return (comp);
}

static nvlist_t *
fmri_create(topo_mod_t *mod, nvlist_t *pfmri, const char *name,
    topo_instance_t inst, nvlist_t *auth)
{
	nvlist_t **pplist = NULL;
	nvlist_t **plist = NULL;
	nvlist_t *fmri = NULL;
	uint_t pelems = 0, elems;
	uint_t i;

	/*
	 * This FMRI will be constructed from the FMRI of the parent, with a
	 * new path component (name=inst) after it. We copy the parent's
	 * property list to this node, and then add our new property to the
	 * end.
	 */

	/* Retrieve the parent's property list */
	if (pfmri != NULL) {
		if (nvlist_lookup_nvlist_array(pfmri, FM_FMRI_PCIE_LIST,
		    &pplist, &pelems) != 0) {
			return (fmri_create_err(mod, plist, pelems, fmri,
			    EMOD_FMRI_MALFORM));
		}
	}

	/* We want space for an extra entry in the new FMRI's property list */
	elems = pelems + 1;

	plist = topo_mod_zalloc(mod, sizeof (nvlist_t *) * elems);
	if (plist == NULL) {
		return (fmri_create_err(mod, plist, elems, fmri,
		    ETOPO_FMRI_NOMEM));
	}

	/* Copy the parent properties */
	for (i = 0; i < pelems; i++) {
		if (topo_mod_nvdup(mod, pplist[i], &plist[i]) != 0) {
			return (fmri_create_err(mod, plist, elems, fmri,
			    EMOD_FMRI_NVL));
		}
	}

	/* Add the new path component */
	if ((plist[i] = fmri_create_component(mod, name, inst)) == NULL) {
		return (fmri_create_err(mod, plist, elems, fmri,
		    EMOD_FMRI_NVL));
	}

	/* Create the fmri */
	if (topo_mod_nvalloc(mod, &fmri, NV_UNIQUE_NAME) != 0) {
		return (fmri_create_err(mod, plist, elems, fmri,
		    EMOD_FMRI_NVL));
	}

	if (nvlist_add_uint8(fmri, FM_VERSION, FM_PCIE_SCHEME_VERSION) ||
	    nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_PCIE)) {
		return (fmri_create_err(mod, plist, elems, fmri,
		    EMOD_FMRI_NVL));
	}

	/* Add the new property list */
	if (nvlist_add_nvlist_array(fmri, FM_FMRI_PCIE_LIST,
	    plist, elems) != 0) {
		return (fmri_create_err(mod, plist, elems, fmri,
		    EMOD_FMRI_NVL));
	}

	if (auth != NULL)
		(void) nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY, auth);

	if (plist != NULL) {
		for (uint_t i = 0; i < elems; i++)
			nvlist_free(plist[i]);
		topo_mod_free(mod, plist, sizeof (nvlist_t *) * elems);
	}

	return (fmri);
}

static int
pcie_fmri_create_meth(topo_mod_t *mod, tnode_t *tnode, topo_version_t version,
    nvlist_t *in, nvlist_t **out)
{
	char *name;
	topo_instance_t inst;
	nvlist_t *args, *auth = NULL, *pfmri = NULL;
	int ret;

	if (version > TOPO_METH_FMRI_VERSION)
		return (topo_mod_seterrno(mod, EMOD_VER_NEW));

	if (nvlist_lookup_string(in, TOPO_METH_FMRI_ARG_NAME, &name) != 0 ||
	    nvlist_lookup_uint64(in, TOPO_METH_FMRI_ARG_INST, &inst) != 0) {
		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
	}

	if ((ret = nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_NVL,
	    &args)) != 0) {
		if (ret != ENOENT)
			return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
	} else {
		(void) nvlist_lookup_nvlist(args, TOPO_METH_FMRI_ARG_PARENT,
		    &pfmri);
		(void) nvlist_lookup_nvlist(args, TOPO_METH_FMRI_ARG_AUTH,
		    &auth);
	}

	*out = fmri_create(mod, pfmri, name, inst, auth);
	if (*out == NULL)
		return (-1);

	return (0);
}

const topo_method_t pcie_methods[] = {
	{
		.tm_name = TOPO_METH_NVL2STR,
		.tm_desc = TOPO_METH_NVL2STR_DESC,
		.tm_version = TOPO_METH_NVL2STR_VERSION,
		.tm_stability = TOPO_STABILITY_INTERNAL,
		.tm_func = pcie_fmri_nvl2str
	},
	{
		.tm_name = TOPO_METH_FMRI,
		.tm_desc = TOPO_METH_FMRI_DESC,
		.tm_version = TOPO_METH_FMRI_VERSION,
		.tm_stability = TOPO_STABILITY_INTERNAL,
		.tm_func = pcie_fmri_create_meth
	},
	{ NULL }
};

int
pcie_enum(topo_mod_t *mod, tnode_t *pnode, const char *name,
    topo_instance_t min, topo_instance_t max, void *u1 __unused,
    void *u2 __unused)
{
	topo_mod_dprintf(mod, "enumerating pcie: %s (%"PRIu64" - %"PRIu64")",
	    name, min, max);

	(void) topo_method_register(mod, pnode, pcie_methods);
	return (0);
}

static void
pcie_rele(topo_mod_t *mp, tnode_t *node)
{
	topo_method_unregister_all(mp, node);
}

static const topo_modops_t pcie_ops = {
	.tmo_enum = pcie_enum,
	.tmo_release = pcie_rele
};

static const topo_modinfo_t pcie_info = {
	.tmi_desc = PCIE,
	.tmi_scheme = FM_FMRI_SCHEME_PCIE,
	.tmi_version = PCIE_VERSION,
	.tmi_ops = &pcie_ops
};

int
pcie_init(topo_mod_t *mod, topo_version_t version)
{
	if (getenv("TOPOPCIEDEBUG"))
		topo_mod_setdebug(mod);

	topo_mod_dprintf(mod, "initializing pcie builtin");

	if (version != PCIE_VERSION)
		return (topo_mod_seterrno(mod, EMOD_VER_NEW));

	if (topo_mod_register(mod, &pcie_info, TOPO_VERSION) != 0) {
		topo_mod_dprintf(mod, "failed to register pcie: %s",
		    topo_mod_errmsg(mod));
		return (-1); /* mod errno already set */
	}

	return (0);
}

void
pcie_fini(topo_mod_t *mod)
{
	topo_mod_unregister(mod);
}