static void
print_node(topo_hdl_t *thp, tnode_t *node, nvlist_t *nvl, const char *fmri)
{
int err, ret;
(void) printf("%s\n", (char *)fmri);
if (opt_p && !(pcnt > 0 || opt_V || opt_all)) {
char *aname = NULL, *fname = NULL, *lname = NULL;
nvlist_t *asru = NULL;
nvlist_t *fru = NULL;
if (topo_node_asru(node, &asru, NULL, &err) == 0)
(void) topo_fmri_nvl2str(thp, asru, &aname, &err);
if (topo_node_fru(node, &fru, NULL, &err) == 0)
(void) topo_fmri_nvl2str(thp, fru, &fname, &err);
(void) topo_node_label(node, &lname, &err);
if (aname != NULL) {
nvlist_free(asru);
(void) printf("\tASRU: %s\n", aname);
topo_hdl_strfree(thp, aname);
} else {
(void) printf("\tASRU: -\n");
}
if (fname != NULL) {
nvlist_free(fru);
(void) printf("\tFRU: %s\n", fname);
topo_hdl_strfree(thp, fname);
} else {
(void) printf("\tFRU: -\n");
}
if (lname != NULL) {
(void) printf("\tLabel: %s\n", lname);
topo_hdl_strfree(thp, lname);
} else {
(void) printf("\tLabel: -\n");
}
}
if (opt_S) {
if ((ret = topo_fmri_present(thp, nvl, &err)) < 0)
(void) printf("\tPresent: -\n");
else
(void) printf("\tPresent: %s\n",
ret ? "true" : "false");
if ((ret = topo_fmri_unusable(thp, nvl, &err)) < 0)
(void) printf("\tUnusable: -\n");
else
(void) printf("\tUnusable: %s\n",
ret ? "true" : "false");
}
}
/*ARGSUSED*/
static int
fru_by_label_cb(topo_hdl_t *thp, tnode_t *node, void *arg)
{
char *lbl;
int err;
char *target = (char *)arg;
if (topo_node_label(node, &lbl, &err) < 0)
return (TOPO_WALK_NEXT); /* no label, try next */
if ((strcmp(target, lbl) == 0) &&
(topo_node_fru(node, &br_memb_nvl, NULL, &err) == 0)) {
topo_hdl_strfree(thp, lbl);
return (TOPO_WALK_TERMINATE);
}
topo_hdl_strfree(thp, lbl);
return (TOPO_WALK_NEXT);
}
static int
use_predecessor_label(topo_mod_t *mod, tnode_t *tn, char *mod_name)
{
tnode_t *pnode = NULL;
int err = 0;
char *plabel = NULL;
if ((pnode = find_predecessor(tn, mod_name)) == NULL)
return (-1);
if ((pnode = topo_node_parent(pnode)) == NULL)
return (-1);
if (topo_node_label(pnode, &plabel, &err) != 0 || plabel == NULL)
return (-1);
(void) topo_node_label_set(tn, plabel, &err);
topo_mod_strfree(mod, plabel);
return (0);
}
/* Topo Methods */
static int
mem_asru_compute(topo_mod_t *mod, tnode_t *node, topo_version_t version,
nvlist_t *in, nvlist_t **out)
{
nvlist_t *asru, *pargs, *args, *hcsp;
int err;
char *serial = NULL, *label = NULL;
uint64_t pa, offset;
if (version > TOPO_METH_ASRU_COMPUTE_VERSION)
return (topo_mod_seterrno(mod, EMOD_VER_NEW));
if (strcmp(topo_node_name(node), DIMM) != 0)
return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
pargs = NULL;
if (nvlist_lookup_nvlist(in, TOPO_PROP_PARGS, &pargs) == 0)
(void) nvlist_lookup_string(pargs, FM_FMRI_HC_SERIAL_ID,
&serial);
if (serial == NULL &&
nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args) == 0)
(void) nvlist_lookup_string(args, FM_FMRI_HC_SERIAL_ID,
&serial);
(void) topo_node_label(node, &label, &err);
asru = mem_fmri_create(mod, serial, label);
if (label != NULL)
topo_mod_strfree(mod, label);
if (asru == NULL)
return (topo_mod_seterrno(mod, EMOD_NOMEM));
err = 0;
/*
* For a memory page, 'in' includes an hc-specific member which
* specifies physaddr and/or offset. Set them in asru as well.
*/
if (pargs && nvlist_lookup_nvlist(pargs,
FM_FMRI_HC_SPECIFIC, &hcsp) == 0) {
if (nvlist_lookup_uint64(hcsp,
FM_FMRI_HC_SPECIFIC_PHYSADDR, &pa) == 0)
err += nvlist_add_uint64(asru, FM_FMRI_MEM_PHYSADDR,
pa);
if (nvlist_lookup_uint64(hcsp,
FM_FMRI_HC_SPECIFIC_OFFSET, &offset) == 0)
err += nvlist_add_uint64(asru, FM_FMRI_MEM_OFFSET,
offset);
}
if (err != 0 || topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) < 0) {
nvlist_free(asru);
return (topo_mod_seterrno(mod, EMOD_NOMEM));
}
err = nvlist_add_string(*out, TOPO_PROP_VAL_NAME, TOPO_PROP_ASRU);
err |= nvlist_add_uint32(*out, TOPO_PROP_VAL_TYPE, TOPO_TYPE_FMRI);
err |= nvlist_add_nvlist(*out, TOPO_PROP_VAL_VAL, asru);
nvlist_free(asru);
if (err != 0) {
nvlist_free(*out);
*out = NULL;
return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
}
return (0);
}
static int
topo_add_bay(topo_hdl_t *thp, tnode_t *node, walk_diskmon_t *wdp)
{
diskmon_t *target_diskp = wdp->target;
nvlist_t *nvlp = find_disk_monitor_private_pgroup(node);
nvlist_t *prop_nvlp;
nvpair_t *nvp = NULL;
char *prop_name, *prop_value;
#define PNAME_MAX 128
char pname[PNAME_MAX];
char msgbuf[MAX_CONF_MSG_LEN];
char *indicator_name, *indicator_action;
char *indrule_states, *indrule_actions;
int err = 0, i;
conf_err_t conferr;
boolean_t conf_failure = B_FALSE;
char *unadj_physid = NULL;
char physid[MAXPATHLEN];
char *label;
nvlist_t *diskprops = NULL;
char *cstr = NULL;
indicator_t *indp = NULL;
indrule_t *indrp = NULL;
void *p;
diskmon_t *diskp;
void *ptr;
/* No private properties -- just ignore the port */
if (nvlp == NULL)
return (0);
/*
* Look for a diskmon based on this node's FMRI string.
* Once a diskmon has been created, it's not re-created. This is
* essential for the times when the tree-walk is called after a
* disk is inserted (or removed) -- in that case, the disk node
* handler simply updates the FRU information in the diskmon.
*/
if ((p = fmri2ptr(thp, node, &cstr, &err)) != NULL) {
diskp = (diskmon_t *)p;
/*
* Delete the FRU information from the diskmon. If a disk
* is connected, its FRU information will be refreshed by
* the disk node code.
*/
if (diskp->frup && (target_diskp == NULL ||
diskp == target_diskp)) {
dm_assert(pthread_mutex_lock(&diskp->fru_mutex) == 0);
dmfru_free(diskp->frup);
diskp->frup = NULL;
dm_assert(pthread_mutex_unlock(&diskp->fru_mutex) == 0);
}
wdp->pfmri = cstr;
nvlist_free(nvlp);
return (0);
}
/*
* Determine the physical path to the attachment point
*/
if (topo_prop_get_string(node, TOPO_PGROUP_IO,
TOPO_IO_AP_PATH, &unadj_physid, &err) == 0) {
adjust_dynamic_ap(unadj_physid, physid);
topo_hdl_strfree(thp, unadj_physid);
} else {
/* unadj_physid cannot have been allocated */
if (cstr)
dstrfree(cstr);
nvlist_free(nvlp);
return (-1);
}
/*
*/
/*
* Process the properties. If we encounter a property that
* is not an indicator name, action, or rule, add it to the
* disk's props list.
*/
/* Process indicators */
i = 0;
indicator_name = NULL;
indicator_action = NULL;
do {
if (indicator_name != NULL && indicator_action != NULL) {
if (topoprop_indicator_add(&indp, indicator_name,
indicator_action) != 0) {
conf_failure = B_TRUE;
}
topo_hdl_strfree(thp, indicator_name);
topo_hdl_strfree(thp, indicator_action);
}
(void) snprintf(pname, PNAME_MAX, BAY_IND_NAME "-%d", i);
if (topo_prop_get_string(node, DISK_MONITOR_PROPERTIES,
pname, &indicator_name, &err) != 0)
break;
(void) snprintf(pname, PNAME_MAX, BAY_IND_ACTION "-%d", i);
if (topo_prop_get_string(node, DISK_MONITOR_PROPERTIES,
pname, &indicator_action, &err) != 0)
break;
i++;
} while (!conf_failure && indicator_name != NULL &&
indicator_action != NULL);
if (!conf_failure && indp != NULL &&
(conferr = check_inds(indp)) != E_NO_ERROR) {
conf_error_msg(conferr, msgbuf, MAX_CONF_MSG_LEN, NULL);
log_msg(MM_CONF, "%s: Not adding disk to list\n", msgbuf);
conf_failure = B_TRUE;
}
/* Process state rules and indicator actions */
i = 0;
indrule_states = NULL;
indrule_actions = NULL;
do {
if (indrule_states != NULL && indrule_actions != NULL) {
if (topoprop_indrule_add(&indrp, indrule_states,
indrule_actions) != 0) {
conf_failure = B_TRUE;
}
topo_hdl_strfree(thp, indrule_states);
topo_hdl_strfree(thp, indrule_actions);
}
(void) snprintf(pname, PNAME_MAX, BAY_INDRULE_STATES "-%d", i);
if (topo_prop_get_string(node, DISK_MONITOR_PROPERTIES,
pname, &indrule_states, &err) != 0)
break;
(void) snprintf(pname, PNAME_MAX, BAY_INDRULE_ACTIONS "-%d",
i);
if (topo_prop_get_string(node, DISK_MONITOR_PROPERTIES,
pname, &indrule_actions, &err) != 0)
break;
i++;
} while (!conf_failure && indrule_states != NULL &&
indrule_actions != NULL);
if (!conf_failure && indrp != NULL && indp != NULL &&
((conferr = check_indrules(indrp, (state_transition_t **)&ptr))
!= E_NO_ERROR ||
(conferr = check_consistent_ind_indrules(indp, indrp,
(ind_action_t **)&ptr)) != E_NO_ERROR)) {
conf_error_msg(conferr, msgbuf, MAX_CONF_MSG_LEN, ptr);
log_msg(MM_CONF, "%s: Not adding disk to list\n", msgbuf);
conf_failure = B_TRUE;
}
/*
* Now collect miscellaneous properties.
* Each property is stored as an embedded nvlist named
* TOPO_PROP_VAL. The property name is stored in the value for
* key=TOPO_PROP_VAL_NAME and the property's value is
* stored in the value for key=TOPO_PROP_VAL_VAL. This is all
* necessary so we can subtractively decode the properties that
* we do not directly handle (so that these properties are added to
* the per-disk properties nvlist), increasing flexibility.
*/
(void) nvlist_alloc(&diskprops, NV_UNIQUE_NAME, 0);
while ((nvp = nvlist_next_nvpair(nvlp, nvp)) != NULL) {
/* Only care about embedded nvlists named TOPO_PROP_VAL */
if (nvpair_type(nvp) != DATA_TYPE_NVLIST ||
strcmp(nvpair_name(nvp), TOPO_PROP_VAL) != 0 ||
nvpair_value_nvlist(nvp, &prop_nvlp) != 0)
continue;
if (nonunique_nvlist_lookup_string(prop_nvlp,
TOPO_PROP_VAL_NAME, &prop_name) != 0)
continue;
/* Filter out indicator properties */
if (strstr(prop_name, BAY_IND_NAME) != NULL ||
strstr(prop_name, BAY_IND_ACTION) != NULL ||
strstr(prop_name, BAY_INDRULE_STATES) != NULL ||
strstr(prop_name, BAY_INDRULE_ACTIONS) != NULL)
continue;
if (nonunique_nvlist_lookup_string(prop_nvlp, TOPO_PROP_VAL_VAL,
&prop_value) != 0)
continue;
/* Add the property to the disk's prop list: */
if (nvlist_add_string(diskprops, prop_name, prop_value) != 0)
log_msg(MM_TOPO,
"Could not add disk property `%s' with "
"value `%s'\n", prop_name, prop_value);
}
nvlist_free(nvlp);
if (cstr != NULL) {
namevalpr_t nvpr;
nvlist_t *dmap_nvl;
nvpr.name = DISK_AP_PROP_APID;
nvpr.value = strncmp(physid, "/devices", 8) == 0 ?
(physid + 8) : physid;
/*
* Set the diskmon's location to the value in this port's label.
* If there's a disk plugged in, the location will be updated
* to be the disk label (e.g. HD_ID_00). Until a disk is
* inserted, though, there won't be a disk libtopo node
* created.
*/
/* Pass physid without the leading "/devices": */
dmap_nvl = namevalpr_to_nvlist(&nvpr);
diskp = new_diskmon(dmap_nvl, indp, indrp, diskprops);
if (topo_node_label(node, &label, &err) == 0) {
diskp->location = dstrdup(label);
topo_hdl_strfree(thp, label);
} else
diskp->location = dstrdup("unknown location");
if (!conf_failure && diskp != NULL) {
/* Add this diskmon to the disk list */
cfgdata_add_diskmon(config_data, diskp);
if (nvlist_add_uint64(g_topo2diskmon, cstr,
(uint64_t)(uintptr_t)diskp) != 0) {
log_msg(MM_TOPO,
"Could not add pointer to nvlist "
"for `%s'!\n", cstr);
}
} else if (diskp != NULL) {
diskmon_free(diskp);
} else {
if (dmap_nvl)
nvlist_free(dmap_nvl);
if (indp)
ind_free(indp);
if (indrp)
indrule_free(indrp);
if (diskprops)
nvlist_free(diskprops);
}
wdp->pfmri = cstr;
}
return (0);
}
static int
topo_add_disk(topo_hdl_t *thp, tnode_t *node, walk_diskmon_t *wdp)
{
diskmon_t *target_diskp = wdp->target;
char *devpath = NULL;
char *capacity = NULL;
char *firmrev = NULL;
char *serial = NULL;
char *manuf = NULL;
char *model = NULL;
char *label;
uint64_t ptr = 0;
int err;
dm_fru_t *frup;
diskmon_t *diskp;
if (wdp->pfmri == NULL) {
log_msg(MM_TOPO, "No diskmon for parent of node %p.\n", node);
return (0);
}
if (nvlist_lookup_uint64(g_topo2diskmon, wdp->pfmri, &ptr) != 0) {
log_msg(MM_TOPO, "No diskmon for %s: parent of node %p.\n",
wdp->pfmri, node);
dstrfree(wdp->pfmri);
/* Skip this disk: */
return (0);
}
dstrfree(wdp->pfmri);
wdp->pfmri = NULL;
diskp = (diskmon_t *)(uintptr_t)ptr;
/* If we were called upon to update a particular disk, do it */
if (target_diskp != NULL && diskp != target_diskp) {
return (0);
}
/*
* Update the diskmon's location field with the disk's label
*/
if (diskp->location)
dstrfree(diskp->location);
if (topo_node_label(node, &label, &err) == 0) {
diskp->location = dstrdup(label);
topo_hdl_strfree(thp, label);
} else
diskp->location = dstrdup("unknown location");
/*
* Check for a device path property (if the disk is configured,
* it will be present) and add it to the diskmon's properties)
*/
if (topo_prop_get_string(node, TOPO_PGROUP_IO, TOPO_IO_DEV_PATH,
&devpath, &err) == 0) {
char devp[PATH_MAX];
/*
* Consumers of the DISK_PROP_DEVPATH property expect a raw
* minor device node
*/
(void) snprintf(devp, PATH_MAX, "%s:q,raw", devpath);
(void) nvlist_add_string(diskp->props, DISK_PROP_DEVPATH,
devp);
topo_hdl_strfree(thp, devpath);
}
/*
* Add the logical disk node, if it exists
*/
if (topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_LOGICAL_DISK_NAME, &devpath, &err) == 0) {
(void) nvlist_add_string(diskp->props, DISK_PROP_LOGNAME,
devpath);
topo_hdl_strfree(thp, devpath);
}
/*
* Add the FRU information (if present in the node) to the diskmon's
* fru data structure:
*/
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_MODEL, &model, &err);
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_MANUFACTURER, &manuf, &err);
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_SERIAL_NUM, &serial, &err);
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_FIRMWARE_REV, &firmrev, &err);
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_CAPACITY, &capacity, &err);
frup = new_dmfru(manuf, model, firmrev, serial,
capacity == NULL ? 0 : strtoull(capacity, 0, 0));
if (model)
topo_hdl_strfree(thp, model);
if (manuf)
topo_hdl_strfree(thp, manuf);
if (serial)
topo_hdl_strfree(thp, serial);
if (firmrev)
topo_hdl_strfree(thp, firmrev);
if (capacity)
topo_hdl_strfree(thp, capacity);
/* Add the fru information to the diskmon: */
dm_assert(pthread_mutex_lock(&diskp->fru_mutex) == 0);
dm_assert(diskp->frup == NULL);
diskp->frup = frup;
dm_assert(pthread_mutex_unlock(&diskp->fru_mutex) == 0);
return (0);
}
static int
topo_add_disk(topo_hdl_t *thp, tnode_t *node, diskmon_t *target_diskp)
{
nvlist_t *fmri = NULL;
nvlist_t *asru_fmri;
nvlist_t *fru_fmri;
char *devpath = NULL;
char *capacity = NULL;
char *firmrev = NULL;
char *serial = NULL;
char *manuf = NULL;
char *model = NULL;
char *cstr = NULL;
char *buf;
char *label;
char *p;
uint64_t ptr = 0;
int buflen;
int err;
int orig_cstr_len;
dm_fru_t *frup;
diskmon_t *diskp;
/*
* Match this node to a disk in the configuration by looking at
* our parent's fmri (and do that by getting our FMRI and chopping
* off the last part).
*/
if (topo_node_resource(node, &fmri, &err) != 0) {
log_msg(MM_TOPO, "topo_add_disk: Could not generate FMRI for "
"node %p!\n", (void *)node);
return (-1);
}
if (topo_fmri_nvl2str(thp, fmri, &cstr, &err) != 0) {
log_msg(MM_TOPO, "topo_add_disk: Could not create string for "
"node %p's FMRI!\n", (void *)node);
nvlist_free(fmri);
return (-1);
}
nvlist_free(fmri);
/*
* Chop off all but last path (since there's no way to get
* the node's parent in the libtopo API).
*/
orig_cstr_len = strlen(cstr) + 1;
p = strrchr(cstr, '/');
dm_assert(p != NULL);
*p = 0;
if (nvlist_lookup_uint64(g_topo2diskmon, cstr, &ptr) != 0) {
log_msg(MM_TOPO, "No diskmon for parent of node %p.\n", node);
topo_hdl_free(thp, cstr, orig_cstr_len);
/* Skip this disk: */
return (0);
}
topo_hdl_free(thp, cstr, orig_cstr_len);
diskp = (diskmon_t *)(uintptr_t)ptr;
/* If we were called upon to update a particular disk, do it */
if (target_diskp != NULL && diskp != target_diskp) {
return (0);
}
/*
* Update the diskmon's ASRU and FRU with our information (this
* information is cached in the diskmon so we don't have to do a
* time-consuming topo traversal when we get an ereport).
*/
if (topo_prop_get_fmri(node, TOPO_PGROUP_PROTOCOL, TOPO_PROP_ASRU,
&asru_fmri, &err) == 0) {
diskmon_add_asru(diskp, asru_fmri);
nvlist_free(asru_fmri);
}
if (topo_prop_get_fmri(node, TOPO_PGROUP_PROTOCOL, TOPO_PROP_FRU,
&fru_fmri, &err) == 0) {
diskmon_add_fru(diskp, fru_fmri);
nvlist_free(fru_fmri);
}
if (topo_node_resource(node, &fmri, &err) == 0) {
diskmon_add_disk_fmri(diskp, fmri);
nvlist_free(fmri);
}
/*
* Update the diskmon's location field with the disk's label
*/
if (diskp->location)
dstrfree(diskp->location);
if (topo_node_label(node, &label, &err) == 0) {
diskp->location = dstrdup(label);
topo_hdl_strfree(thp, label);
} else
diskp->location = dstrdup("unknown location");
/*
* Check for a device path property (if the disk is configured,
* it will be present) and add it to the diskmon's properties)
*/
if (topo_prop_get_string(node, TOPO_PGROUP_IO, TOPO_IO_DEV_PATH,
&devpath, &err) == 0) {
char devp[PATH_MAX];
/*
* Consumers of the DISK_PROP_DEVPATH property expect a raw
* minor device node
*/
(void) snprintf(devp, PATH_MAX, "%s:q,raw", devpath);
(void) nvlist_add_string(diskp->props, DISK_PROP_DEVPATH,
devp);
topo_hdl_strfree(thp, devpath);
}
/*
* Add the logical disk node, if it exists
*/
if (topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_LOGICAL_DISK_NAME, &devpath, &err) == 0) {
(void) nvlist_add_string(diskp->props, DISK_PROP_LOGNAME,
devpath);
topo_hdl_strfree(thp, devpath);
}
/*
* Add the FRU information (if present in the node) to the diskmon's
* fru data structure:
*/
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_MODEL, &model, &err);
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_MANUFACTURER, &manuf, &err);
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_SERIAL_NUM, &serial, &err);
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_FIRMWARE_REV, &firmrev, &err);
(void) topo_prop_get_string(node, TOPO_STORAGE_PGROUP,
TOPO_STORAGE_CAPACITY, &capacity, &err);
frup = new_dmfru(manuf, model, firmrev, serial,
capacity == NULL ? 0 : strtoull(capacity, 0, 0));
/*
* Update the disk's resource FMRI with the
* SunService-required members:
* FM_FMRI_HC_SERIAL_ID, FM_FMRI_HC_PART, and
* FM_FMRI_HC_REVISION
*/
(void) nvlist_add_string(diskp->disk_res_fmri,
FM_FMRI_HC_SERIAL_ID, serial);
transform_model_string(manuf, model, &buf, &buflen);
(void) nvlist_add_string(diskp->disk_res_fmri,
FM_FMRI_HC_PART, buf);
/*
* Add the serial number to the ASRU so that when the resource
* is marked faulty in the fmd resource cache, the hc scheme
* plugin can detect when the disk is no longer installed (and so,
* can clear the faulty state automatically across fmd restarts).
*
* The serial number is only updated when a disk comes online
* because that's when the disk node exists in the topo tree.
* It's ok to keep a stale value in the ASRU when the disk is removed
* because it's only used as part of fault creation when the disk
* is configured (online), at which point it will be updated with
* the (current) serial number of the disk inserted.
*/
(void) nvlist_add_string(diskp->asru_fmri,
FM_FMRI_HC_SERIAL_ID, serial);
dfree(buf, buflen);
(void) nvlist_add_string(diskp->disk_res_fmri,
FM_FMRI_HC_REVISION, firmrev);
if (model) {
topo_hdl_strfree(thp, model);
}
if (manuf) {
topo_hdl_strfree(thp, manuf);
}
if (serial) {
topo_hdl_strfree(thp, serial);
}
if (firmrev) {
topo_hdl_strfree(thp, firmrev);
}
if (capacity) {
topo_hdl_strfree(thp, capacity);
}
/* Add the fru information to the diskmon: */
dm_assert(pthread_mutex_lock(&diskp->fru_mutex) == 0);
dm_assert(diskp->frup == NULL);
diskp->frup = frup;
dm_assert(pthread_mutex_unlock(&diskp->fru_mutex) == 0);
return (0);
}
/*
* Set the properties of the disk node, from dev_di_node_t data.
* Properties include:
* group: protocol properties: resource, asru, label, fru
* group: authority properties: product-id, chasis-id, server-id
* group: io properties: devfs-path, devid
* group: storage properties:
* - logical-disk, disk-model, disk-manufacturer, serial-number
* - firmware-revision, capacity-in-bytes
*
* NOTE: the io and storage groups won't be present if the dnode passed in is
* NULL. This happens when a disk is found through ses, but is not enumerated
* in the devinfo tree.
*/
static int
disk_set_props(topo_mod_t *mod, tnode_t *parent,
tnode_t *dtn, dev_di_node_t *dnode)
{
nvlist_t *asru = NULL, *drive_attrs;
char *label = NULL;
nvlist_t *fmri = NULL;
dm_descriptor_t drive_descr = NULL;
uint32_t rpm;
int err;
/* pull the label property down from our parent 'bay' node */
if (topo_node_label(parent, &label, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"label error %s\n", topo_strerror(err));
goto error;
}
if (topo_node_label_set(dtn, label, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"label_set error %s\n", topo_strerror(err));
goto error;
}
/* get the resource fmri, and use it as the fru */
if (topo_node_resource(dtn, &fmri, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"resource error: %s\n", topo_strerror(err));
goto error;
}
if (topo_node_fru_set(dtn, fmri, 0, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"fru_set error: %s\n", topo_strerror(err));
goto error;
}
/* create/set the authority group */
if ((topo_pgroup_create(dtn, &disk_auth_pgroup, &err) != 0) &&
(err != ETOPO_PROP_DEFD)) {
topo_mod_dprintf(mod, "disk_set_props: "
"create disk_auth error %s\n", topo_strerror(err));
goto error;
}
/* create the storage group */
if (topo_pgroup_create(dtn, &storage_pgroup, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"create storage error %s\n", topo_strerror(err));
goto error;
}
/* no dnode was found for this disk - skip the io and storage groups */
if (dnode == NULL) {
err = 0;
goto out;
}
/* form and set the asru */
if ((asru = topo_mod_devfmri(mod, FM_DEV_SCHEME_VERSION,
dnode->ddn_dpath, dnode->ddn_devid)) == NULL) {
err = ETOPO_FMRI_UNKNOWN;
topo_mod_dprintf(mod, "disk_set_props: "
"asru error %s\n", topo_strerror(err));
goto error;
}
if (topo_node_asru_set(dtn, asru, 0, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"asru_set error %s\n", topo_strerror(err));
goto error;
}
/* create/set the devfs-path and devid in the io group */
if (topo_pgroup_create(dtn, &io_pgroup, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"create io error %s\n", topo_strerror(err));
goto error;
}
if (topo_prop_set_string(dtn, TOPO_PGROUP_IO, TOPO_IO_DEV_PATH,
TOPO_PROP_IMMUTABLE, dnode->ddn_dpath, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set dev error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_devid && topo_prop_set_string(dtn, TOPO_PGROUP_IO,
TOPO_IO_DEVID, TOPO_PROP_IMMUTABLE, dnode->ddn_devid, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set devid error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_ppath_count != 0 &&
topo_prop_set_string_array(dtn, TOPO_PGROUP_IO, TOPO_IO_PHYS_PATH,
TOPO_PROP_IMMUTABLE, (const char **)dnode->ddn_ppath,
dnode->ddn_ppath_count, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set phys-path error %s\n", topo_strerror(err));
goto error;
}
/* set the storage group public /dev name */
if (dnode->ddn_lpath != NULL &&
topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_LOGICAL_DISK_NAME, TOPO_PROP_IMMUTABLE,
dnode->ddn_lpath, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set disk_name error %s\n", topo_strerror(err));
goto error;
}
/* populate other misc storage group properties */
if (dnode->ddn_mfg && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_MANUFACTURER, TOPO_PROP_IMMUTABLE,
dnode->ddn_mfg, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set mfg error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_model && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_MODEL, TOPO_PROP_IMMUTABLE,
dnode->ddn_model, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set model error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_serial && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_SERIAL_NUM, TOPO_PROP_IMMUTABLE,
dnode->ddn_serial, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set serial error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_firm && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE,
dnode->ddn_firm, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set firm error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_cap && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_CAPACITY, TOPO_PROP_IMMUTABLE,
dnode->ddn_cap, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set cap error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_devid == NULL ||
(drive_descr = dm_get_descriptor_by_name(DM_DRIVE,
dnode->ddn_devid, &err)) == NULL ||
(drive_attrs = dm_get_attributes(drive_descr, &err)) == NULL)
goto out;
if (nvlist_lookup_boolean(drive_attrs, DM_SOLIDSTATE) == 0 ||
nvlist_lookup_uint32(drive_attrs, DM_RPM, &rpm) != 0)
goto out;
if (topo_prop_set_uint32(dtn, TOPO_PGROUP_STORAGE, TOPO_STORAGE_RPM,
TOPO_PROP_IMMUTABLE, rpm, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set rpm error %s\n", topo_strerror(err));
dm_free_descriptor(drive_descr);
goto error;
}
err = 0;
out:
if (drive_descr != NULL)
dm_free_descriptor(drive_descr);
nvlist_free(fmri);
if (label)
topo_mod_strfree(mod, label);
nvlist_free(asru);
return (err);
error: err = topo_mod_seterrno(mod, err);
goto out;
}
