int
topo_fmri_unusable(topo_hdl_t *thp, nvlist_t *fmri, int *err)
{
char *scheme;
uint32_t unusable = 0;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_UNUSABLE, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_UNUSABLE, out));
if (topo_method_invoke(rnode, TOPO_METH_UNUSABLE,
TOPO_METH_UNUSABLE_VERSION, fmri, &out, err) < 0)
return (set_error(thp, *err, err, TOPO_METH_UNUSABLE, out));
(void) nvlist_lookup_uint32(out, TOPO_METH_UNUSABLE_RET, &unusable);
nvlist_free(out);
return (unusable);
}
int
topo_fmri_replaced(topo_hdl_t *thp, nvlist_t *fmri, int *err)
{
uint32_t replaced = FMD_OBJ_STATE_NOT_PRESENT;
char *scheme;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_REPLACED, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_REPLACED, out));
if (topo_method_invoke(rnode, TOPO_METH_REPLACED,
TOPO_METH_REPLACED_VERSION, fmri, &out, err) < 0) {
(void) set_error(thp, *err, err, TOPO_METH_REPLACED, out);
return (FMD_OBJ_STATE_UNKNOWN);
}
(void) nvlist_lookup_uint32(out, TOPO_METH_REPLACED_RET, &replaced);
nvlist_free(out);
return (replaced);
}
int
topo_fmri_contains(topo_hdl_t *thp, nvlist_t *fmri, nvlist_t *subfmri, int *err)
{
uint32_t contains;
char *scheme;
nvlist_t *in = NULL, *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_CONTAINS, NULL));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_CONTAINS, NULL));
if (topo_hdl_nvalloc(thp, &in, NV_UNIQUE_NAME) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err, TOPO_METH_CONTAINS,
NULL));
if (nvlist_add_nvlist(in, TOPO_METH_FMRI_ARG_FMRI, fmri) != 0 ||
nvlist_add_nvlist(in, TOPO_METH_FMRI_ARG_SUBFMRI, subfmri) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err, TOPO_METH_CONTAINS,
in));
if (topo_method_invoke(rnode, TOPO_METH_CONTAINS,
TOPO_METH_CONTAINS_VERSION, in, &out, err) < 0)
return (set_error(thp, *err, err, TOPO_METH_CONTAINS, in));
(void) nvlist_lookup_uint32(out, TOPO_METH_CONTAINS_RET, &contains);
nvlist_free(in);
nvlist_free(out);
return (contains);
}
int
topo_fmri_present(topo_hdl_t *thp, nvlist_t *fmri, int *err)
{
uint32_t present = 0;
char *scheme;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_PRESENT, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_PRESENT, out));
if (topo_method_invoke(rnode, TOPO_METH_PRESENT,
TOPO_METH_PRESENT_VERSION, fmri, &out, err) < 0) {
(void) set_error(thp, *err, err, TOPO_METH_PRESENT, out);
return (present);
}
(void) nvlist_lookup_uint32(out, TOPO_METH_PRESENT_RET, &present);
nvlist_free(out);
return (present);
}
int
topo_fmri_service_state(topo_hdl_t *thp, nvlist_t *fmri, int *err)
{
char *scheme;
uint32_t service_state = FMD_SERVICE_STATE_UNKNOWN;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_SERVICE_STATE, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_SERVICE_STATE, out));
if (topo_method_invoke(rnode, TOPO_METH_SERVICE_STATE,
TOPO_METH_SERVICE_STATE_VERSION, fmri, &out, err) < 0)
return (set_error(thp, *err, err, TOPO_METH_SERVICE_STATE,
out));
(void) nvlist_lookup_uint32(out, TOPO_METH_SERVICE_STATE_RET,
&service_state);
nvlist_free(out);
return (service_state);
}
int
topo_fmri_nvl2str(topo_hdl_t *thp, nvlist_t *fmri, char **fmristr, int *err)
{
char *scheme, *str;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_NVL2STR, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_NVL2STR, out));
if (topo_method_invoke(rnode, TOPO_METH_NVL2STR,
TOPO_METH_NVL2STR_VERSION, fmri, &out, err) != 0)
return (set_error(thp, *err, err, TOPO_METH_NVL2STR, out));
if (out == NULL || nvlist_lookup_string(out, "fmri-string", &str) != 0)
return (set_error(thp, ETOPO_METHOD_INVAL, err,
TOPO_METH_NVL2STR, out));
if ((*fmristr = topo_hdl_strdup(thp, str)) == NULL)
return (set_error(thp, ETOPO_NOMEM, err,
TOPO_METH_NVL2STR, out));
nvlist_free(out);
return (0);
}
int
topo_fmri_unretire(topo_hdl_t *thp, nvlist_t *fmri, int *err)
{
char *scheme;
uint32_t status;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_UNRETIRE, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_UNRETIRE, out));
if (topo_method_invoke(rnode, TOPO_METH_UNRETIRE,
TOPO_METH_UNRETIRE_VERSION, fmri, &out, err) < 0)
return (set_error(thp, *err, err, TOPO_METH_UNRETIRE, out));
if (nvlist_lookup_uint32(out, TOPO_METH_UNRETIRE_RET, &status) != 0) {
nvlist_free(out);
return (set_error(thp, ETOPO_METHOD_FAIL, err,
TOPO_METH_UNRETIRE, out));
}
nvlist_free(out);
return (status);
}
int
topo_fmri_contains(topo_hdl_t *thp, nvlist_t *fmri, nvlist_t *subfmri, int *err)
{
int rc;
char *scheme;
nvlist_t *in, *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_CONTAINS, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_CONTAINS, out));
if (topo_hdl_nvalloc(thp, &in, NV_UNIQUE_NAME) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err, TOPO_METH_CONTAINS,
out));
if (nvlist_add_nvlist(in, "fmri", fmri) != 0 ||
nvlist_add_nvlist(in, "subfmri", subfmri) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err, TOPO_METH_CONTAINS,
out));
if (topo_hdl_nvalloc(thp, &out, NV_UNIQUE_NAME) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err, TOPO_METH_CONTAINS,
out));
if ((rc = topo_method_invoke(rnode, TOPO_METH_CONTAINS,
TOPO_METH_CONTAINS_VERSION, fmri, &out, err)) < 0)
return (set_error(thp, *err, err, TOPO_METH_CONTAINS, out));
return (rc);
}
/*ARGSUSED*/
static int
label_set(tnode_t *tn, did_t *pd,
const char *dpnm, const char *tpgrp, const char *tpnm)
{
topo_mod_t *mp;
nvlist_t *in, *out;
char *label;
int err;
mp = did_mod(pd);
/*
* If this is a PCIEX_BUS and its parent is a PCIEX_ROOT,
* check for a CPUBOARD predecessor. If found, inherit its
* parent's Label. Otherwise, continue with label set.
*/
if ((strcmp(topo_node_name(tn), PCIEX_BUS) == 0) &&
(strcmp(topo_node_name(topo_node_parent(tn)), PCIEX_ROOT) == 0)) {
if (use_predecessor_label(mp, tn, CPUBOARD) == 0)
return (0);
}
if (topo_mod_nvalloc(mp, &in, NV_UNIQUE_NAME) != 0)
return (topo_mod_seterrno(mp, EMOD_FMRI_NVL));
if (nvlist_add_uint64(in, TOPO_METH_LABEL_ARG_NVL, (uintptr_t)pd) !=
0) {
nvlist_free(in);
return (topo_mod_seterrno(mp, EMOD_NOMEM));
}
if (topo_method_invoke(tn,
TOPO_METH_LABEL, TOPO_METH_LABEL_VERSION, in, &out, &err) != 0) {
nvlist_free(in);
return (topo_mod_seterrno(mp, err));
}
nvlist_free(in);
if (out != NULL &&
nvlist_lookup_string(out, TOPO_METH_LABEL_RET_STR, &label) == 0) {
if (topo_prop_set_string(tn, TOPO_PGROUP_PROTOCOL,
TOPO_PROP_LABEL, TOPO_PROP_IMMUTABLE, label, &err) != 0) {
nvlist_free(out);
return (topo_mod_seterrno(mp, err));
}
nvlist_free(out);
}
return (0);
}
static int
fmri_prop(topo_hdl_t *thp, nvlist_t *rsrc, const char *pgname,
const char *pname, nvlist_t *args, nvlist_t **prop,
int *err)
{
int rv;
nvlist_t *in = NULL;
tnode_t *rnode;
char *scheme;
if (nvlist_lookup_string(rsrc, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_PROP_GET, in));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_PROP_GET, in));
if (topo_hdl_nvalloc(thp, &in, NV_UNIQUE_NAME) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_PROP_GET, in));
rv = nvlist_add_nvlist(in, TOPO_PROP_RESOURCE, rsrc);
rv |= nvlist_add_string(in, TOPO_PROP_GROUP, pgname);
rv |= nvlist_add_string(in, TOPO_PROP_VAL_NAME, pname);
if (args != NULL)
rv |= nvlist_add_nvlist(in, TOPO_PROP_PARGS, args);
if (rv != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_PROP_GET, in));
*prop = NULL;
rv = topo_method_invoke(rnode, TOPO_METH_PROP_GET,
TOPO_METH_PROP_GET_VERSION, in, prop, err);
nvlist_free(in);
if (rv != 0)
return (-1); /* *err is set for us */
if (*prop == NULL)
return (set_error(thp, ETOPO_PROP_NOENT, err,
TOPO_METH_PROP_GET, NULL));
return (0);
}
int topo_fmri_setprop(topo_hdl_t *thp, nvlist_t *nvl, const char *pg,
nvlist_t *prop, int flag, nvlist_t *args, int *err)
{
int rv;
nvlist_t *in = NULL, *out = NULL;
tnode_t *rnode;
char *scheme;
if (nvlist_lookup_string(nvl, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_PROP_SET, in));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_PROP_SET, in));
if (topo_hdl_nvalloc(thp, &in, NV_UNIQUE_NAME) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_PROP_SET, in));
rv = nvlist_add_nvlist(in, TOPO_PROP_RESOURCE, nvl);
rv |= nvlist_add_string(in, TOPO_PROP_GROUP, pg);
rv |= nvlist_add_nvlist(in, TOPO_PROP_VAL, prop);
rv |= nvlist_add_int32(in, TOPO_PROP_FLAG, (int32_t)flag);
if (args != NULL)
rv |= nvlist_add_nvlist(in, TOPO_PROP_PARGS, args);
if (rv != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_PROP_SET, in));
rv = topo_method_invoke(rnode, TOPO_METH_PROP_SET,
TOPO_METH_PROP_SET_VERSION, in, &out, err);
nvlist_free(in);
/* no return values */
nvlist_free(out);
if (rv)
return (-1);
return (0);
}
int
topo_fmri_compare(topo_hdl_t *thp, nvlist_t *f1, nvlist_t *f2, int *err)
{
uint32_t compare;
char *scheme1, *scheme2;
nvlist_t *in;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(f1, FM_FMRI_SCHEME, &scheme1) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_COMPARE, NULL));
if (nvlist_lookup_string(f2, FM_FMRI_SCHEME, &scheme2) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_COMPARE, NULL));
if (strcmp(scheme1, scheme2) != 0)
return (0);
if ((rnode = topo_hdl_root(thp, scheme1)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_COMPARE, NULL));
if (topo_hdl_nvalloc(thp, &in, NV_UNIQUE_NAME) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err, TOPO_METH_COMPARE,
NULL));
if (nvlist_add_nvlist(in, TOPO_METH_FMRI_ARG_NV1, f1) != 0 ||
nvlist_add_nvlist(in, TOPO_METH_FMRI_ARG_NV2, f2) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err, TOPO_METH_COMPARE,
in));
if (topo_method_invoke(rnode, TOPO_METH_COMPARE,
TOPO_METH_COMPARE_VERSION, in, &out, err) < 0)
return (set_error(thp, *err, err, TOPO_METH_COMPARE, in));
(void) nvlist_lookup_uint32(out, TOPO_METH_COMPARE_RET, &compare);
nvlist_free(out);
nvlist_free(in);
return (compare);
}
int
topo_fmri_str2nvl(topo_hdl_t *thp, const char *fmristr, nvlist_t **fmri,
int *err)
{
char *f, buf[PATH_MAX];
nvlist_t *out = NULL, *in = NULL;
tnode_t *rnode;
(void) strlcpy(buf, fmristr, sizeof (buf));
if ((f = strchr(buf, ':')) == NULL)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_STR2NVL, in));
*f = '\0'; /* strip trailing FMRI path */
if ((rnode = topo_hdl_root(thp, buf)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_STR2NVL, in));
if (topo_hdl_nvalloc(thp, &in, NV_UNIQUE_NAME) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err, TOPO_METH_STR2NVL,
in));
if (nvlist_add_string(in, "fmri-string", fmristr) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err, TOPO_METH_STR2NVL,
in));
if (topo_method_invoke(rnode, TOPO_METH_STR2NVL,
TOPO_METH_STR2NVL_VERSION, in, &out, err) != 0)
return (set_error(thp, *err, err, TOPO_METH_STR2NVL, in));
nvlist_free(in);
if (out == NULL ||
topo_hdl_nvdup(thp, out, fmri) != 0)
return (set_error(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_STR2NVL, out));
nvlist_free(out);
return (0);
}
int
topo_fmri_expand(topo_hdl_t *thp, nvlist_t *fmri, int *err)
{
char *scheme;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_EXPAND, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_EXPAND, out));
if (topo_method_invoke(rnode, TOPO_METH_EXPAND,
TOPO_METH_EXPAND_VERSION, fmri, &out, err) != 0)
return (set_error(thp, *err, err, TOPO_METH_EXPAND, out));
return (0);
}
/*ARGSUSED*/
static int
fac_walker(topo_hdl_t *thp, tnode_t *node, void *arg)
{
int err;
nvlist_t *out;
if (topo_method_supported(node, TOPO_METH_FAC_ENUM, 0)) {
/*
* If the facility enumeration method fails, note the failure,
* but continue on with the walk.
*/
if (topo_method_invoke(node, TOPO_METH_FAC_ENUM, 0, NULL, &out,
&err) != 0) {
topo_dprintf(thp, TOPO_DBG_ERR,
"facility enumeration method failed on node %s=%d "
"(%s)\n", topo_node_name(node),
topo_node_instance(node), topo_strerror(err));
}
}
return (TOPO_WALK_NEXT);
}
int
topo_fmri_unusable(topo_hdl_t *thp, nvlist_t *fmri, int *err)
{
int rc;
char *scheme;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_UNUSABLE, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_UNUSABLE, out));
if ((rc = topo_method_invoke(rnode, TOPO_METH_UNUSABLE,
TOPO_METH_UNUSABLE_VERSION, fmri, &out, err)) < 0)
return (set_error(thp, *err, err, TOPO_METH_UNUSABLE, out));
return (rc);
}
/*
* topo_fmri_create
*
* If possible, creates an FMRI of the requested version in the
* requested scheme. Args are passed as part of the inputs to the
* fmri-create method of the scheme.
*/
nvlist_t *
topo_fmri_create(topo_hdl_t *thp, const char *scheme, const char *name,
topo_instance_t inst, nvlist_t *nvl, int *err)
{
nvlist_t *ins;
nvlist_t *out;
tnode_t *rnode;
ins = out = NULL;
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_nverror(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_FMRI, NULL));
if ((*err = topo_hdl_nvalloc(thp, &ins, NV_UNIQUE_NAME)) != 0)
return (set_nverror(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_FMRI, NULL));
if (nvlist_add_string(ins, TOPO_METH_FMRI_ARG_NAME, name) != 0 ||
nvlist_add_uint32(ins, TOPO_METH_FMRI_ARG_INST, inst) != 0) {
return (set_nverror(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_FMRI, ins));
}
if (nvl != NULL &&
nvlist_add_nvlist(ins, TOPO_METH_FMRI_ARG_NVL, nvl) != 0) {
return (set_nverror(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_FMRI, ins));
}
if (topo_method_invoke(rnode,
TOPO_METH_FMRI, TOPO_METH_FMRI_VERSION, ins, &out, err) != 0) {
return (set_nverror(thp, *err, err, TOPO_METH_FMRI, ins));
}
nvlist_free(ins);
return (out);
}
/*ARGSUSED*/
static int
FRU_set(tnode_t *tn, did_t *pd,
const char *dpnm, const char *tpgrp, const char *tpnm)
{
topo_mod_t *mp;
char *nm;
int e = 0, err = 0;
nm = topo_node_name(tn);
mp = did_mod(pd);
/*
* If this is a PCIEX_BUS and its parent is a PCIEX_ROOT,
* check for a CPUBOARD predecessor. If found, inherit its
* parent's FRU. Otherwise, continue with FRU set.
*/
if ((strcmp(nm, PCIEX_BUS) == 0) &&
(strcmp(topo_node_name(topo_node_parent(tn)), PCIEX_ROOT) == 0)) {
if (use_predecessor_fru(tn, CPUBOARD) == 0)
return (0);
}
/*
* If this topology node represents something other than an
* ioboard or a device that implements a slot, inherit the
* parent's FRU value. If there is no label, inherit our
* parent's FRU value. Otherwise, munge up an fmri based on
* the label.
*/
if (strcmp(nm, IOBOARD) != 0 && strcmp(nm, PCI_DEVICE) != 0 &&
strcmp(nm, PCIEX_DEVICE) != 0 && strcmp(nm, PCIEX_BUS) != 0) {
(void) topo_node_fru_set(tn, NULL, 0, &e);
return (0);
}
/*
* If ioboard, set fru fmri to hc fmri
*/
if (strcmp(nm, IOBOARD) == 0) {
e = FRU_fmri_set(mp, tn);
return (e);
} else if (strcmp(nm, PCI_DEVICE) == 0 ||
strcmp(nm, PCIEX_DEVICE) == 0 || strcmp(nm, PCIEX_BUS) == 0) {
nvlist_t *in, *out;
mp = did_mod(pd);
if (topo_mod_nvalloc(mp, &in, NV_UNIQUE_NAME) != 0)
return (topo_mod_seterrno(mp, EMOD_FMRI_NVL));
if (nvlist_add_uint64(in, "nv1", (uintptr_t)pd) != 0) {
nvlist_free(in);
return (topo_mod_seterrno(mp, EMOD_NOMEM));
}
if (topo_method_invoke(tn,
TOPO_METH_FRU_COMPUTE, TOPO_METH_FRU_COMPUTE_VERSION,
in, &out, &err) != 0) {
nvlist_free(in);
return (topo_mod_seterrno(mp, err));
}
nvlist_free(in);
(void) topo_node_fru_set(tn, out, 0, &err);
if (out != NULL)
nvlist_free(out);
} else
(void) topo_node_fru_set(tn, NULL, 0, &err);
return (0);
}
/*
* Create a generic topo node based on the hcfmri strcuture passed in.
*/
int
x86pi_enum_generic(topo_mod_t *mod, x86pi_hcfmri_t *hcfmri,
tnode_t *t_bindparent, tnode_t *t_fmriparent, tnode_t **t_node, int flag)
{
int rv;
int err;
nvlist_t *out;
nvlist_t *fmri;
nvlist_t *auth;
topo_mod_dprintf(mod, "%s adding entry for type (%s)\n",
_ENUM_NAME, hcfmri->hc_name);
if (t_bindparent == NULL) {
topo_mod_dprintf(mod,
"%s called with NULL parent for type %s\n",
_ENUM_NAME, hcfmri->hc_name);
return (-1);
}
/* Create the FMRI for this node */
auth = topo_mod_auth(mod, t_bindparent);
fmri = topo_mod_hcfmri(mod, t_fmriparent, FM_HC_SCHEME_VERSION,
hcfmri->hc_name, hcfmri->instance, NULL, auth,
hcfmri->part_number, hcfmri->version, hcfmri->serial_number);
nvlist_free(auth);
if (fmri == NULL) {
topo_mod_dprintf(mod,
"%s failed to create %s fmri : %s\n", _ENUM_NAME,
hcfmri->hc_name, topo_strerror(topo_mod_errno(mod)));
return (-1);
}
rv = topo_node_range_create(mod, t_bindparent, hcfmri->hc_name, 0, 4);
if (rv != 0 && topo_mod_errno(mod) != EMOD_NODE_DUP) {
topo_mod_dprintf(mod, "%s range create failed for node %s\n",
_ENUM_NAME, hcfmri->hc_name);
}
/* Bind this node to the parent */
*t_node = x86pi_node_bind(mod, t_bindparent, hcfmri, fmri, flag);
nvlist_free(fmri);
if (*t_node == NULL) {
topo_mod_dprintf(mod,
"%s failed to bind %s node instance %d: %s\n",
_ENUM_NAME, hcfmri->hc_name, hcfmri->instance,
topo_strerror(topo_mod_errno(mod)));
return (-1);
}
/* call IPMI facility provider to register fac methods */
if (topo_mod_load(mod, _FAC_PROV, TOPO_VERSION) == NULL) {
topo_mod_dprintf(mod,
"%s: Failed to load %s module: %s\n", _ENUM_NAME, _FAC_PROV,
topo_mod_errmsg(mod));
return (-1);
}
rv = topo_mod_enumerate(mod, *t_node, _FAC_PROV, _FAC_PROV, 0, 0, NULL);
if (rv != 0) {
topo_mod_dprintf(mod,
"%s: %s failed: %s\n", _ENUM_NAME, _FAC_PROV,
topo_mod_errmsg(mod));
return (-1);
}
/* invoke fac_prov_ipmi_enum method */
if (topo_method_supported(*t_node, TOPO_METH_FAC_ENUM, 0)) {
if (topo_method_invoke(*t_node, TOPO_METH_FAC_ENUM, 0, NULL,
&out, &err) != 0) {
/* log the error and drive on */
topo_mod_dprintf(mod,
"%s: TOPO_METH_FAC_ENUM failed\n", _ENUM_NAME);
} else {
fac_done = 1;
}
}
topo_mod_dprintf(mod, "%s added (%s) node\n", _ENUM_NAME,
topo_node_name(*t_node));
return (0);
}
/*ARGSUSED*/
static int
walk_node(topo_hdl_t *thp, tnode_t *node, void *arg)
{
int err;
nvlist_t *nvl;
nvlist_t *rsrc, *out;
char *s;
if (opt_e && strcmp(opt_s, FM_FMRI_SCHEME_HC) == 0) {
print_everstyle(node);
return (TOPO_WALK_NEXT);
}
if (topo_node_resource(node, &rsrc, &err) < 0) {
(void) fprintf(stderr, "%s: failed to get resource: "
"%s", g_pname, topo_strerror(err));
return (TOPO_WALK_NEXT);
}
if (topo_fmri_nvl2str(thp, rsrc, &s, &err) < 0) {
(void) fprintf(stderr, "%s: failed to convert "
"resource to FMRI string: %s", g_pname,
topo_strerror(err));
nvlist_free(rsrc);
return (TOPO_WALK_NEXT);
}
if (g_fmri != NULL && fnmatch(g_fmri, s, 0) != 0) {
nvlist_free(rsrc);
topo_hdl_strfree(thp, s);
return (TOPO_WALK_NEXT);
}
print_node(thp, node, rsrc, s);
topo_hdl_strfree(thp, s);
nvlist_free(rsrc);
if (opt_m != NULL) {
if (topo_method_invoke(node, opt_m, 0, NULL, &out, &err) == 0) {
nvlist_print(stdout, out);
nvlist_free(out);
} else if (err != ETOPO_METHOD_NOTSUP)
(void) fprintf(stderr, "%s: method failed unexpectedly "
"on %s=%d (%s)\n", g_pname, topo_node_name(node),
topo_node_instance(node), topo_strerror(err));
}
if (opt_V || opt_all) {
if ((nvl = topo_prop_getprops(node, &err)) == NULL) {
(void) fprintf(stderr, "%s: failed to get "
"properties for %s=%d: %s\n", g_pname,
topo_node_name(node), topo_node_instance(node),
topo_strerror(err));
} else {
print_all_props(thp, node, nvl, ALL);
nvlist_free(nvl);
}
} else if (pcnt > 0)
print_props(thp, node);
(void) printf("\n");
return (TOPO_WALK_NEXT);
}
