/* * 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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright 2020 Joyent, Inc. */ /* * Topology Nodes * * Topology nodes, tnode_t, are data structures containing per-FMRI * information and are linked together to form the topology tree. * Nodes are created during the enumeration process of topo_snap_hold() * and destroyed during topo_snap_rele(). For the most part, tnode_t data * is read-only and no lock protection is required. Nodes are * held in place during tree walk functions. Tree walk functions * may access node data safely without locks. The exception to this rule * is data associated with node properties (topo_prop.c). Properties * may change at anytime and are protected by a per-property locking * strategy. * * Enumerator plugin modules may also safely access topology nodes within their * scope of operation: the parent node passed into the enumeration op or those * nodes created by the enumerator. Enumeration occurs only during * topo_snap_hold() where a per-topo_hdl_t lock prevents multi-threaded access * to the topology trees. * * Enumerator method operation functions may safely access and change topology * node property data, and contruct or destroy child nodes for the node * on which the operation applies. The method may also be called to destroy * the node for which the method operation is called. This permits * dynamic topology tree snapshots and partial enumerations for branches that * may not be needed right away. * * Node Interfaces * * Nodes are created when an enumerator calls topo_node_bind(). Prior to * calling topo_node_bind(), the enumerator should have reserved a range of * node instances with topo_node_range_create(). topo_node_range_create() * does not allocate any node resources but creates the infrastruture * required for a fully populated topology level. This allows enumerators * reading from a -topology.xml file to parse the file for a range * of resources before confirming the existence of a resource via a helper * plugin. Only when the resource has been confirmed to exist should * the node be bound. * * Node range and node linkage and unlinkage is performed during enumeration and * method operations when it is safe to change node hash lists. Nodes and node * ranges are deallocated when all references to the node have been released: * last walk completes and topo_snap_rele() is called. * * Node Hash/Ranges * * Each parent node may have one or more ranges of child nodes. Each range * is uniquely named and serves as a hash list of like sibling nodes with * different instance numbers. A parent may have more than one node hash * (child range). If that is the case, the hash lists are strung together to * form sibling relationships between ranges. Hash/Ranges are sparsely * populated with only nodes that have represented resources in the system. * * _________________ * | | * | tnode_t | ----------------------------- * | tn_phash ---> | topo_nodehash_t | * | (children)| | th_nodearr (instances)| * ----------------- | ------------------- | * | ---| 0 | 1 | ...| N | | * | | ------------------- | ------------------- * | | th_list (siblings) ----->| topo_nodehash_t | * | | | ------------------- * ---|------------------------- * | * v * ----------- * | tnode_t | * ----------- * * Facility Nodes * * Facility nodes are always leaf nodes in the topology and represent a FMRI * sensor or indicator facility for the path to which it is connected. * Facility nodes are bound to the topology with topo_node_facbind() and * unbound with topo_node_unbind(). */ #include #include #include #include #include #include #include #include #include #include static topo_pgroup_info_t protocol_pgroup = { TOPO_PGROUP_PROTOCOL, TOPO_STABILITY_PRIVATE, TOPO_STABILITY_PRIVATE, 1 }; static const topo_pgroup_info_t auth_pgroup = { FM_FMRI_AUTHORITY, TOPO_STABILITY_PRIVATE, TOPO_STABILITY_PRIVATE, 1 }; static void topo_node_destroy(tnode_t *node) { int i; tnode_t *pnode; topo_nodehash_t *nhp; topo_mod_t *hmod, *mod; if (node == NULL) return; pnode = node->tn_parent; mod = node->tn_enum; topo_dprintf(mod->tm_hdl, TOPO_DBG_MODSVC, "destroying node %s=%d\n", topo_node_name(node), topo_node_instance(node)); assert(node->tn_refs == 0); /* * If not a root node, remove this node from the parent's node hash */ if (!(node->tn_state & TOPO_NODE_ROOT)) { topo_node_lock(pnode); nhp = node->tn_phash; for (i = 0; i < nhp->th_arrlen; i++) { if (node == nhp->th_nodearr[i]) { nhp->th_nodearr[i] = NULL; /* * Release hold on parent */ --pnode->tn_refs; if (pnode->tn_refs == 0) topo_node_destroy(pnode); } } topo_node_unlock(pnode); } topo_node_unlock(node); /* * Allow enumerator to clean-up private data and then release * ref count */ if (mod->tm_info->tmi_ops->tmo_release != NULL) mod->tm_info->tmi_ops->tmo_release(mod, node); topo_method_unregister_all(mod, node); /* * Destroy all node hash lists */ while ((nhp = topo_list_next(&node->tn_children)) != NULL) { for (i = 0; i < nhp->th_arrlen; i++) { assert(nhp->th_nodearr[i] == NULL); } hmod = nhp->th_enum; topo_mod_strfree(hmod, nhp->th_name); topo_mod_free(hmod, nhp->th_nodearr, nhp->th_arrlen * sizeof (tnode_t *)); topo_list_delete(&node->tn_children, nhp); topo_mod_free(hmod, nhp, sizeof (topo_nodehash_t)); topo_mod_rele(hmod); } /* * Nodes in a directed graph structure have no children, so the node * name is still intact. We must free it now. */ if (node->tn_vtx != NULL) { topo_mod_strfree(mod, node->tn_name); } /* * Destroy all property data structures, free the node and release * the module that created it */ topo_pgroup_destroy_all(node); topo_mod_free(mod, node, sizeof (tnode_t)); topo_mod_rele(mod); } void topo_node_lock(tnode_t *node) { (void) pthread_mutex_lock(&node->tn_lock); } void topo_node_unlock(tnode_t *node) { (void) pthread_mutex_unlock(&node->tn_lock); } void topo_node_hold(tnode_t *node) { topo_node_lock(node); ++node->tn_refs; topo_node_unlock(node); } void topo_node_rele(tnode_t *node) { topo_node_lock(node); --node->tn_refs; /* * Ok to remove this node from the topo tree and destroy it */ if (node->tn_refs == 0) topo_node_destroy(node); else topo_node_unlock(node); } char * topo_node_name(tnode_t *node) { return (node->tn_name); } topo_instance_t topo_node_instance(tnode_t *node) { return (node->tn_instance); } tnode_t * topo_node_parent(tnode_t *node) { return (node->tn_parent); } topo_vertex_t * topo_node_vertex(tnode_t *node) { return (node->tn_vtx); } int topo_node_flags(tnode_t *node) { return (node->tn_fflags); } void topo_node_setspecific(tnode_t *node, void *data) { node->tn_priv = data; } void * topo_node_getspecific(tnode_t *node) { return (node->tn_priv); } static int node_create_seterror(topo_mod_t *mod, tnode_t *pnode, topo_nodehash_t *nhp, int err) { topo_node_unlock(pnode); topo_dprintf(mod->tm_hdl, TOPO_DBG_ERR, "unable to insert child:" "%s\n", topo_strerror(err)); if (nhp != NULL) { if (nhp->th_name != NULL) topo_mod_strfree(mod, nhp->th_name); if (nhp->th_nodearr != NULL) { topo_mod_free(mod, nhp->th_nodearr, nhp->th_arrlen * sizeof (tnode_t *)); } topo_mod_free(mod, nhp, sizeof (topo_nodehash_t)); } return (topo_mod_seterrno(mod, err)); } int topo_node_range_create(topo_mod_t *mod, tnode_t *pnode, const char *name, topo_instance_t min, topo_instance_t max) { topo_nodehash_t *nhp; topo_node_lock(pnode); assert((pnode->tn_state & TOPO_NODE_BOUND) || (pnode->tn_state & TOPO_NODE_ROOT)); for (nhp = topo_list_next(&pnode->tn_children); nhp != NULL; nhp = topo_list_next(nhp)) { if (strcmp(nhp->th_name, name) == 0) return (node_create_seterror(mod, pnode, NULL, EMOD_NODE_DUP)); } if (max < min) return (node_create_seterror(mod, pnode, NULL, EMOD_NODE_RANGE)); if ((nhp = topo_mod_zalloc(mod, sizeof (topo_nodehash_t))) == NULL) return (node_create_seterror(mod, pnode, nhp, EMOD_NOMEM)); if ((nhp->th_name = topo_mod_strdup(mod, name)) == NULL) return (node_create_seterror(mod, pnode, nhp, EMOD_NOMEM)); nhp->th_arrlen = max - min + 1; if ((nhp->th_nodearr = topo_mod_zalloc(mod, nhp->th_arrlen * sizeof (tnode_t *))) == NULL) return (node_create_seterror(mod, pnode, nhp, EMOD_NOMEM)); nhp->th_range.tr_min = min; nhp->th_range.tr_max = max; nhp->th_enum = mod; topo_mod_hold(mod); /* * Add these nodes to parent child list */ topo_list_append(&pnode->tn_children, nhp); topo_node_unlock(pnode); topo_dprintf(mod->tm_hdl, TOPO_DBG_MODSVC, "created node range %s[%d-%d]\n", name, min, max); return (0); } void topo_node_range_destroy(tnode_t *pnode, const char *name) { int i; topo_nodehash_t *nhp; topo_mod_t *mod; topo_node_lock(pnode); for (nhp = topo_list_next(&pnode->tn_children); nhp != NULL; nhp = topo_list_next(nhp)) { if (strcmp(nhp->th_name, name) == 0) { break; } } if (nhp == NULL) { topo_node_unlock(pnode); return; } for (i = 0; i < nhp->th_arrlen; i++) assert(nhp->th_nodearr[i] == NULL); topo_list_delete(&pnode->tn_children, nhp); topo_node_unlock(pnode); mod = nhp->th_enum; if (nhp->th_name != NULL) topo_mod_strfree(mod, nhp->th_name); if (nhp->th_nodearr != NULL) { topo_mod_free(mod, nhp->th_nodearr, nhp->th_arrlen * sizeof (tnode_t *)); } topo_mod_free(mod, nhp, sizeof (topo_nodehash_t)); topo_mod_rele(mod); } tnode_t * topo_node_lookup(tnode_t *pnode, const char *name, topo_instance_t inst) { int h; tnode_t *node; topo_nodehash_t *nhp; topo_dprintf(pnode->tn_hdl, TOPO_DBG_MODSVC, "topo_node_lookup: looking for '%s' instance %d\n", name, inst); topo_node_lock(pnode); for (nhp = topo_list_next(&pnode->tn_children); nhp != NULL; nhp = topo_list_next(nhp)) { if (strcmp(nhp->th_name, name) == 0) { if (inst > nhp->th_range.tr_max || inst < nhp->th_range.tr_min) { topo_node_unlock(pnode); return (NULL); } h = topo_node_hash(nhp, inst); node = nhp->th_nodearr[h]; topo_node_unlock(pnode); return (node); } } topo_node_unlock(pnode); return (NULL); } int topo_node_hash(topo_nodehash_t *nhp, topo_instance_t inst) { return ((inst - nhp->th_range.tr_min) % nhp->th_arrlen); } static tnode_t * node_bind_seterror(topo_mod_t *mod, tnode_t *pnode, tnode_t *node, boolean_t pnode_locked, int err) { if (pnode_locked) topo_node_unlock(pnode); (void) topo_mod_seterrno(mod, err); if (node == NULL) return (NULL); topo_dprintf(mod->tm_hdl, TOPO_DBG_ERR, "unable to bind %s=%d: " "%s\n", (node->tn_name != NULL ? node->tn_name : "unknown"), node->tn_instance, topo_strerror(err)); topo_node_lock(node); /* expected to be locked */ topo_node_destroy(node); return (NULL); } tnode_t * topo_node_bind(topo_mod_t *mod, tnode_t *pnode, const char *name, topo_instance_t inst, nvlist_t *fmri) { int h, err; tnode_t *node; topo_nodehash_t *nhp; topo_node_lock(pnode); for (nhp = topo_list_next(&pnode->tn_children); nhp != NULL; nhp = topo_list_next(nhp)) { if (strcmp(nhp->th_name, name) == 0) { if (inst > nhp->th_range.tr_max || inst < nhp->th_range.tr_min) return (node_bind_seterror(mod, pnode, NULL, B_TRUE, EMOD_NODE_RANGE)); h = topo_node_hash(nhp, inst); if (nhp->th_nodearr[h] != NULL) return (node_bind_seterror(mod, pnode, NULL, B_TRUE, EMOD_NODE_BOUND)); else break; } } if (nhp == NULL) return (node_bind_seterror(mod, pnode, NULL, B_TRUE, EMOD_NODE_NOENT)); if ((node = topo_mod_zalloc(mod, sizeof (tnode_t))) == NULL) return (node_bind_seterror(mod, pnode, NULL, B_TRUE, EMOD_NOMEM)); (void) pthread_mutex_init(&node->tn_lock, NULL); node->tn_enum = mod; node->tn_hdl = mod->tm_hdl; node->tn_parent = pnode; node->tn_name = nhp->th_name; node->tn_instance = inst; node->tn_phash = nhp; node->tn_refs = 0; /* Ref count module that bound this node */ topo_mod_hold(mod); if (fmri == NULL) return (node_bind_seterror(mod, pnode, node, B_TRUE, EMOD_NVL_INVAL)); if (topo_pgroup_create(node, &protocol_pgroup, &err) < 0) return (node_bind_seterror(mod, pnode, node, B_TRUE, err)); if (topo_prop_set_fmri(node, TOPO_PGROUP_PROTOCOL, TOPO_PROP_RESOURCE, TOPO_PROP_IMMUTABLE, fmri, &err) < 0) return (node_bind_seterror(mod, pnode, node, B_TRUE, err)); topo_dprintf(mod->tm_hdl, TOPO_DBG_MODSVC, "node bound %s=%d/%s=%d\n", topo_node_name(pnode), topo_node_instance(pnode), node->tn_name, node->tn_instance); node->tn_state |= TOPO_NODE_BOUND; topo_node_hold(node); nhp->th_nodearr[h] = node; ++pnode->tn_refs; topo_node_unlock(pnode); if (topo_pgroup_create(node, &auth_pgroup, &err) == 0) { (void) topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_PRODUCT, &err); (void) topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_PRODUCT_SN, &err); (void) topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_CHASSIS, &err); (void) topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_SERVER, &err); } return (node); } tnode_t * topo_node_facbind(topo_mod_t *mod, tnode_t *pnode, const char *name, const char *type) { int h, err; tnode_t *node; topo_nodehash_t *nhp; topo_instance_t inst = 0; nvlist_t *pfmri, *fnvl; /* * Create a single entry range for this facility */ if (topo_node_range_create(mod, pnode, name, 0, 0) < 0) return (NULL); /* mod errno set */ topo_node_hold(pnode); topo_node_lock(pnode); for (nhp = topo_list_next(&pnode->tn_children); nhp != NULL; nhp = topo_list_next(nhp)) { if (strcmp(nhp->th_name, name) == 0) { if (inst > nhp->th_range.tr_max || inst < nhp->th_range.tr_min) { topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, NULL, B_TRUE, EMOD_NVL_INVAL)); } h = topo_node_hash(nhp, inst); if (nhp->th_nodearr[h] != NULL) { topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, NULL, B_TRUE, EMOD_NODE_BOUND)); } else break; } } topo_node_unlock(pnode); if (nhp == NULL) { topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, NULL, B_FALSE, EMOD_NODE_NOENT)); } if ((node = topo_mod_zalloc(mod, sizeof (tnode_t))) == NULL) { topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, NULL, B_FALSE, EMOD_NOMEM)); } (void) pthread_mutex_init(&node->tn_lock, NULL); node->tn_enum = mod; node->tn_hdl = mod->tm_hdl; node->tn_parent = pnode; node->tn_name = nhp->th_name; node->tn_instance = inst; node->tn_phash = nhp; node->tn_refs = 0; node->tn_fflags = TOPO_NODE_FACILITY; /* Ref count module that bound this node */ topo_mod_hold(mod); if (topo_pgroup_create(node, &protocol_pgroup, &err) < 0) { topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, node, B_FALSE, err)); } if (topo_mod_nvalloc(mod, &fnvl, NV_UNIQUE_NAME) < 0) { topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, node, B_FALSE, EMOD_NOMEM)); } if (nvlist_add_string(fnvl, FM_FMRI_FACILITY_NAME, name) != 0 || nvlist_add_string(fnvl, FM_FMRI_FACILITY_TYPE, type) != 0) { nvlist_free(fnvl); topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, node, B_FALSE, EMOD_FMRI_NVL)); } if (topo_node_resource(pnode, &pfmri, &err) < 0) { nvlist_free(fnvl); topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, node, B_FALSE, err)); } if (nvlist_add_nvlist(pfmri, FM_FMRI_FACILITY, fnvl) != 0) { nvlist_free(fnvl); nvlist_free(pfmri); topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, node, B_FALSE, EMOD_FMRI_NVL)); } nvlist_free(fnvl); if (topo_prop_set_fmri(node, TOPO_PGROUP_PROTOCOL, TOPO_PROP_RESOURCE, TOPO_PROP_IMMUTABLE, pfmri, &err) < 0) { nvlist_free(pfmri); topo_node_rele(pnode); return (node_bind_seterror(mod, pnode, node, B_FALSE, err)); } nvlist_free(pfmri); topo_dprintf(mod->tm_hdl, TOPO_DBG_MODSVC, "facility node bound %s=%s\n", type, node->tn_name); node->tn_state |= TOPO_NODE_BOUND; topo_node_hold(node); nhp->th_nodearr[h] = node; topo_node_lock(pnode); ++pnode->tn_refs; topo_node_unlock(pnode); topo_node_rele(pnode); if (topo_pgroup_create(node, &auth_pgroup, &err) == 0) { (void) topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_PRODUCT, &err); (void) topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_PRODUCT_SN, &err); (void) topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_CHASSIS, &err); (void) topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_SERVER, &err); } return (node); } int topo_node_facility(topo_hdl_t *thp, tnode_t *node, const char *fac_type, uint32_t fac_subtype, topo_faclist_t *faclist, int *errp) { tnode_t *tmp; nvlist_t *rsrc, *fac; char *tmp_factype; uint32_t tmp_facsubtype; boolean_t list_empty = 1; topo_faclist_t *fac_ele; bzero(faclist, sizeof (topo_faclist_t)); for (tmp = topo_child_first(node); tmp != NULL; tmp = topo_child_next(node, tmp)) { topo_node_hold(tmp); /* * If it's not a facility node, move on */ if (topo_node_flags(tmp) != TOPO_NODE_FACILITY) { topo_node_rele(tmp); continue; } /* * Lookup whether the fac type is sensor or indicator and if * it's not the type we're looking for, move on */ if (topo_node_resource(tmp, &rsrc, errp) != 0) { topo_dprintf(thp, TOPO_DBG_ERR, "Failed to get resource for node %s=%d (%s)\n", topo_node_name(node), topo_node_instance(node), topo_strerror(*errp)); topo_node_rele(tmp); return (-1); } if ((nvlist_lookup_nvlist(rsrc, "facility", &fac) != 0) || (nvlist_lookup_string(fac, FM_FMRI_FACILITY_TYPE, &tmp_factype) != 0)) { nvlist_free(rsrc); topo_node_rele(tmp); return (-1); } if (strcmp(fac_type, tmp_factype) != 0) { topo_node_rele(tmp); nvlist_free(rsrc); continue; } nvlist_free(rsrc); /* * Finally, look up the subtype, which is a property in the * facility propgroup. If it's a match return a pointer to the * node. Otherwise, move on. */ if (topo_prop_get_uint32(tmp, TOPO_PGROUP_FACILITY, TOPO_FACILITY_TYPE, &tmp_facsubtype, errp) != 0) { topo_node_rele(tmp); return (-1); } if (fac_subtype == tmp_facsubtype || fac_subtype == TOPO_FAC_TYPE_ANY) { if ((fac_ele = topo_mod_zalloc(tmp->tn_enum, sizeof (topo_faclist_t))) == NULL) { *errp = ETOPO_NOMEM; topo_node_rele(tmp); return (-1); } fac_ele->tf_node = tmp; topo_list_append(&faclist->tf_list, fac_ele); list_empty = 0; } topo_node_rele(tmp); } if (list_empty) { *errp = ETOPO_FAC_NOENT; return (-1); } return (0); } void topo_node_unbind(tnode_t *node) { if (node == NULL) return; topo_node_lock(node); if (!(node->tn_state & TOPO_NODE_BOUND)) { topo_node_unlock(node); return; } node->tn_state &= ~TOPO_NODE_BOUND; topo_node_unlock(node); topo_dprintf(node->tn_hdl, TOPO_DBG_MODSVC, "node unbound %s=%d refs = %d\n", node->tn_name, node->tn_instance, node->tn_refs); topo_node_rele(node); } /*ARGSUSED*/ int topo_node_present(tnode_t *node) { return (0); } /*ARGSUSED*/ int topo_node_contains(tnode_t *er, tnode_t *ee) { return (0); } /*ARGSUSED*/ int topo_node_unusable(tnode_t *node) { return (0); } topo_walk_t * topo_node_walk_init(topo_hdl_t *thp, topo_mod_t *mod, tnode_t *node, int (*cb_f)(), void *pdata, int *errp) { tnode_t *child; topo_walk_t *wp; topo_node_hold(node); if ((wp = topo_hdl_zalloc(thp, sizeof (topo_walk_t))) == NULL) { *errp = ETOPO_HDL_NOMEM; topo_node_rele(node); return (NULL); } /* * If this is the root of the scheme tree, start with the first * child */ topo_node_lock(node); if (node->tn_state & TOPO_NODE_ROOT) { if ((child = topo_child_first(node)) == NULL) { /* Nothing to walk */ *errp = ETOPO_WALK_EMPTY; topo_node_unlock(node); topo_node_rele(node); topo_hdl_free(thp, wp, sizeof (topo_walk_t)); return (NULL); } topo_node_unlock(node); topo_node_hold(child); wp->tw_node = child; } else { topo_node_unlock(node); topo_node_hold(node); /* rele at walk end */ wp->tw_node = node; } wp->tw_root = node; wp->tw_cb = cb_f; wp->tw_pdata = pdata; wp->tw_thp = thp; wp->tw_mod = mod; return (wp); } /* * Walk the direct children of the given node. */ int topo_node_child_walk(topo_hdl_t *thp, tnode_t *pnode, topo_walk_cb_t cb_f, void *arg, int *errp) { int ret = TOPO_WALK_TERMINATE; tnode_t *cnode; topo_node_hold(pnode); /* * First Child: */ topo_node_lock(pnode); cnode = topo_child_first(pnode); topo_node_unlock(pnode); if (cnode == NULL) { *errp = ETOPO_WALK_EMPTY; ret = TOPO_WALK_ERR; goto out; } while (cnode != NULL) { int iret; /* * Call the walker callback: */ topo_node_hold(cnode); iret = cb_f(thp, cnode, arg); topo_node_rele(cnode); if (iret != TOPO_WALK_NEXT) { ret = iret; break; } /* * Next child: */ topo_node_lock(pnode); cnode = topo_child_next(pnode, cnode); topo_node_unlock(pnode); } out: topo_node_rele(pnode); return (ret); } int topo_node_occupied(tnode_t *node, boolean_t *is_occupied) { nvlist_t *out; int err; if (topo_method_invoke(node, TOPO_METH_OCCUPIED, TOPO_METH_OCCUPIED_VERSION, NULL, &out, &err) != 0) { return (err); } (void) nvlist_lookup_boolean_value(out, TOPO_METH_OCCUPIED_RET, is_occupied); nvlist_free(out); return (0); }