/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <alloca.h>
#include <dirent.h>
#include <devid.h>
#include <fm/libdiskstatus.h>
#include <inttypes.h>
#include <pthread.h>
#include <strings.h>
#include <unistd.h>
#include <sys/dkio.h>
#include <sys/fm/protocol.h>
#include <sys/scsi/scsi_types.h>
#include "disk.h"
#include "ses.h"
#define SES_VERSION 1
static int ses_snap_freq = 250; /* in milliseconds */
#define SES_STATUS_UNAVAIL(s) \
((s) == SES_ESC_UNSUPPORTED || (s) >= SES_ESC_NOT_INSTALLED)
/*
* Because multiple SES targets can be part of a single chassis, we construct
* our own hierarchy that takes this into account. These SES targets may refer
* to the same devices (multiple paths) or to different devices (managing
* different portions of the space). We arrange things into a
* ses_enum_enclosure_t, which contains a set of ses targets, and a list of all
* nodes found so far.
*/
typedef struct ses_alt_node {
topo_list_t san_link;
ses_node_t *san_node;
} ses_alt_node_t;
typedef struct ses_enum_node {
topo_list_t sen_link;
ses_node_t *sen_node;
topo_list_t sen_alt_nodes;
uint64_t sen_type;
uint64_t sen_instance;
ses_enum_target_t *sen_target;
} ses_enum_node_t;
typedef struct ses_enum_chassis {
topo_list_t sec_link;
topo_list_t sec_subchassis;
topo_list_t sec_nodes;
topo_list_t sec_targets;
const char *sec_csn;
const char *sec_lid;
ses_node_t *sec_enclosure;
ses_enum_target_t *sec_target;
topo_instance_t sec_instance;
topo_instance_t sec_scinstance;
boolean_t sec_hasdev;
boolean_t sec_internal;
} ses_enum_chassis_t;
typedef struct ses_enum_data {
topo_list_t sed_disks;
topo_list_t sed_chassis;
ses_enum_chassis_t *sed_current;
ses_enum_target_t *sed_target;
int sed_errno;
char *sed_name;
topo_mod_t *sed_mod;
topo_instance_t sed_instance;
} ses_enum_data_t;
typedef enum {
SES_NEW_CHASSIS = 0x1,
SES_NEW_SUBCHASSIS = 0x2,
SES_DUP_CHASSIS = 0x4,
SES_DUP_SUBCHASSIS = 0x8
} ses_chassis_type_e;
static int ses_present(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
nvlist_t **);
static int ses_contains(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
nvlist_t **);
static const topo_method_t ses_component_methods[] = {
{ TOPO_METH_PRESENT, TOPO_METH_PRESENT_DESC,
TOPO_METH_PRESENT_VERSION0, TOPO_STABILITY_INTERNAL, ses_present },
{ TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0,
TOPO_STABILITY_INTERNAL, ses_node_enum_facility },
{ TOPO_METH_SENSOR_FAILURE, TOPO_METH_SENSOR_FAILURE_DESC,
TOPO_METH_SENSOR_FAILURE_VERSION, TOPO_STABILITY_INTERNAL,
topo_method_sensor_failure },
{ NULL }
};
static const topo_method_t ses_bay_methods[] = {
{ TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0,
TOPO_STABILITY_INTERNAL, ses_node_enum_facility },
{ NULL }
};
static const topo_method_t ses_enclosure_methods[] = {
{ TOPO_METH_CONTAINS, TOPO_METH_CONTAINS_DESC,
TOPO_METH_CONTAINS_VERSION, TOPO_STABILITY_INTERNAL, ses_contains },
{ TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0,
TOPO_STABILITY_INTERNAL, ses_enc_enum_facility },
{ NULL }
};
static void
ses_target_free(topo_mod_t *mod, ses_enum_target_t *stp)
{
if (--stp->set_refcount == 0) {
ses_snap_rele(stp->set_snap);
ses_close(stp->set_target);
topo_mod_strfree(mod, stp->set_devpath);
topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
}
}
static void
ses_data_free(ses_enum_data_t *sdp, ses_enum_chassis_t *pcp)
{
topo_mod_t *mod = sdp->sed_mod;
ses_enum_chassis_t *cp;
ses_enum_node_t *np;
ses_enum_target_t *tp;
ses_alt_node_t *ap;
topo_list_t *cpl;
if (pcp != NULL)
cpl = &pcp->sec_subchassis;
else
cpl = &sdp->sed_chassis;
while ((cp = topo_list_next(cpl)) != NULL) {
topo_list_delete(cpl, cp);
while ((np = topo_list_next(&cp->sec_nodes)) != NULL) {
while ((ap = topo_list_next(&np->sen_alt_nodes)) !=
NULL) {
topo_list_delete(&np->sen_alt_nodes, ap);
topo_mod_free(mod, ap, sizeof (ses_alt_node_t));
}
topo_list_delete(&cp->sec_nodes, np);
topo_mod_free(mod, np, sizeof (ses_enum_node_t));
}
while ((tp = topo_list_next(&cp->sec_targets)) != NULL) {
topo_list_delete(&cp->sec_targets, tp);
ses_target_free(mod, tp);
}
topo_mod_free(mod, cp, sizeof (ses_enum_chassis_t));
}
if (pcp == NULL) {
disk_list_free(mod, &sdp->sed_disks);
topo_mod_free(mod, sdp, sizeof (ses_enum_data_t));
}
}
/*
* For enclosure nodes, we have a special contains method. By default, the hc
* walker will compare the node name and instance number to determine if an
* FMRI matches. For enclosures where the enumeration order is impossible to
* predict, we instead use the chassis-id as a unique identifier, and ignore
* the instance number.
*/
static int
fmri_contains(topo_mod_t *mod, nvlist_t *nv1, nvlist_t *nv2)
{
uint8_t v1, v2;
nvlist_t **hcp1, **hcp2;
int err, i;
uint_t nhcp1, nhcp2;
nvlist_t *a1, *a2;
char *c1, *c2;
int mindepth;
if (nvlist_lookup_uint8(nv1, FM_VERSION, &v1) != 0 ||
nvlist_lookup_uint8(nv2, FM_VERSION, &v2) != 0 ||
v1 > FM_HC_SCHEME_VERSION || v2 > FM_HC_SCHEME_VERSION)
return (topo_mod_seterrno(mod, EMOD_FMRI_VERSION));
err = nvlist_lookup_nvlist_array(nv1, FM_FMRI_HC_LIST, &hcp1, &nhcp1);
err |= nvlist_lookup_nvlist_array(nv2, FM_FMRI_HC_LIST, &hcp2, &nhcp2);
if (err != 0)
return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
/*
* If the chassis-id doesn't match, then these FMRIs are not
* equivalent. If one of the FMRIs doesn't have a chassis ID, then we
* have no choice but to fall back to the instance ID.
*/
if (nvlist_lookup_nvlist(nv1, FM_FMRI_AUTHORITY, &a1) == 0 &&
nvlist_lookup_nvlist(nv2, FM_FMRI_AUTHORITY, &a2) == 0 &&
nvlist_lookup_string(a1, FM_FMRI_AUTH_CHASSIS, &c1) == 0 &&
nvlist_lookup_string(a2, FM_FMRI_AUTH_CHASSIS, &c2) == 0) {
if (strcmp(c1, c2) != 0)
return (0);
mindepth = 1;
} else {
mindepth = 0;
}
if (nhcp2 < nhcp1)
return (0);
for (i = 0; i < nhcp1; i++) {
char *nm1 = NULL;
char *nm2 = NULL;
char *id1 = NULL;
char *id2 = NULL;
(void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_NAME, &nm1);
(void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_NAME, &nm2);
(void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_ID, &id1);
(void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_ID, &id2);
if (nm1 == NULL || nm2 == NULL || id1 == NULL || id2 == NULL)
return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
if (strcmp(nm1, nm2) == 0 &&
(i < mindepth || strcmp(id1, id2) == 0))
continue;
return (0);
}
return (1);
}
/*ARGSUSED*/
static int
ses_contains(topo_mod_t *mod, tnode_t *tn, topo_version_t version,
nvlist_t *in, nvlist_t **out)
{
int ret;
nvlist_t *nv1, *nv2;
if (version > TOPO_METH_CONTAINS_VERSION)
return (topo_mod_seterrno(mod, EMOD_VER_NEW));
if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_FMRI, &nv1) != 0 ||
nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_SUBFMRI, &nv2) != 0)
return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
ret = fmri_contains(mod, nv1, nv2);
if (ret < 0)
return (-1);
if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) == 0) {
if (nvlist_add_uint32(*out, TOPO_METH_CONTAINS_RET,
ret) == 0)
return (0);
else
nvlist_free(*out);
}
return (-1);
}
/*
* Return a current instance of the node. This is somewhat complicated because
* we need to take a new snapshot in order to get the new data, but we don't
* want to be constantly taking SES snapshots if the consumer is going to do a
* series of queries. So we adopt the strategy of assuming that the SES state
* is not going to be rapidly changing, and limit our snapshot frequency to
* some defined bounds.
*/
ses_node_t *
ses_node_lock(topo_mod_t *mod, tnode_t *tn)
{
ses_enum_target_t *tp = topo_node_getspecific(tn);
hrtime_t now;
ses_snap_t *snap;
int err;
uint64_t nodeid;
ses_node_t *np;
if (tp == NULL) {
(void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
return (NULL);
}
(void) pthread_mutex_lock(&tp->set_lock);
/*
* Determine if we need to take a new snapshot.
*/
now = gethrtime();
if (now - tp->set_snaptime > (ses_snap_freq * 1000 * 1000) &&
(snap = ses_snap_new(tp->set_target)) != NULL) {
if (ses_snap_generation(snap) !=
ses_snap_generation(tp->set_snap)) {
/*
* If we find ourselves in this situation, we're in
* trouble. The generation count has changed, which
* indicates that our current topology is out of date.
* But we need to consult the new topology in order to
* determine presence at this moment in time. We can't
* go back and change the topo snapshot in situ, so
* we'll just have to fail the call in this unlikely
* scenario.
*/
ses_snap_rele(snap);
(void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
(void) pthread_mutex_unlock(&tp->set_lock);
return (NULL);
} else {
ses_snap_rele(tp->set_snap);
tp->set_snap = snap;
}
tp->set_snaptime = gethrtime();
}
snap = tp->set_snap;
verify(topo_prop_get_uint64(tn, TOPO_PGROUP_SES,
TOPO_PROP_NODE_ID, &nodeid, &err) == 0);
verify((np = ses_node_lookup(snap, nodeid)) != NULL);
return (np);
}
/*ARGSUSED*/
void
ses_node_unlock(topo_mod_t *mod, tnode_t *tn)
{
ses_enum_target_t *tp = topo_node_getspecific(tn);
verify(tp != NULL);
(void) pthread_mutex_unlock(&tp->set_lock);
}
/*
* Determine if the element is present.
*/
/*ARGSUSED*/
static int
ses_present(topo_mod_t *mod, tnode_t *tn, topo_version_t version,
nvlist_t *in, nvlist_t **out)
{
boolean_t present;
ses_node_t *np;
nvlist_t *props, *nvl;
uint64_t status;
if ((np = ses_node_lock(mod, tn)) == NULL)
return (-1);
verify((props = ses_node_props(np)) != NULL);
verify(nvlist_lookup_uint64(props,
SES_PROP_STATUS_CODE, &status) == 0);
ses_node_unlock(mod, tn);
present = (status != SES_ESC_NOT_INSTALLED);
if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0)
return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
if (nvlist_add_uint32(nvl, TOPO_METH_PRESENT_RET,
present) != 0) {
nvlist_free(nvl);
return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
}
*out = nvl;
return (0);
}
/*
* Sets standard properties for a ses node (enclosure or bay). This includes
* setting the FRU to be the same as the resource, as well as setting the
* authority information.
*/
static int
ses_set_standard_props(topo_mod_t *mod, tnode_t *tn, nvlist_t *auth,
uint64_t nodeid, const char *path)
{
int err;
char *product, *chassis;
nvlist_t *fmri;
topo_pgroup_info_t pgi;
/*
* Set the authority explicitly if specified.
*/
if (auth) {
verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT,
&product) == 0);
verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS,
&chassis) == 0);
if (topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
FM_FMRI_AUTH_PRODUCT, TOPO_PROP_IMMUTABLE, product,
&err) != 0 ||
topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
FM_FMRI_AUTH_CHASSIS, TOPO_PROP_IMMUTABLE, chassis,
&err) != 0 ||
topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
FM_FMRI_AUTH_SERVER, TOPO_PROP_IMMUTABLE, "",
&err) != 0) {
topo_mod_dprintf(mod, "failed to add authority "
"properties: %s\n", topo_strerror(err));
return (topo_mod_seterrno(mod, err));
}
}
/*
* Copy the resource and set that as the FRU.
*/
if (topo_node_resource(tn, &fmri, &err) != 0) {
topo_mod_dprintf(mod,
"topo_node_resource() failed : %s\n",
topo_strerror(err));
return (topo_mod_seterrno(mod, err));
}
if (topo_node_fru_set(tn, fmri, 0, &err) != 0) {
topo_mod_dprintf(mod,
"topo_node_fru_set() failed : %s\n",
topo_strerror(err));
nvlist_free(fmri);
return (topo_mod_seterrno(mod, err));
}
nvlist_free(fmri);
/*
* Set the SES-specific properties so that consumers can query
* additional information about the particular SES element.
*/
pgi.tpi_name = TOPO_PGROUP_SES;
pgi.tpi_namestab = TOPO_STABILITY_PRIVATE;
pgi.tpi_datastab = TOPO_STABILITY_PRIVATE;
pgi.tpi_version = TOPO_VERSION;
if (topo_pgroup_create(tn, &pgi, &err) != 0) {
topo_mod_dprintf(mod, "failed to create propgroup "
"%s: %s\n", TOPO_PGROUP_SES, topo_strerror(err));
return (-1);
}
if (topo_prop_set_uint64(tn, TOPO_PGROUP_SES,
TOPO_PROP_NODE_ID, TOPO_PROP_IMMUTABLE,
nodeid, &err) != 0) {
topo_mod_dprintf(mod,
"failed to create property %s: %s\n",
TOPO_PROP_NODE_ID, topo_strerror(err));
return (-1);
}
if (topo_prop_set_string(tn, TOPO_PGROUP_SES,
TOPO_PROP_TARGET_PATH, TOPO_PROP_IMMUTABLE,
path, &err) != 0) {
topo_mod_dprintf(mod,
"failed to create property %s: %s\n",
TOPO_PROP_TARGET_PATH, topo_strerror(err));
return (-1);
}
return (0);
}
/*
* Callback to add a disk to a given bay. We first check the status-code to
* determine if a disk is present, ignoring those that aren't in an appropriate
* state. We then scan the parent bay node's SAS address array to determine
* possible attached SAS addresses. We create a disk node if the disk is not
* SAS or the SES target does not support the necessary pages for this; if we
* find the SAS address, we create a disk node and also correlate it with
* the corresponding Solaris device node to fill in the rest of the data.
*/
static int
ses_create_disk(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props)
{
topo_mod_t *mod = sdp->sed_mod;
uint64_t status;
nvlist_t **sas;
uint_t s, nsas;
char **paths;
int err;
/*
* Skip devices that are not in a present (and possibly damaged) state.
*/
if (nvlist_lookup_uint64(props, SES_PROP_STATUS_CODE, &status) != 0)
return (0);
if (status != SES_ESC_OK &&
status != SES_ESC_CRITICAL &&
status != SES_ESC_NONCRITICAL &&
status != SES_ESC_UNRECOVERABLE &&
status != SES_ESC_NO_ACCESS)
return (0);
topo_mod_dprintf(mod, "found attached disk");
/*
* Create the disk range.
*/
if (topo_node_range_create(mod, pnode, DISK, 0, 0) != 0) {
topo_mod_dprintf(mod,
"topo_node_create_range() failed: %s",
topo_mod_errmsg(mod));
return (-1);
}
/*
* Look through all SAS addresses and attempt to correlate them to a
* known Solaris device. If we don't find a matching node, then we
* don't enumerate the disk node.
*/
if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
&sas, &nsas) != 0)
return (0);
if (topo_prop_get_string_array(pnode, TOPO_PGROUP_SES,
TOPO_PROP_SAS_ADDR, &paths, &nsas, &err) != 0)
return (0);
err = 0;
for (s = 0; s < nsas; s++) {
if (disk_declare_addr(mod, pnode,
&sdp->sed_disks, paths[s]) != 0 &&
topo_mod_errno(mod) != EMOD_NODE_BOUND) {
err = -1;
break;
}
}
for (s = 0; s < nsas; s++)
topo_mod_free(mod, paths[s], strlen(paths[s]) + 1);
topo_mod_free(mod, paths, nsas * sizeof (char *));
return (err);
}
static int
ses_add_bay_props(topo_mod_t *mod, tnode_t *tn, ses_enum_node_t *snp)
{
ses_alt_node_t *ap;
ses_node_t *np;
nvlist_t *props;
nvlist_t **phys;
uint_t i, j, n_phys, all_phys = 0;
char **paths;
uint64_t addr;
size_t len;
int terr, err = -1;
for (ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL;
ap = topo_list_next(ap)) {
np = ap->san_node;
props = ses_node_props(np);
if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
&phys, &n_phys) != 0)
continue;
all_phys += n_phys;
}
if (all_phys == 0)
return (0);
if ((paths = topo_mod_zalloc(mod, all_phys * sizeof (char *))) == NULL)
return (-1);
for (i = 0, ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL;
ap = topo_list_next(ap)) {
np = ap->san_node;
props = ses_node_props(np);
if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
&phys, &n_phys) != 0)
continue;
for (j = 0; j < n_phys; j++) {
if (nvlist_lookup_uint64(phys[j], SES_SAS_PROP_ADDR,
&addr) != 0)
continue;
len = snprintf(NULL, 0, "%016llx", addr) + 1;
if ((paths[i] = topo_mod_alloc(mod, len)) == NULL)
goto error;
(void) snprintf(paths[i], len, "%016llx", addr);
++i;
}
}
err = topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE,
(const char **)paths, i, &terr);
if (err != 0)
err = topo_mod_seterrno(mod, terr);
error:
for (i = 0; i < all_phys && paths[i] != NULL; i++)
topo_mod_free(mod, paths[i], strlen(paths[i]) + 1);
topo_mod_free(mod, paths, all_phys * sizeof (char *));
return (err);
}
/*
* Callback to create a basic node (bay, psu, fan, or controller).
*/
static int
ses_create_generic(ses_enum_data_t *sdp, ses_enum_node_t *snp,
tnode_t *pnode, const char *nodename, const char *labelname)
{
ses_node_t *np = snp->sen_node;
ses_node_t *parent;
uint64_t instance = snp->sen_instance;
topo_mod_t *mod = sdp->sed_mod;
nvlist_t *props, *aprops;
nvlist_t *auth = NULL, *fmri = NULL;
tnode_t *tn;
char label[128];
int err;
char *part = NULL, *serial = NULL, *revision = NULL;
char *desc;
boolean_t report;
props = ses_node_props(np);
(void) nvlist_lookup_string(props, LIBSES_PROP_PART, &part);
(void) nvlist_lookup_string(props, LIBSES_PROP_SERIAL, &serial);
topo_mod_dprintf(mod, "adding %s %llu", nodename, instance);
/*
* Create the node. The interesting information is all copied from the
* parent enclosure node, so there is not much to do.
*/
if ((auth = topo_mod_auth(mod, pnode)) == NULL)
goto error;
/*
* We want to report revision information for the controller nodes, but
* we do not get per-element revision information. However, we do have
* revision information for the entire enclosure, and we can use the
* 'reported-via' property to know that this controller corresponds to
* the given revision information. This means we cannot get revision
* information for targets we are not explicitly connected to, but
* there is little we can do about the situation.
*/
if (strcmp(nodename, CONTROLLER) == 0 &&
nvlist_lookup_boolean_value(props, SES_PROP_REPORT, &report) == 0 &&
report) {
for (parent = ses_node_parent(np); parent != NULL;
parent = ses_node_parent(parent)) {
if (ses_node_type(parent) == SES_NODE_ENCLOSURE) {
(void) nvlist_lookup_string(
ses_node_props(parent),
SES_EN_PROP_REV, &revision);
break;
}
}
}
if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION,
nodename, (topo_instance_t)instance, NULL, auth, part, revision,
serial)) == NULL) {
topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
if ((tn = topo_node_bind(mod, pnode, nodename,
instance, fmri)) == NULL) {
topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
/*
* For the node label, we look for the following in order:
*
* <ses-description>
* <ses-class-description> <instance>
* <default-type-label> <instance>
*/
if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 ||
desc[0] == '\0') {
parent = ses_node_parent(np);
aprops = ses_node_props(parent);
if (nvlist_lookup_string(aprops, SES_PROP_CLASS_DESCRIPTION,
&desc) == 0 && desc[0] != '\0')
labelname = desc;
(void) snprintf(label, sizeof (label), "%s %llu", desc,
instance);
desc = label;
}
if (topo_node_label_set(tn, desc, &err) != 0)
goto error;
if (ses_set_standard_props(mod, tn, NULL, ses_node_id(np),
snp->sen_target->set_devpath) != 0)
goto error;
if (strcmp(nodename, "bay") == 0) {
if (ses_add_bay_props(mod, tn, snp) != 0)
goto error;
if (ses_create_disk(sdp, tn, props) != 0)
goto error;
if (topo_method_register(mod, tn, ses_bay_methods) != 0) {
topo_mod_dprintf(mod,
"topo_method_register() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
} else {
/*
* Only fan, psu, and controller nodes have a 'present' method.
* Bay nodes are always present, and disk nodes are present by
* virtue of being enumerated.
*/
if (topo_method_register(mod, tn, ses_component_methods) != 0) {
topo_mod_dprintf(mod,
"topo_method_register() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
}
snp->sen_target->set_refcount++;
topo_node_setspecific(tn, snp->sen_target);
nvlist_free(auth);
nvlist_free(fmri);
return (0);
error:
nvlist_free(auth);
nvlist_free(fmri);
return (-1);
}
/*
* Instantiate any children of a given type.
*/
static int
ses_create_children(ses_enum_data_t *sdp, tnode_t *pnode, uint64_t type,
const char *nodename, const char *defaultlabel, ses_enum_chassis_t *cp,
boolean_t dorange)
{
topo_mod_t *mod = sdp->sed_mod;
boolean_t found;
uint64_t max;
ses_enum_node_t *snp;
/*
* First go through and count how many matching nodes we have.
*/
max = 0;
found = B_FALSE;
for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
snp = topo_list_next(snp)) {
if (snp->sen_type == type) {
found = B_TRUE;
if (snp->sen_instance > max)
max = snp->sen_instance;
}
}
/*
* No enclosure should export both DEVICE and ARRAY_DEVICE elements.
* Since we map both of these to 'disk', if an enclosure does this, we
* just ignore the array elements.
*/
if (!found ||
(type == SES_ET_ARRAY_DEVICE && cp->sec_hasdev))
return (0);
topo_mod_dprintf(mod, "%s: creating %llu %s nodes",
cp->sec_csn, max + 1, nodename);
if (dorange && topo_node_range_create(mod, pnode,
nodename, 0, max) != 0) {
topo_mod_dprintf(mod,
"topo_node_create_range() failed: %s",
topo_mod_errmsg(mod));
return (-1);
}
for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
snp = topo_list_next(snp)) {
if (snp->sen_type == type) {
if (ses_create_generic(sdp, snp, pnode,
nodename, defaultlabel) != 0)
return (-1);
}
}
return (0);
}
/*
* Instantiate a new subchassis instance in the topology.
*/
static int
ses_create_subchassis(ses_enum_data_t *sdp, tnode_t *pnode,
ses_enum_chassis_t *scp)
{
topo_mod_t *mod = sdp->sed_mod;
tnode_t *tn;
nvlist_t *props;
nvlist_t *auth = NULL, *fmri = NULL;
char *part = NULL, *revision = NULL;
uint64_t instance = scp->sec_instance;
char *desc;
char label[128];
char **paths;
int i, err;
ses_enum_target_t *stp;
int ret = -1;
/*
* Copy authority information from parent enclosure node
*/
if ((auth = topo_mod_auth(mod, pnode)) == NULL)
goto error;
/*
* Record the subchassis serial number in the FMRI.
* For now, we assume that logical id is the subchassis serial number.
* If this assumption changes in future, then the following
* piece of code will need to be updated via an RFE.
*/
if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION,
SUBCHASSIS, (topo_instance_t)instance, NULL, auth, part, revision,
scp->sec_lid)) == NULL) {
topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
if ((tn = topo_node_bind(mod, pnode, SUBCHASSIS,
instance, fmri)) == NULL) {
topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
props = ses_node_props(scp->sec_enclosure);
/*
* Look for the subchassis label in the following order:
* <ses-description>
* <ses-class-description> <instance>
* <default-type-label> <instance>
*
* For subchassis, the default label is "SUBCHASSIS"
*/
if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 ||
desc[0] == '\0') {
if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION,
&desc) == 0 && desc[0] != '\0')
(void) snprintf(label, sizeof (label), "%s %llu", desc,
instance);
else
(void) snprintf(label, sizeof (label),
"SUBCHASSIS %llu", instance);
desc = label;
}
if (topo_node_label_set(tn, desc, &err) != 0)
goto error;
if (ses_set_standard_props(mod, tn, NULL,
ses_node_id(scp->sec_enclosure), scp->sec_target->set_devpath) != 0)
goto error;
/*
* For enclosures, we want to include all possible targets (for upgrade
* purposes).
*/
for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL;
stp = topo_list_next(stp), i++)
;
verify(i != 0);
paths = alloca(i * sizeof (char *));
for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL;
stp = topo_list_next(stp), i++)
paths[i] = stp->set_devpath;
if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths,
i, &err) != 0) {
topo_mod_dprintf(mod, "failed to create property %s: %s\n",
TOPO_PROP_PATHS, topo_strerror(err));
goto error;
}
if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) {
topo_mod_dprintf(mod, "topo_method_register() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
/*
* Create the nodes for controllers and bays.
*/
if (ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS,
CONTROLLER, "CONTROLLER", scp, B_TRUE) != 0 ||
ses_create_children(sdp, tn, SES_ET_DEVICE,
BAY, "BAY", scp, B_TRUE) != 0 ||
ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE,
BAY, "BAY", scp, B_TRUE) != 0)
goto error;
ret = 0;
error:
nvlist_free(auth);
nvlist_free(fmri);
return (ret);
}
/*
* Instantiate a new chassis instance in the topology.
*/
static int
ses_create_chassis(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp)
{
topo_mod_t *mod = sdp->sed_mod;
nvlist_t *props;
char *raw_manufacturer, *raw_model, *raw_revision;
char *manufacturer = NULL, *model = NULL, *product = NULL;
char *revision = NULL;
char *serial;
char **paths;
size_t prodlen;
tnode_t *tn;
nvlist_t *fmri = NULL, *auth = NULL;
int ret = -1;
ses_enum_node_t *snp;
ses_enum_target_t *stp;
ses_enum_chassis_t *scp;
int i, err;
uint64_t sc_count = 0;
/*
* Ignore any internal enclosures.
*/
if (cp->sec_internal)
return (0);
/*
* Check to see if there are any devices presennt in the chassis. If
* not, ignore the chassis alltogether. This is most useful for
* ignoring internal HBAs that present a SES target but don't actually
* manage any of the devices.
*/
for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
snp = topo_list_next(snp)) {
if (snp->sen_type == SES_ET_DEVICE ||
snp->sen_type == SES_ET_ARRAY_DEVICE)
break;
}
if (snp == NULL)
return (0);
props = ses_node_props(cp->sec_enclosure);
/*
* We use the following property mappings:
*
* manufacturer vendor-id
* model product-id
* serial-number libses-chassis-serial
*/
verify(nvlist_lookup_string(props, SES_EN_PROP_VID,
&raw_manufacturer) == 0);
verify(nvlist_lookup_string(props, SES_EN_PROP_PID, &raw_model) == 0);
verify(nvlist_lookup_string(props, SES_EN_PROP_REV,
&raw_revision) == 0);
verify(nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, &serial) == 0);
/*
* To construct the authority information, we 'clean' each string by
* removing any offensive characters and trimmming whitespace. For the
* 'product-id', we use a concatenation of 'manufacturer-model'. We
* also take the numerical serial number and convert it to a string.
*/
if ((manufacturer = disk_auth_clean(mod, raw_manufacturer)) == NULL ||
(model = disk_auth_clean(mod, raw_model)) == NULL ||
(revision = disk_auth_clean(mod, raw_revision)) == NULL) {
goto error;
}
prodlen = strlen(manufacturer) + strlen(model) + 2;
if ((product = topo_mod_alloc(mod, prodlen)) == NULL)
goto error;
(void) snprintf(product, prodlen, "%s-%s", manufacturer, model);
/*
* Construct the topo node and bind it to our parent.
*/
if (topo_mod_nvalloc(mod, &auth, NV_UNIQUE_NAME) != 0)
goto error;
if (nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT, product) != 0 ||
nvlist_add_string(auth, FM_FMRI_AUTH_CHASSIS, serial) != 0) {
(void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
goto error;
}
/*
* We pass NULL for the parent FMRI because there is no resource
* associated with it. For the toplevel enclosure, we leave the
* serial/part/revision portions empty, which are reserved for
* individual components within the chassis.
*/
if ((fmri = topo_mod_hcfmri(mod, NULL, FM_HC_SCHEME_VERSION,
SES_ENCLOSURE, cp->sec_instance, NULL, auth,
model, revision, serial)) == NULL) {
topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
if ((tn = topo_node_bind(mod, pnode, SES_ENCLOSURE,
cp->sec_instance, fmri)) == NULL) {
topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) {
topo_mod_dprintf(mod,
"topo_method_register() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
if (ses_set_standard_props(mod, tn, auth,
ses_node_id(cp->sec_enclosure), cp->sec_target->set_devpath) != 0)
goto error;
/*
* For enclosures, we want to include all possible targets (for upgrade
* purposes).
*/
for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL;
stp = topo_list_next(stp), i++)
;
verify(i != 0);
paths = alloca(i * sizeof (char *));
for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL;
stp = topo_list_next(stp), i++)
paths[i] = stp->set_devpath;
if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths,
i, &err) != 0) {
topo_mod_dprintf(mod,
"failed to create property %s: %s\n",
TOPO_PROP_PATHS, topo_strerror(err));
goto error;
}
/*
* Create the nodes for power supplies, fans, and devices.
*/
if (ses_create_children(sdp, tn, SES_ET_POWER_SUPPLY,
PSU, "PSU", cp, B_TRUE) != 0 ||
ses_create_children(sdp, tn, SES_ET_COOLING,
FAN, "FAN", cp, B_TRUE) != 0 ||
ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS,
CONTROLLER, "CONTROLLER", cp, B_TRUE) != 0 ||
ses_create_children(sdp, tn, SES_ET_DEVICE,
BAY, "BAY", cp, B_TRUE) != 0 ||
ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE,
BAY, "BAY", cp, B_TRUE) != 0)
goto error;
if (cp->sec_scinstance > 0 &&
topo_node_range_create(mod, tn, SUBCHASSIS, 0,
cp->sec_scinstance - 1) != 0) {
topo_mod_dprintf(mod, "topo_node_create_range() failed: %s",
topo_mod_errmsg(mod));
goto error;
}
for (scp = topo_list_next(&cp->sec_subchassis); scp != NULL;
scp = topo_list_next(scp)) {
if (ses_create_subchassis(sdp, tn, scp) != 0)
goto error;
topo_mod_dprintf(mod, "created Subchassis node with "
"LID (%s)\n and target (%s) under Chassis with CSN (%s)",
scp->sec_lid, scp->sec_target->set_devpath, cp->sec_csn);
sc_count++;
}
topo_mod_dprintf(mod, "%s: created %llu %s nodes",
cp->sec_csn, sc_count, SUBCHASSIS);
cp->sec_target->set_refcount++;
topo_node_setspecific(tn, cp->sec_target);
ret = 0;
error:
topo_mod_strfree(mod, manufacturer);
topo_mod_strfree(mod, model);
topo_mod_strfree(mod, revision);
topo_mod_strfree(mod, product);
nvlist_free(fmri);
nvlist_free(auth);
return (ret);
}
/*
* Create a bay node explicitly enumerated via XML.
*/
static int
ses_create_bays(ses_enum_data_t *sdp, tnode_t *pnode)
{
topo_mod_t *mod = sdp->sed_mod;
ses_enum_chassis_t *cp;
/*
* Iterate over chassis looking for an internal enclosure. This
* property is set via a vendor-specific plugin, and there should only
* ever be a single internal chassis in a system.
*/
for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL;
cp = topo_list_next(cp)) {
if (cp->sec_internal)
break;
}
if (cp == NULL) {
topo_mod_dprintf(mod, "failed to find internal chassis\n");
return (-1);
}
if (ses_create_children(sdp, pnode, SES_ET_DEVICE,
BAY, "BAY", cp, B_FALSE) != 0 ||
ses_create_children(sdp, pnode, SES_ET_ARRAY_DEVICE,
BAY, "BAY", cp, B_FALSE) != 0)
return (-1);
return (0);
}
/*
* Initialize chassis or subchassis.
*/
static int
ses_init_chassis(topo_mod_t *mod, ses_enum_data_t *sdp, ses_enum_chassis_t *pcp,
ses_enum_chassis_t *cp, ses_node_t *np, nvlist_t *props,
char *lid, ses_chassis_type_e flags)
{
boolean_t internal, ident;
assert((flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS |
SES_DUP_CHASSIS | SES_DUP_SUBCHASSIS)) != 0);
assert((cp != NULL) && (np != NULL) && (props != NULL) &&
(lid != NULL));
if (flags & (SES_NEW_SUBCHASSIS | SES_DUP_SUBCHASSIS))
assert(pcp != NULL);
topo_mod_dprintf(mod, "ses_init_chassis: %s: lid(%s), flags (%d)",
sdp->sed_name, lid, flags);
if (flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS)) {
topo_mod_dprintf(mod, "new chassis/subchassis");
if (nvlist_lookup_boolean_value(props,
LIBSES_EN_PROP_INTERNAL, &internal) == 0)
cp->sec_internal = internal;
cp->sec_lid = lid;
cp->sec_enclosure = np;
cp->sec_target = sdp->sed_target;
if (flags & SES_NEW_CHASSIS) {
cp->sec_instance = sdp->sed_instance++;
topo_list_append(&sdp->sed_chassis, cp);
} else {
cp->sec_instance = pcp->sec_scinstance++;
topo_list_append(&pcp->sec_subchassis, cp);
}
} else {
topo_mod_dprintf(mod, "dup chassis/subchassis");
if (nvlist_lookup_boolean_value(props,
SES_PROP_IDENT, &ident) == 0) {
topo_mod_dprintf(mod, "overriding enclosure node");
cp->sec_enclosure = np;
cp->sec_target = sdp->sed_target;
}
}
topo_list_append(&cp->sec_targets, sdp->sed_target);
sdp->sed_current = cp;
return (0);
}
/*
* Gather nodes from the current SES target into our chassis list, merging the
* results if necessary.
*/
static ses_walk_action_t
ses_enum_gather(ses_node_t *np, void *data)
{
nvlist_t *props = ses_node_props(np);
ses_enum_data_t *sdp = data;
topo_mod_t *mod = sdp->sed_mod;
ses_enum_chassis_t *cp, *scp;
ses_enum_node_t *snp;
ses_alt_node_t *sap;
char *csn;
uint64_t instance, type;
uint64_t prevstatus, status;
boolean_t report;
boolean_t have_subchassis = B_TRUE;
char *lid;
if (ses_node_type(np) == SES_NODE_ENCLOSURE) {
/*
* If we have already identified the chassis for this target,
* then this is a secondary enclosure and we should ignore it,
* along with the rest of the tree (since this is depth-first).
*/
if (sdp->sed_current != NULL)
return (SES_WALK_ACTION_TERMINATE);
/*
* Go through the list of chassis we have seen so far and see
* if this serial number matches one of the known values.
* If so, check whether this enclosure is a subchassis.
*/
if (nvlist_lookup_string(props, LIBSES_EN_PROP_CSN,
&csn) != 0)
return (SES_WALK_ACTION_TERMINATE);
if (nvlist_lookup_string(props, LIBSES_EN_PROP_SUBCHASSIS_ID,
&lid) != 0) {
have_subchassis = B_FALSE;
if ((lid = topo_mod_zalloc(mod, sizeof (char))) == NULL)
goto error;
}
topo_mod_dprintf(mod, "ses_enum_gather: Enclosure Node (%s) "
"CSN (%s), LID (%s)", sdp->sed_name, csn, lid);
/*
* We need to determine whether this enclosure node
* represents a chassis or a subchassis. Since we may
* receive the enclosure nodes in a non-deterministic
* manner, we need to account for all possible combinations:
* 1. Chassis for the current CSN has not yet been
* allocated
* 1.1 This is a new chassis:
* allocate and instantiate the chassis
* 1.2 This is a new subchassis:
* allocate a placeholder chassis
* allocate and instantiate the subchassis
* link the subchassis to the chassis
* 2. Chassis for the current CSN has been allocated
* 2.1 This is a duplicate chassis enclosure
* check whether to override old chassis
* append to chassis' target list
* 2.2 Only placeholder chassis exists
* fill in the chassis fields
* 2.3 This is a new subchassis
* allocate and instantiate the subchassis
* link the subchassis to the chassis
* 2.4 This is a duplicate subchassis enclosure
* check whether to override old chassis
* append to chassis' target list
*/
for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL;
cp = topo_list_next(cp))
if (strcmp(cp->sec_csn, csn) == 0)
break;
if (cp == NULL) {
/* 1. Haven't seen a chassis with this CSN before */
if ((cp = topo_mod_zalloc(mod,
sizeof (ses_enum_chassis_t))) == NULL)
goto error;
cp->sec_csn = csn;
if (!have_subchassis || strcmp(csn, lid) == 0) {
/* 1.1 This is a new chassis */
topo_mod_dprintf(mod, "%s: Initialize new "
"chassis with CSN (%s) and LID (%s)",
sdp->sed_name, csn, lid);
if (ses_init_chassis(mod, sdp, NULL, cp,
np, props, lid, SES_NEW_CHASSIS) < 0)
goto error;
} else {
/* 1.2 This is a new subchassis */
topo_mod_dprintf(mod, "%s: Initialize new "
"subchassis with CSN (%s) and LID (%s)",
sdp->sed_name, csn, lid);
if ((scp = topo_mod_zalloc(mod,
sizeof (ses_enum_chassis_t))) == NULL)
goto error;
scp->sec_csn = csn;
if (ses_init_chassis(mod, sdp, cp, scp,
np, props, lid, SES_NEW_SUBCHASSIS) < 0)
goto error;
}
} else {
/* 2. We have a chassis with this CSN */
if (!have_subchassis || strcmp(csn, lid) == 0) {
/* This is a chassis */
if (!have_subchassis ||
strlen(cp->sec_lid) > 0) {
/* 2.1 This is a duplicate chassis */
topo_mod_dprintf(mod, "%s: Append "
"duplicate chassis with CSN (%s) "
"and LID (%s)",
sdp->sed_name, csn, lid);
if (ses_init_chassis(mod, sdp, NULL, cp,
np, props, lid,
SES_DUP_CHASSIS) < 0)
goto error;
} else {
/* 2.2 Init the placeholder chassis */
topo_mod_dprintf(mod, "%s: Initialize"
"placeholder chassis with CSN (%s) "
"and LID (%s)",
sdp->sed_name, csn, lid);
if (ses_init_chassis(mod, sdp, NULL, cp,
np, props, lid,
SES_NEW_CHASSIS) < 0)
goto error;
}
} else {
/* This is a subchassis */
for (scp = topo_list_next(&cp->sec_subchassis);
scp != NULL; scp = topo_list_next(scp))
if (strcmp(scp->sec_lid, lid) == 0)
break;
if (scp == NULL) {
/* 2.3 This is a new subchassis */
topo_mod_dprintf(mod, "%s: Initialize "
"new subchassis with CSN (%s) "
"and LID (%s)",
sdp->sed_name, csn, lid);
if ((scp = topo_mod_zalloc(mod,
sizeof (ses_enum_chassis_t)))
== NULL)
goto error;
scp->sec_csn = csn;
if (ses_init_chassis(mod, sdp, cp, scp,
np, props, lid,
SES_NEW_SUBCHASSIS) < 0)
goto error;
} else {
/* 2.4 This is a duplicate subchassis */
topo_mod_dprintf(mod, "%s: Append "
"duplicate subchassis with "
"CSN (%s) and LID (%s)",
sdp->sed_name, csn, lid);
if (ses_init_chassis(mod, sdp, cp, scp,
np, props, lid,
SES_DUP_SUBCHASSIS) < 0)
goto error;
}
}
}
} else if (ses_node_type(np) == SES_NODE_ELEMENT) {
/*
* If we haven't yet seen an enclosure node and identified the
* current chassis, something is very wrong; bail out.
*/
if (sdp->sed_current == NULL)
return (SES_WALK_ACTION_TERMINATE);
/*
* If this isn't one of the element types we care about, then
* ignore it.
*/
verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_TYPE,
&type) == 0);
if (type != SES_ET_DEVICE &&
type != SES_ET_ARRAY_DEVICE &&
type != SES_ET_COOLING &&
type != SES_ET_POWER_SUPPLY &&
type != SES_ET_ESC_ELECTRONICS)
return (SES_WALK_ACTION_CONTINUE);
/*
* Get the current instance number and see if we already know
* about this element. If so, it means we have multiple paths
* to the same elements, and we should ignore the current path.
*/
verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_CLASS_INDEX,
&instance) == 0);
if (type == SES_ET_DEVICE || type == SES_ET_ARRAY_DEVICE)
(void) nvlist_lookup_uint64(props, SES_PROP_BAY_NUMBER,
&instance);
cp = sdp->sed_current;
for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
snp = topo_list_next(snp)) {
if (snp->sen_type == type &&
snp->sen_instance == instance)
break;
}
/*
* We prefer the new element under the following circumstances:
*
* - The currently known element's status is unknown or not
* available, but the new element has a known status. This
* occurs if a given element is only available through a
* particular target.
*
* - This is an ESC_ELECTRONICS element, and the 'reported-via'
* property is set. This allows us to get reliable firmware
* revision information from the enclosure node.
*/
if (snp != NULL) {
if (nvlist_lookup_uint64(
ses_node_props(snp->sen_node),
SES_PROP_STATUS_CODE, &prevstatus) != 0)
prevstatus = SES_ESC_UNSUPPORTED;
if (nvlist_lookup_uint64(
props, SES_PROP_STATUS_CODE, &status) != 0)
status = SES_ESC_UNSUPPORTED;
if (nvlist_lookup_boolean_value(
props, SES_PROP_REPORT, &report) != 0)
report = B_FALSE;
if ((SES_STATUS_UNAVAIL(prevstatus) &&
!SES_STATUS_UNAVAIL(status)) ||
(type == SES_ET_ESC_ELECTRONICS &&
report)) {
snp->sen_node = np;
snp->sen_target = sdp->sed_target;
}
if ((sap = topo_mod_zalloc(mod,
sizeof (ses_alt_node_t))) == NULL)
goto error;
sap->san_node = np;
topo_list_append(&snp->sen_alt_nodes, sap);
return (SES_WALK_ACTION_CONTINUE);
}
if ((snp = topo_mod_zalloc(mod,
sizeof (ses_enum_node_t))) == NULL)
goto error;
if ((sap = topo_mod_zalloc(mod,
sizeof (ses_alt_node_t))) == NULL) {
topo_mod_free(mod, snp, sizeof (ses_enum_node_t));
goto error;
}
topo_mod_dprintf(mod, "%s: adding node (%llu, %llu)",
sdp->sed_name, type, instance);
snp->sen_node = np;
snp->sen_type = type;
snp->sen_instance = instance;
snp->sen_target = sdp->sed_target;
sap->san_node = np;
topo_list_append(&snp->sen_alt_nodes, sap);
topo_list_append(&cp->sec_nodes, snp);
if (type == SES_ET_DEVICE)
cp->sec_hasdev = B_TRUE;
}
return (SES_WALK_ACTION_CONTINUE);
error:
sdp->sed_errno = -1;
return (SES_WALK_ACTION_TERMINATE);
}
static int
ses_process_dir(const char *dirpath, ses_enum_data_t *sdp)
{
topo_mod_t *mod = sdp->sed_mod;
DIR *dir;
struct dirent *dp;
char path[PATH_MAX];
ses_enum_target_t *stp;
int err = -1;
/*
* Open the SES target directory and iterate over any available
* targets.
*/
if ((dir = opendir(dirpath)) == NULL) {
/*
* If the SES target directory does not exist, then return as if
* there are no active targets.
*/
topo_mod_dprintf(mod, "failed to open ses "
"directory '%s'", dirpath);
return (0);
}
while ((dp = readdir(dir)) != NULL) {
if (strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0)
continue;
/*
* Create a new target instance and take a snapshot.
*/
if ((stp = topo_mod_zalloc(mod,
sizeof (ses_enum_target_t))) == NULL)
goto error;
(void) pthread_mutex_init(&stp->set_lock, NULL);
(void) snprintf(path, sizeof (path), "%s/%s", dirpath,
dp->d_name);
/*
* We keep track of the SES device path and export it on a
* per-node basis to allow higher level software to get to the
* corresponding SES state.
*/
if ((stp->set_devpath = topo_mod_strdup(mod, path)) == NULL) {
topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
goto error;
}
if ((stp->set_target =
ses_open(LIBSES_VERSION, path)) == NULL) {
topo_mod_dprintf(mod, "failed to open ses target "
"'%s': %s", dp->d_name, ses_errmsg());
topo_mod_strfree(mod, stp->set_devpath);
topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
continue;
}
stp->set_refcount = 1;
sdp->sed_target = stp;
stp->set_snap = ses_snap_hold(stp->set_target);
stp->set_snaptime = gethrtime();
/*
* Enumerate over all SES elements and merge them into the
* correct ses_enum_chassis_t.
*/
sdp->sed_current = NULL;
sdp->sed_errno = 0;
sdp->sed_name = dp->d_name;
(void) ses_walk(stp->set_snap, ses_enum_gather, sdp);
if (sdp->sed_errno != 0)
goto error;
}
err = 0;
error:
closedir(dir);
return (err);
}
static void
ses_release(topo_mod_t *mod, tnode_t *tn)
{
ses_enum_target_t *stp;
if ((stp = topo_node_getspecific(tn)) != NULL)
ses_target_free(mod, stp);
}
/*ARGSUSED*/
static int
ses_enum(topo_mod_t *mod, tnode_t *rnode, const char *name,
topo_instance_t min, topo_instance_t max, void *arg, void *notused)
{
ses_enum_chassis_t *cp;
ses_enum_data_t *data;
/*
* Check to make sure we're being invoked sensibly, and that we're not
* being invoked as part of a post-processing step.
*/
if (strcmp(name, SES_ENCLOSURE) != 0 && strcmp(name, BAY) != 0)
return (0);
/*
* If this is the first time we've called our enumeration method, then
* gather information about any available enclosures.
*/
if ((data = topo_mod_getspecific(mod)) == NULL) {
if ((data = topo_mod_zalloc(mod, sizeof (ses_enum_data_t))) ==
NULL)
return (-1);
data->sed_mod = mod;
topo_mod_setspecific(mod, data);
if (disk_list_gather(mod, &data->sed_disks) != 0)
goto error;
/*
* We search both the ses(7D) and sgen(7D) locations, so we are
* independent of any particular driver class bindings.
*/
if (ses_process_dir("/dev/es", data) != 0 ||
ses_process_dir("/dev/scsi/ses", data) != 0)
goto error;
}
if (strcmp(name, SES_ENCLOSURE) == 0) {
/*
* This is a request to enumerate external enclosures. Go
* through all the targets and create chassis nodes where
* necessary.
*/
for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
cp = topo_list_next(cp)) {
if (ses_create_chassis(data, rnode, cp) != 0)
goto error;
}
} else {
/*
* This is a request to enumerate a specific bay underneath the
* root chassis (for internal disks).
*/
if (ses_create_bays(data, rnode) != 0)
goto error;
}
/*
* This is a bit of a kludge. In order to allow internal disks to be
* enumerated and share snapshot-specific information with the external
* enclosure enumeration, we rely on the fact that we will be invoked
* for the 'ses-enclosure' node last.
*/
if (strcmp(name, SES_ENCLOSURE) == 0) {
for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
cp = topo_list_next(cp))
ses_data_free(data, cp);
ses_data_free(data, NULL);
topo_mod_setspecific(mod, NULL);
}
return (0);
error:
for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
cp = topo_list_next(cp))
ses_data_free(data, cp);
ses_data_free(data, NULL);
topo_mod_setspecific(mod, NULL);
return (-1);
}
static const topo_modops_t ses_ops =
{ ses_enum, ses_release };
static topo_modinfo_t ses_info =
{ SES_ENCLOSURE, FM_FMRI_SCHEME_HC, SES_VERSION, &ses_ops };
/*ARGSUSED*/
int
_topo_init(topo_mod_t *mod, topo_version_t version)
{
if (getenv("TOPOSESDEBUG") != NULL)
topo_mod_setdebug(mod);
topo_mod_dprintf(mod, "initializing %s enumerator\n",
SES_ENCLOSURE);
return (topo_mod_register(mod, &ses_info, TOPO_VERSION));
}
void
_topo_fini(topo_mod_t *mod)
{
topo_mod_unregister(mod);
}