/*
* 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) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
*/
/*
* Walk the LDOM PRI component nodes and create appropriate topology nodes
*/
#include <sys/types.h>
#include <sys/time.h>
#include <stddef.h>
#include <inttypes.h>
#include <strings.h>
#include <string.h>
#include <libuutil.h>
#include <libnvpair.h>
#include <sys/mdesc.h>
#include <fm/topo_mod.h>
#include <fm/topo_hc.h>
#include "pi_impl.h"
#define PI_STR_MIN "instance_min"
#define PI_STR_MAX "instance_max"
/*
* Allow for custom topo node creation routines based on topo-hc-name.
*/
struct pi_enum_functions_s {
pi_enum_fn_t *func;
char *hc_name; /* topo-hc-name */
};
typedef struct pi_enum_functions_s pi_enum_functions_t;
struct pi_methods_s {
topo_method_t *meths;
char *hc_name;
};
typedef struct pi_methods_s pi_methods_t;
extern topo_method_t
pi_chip_methods[],
pi_core_methods[],
pi_strand_methods[],
pi_mem_methods[];
/*
* List of custom enumerators for PRI nodes that require them. The most
* common nodes are listed first.
*/
static pi_enum_functions_t pi_enum_fns_builtin[] = {
{pi_enum_cpu, STRAND},
{pi_enum_cpu, CPU},
{pi_enum_mem, DIMM},
{pi_enum_cpu, CORE},
{pi_enum_cpu, CHIP},
{pi_enum_hostbridge, HOSTBRIDGE},
{pi_enum_pciexrc, PCIEX_ROOT},
{pi_enum_niu, NIU},
{pi_enum_bay, BAY},
{NULL, NULL}
};
static nvlist_t *pi_enum_fns;
/* List of methods that will be registered in the nodes. */
static pi_methods_t pi_meths_builtin[] = {
{pi_chip_methods, CHIP},
{pi_core_methods, CORE},
{pi_strand_methods, STRAND},
{pi_strand_methods, CPU},
{pi_mem_methods, DIMM},
{NULL, NULL}
};
nvlist_t *pi_meths;
/*
* In order to create a topology node from a PRI MDE node we need to know the
* topology parent node that should be used. So, after creating a topology
* node from an MDE node, we associate children of the MDE node with the new
* topology node. Thus, when the children are visited we can know the
* appropriate parent topology node to use.
*
* We take advantage of the libtopo threading model here, which guarantees a
* single thread and a single invocation at a time for an enumerator. This
* makes using a file-global safe.
*/
static uu_list_pool_t *walker_pool = NULL;
static uu_list_t *walker_list = NULL;
struct pi_walkernode_s {
uu_list_node_t walker_node;
tnode_t *t_parent; /* Parent topology node */
mde_cookie_t mde_node; /* Child MDE node index */
};
typedef struct pi_walkernode_s pi_walkernode_t;
/* The routine called for each node in the PRI while walking the graph */
static int pi_walker_node(md_t *, mde_cookie_t, mde_cookie_t, void *);
/*
* Create a sub-range for a given PRI node and associate the given topology
* node with the children.
*/
static int pi_walker_node_range(topo_mod_t *, md_t *, tnode_t *, mde_cookie_t);
static int pi_walker_node_create(topo_mod_t *, md_t *, mde_cookie_t, tnode_t *,
topo_instance_t, tnode_t **);
/* Routines to handle the list of topology parents and mde_nodes */
static int pi_walkerlist_compare(const void *, const void *, void *);
static int pi_walkerlist_create(topo_mod_t *);
static void pi_walkerlist_destroy(topo_mod_t *);
static int pi_walkerlist_add(topo_mod_t *, tnode_t *, mde_cookie_t);
static int pi_walkerlist_addtype(topo_mod_t *, nvlist_t *, char *, uint32_t,
uint32_t);
static int pi_walkerlist_find(topo_mod_t *, mde_cookie_t, tnode_t **);
int
pi_walker_init(topo_mod_t *mod)
{
int result;
pi_enum_functions_t *fp;
pi_methods_t *mp;
result = topo_mod_nvalloc(mod, &pi_enum_fns, NV_UNIQUE_NAME);
result |= topo_mod_nvalloc(mod, &pi_meths, NV_UNIQUE_NAME);
if (result != 0) {
topo_mod_dprintf(mod, "pi_walker_init failed\n");
nvlist_free(pi_enum_fns);
nvlist_free(pi_meths);
return (-1);
}
/* Add the builtin functions to the list */
fp = pi_enum_fns_builtin;
while (fp != NULL && fp->hc_name != NULL) {
uint64_t faddr;
faddr = (uint64_t)(uintptr_t)*(fp->func);
result |= nvlist_add_uint64(pi_enum_fns, fp->hc_name, faddr);
fp++;
}
/* Add the builtin methods to the list */
mp = pi_meths_builtin;
while (mp != NULL && mp->hc_name != NULL) {
uint64_t maddr;
maddr = (uint64_t)(uintptr_t)mp->meths;
result |= nvlist_add_uint64(pi_meths, mp->hc_name, maddr);
mp++;
}
if (result != 0) {
topo_mod_dprintf(mod, "pi_walker_init failed\n");
nvlist_free(pi_enum_fns);
nvlist_free(pi_meths);
return (-1);
}
return (0);
}
void
pi_walker_fini(topo_mod_t *mod)
{
topo_mod_dprintf(mod, "pi_walker_fini: enter\n");
nvlist_free(pi_enum_fns);
nvlist_free(pi_meths);
}
/*
* Begin to walk the machine description array starting at the given PRI node.
*/
int
pi_walker(pi_enum_t *pip, tnode_t *t_parent, const char *hc_name,
mde_cookie_t mde_node, mde_str_cookie_t component_cookie,
mde_str_cookie_t arc_cookie)
{
int result;
hrtime_t starttime;
hrtime_t endtime;
topo_mod_t *mod;
if (pip == NULL) {
return (-1);
}
mod = pip->mod;
starttime = gethrtime();
topo_mod_dprintf(mod, "walker starting at node_0x%llx\n",
mde_node);
/*
* Create a list to store topology nodes and their associated machine
* description index. This allows the code to know the parent of a
* node when creating topology entries.
*/
result = pi_walkerlist_create(mod);
if (result != 0) {
topo_mod_dprintf(mod, "walker could not create list\n");
return (result);
}
/* Create a walker node for the parent of the start node */
result = pi_walkerlist_add(mod, t_parent, mde_node);
if (result != 0) {
pi_walkerlist_destroy(mod);
topo_mod_dprintf(mod, "walker could not add to list\n");
(void) topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
return (result);
}
/*
* This is a top-level node. Make sure we call the top level
* enumerator if there is not already a custom enumerator registered.
*/
if (! nvlist_exists(pi_enum_fns, hc_name)) {
uint64_t faddr;
/*
* There is no enumerator function registered for this
* hc name. Automatically register the top level node
* enumerator function.
*/
faddr = (uint64_t)(uintptr_t)pi_enum_top;
result = nvlist_add_uint64(pi_enum_fns, hc_name, faddr);
if (result != 0) {
pi_walkerlist_destroy(mod);
topo_mod_dprintf(mod,
"walker could not register enumerator for type "
"%s\n", hc_name);
(void) topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
return (-1);
}
topo_mod_dprintf(mod,
"walker registered pi_enum_top enumerator for type %s\n",
hc_name);
}
/* Walk the machine description list starting at the given node */
result = md_walk_dag(pip->mdp, mde_node, component_cookie, arc_cookie,
pi_walker_node, (void *)pip);
switch (result) {
case 0:
/* Successful completion */
/* DO NOTHING */
break;
case MDE_WALK_ERROR:
/*
* Store that we have a partial enumeration and return
* that we have encountered an error.
*/
(void) topo_mod_seterrno(mod, EMOD_PARTIAL_ENUM);
result = -1;
break;
default:
/*
* This should not happen. We want to always produce
* as complete a topology as possible, even in the face
* of errors, however, so set an error and continue.
*/
topo_mod_dprintf(mod,
"walker encountered invalid result: %d. "
"Continuing\n", result);
(void) topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM);
result = 0;
break;
}
/* Destroy the walker list, which is no longer necessary */
pi_walkerlist_destroy(mod);
topo_mod_dprintf(mod, "walker done with node_0x%llx\n", mde_node);
endtime = gethrtime();
topo_mod_dprintf(mod, "walker scan time %lld ms\n",
(endtime-starttime)/MICROSEC);
return (result);
}
/*
* Visited once for each node in the machine description. Creates a topo
* node for the machine description node and associates it with it's parent,
* by calling an appropriate creation routine for the node type.
*
* Output:
* This routine returns MDE_WALK_NEXT, MDE_WALK_DONE or MDE_WALK_ERROR
* only.
*/
static int
pi_walker_node(md_t *mdp, mde_cookie_t parent_mde_node, mde_cookie_t mde_node,
void *private)
{
int result;
pi_enum_t *pip = (pi_enum_t *)private;
uint64_t skip; /* flag in md to skip this node */
tnode_t *t_parent; /* topo parent to this md node */
tnode_t *t_node; /* topo parent to this md node */
topo_instance_t inst;
topo_mod_t *mod;
/* Make sure we have our private data */
if (pip == NULL) {
return (MDE_WALK_ERROR);
}
mod = pip->mod;
topo_mod_dprintf(pip->mod,
"walker processing node_0x%llx parent node 0x%llx\n",
(uint64_t)mde_node, (uint64_t)parent_mde_node);
/* Should we skip this node ? */
skip = pi_skip_node(mod, pip->mdp, mde_node);
if (skip) {
/* Skip this node and continue to the next node */
topo_mod_dprintf(mod, "walker skipping node_0x%llx\n",
(uint64_t)mde_node);
return (MDE_WALK_NEXT);
}
result = pi_get_instance(mod, mdp, mde_node, &inst);
if (result != 0) {
/*
* No ID available to place this mde node in the topology so
* we cannot create a topology node.
*/
topo_mod_dprintf(mod, "walker skipping node_0x%llx: "
"no instance\n", (uint64_t)mde_node);
(void) topo_mod_seterrno(mod, EMOD_PARTIAL_ENUM);
return (MDE_WALK_NEXT);
}
/*
* Find the parent topo node for this machine description node.
*
* If found, the element will also be removed from the list and the
* memory used to keep track of it released. We will only visit an
* MDE node once and so the memory is no longer needed.
*/
t_parent = NULL;
result = pi_walkerlist_find(mod, mde_node, &t_parent);
if (result != 0 || t_parent == NULL) {
/*
* No parent was found or a NULL parent encountered. We
* cannot create a new topology node without a parent (
* even for top level nodes). We associate children of
* this MDE node with a NULL parent to silently skip the
* remainder of this MDE branch.
*/
topo_mod_dprintf(mod, "no topo parent found for node_0x%llx\n",
mde_node);
result = pi_walker_node_range(mod, mdp, NULL, mde_node);
(void) topo_mod_seterrno(mod, EMOD_PARTIAL_ENUM);
return (result);
}
/*
* We have the mde node instance and parent information.
* Attempt to create a topology node for this mde node.
*/
t_node = NULL;
result = pi_walker_node_create(mod, mdp, mde_node, t_parent, inst,
&t_node);
if (result != MDE_WALK_NEXT || t_node == NULL) {
/*
* We have failed to create a new topology node based on
* the current MDE node. We set partial enumeration and
* return without associating the children of this MDE
* node with a topology parent. This will propgate the
* creation error down this MDE branch.
*/
(void) topo_mod_seterrno(mod, EMOD_PARTIAL_ENUM);
return (result);
}
/*
* Associate the new topology node with any children of this mde node.
*/
result = pi_walker_node_range(mod, mdp, t_node, mde_node);
topo_mod_dprintf(mod, "walker completed node_0x%llx result = %d\n",
(uint64_t)mde_node, result);
return (result);
}
static int
pi_walker_node_create(topo_mod_t *mod, md_t *mdp, mde_cookie_t mde_node,
tnode_t *t_parent, topo_instance_t inst, tnode_t **t_node)
{
int result;
char *hc_name;
uint64_t faddr;
pi_enum_fn_t *func;
if (t_parent == NULL) {
/*
* A parent topology node is required even for top-level
* nodes.
*/
return (MDE_WALK_NEXT);
}
/*
* Find the topo-hc-name for this node which is used to find
* the specific creation function
*/
hc_name = pi_get_topo_hc_name(mod, mdp, mde_node);
if (hc_name == NULL) {
/* Cannot get the hc-name */
topo_mod_dprintf(mod,
"failed to find hc-name for node_0x%llx\n", mde_node);
return (MDE_WALK_NEXT);
}
/* Determine the topology node creation routine to use */
func = pi_enum_generic;
faddr = 0;
result = nvlist_lookup_uint64(pi_enum_fns, hc_name, &faddr);
if (result == 0) {
/*
* A function is registered for this node. Convert the
* address to a pointer to function
*/
func = (pi_enum_fn_t *)(uintptr_t)faddr;
}
/*
* Create a topology node for this mde node by calling the identified
* enumeration function
*/
*t_node = NULL;
result = (func)(mod, mdp, mde_node, inst, t_parent, hc_name, t_node);
if (result != 0) {
topo_mod_dprintf(mod,
"failed to create topo entry for node_0x%llx type %s\n",
(uint64_t)mde_node, hc_name);
} else {
/*
* Need to check if we need enumerate internal expander
* attached bays. Since there is no MDE(PRI record) for
* an internal expander we are invoking the ses enumerator
* here. It will check if there is any internal enclosure
* and enumerate expander attached disks.
* Note that those nodes will be enumerated as a child of
* of chassis.
*/
if (strcmp(hc_name, CHASSIS) == 0) {
if (topo_mod_load(mod, SES, TOPO_VERSION) == NULL) {
topo_mod_dprintf(mod, "Failed to load %s "
" enumerator: %s",
SES, topo_strerror(topo_mod_errno(mod)));
} else {
/*
* min and max instance is handled by
* the ses enumerator.
*/
result = topo_mod_enumerate(mod, *t_node, SES,
SES_ENCLOSURE, 0, 0, NULL);
if (result != 0)
topo_mod_dprintf(mod, "Failed to "
"enumerate expander attached "
"internal bays. Continue on.");
}
}
}
topo_mod_strfree(mod, hc_name);
return (MDE_WALK_NEXT);
}
/*
* Scan the children of a given MDE node and find all the sets of topo-hc-name
* types and their instance ranges. From this information we create topology
* node ranges on the given parent so that when the children are visited and a
* topology node is created, the range exists and the creation will succeed.
*/
static int
pi_walker_node_range(topo_mod_t *mod, md_t *mdp, tnode_t *t_parent,
mde_cookie_t mde_node)
{
int result;
int rc;
int num_arcs;
nvlist_t *typelist;
nvpair_t *nvp;
mde_cookie_t *arcp;
size_t arcsize;
int arcidx;
char *hc_name;
nvlist_t *hc_range;
topo_instance_t inst;
uint32_t min;
uint32_t max;
if (t_parent == NULL) {
topo_mod_dprintf(mod,
"walker failed to create node range with a NULL parent\n");
return (MDE_WALK_NEXT);
}
/* Determine how many children the given node has */
num_arcs = md_get_prop_arcs(mdp, mde_node, MD_STR_FWD, NULL, 0);
if (num_arcs == 0) {
/* This node has no children */
return (MDE_WALK_NEXT);
}
topo_mod_dprintf(mod, "node_0x%llx has %d children\n",
(uint64_t)mde_node, num_arcs);
/* Get the indexes for all the child nodes and put them in an array */
arcsize = sizeof (mde_cookie_t) * num_arcs;
arcp = topo_mod_zalloc(mod, arcsize);
if (arcp == NULL) {
topo_mod_dprintf(mod, "out of memory\n");
(void) topo_mod_seterrno(mod, EMOD_NOMEM);
return (MDE_WALK_ERROR);
}
num_arcs = md_get_prop_arcs(mdp, mde_node, MD_STR_FWD, arcp, arcsize);
/*
* The children of the given node may have multiple types.
* Potentially, each child may have a different type and we need to
* create a topo node range for each one.
*
* We loop through the children and collect the type information for
* each one and associate the child with the given parent topo node.
*/
result = topo_mod_nvalloc(mod, &typelist, NV_UNIQUE_NAME);
if (result != 0) {
topo_mod_free(mod, arcp, arcsize);
(void) topo_mod_seterrno(mod, EMOD_NOMEM);
return (MDE_WALK_ERROR);
}
arcidx = 0;
for (arcidx = 0; arcidx < num_arcs; arcidx++) {
/* Should this node be skipped? */
if (pi_skip_node(mod, mdp, arcp[arcidx])) {
/* Skip this node */
topo_mod_dprintf(mod, "skipping node_0x%llx\n",
(uint64_t)arcp[arcidx]);
continue;
}
/* Get the type of this node */
hc_name = pi_get_topo_hc_name(mod, mdp, arcp[arcidx]);
rc = pi_get_instance(mod, mdp, arcp[arcidx], &inst);
if (rc == 0 && hc_name != NULL) {
/* Increment the count of nodes with this type */
hc_range = NULL;
rc = nvlist_lookup_nvlist(typelist, hc_name, &hc_range);
if (rc != 0) {
/*
* We have not visited this type yet. Create
* a new range based on this nodes instance
* information.
*/
result = pi_walkerlist_addtype(mod, typelist,
hc_name, (uint32_t)inst, (uint32_t)inst);
if (result != 0) {
/*
* This error can only if there was a
* memory failure of some kind. Stop
* the walk or it will just get worse.
*/
nvlist_free(typelist);
topo_mod_strfree(mod, hc_name);
topo_mod_free(mod, arcp, arcsize);
(void) topo_mod_seterrno(mod,
EMOD_PARTIAL_ENUM);
return (MDE_WALK_ERROR);
}
/*
* We know the list exists now or the above
* would have failed. Just look it up.
*/
(void) nvlist_lookup_nvlist(typelist, hc_name,
&hc_range);
}
/* Re-calculate the range minimums and maximums */
(void) nvlist_lookup_uint32(hc_range, PI_STR_MIN, &min);
(void) nvlist_lookup_uint32(hc_range, PI_STR_MAX, &max);
min = MIN(min, (uint32_t)inst);
max = MAX(max, (uint32_t)inst);
(void) nvlist_add_uint32(hc_range, PI_STR_MIN, min);
(void) nvlist_add_uint32(hc_range, PI_STR_MAX, max);
} else {
if (hc_name == NULL) {
topo_mod_dprintf(mod, "node_0x%llx has no "
"topo_hc_name.", (uint64_t)arcp[arcidx]);
(void) topo_mod_seterrno(mod,
EMOD_PARTIAL_ENUM);
return (MDE_WALK_ERROR);
}
topo_mod_dprintf(mod, "node_0x%llx type %s has no id. "
"Excluding from range", (uint64_t)arcp[arcidx],
hc_name);
}
topo_mod_strfree(mod, hc_name);
/*
* Associate this node with the given topo parent even if it
* has no instance. We do this so that later an error with
* the PRI node will be reported instead of an internal
* error about not being able to find the parent of a node
*/
rc = pi_walkerlist_add(mod, t_parent, arcp[arcidx]);
if (rc != 0) {
topo_mod_dprintf(mod,
"could not add node_0x%llx to walker list\n",
(uint64_t)arcp[arcidx]);
}
}
/*
* We have associated all the child nodes with the given topo parent
* in the walker list. Now we need to create topo ranges for each
* set of child types under the parent.
*/
nvp = nvlist_next_nvpair(typelist, NULL);
while (nvp != NULL) {
/* Get the type name and count from the list element */
hc_name = nvpair_name(nvp);
(void) nvpair_value_nvlist(nvp, &hc_range);
(void) nvlist_lookup_uint32(hc_range, PI_STR_MIN, &min);
(void) nvlist_lookup_uint32(hc_range, PI_STR_MAX, &max);
/*
* We have the number of children with this type.
* Create an appropriate range.
*/
topo_mod_dprintf(mod,
"creating instance range %d to %d of type %s\n",
min, max, hc_name);
rc = topo_node_range_create(mod, t_parent, hc_name,
(topo_instance_t)min, (topo_instance_t)max);
if (rc != 0) {
topo_mod_dprintf(mod,
"failed to created node range %d to %d for "
"nodes of type %s\n", min, max, hc_name);
}
/* Check the next node */
nvp = nvlist_next_nvpair(typelist, nvp);
}
topo_mod_free(mod, arcp, arcsize);
nvlist_free(typelist);
return (MDE_WALK_NEXT);
}
static int
pi_walkerlist_addtype(topo_mod_t *mod, nvlist_t *typelist, char *hc_name,
uint32_t min, uint32_t max)
{
int result;
nvlist_t *nvl;
result = topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME);
if (result != 0) {
return (result);
}
/* Create min and max elements in this list */
if (nvlist_add_uint32(nvl, PI_STR_MIN, min) != 0 ||
nvlist_add_uint32(nvl, PI_STR_MAX, max) != 0 ||
nvlist_add_nvlist(typelist, hc_name, nvl) != 0) {
nvlist_free(nvl);
return (-1);
}
nvlist_free(nvl);
return (0);
}
/* ARGSUSED */
static int
pi_walkerlist_compare(const void *left, const void *right, void *private)
{
pi_walkernode_t *lp = (pi_walkernode_t *)left;
pi_walkernode_t *rp = (pi_walkernode_t *)right;
if (lp->mde_node > rp->mde_node) {
return (1);
}
if (lp->mde_node < rp->mde_node) {
return (-1);
}
return (0);
}
static int
pi_walkerlist_create(topo_mod_t *mod)
{
/* Initialize the uutil list structure */
walker_pool = uu_list_pool_create("pi_walker_pool",
sizeof (pi_walkernode_t), offsetof(pi_walkernode_t, walker_node),
pi_walkerlist_compare, NULL);
if (walker_pool == NULL) {
(void) topo_mod_seterrno(mod, EMOD_NOMEM);
return (-1);
}
walker_list = uu_list_create(walker_pool, NULL, 0);
if (walker_list == NULL) {
uu_list_pool_destroy(walker_pool);
walker_pool = NULL;
return (-1);
}
return (0);
}
static void
pi_walkerlist_destroy(topo_mod_t *mod)
{
void *wvp;
pi_walkernode_t *wp;
/* Destroy our list of items */
while ((wvp = uu_list_first(walker_list)) != NULL) {
/*
* First, we empty the list of elements and free each one.
* We do not free the data elements as they are libtopo nodes
* and will be freed by libtopo
*/
wp = (pi_walkernode_t *)wvp;
uu_list_remove(walker_list, wvp);
uu_list_node_fini(wp, &(wp->walker_node), walker_pool);
topo_mod_free(mod, wvp, sizeof (pi_walkernode_t));
}
uu_list_destroy(walker_list);
uu_list_pool_destroy(walker_pool);
walker_list = NULL;
walker_pool = NULL;
}
static int
pi_walkerlist_add(topo_mod_t *mod, tnode_t *t_parent, mde_cookie_t mde_node)
{
uu_list_index_t idx;
pi_walkernode_t *wnp;
wnp = topo_mod_zalloc(mod, sizeof (pi_walkernode_t));
if (wnp == NULL) {
topo_mod_dprintf(mod, "failed to add node_0x%llx parent %p\n",
(uint64_t)mde_node, t_parent);
return (-1);
}
uu_list_node_init(wnp, &(wnp->walker_node), walker_pool);
wnp->t_parent = t_parent;
wnp->mde_node = mde_node;
(void) uu_list_find(walker_list, wnp, NULL, &idx);
uu_list_insert(walker_list, wnp, idx);
return (0);
}
/*
* Find the parent topo node for this machine description node.
*
* Nodes are removed from the list as they are found. They are only
* visited once and this eliminates the need for a separate routine
* that walks the list to free elements later.
*/
static int
pi_walkerlist_find(topo_mod_t *mod, mde_cookie_t mde_node, tnode_t **tpp)
{
pi_walkernode_t *result;
uu_list_index_t idx;
pi_walkernode_t search_criteria;
search_criteria.mde_node = mde_node;
search_criteria.t_parent = NULL;
*tpp = NULL;
result = uu_list_find(walker_list, &search_criteria, NULL, &idx);
if (result == NULL) {
return (-1);
}
*tpp = result->t_parent;
/* Remove this element from the list */
uu_list_remove(walker_list, result);
uu_list_node_fini(result, &(result->walker_node), walker_pool);
topo_mod_free(mod, result, sizeof (pi_walkernode_t));
return (0);
}