xref: /titanic_50/usr/src/lib/libdevinfo/devinfo.c (revision 683b29499b14fddf042df3e4ecb71a1d5bebe3a8)

/*
 * 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) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Interfaces for getting device configuration data from kernel
 * through the devinfo driver.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <stropts.h>
#include <fcntl.h>
#include <poll.h>
#include <synch.h>
#include <unistd.h>
#include <sys/mkdev.h>
#include <sys/obpdefs.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/autoconf.h>
#include <stdarg.h>
#include <sys/ddi_hp.h>

#define	NDEBUG 1
#include <assert.h>

#include "libdevinfo.h"

/*
 * Debug message levels
 */
typedef enum {
	DI_QUIET = 0,	/* No debug messages - the default */
	DI_ERR = 1,
	DI_INFO,
	DI_TRACE,
	DI_TRACE1,
	DI_TRACE2
} di_debug_t;

int di_debug = DI_QUIET;

#define	DPRINTF(args)	{ if (di_debug != DI_QUIET) dprint args; }

void dprint(di_debug_t msglevel, const char *fmt, ...);


#pragma init(_libdevinfo_init)

void
_libdevinfo_init()
{
	char	*debug_str = getenv("_LIBDEVINFO_DEBUG");

	if (debug_str) {
		errno = 0;
		di_debug = atoi(debug_str);
		if (errno || di_debug < DI_QUIET)
			di_debug = DI_QUIET;
	}
}

di_node_t
di_init(const char *phys_path, uint_t flag)
{
	return (di_init_impl(phys_path, flag, NULL));
}

/*
 * We use blocking_open() to guarantee access to the devinfo device, if open()
 * is failing with EAGAIN.
 */
static int
blocking_open(const char *path, int oflag)
{
	int fd;

	while ((fd = open(path, oflag)) == -1 && errno == EAGAIN)
		(void) poll(NULL, 0, 1 * MILLISEC);

	return (fd);
}

/* private interface */
di_node_t
di_init_driver(const char *drv_name, uint_t flag)
{
	int fd;
	char driver[MAXPATHLEN];

	/*
	 * Don't allow drv_name to exceed MAXPATHLEN - 1, or 1023,
	 * which should be sufficient for any sensible programmer.
	 */
	if ((drv_name == NULL) || (strlen(drv_name) >= MAXPATHLEN)) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}
	(void) strcpy(driver, drv_name);

	/*
	 * open the devinfo driver
	 */
	if ((fd = blocking_open("/devices/pseudo/devinfo@0:devinfo",
	    O_RDONLY)) == -1) {
		DPRINTF((DI_ERR, "devinfo open failed: errno = %d\n", errno));
		return (DI_NODE_NIL);
	}

	if (ioctl(fd, DINFOLODRV, driver) != 0) {
		DPRINTF((DI_ERR, "failed to load driver %s\n", driver));
		(void) close(fd);
		errno = ENXIO;
		return (DI_NODE_NIL);
	}
	(void) close(fd);

	/*
	 * Driver load succeeded, return a snapshot
	 */
	return (di_init("/", flag));
}

di_node_t
di_init_impl(const char *phys_path, uint_t flag,
	struct di_priv_data *priv)
{
	caddr_t pa;
	int fd, map_size;
	struct di_all *dap;
	struct dinfo_io dinfo_io;

	uint_t pageoffset = sysconf(_SC_PAGESIZE) - 1;
	uint_t pagemask = ~pageoffset;

	DPRINTF((DI_INFO, "di_init: taking a snapshot\n"));

	/*
	 * Make sure there is no minor name in the path
	 * and the path do not start with /devices....
	 */
	if (strchr(phys_path, ':') ||
	    (strncmp(phys_path, "/devices", 8) == 0) ||
	    (strlen(phys_path) > MAXPATHLEN)) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	if (strlen(phys_path) == 0)
		(void) sprintf(dinfo_io.root_path, "/");
	else if (*phys_path != '/')
		(void) snprintf(dinfo_io.root_path, sizeof (dinfo_io.root_path),
		    "/%s", phys_path);
	else
		(void) snprintf(dinfo_io.root_path, sizeof (dinfo_io.root_path),
		    "%s", phys_path);

	/*
	 * If private data is requested, copy the format specification
	 */
	if (flag & DINFOPRIVDATA & 0xff) {
		if (priv)
			bcopy(priv, &dinfo_io.priv,
			    sizeof (struct di_priv_data));
		else {
			errno = EINVAL;
			return (DI_NODE_NIL);
		}
	}

	/*
	 * Attempt to open the devinfo driver.  Make a second attempt at the
	 * read-only minor node if we don't have privileges to open the full
	 * version _and_ if we're not requesting operations that the read-only
	 * node can't perform.  (Setgid processes would fail an access() test,
	 * of course.)
	 */
	if ((fd = blocking_open("/devices/pseudo/devinfo@0:devinfo",
	    O_RDONLY)) == -1) {
		if ((flag & DINFOFORCE) == DINFOFORCE ||
		    (flag & DINFOPRIVDATA) == DINFOPRIVDATA) {
			/*
			 * We wanted to perform a privileged operation, but the
			 * privileged node isn't available.  Don't modify errno
			 * on our way out (but display it if we're running with
			 * di_debug set).
			 */
			DPRINTF((DI_ERR, "devinfo open failed: errno = %d\n",
			    errno));
			return (DI_NODE_NIL);
		}

		if ((fd = blocking_open("/devices/pseudo/devinfo@0:devinfo,ro",
		    O_RDONLY)) == -1) {
			DPRINTF((DI_ERR, "devinfo open failed: errno = %d\n",
			    errno));
			return (DI_NODE_NIL);
		}
	}

	/*
	 * Verify that there is no major conflict, i.e., we are indeed opening
	 * the devinfo driver.
	 */
	if (ioctl(fd, DINFOIDENT, NULL) != DI_MAGIC) {
		DPRINTF((DI_ERR,
		    "driver ID failed; check for major conflict\n"));
		(void) close(fd);
		return (DI_NODE_NIL);
	}

	/*
	 * create snapshot
	 */
	if ((map_size = ioctl(fd, flag, &dinfo_io)) < 0) {
		DPRINTF((DI_ERR, "devinfo ioctl failed with "
		    "error: %d\n", errno));
		(void) close(fd);
		return (DI_NODE_NIL);
	} else if (map_size == 0) {
		DPRINTF((DI_ERR, "%s not found\n", phys_path));
		errno = ENXIO;
		(void) close(fd);
		return (DI_NODE_NIL);
	}

	/*
	 * copy snapshot to userland
	 */
	map_size = (map_size + pageoffset) & pagemask;
	if ((pa = valloc(map_size)) == NULL) {
		DPRINTF((DI_ERR, "valloc failed for snapshot\n"));
		(void) close(fd);
		return (DI_NODE_NIL);
	}

	if (ioctl(fd, DINFOUSRLD, pa) != map_size) {
		DPRINTF((DI_ERR, "failed to copy snapshot to usrld\n"));
		(void) close(fd);
		free(pa);
		errno = EFAULT;
		return (DI_NODE_NIL);
	}

	(void) close(fd);

	dap = DI_ALL(pa);
	if (dap->version != DI_SNAPSHOT_VERSION) {
		DPRINTF((DI_ERR, "wrong snapshot version "
		    "(expected=%d, actual=%d)\n",
		    DI_SNAPSHOT_VERSION, dap->version));
		free(pa);
		errno = ESTALE;
		return (DI_NODE_NIL);
	}
	if (dap->top_devinfo == 0) {	/* phys_path not found */
		DPRINTF((DI_ERR, "%s not found\n", phys_path));
		free(pa);
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	return (DI_NODE(pa + dap->top_devinfo));
}

void
di_fini(di_node_t root)
{
	caddr_t pa;		/* starting address of map */

	DPRINTF((DI_INFO, "di_fini: freeing a snapshot\n"));

	/*
	 * paranoid checking
	 */
	if (root == DI_NODE_NIL) {
		DPRINTF((DI_ERR, "di_fini called with NIL arg\n"));
		return;
	}

	/*
	 * The root contains its own offset--self.
	 * Subtracting it from root address, we get the starting addr.
	 * The map_size is stored at the beginning of snapshot.
	 * Once we have starting address and size, we can free().
	 */
	pa = (caddr_t)root - DI_NODE(root)->self;

	free(pa);
}

di_node_t
di_parent_node(di_node_t node)
{
	caddr_t pa;		/* starting address of map */

	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	DPRINTF((DI_TRACE, "Get parent of node %s\n", di_node_name(node)));

	pa = (caddr_t)node - DI_NODE(node)->self;

	if (DI_NODE(node)->parent) {
		return (DI_NODE(pa + DI_NODE(node)->parent));
	}

	/*
	 * Deal with error condition:
	 *   If parent doesn't exist and node is not the root,
	 *   set errno to ENOTSUP. Otherwise, set errno to ENXIO.
	 */
	if (strcmp(DI_ALL(pa)->root_path, "/") != 0)
		errno = ENOTSUP;
	else
		errno = ENXIO;

	return (DI_NODE_NIL);
}

di_node_t
di_sibling_node(di_node_t node)
{
	caddr_t pa;		/* starting address of map */

	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	DPRINTF((DI_TRACE, "Get sibling of node %s\n", di_node_name(node)));

	pa = (caddr_t)node - DI_NODE(node)->self;

	if (DI_NODE(node)->sibling) {
		return (DI_NODE(pa + DI_NODE(node)->sibling));
	}

	/*
	 * Deal with error condition:
	 *   Sibling doesn't exist, figure out if ioctl command
	 *   has DINFOSUBTREE set. If it doesn't, set errno to
	 *   ENOTSUP.
	 */
	if (!(DI_ALL(pa)->command & DINFOSUBTREE))
		errno = ENOTSUP;
	else
		errno = ENXIO;

	return (DI_NODE_NIL);
}

di_node_t
di_child_node(di_node_t node)
{
	caddr_t pa;		/* starting address of map */

	DPRINTF((DI_TRACE, "Get child of node %s\n", di_node_name(node)));

	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	pa = (caddr_t)node - DI_NODE(node)->self;

	if (DI_NODE(node)->child) {
		return (DI_NODE(pa + DI_NODE(node)->child));
	}

	/*
	 * Deal with error condition:
	 *   Child doesn't exist, figure out if DINFOSUBTREE is set.
	 *   If it isn't, set errno to ENOTSUP.
	 */
	if (!(DI_ALL(pa)->command & DINFOSUBTREE))
		errno = ENOTSUP;
	else
		errno = ENXIO;

	return (DI_NODE_NIL);
}

di_node_t
di_drv_first_node(const char *drv_name, di_node_t root)
{
	caddr_t		pa;		/* starting address of map */
	int		major, devcnt;
	struct di_devnm	*devnm;

	DPRINTF((DI_INFO, "Get first node of driver %s\n", drv_name));

	if (root == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	/*
	 * get major number of driver
	 */
	pa = (caddr_t)root - DI_NODE(root)->self;
	devcnt = DI_ALL(pa)->devcnt;
	devnm = DI_DEVNM(pa + DI_ALL(pa)->devnames);

	for (major = 0; major < devcnt; major++)
		if (devnm[major].name && (strcmp(drv_name,
		    (char *)(pa + devnm[major].name)) == 0))
			break;

	if (major >= devcnt) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	if (!(devnm[major].head)) {
		errno = ENXIO;
		return (DI_NODE_NIL);
	}

	return (DI_NODE(pa + devnm[major].head));
}

di_node_t
di_drv_next_node(di_node_t node)
{
	caddr_t		pa;		/* starting address of map */

	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	DPRINTF((DI_TRACE, "next node on per driver list:"
	    " current=%s, driver=%s\n",
	    di_node_name(node), di_driver_name(node)));

	if (DI_NODE(node)->next == (di_off_t)-1) {
		errno = ENOTSUP;
		return (DI_NODE_NIL);
	}

	pa = (caddr_t)node - DI_NODE(node)->self;

	if (DI_NODE(node)->next == NULL) {
		errno = ENXIO;
		return (DI_NODE_NIL);
	}

	return (DI_NODE(pa + DI_NODE(node)->next));
}

/*
 * Internal library interfaces:
 *   node_list etc. for node walking
 */
struct node_list {
	struct node_list *next;
	di_node_t node;
};

static void
free_node_list(struct node_list **headp)
{
	struct node_list *tmp;

	while (*headp) {
		tmp = *headp;
		*headp = (*headp)->next;
		free(tmp);
	}
}

static void
append_node_list(struct node_list **headp, struct node_list *list)
{
	struct node_list *tmp;

	if (*headp == NULL) {
		*headp = list;
		return;
	}

	if (list == NULL)	/* a minor optimization */
		return;

	tmp = *headp;
	while (tmp->next)
		tmp = tmp->next;

	tmp->next = list;
}

static void
prepend_node_list(struct node_list **headp, struct node_list *list)
{
	struct node_list *tmp;

	if (list == NULL)
		return;

	tmp = *headp;
	*headp = list;

	if (tmp == NULL)	/* a minor optimization */
		return;

	while (list->next)
		list = list->next;

	list->next = tmp;
}

/*
 * returns 1 if node is a descendant of parent, 0 otherwise
 */
static int
is_descendant(di_node_t node, di_node_t parent)
{
	/*
	 * DI_NODE_NIL is parent of root, so it is
	 * the parent of all nodes.
	 */
	if (parent == DI_NODE_NIL) {
		return (1);
	}

	do {
		node = di_parent_node(node);
	} while ((node != DI_NODE_NIL) && (node != parent));

	return (node != DI_NODE_NIL);
}

/*
 * Insert list before the first node which is NOT a descendent of parent.
 * This is needed to reproduce the exact walking order of link generators.
 */
static void
insert_node_list(struct node_list **headp, struct node_list *list,
    di_node_t parent)
{
	struct node_list *tmp, *tmp1;

	if (list == NULL)
		return;

	tmp = *headp;
	if (tmp == NULL) {	/* a minor optimization */
		*headp = list;
		return;
	}

	if (!is_descendant(tmp->node, parent)) {
		prepend_node_list(headp, list);
		return;
	}

	/*
	 * Find first node which is not a descendant
	 */
	while (tmp->next && is_descendant(tmp->next->node, parent)) {
		tmp = tmp->next;
	}

	tmp1 = tmp->next;
	tmp->next = list;
	append_node_list(headp, tmp1);
}

/*
 *   Get a linked list of handles of all children
 */
static struct node_list *
get_children(di_node_t node)
{
	di_node_t child;
	struct node_list *result, *tmp;

	DPRINTF((DI_TRACE1, "Get children of node %s\n", di_node_name(node)));

	if ((child = di_child_node(node)) == DI_NODE_NIL) {
		return (NULL);
	}

	if ((result = malloc(sizeof (struct node_list))) == NULL) {
		DPRINTF((DI_ERR, "malloc of node_list failed\n"));
		return (NULL);
	}

	result->node = child;
	tmp = result;

	while ((child = di_sibling_node(tmp->node)) != DI_NODE_NIL) {
		if ((tmp->next = malloc(sizeof (struct node_list))) == NULL) {
			DPRINTF((DI_ERR, "malloc of node_list failed\n"));
			free_node_list(&result);
			return (NULL);
		}
		tmp = tmp->next;
		tmp->node = child;
	}

	tmp->next = NULL;

	return (result);
}

/*
 * Internal library interface:
 *   Delete all siblings of the first node from the node_list, along with
 *   the first node itself.
 */
static void
prune_sib(struct node_list **headp)
{
	di_node_t parent, curr_par, curr_gpar;
	struct node_list *curr, *prev;

	/*
	 * get handle to parent of first node
	 */
	if ((parent = di_parent_node((*headp)->node)) == DI_NODE_NIL) {
		/*
		 * This must be the root of the snapshot, so can't
		 * have any siblings.
		 *
		 * XXX Put a check here just in case.
		 */
		if ((*headp)->next)
			DPRINTF((DI_ERR, "Unexpected err in di_walk_node.\n"));

		free(*headp);
		*headp = NULL;
		return;
	}

	/*
	 * To be complete, we should also delete the children
	 * of siblings that have already been visited.
	 * This happens for DI_WALK_SIBFIRST when the first node
	 * is NOT the first in the linked list of siblings.
	 *
	 * Hence, we compare parent with BOTH the parent and grandparent
	 * of nodes, and delete node is a match is found.
	 */
	prev = *headp;
	curr = prev->next;
	while (curr) {
		if (((curr_par = di_parent_node(curr->node)) != DI_NODE_NIL) &&
		    ((curr_par == parent) || ((curr_gpar =
		    di_parent_node(curr_par)) != DI_NODE_NIL) &&
		    (curr_gpar == parent))) {
			/*
			 * match parent/grandparent: delete curr
			 */
			prev->next = curr->next;
			free(curr);
			curr = prev->next;
		} else
			curr = curr->next;
	}

	/*
	 * delete the first node
	 */
	curr = *headp;
	*headp = curr->next;
	free(curr);
}

/*
 * Internal library function:
 *	Update node list based on action (return code from callback)
 *	and flag specifying walking behavior.
 */
static void
update_node_list(int action, uint_t flag, struct node_list **headp)
{
	struct node_list *children, *tmp;
	di_node_t parent = di_parent_node((*headp)->node);

	switch (action) {
	case DI_WALK_TERMINATE:
		/*
		 * free the node list and be done
		 */
		children = NULL;
		free_node_list(headp);
		break;

	case DI_WALK_PRUNESIB:
		/*
		 * Get list of children and prune siblings
		 */
		children = get_children((*headp)->node);
		prune_sib(headp);
		break;

	case DI_WALK_PRUNECHILD:
		/*
		 * Set children to NULL and pop first node
		 */
		children = NULL;
		tmp = *headp;
		*headp = tmp->next;
		free(tmp);
		break;

	case DI_WALK_CONTINUE:
	default:
		/*
		 * Get list of children and pop first node
		 */
		children = get_children((*headp)->node);
		tmp = *headp;
		*headp = tmp->next;
		free(tmp);
		break;
	}

	/*
	 * insert the list of children
	 */
	switch (flag) {
	case DI_WALK_CLDFIRST:
		prepend_node_list(headp, children);
		break;

	case DI_WALK_SIBFIRST:
		append_node_list(headp, children);
		break;

	case DI_WALK_LINKGEN:
	default:
		insert_node_list(headp, children, parent);
		break;
	}
}

/*
 * Internal library function:
 *   Invoke callback on one node and update the list of nodes to be walked
 *   based on the flag and return code.
 */
static void
walk_one_node(struct node_list **headp, uint_t flag, void *arg,
	int (*callback)(di_node_t, void *))
{
	DPRINTF((DI_TRACE, "Walking node %s\n", di_node_name((*headp)->node)));

	update_node_list(callback((*headp)->node, arg),
	    flag & DI_WALK_MASK, headp);
}

int
di_walk_node(di_node_t root, uint_t flag, void *arg,
	int (*node_callback)(di_node_t, void *))
{
	struct node_list  *head;	/* node_list for tree walk */

	if (root == NULL) {
		errno = EINVAL;
		return (-1);
	}

	if ((head = malloc(sizeof (struct node_list))) == NULL) {
		DPRINTF((DI_ERR, "malloc of node_list failed\n"));
		return (-1);
	}

	head->next = NULL;
	head->node = root;

	DPRINTF((DI_INFO, "Start node walking from node %s\n",
	    di_node_name(root)));

	while (head != NULL)
		walk_one_node(&head, flag, arg, node_callback);

	return (0);
}

/*
 * Internal library function:
 *   Invoke callback for each minor on the minor list of first node
 *   on node_list headp, and place children of first node on the list.
 *
 *   This is similar to walk_one_node, except we only walk in child
 *   first mode.
 */
static void
walk_one_minor_list(struct node_list **headp, const char *desired_type,
	uint_t flag, void *arg, int (*callback)(di_node_t, di_minor_t, void *))
{
	int ddm_type;
	int action = DI_WALK_CONTINUE;
	char *node_type;
	di_minor_t minor = DI_MINOR_NIL;
	di_node_t node = (*headp)->node;

	while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {
		ddm_type = di_minor_type(minor);

		if ((ddm_type == DDM_ALIAS) && !(flag & DI_CHECK_ALIAS))
			continue;

		if ((ddm_type == DDM_INTERNAL_PATH) &&
		    !(flag & DI_CHECK_INTERNAL_PATH))
			continue;

		node_type = di_minor_nodetype(minor);
		if ((desired_type != NULL) && ((node_type == NULL) ||
		    strncmp(desired_type, node_type, strlen(desired_type))
		    != 0))
			continue;

		if ((action = callback(node, minor, arg)) ==
		    DI_WALK_TERMINATE) {
			break;
		}
	}

	update_node_list(action, DI_WALK_LINKGEN, headp);
}

int
di_walk_minor(di_node_t root, const char *minor_type, uint_t flag, void *arg,
	int (*minor_callback)(di_node_t, di_minor_t, void *))
{
	struct node_list	*head;	/* node_list for tree walk */

#ifdef DEBUG
	char	*devfspath = di_devfs_path(root);
	DPRINTF((DI_INFO, "walking minor nodes under %s\n", devfspath));
	di_devfs_path_free(devfspath);
#endif

	if (root == NULL) {
		errno = EINVAL;
		return (-1);
	}

	if ((head = malloc(sizeof (struct node_list))) == NULL) {
		DPRINTF((DI_ERR, "malloc of node_list failed\n"));
		return (-1);
	}

	head->next = NULL;
	head->node = root;

	DPRINTF((DI_INFO, "Start minor walking from node %s\n",
	    di_node_name(root)));

	while (head != NULL)
		walk_one_minor_list(&head, minor_type, flag, arg,
		    minor_callback);

	return (0);
}

/*
 * generic node parameters
 *   Calling these routines always succeeds.
 */
char *
di_node_name(di_node_t node)
{
	return ((caddr_t)node + DI_NODE(node)->node_name - DI_NODE(node)->self);
}

/* returns NULL ptr or a valid ptr to non-NULL string */
char *
di_bus_addr(di_node_t node)
{
	caddr_t pa = (caddr_t)node - DI_NODE(node)->self;

	if (DI_NODE(node)->address == 0)
		return (NULL);

	return ((char *)(pa + DI_NODE(node)->address));
}

char *
di_binding_name(di_node_t node)
{
	caddr_t pa = (caddr_t)node - DI_NODE(node)->self;

	if (DI_NODE(node)->bind_name == 0)
		return (NULL);

	return ((char *)(pa + DI_NODE(node)->bind_name));
}

int
di_compatible_names(di_node_t node, char **names)
{
	char *c;
	int len, size, entries = 0;

	if (DI_NODE(node)->compat_names == 0) {
		*names = NULL;
		return (0);
	}

	*names = (caddr_t)node +
	    DI_NODE(node)->compat_names - DI_NODE(node)->self;

	c = *names;
	len = DI_NODE(node)->compat_length;
	while (len > 0) {
		entries++;
		size = strlen(c) + 1;
		len -= size;
		c += size;
	}

	return (entries);
}

int
di_instance(di_node_t node)
{
	return (DI_NODE(node)->instance);
}

/*
 * XXX: emulate the return value of the old implementation
 * using info from devi_node_class and devi_node_attributes.
 */
int
di_nodeid(di_node_t node)
{
	if (DI_NODE(node)->node_class == DDI_NC_PROM)
		return (DI_PROM_NODEID);

	if (DI_NODE(node)->attributes & DDI_PERSISTENT)
		return (DI_SID_NODEID);

	return (DI_PSEUDO_NODEID);
}

uint_t
di_state(di_node_t node)
{
	uint_t result = 0;

	if (di_node_state(node) < DS_ATTACHED)
		result |= DI_DRIVER_DETACHED;
	if (DI_NODE(node)->state & DEVI_DEVICE_OFFLINE)
		result |= DI_DEVICE_OFFLINE;
	if (DI_NODE(node)->state & DEVI_DEVICE_DOWN)
		result |= DI_DEVICE_DOWN;
	if (DI_NODE(node)->state & DEVI_DEVICE_DEGRADED)
		result |= DI_DEVICE_DEGRADED;
	if (DI_NODE(node)->state & DEVI_DEVICE_REMOVED)
		result |= DI_DEVICE_REMOVED;
	if (DI_NODE(node)->state & DEVI_BUS_QUIESCED)
		result |= DI_BUS_QUIESCED;
	if (DI_NODE(node)->state & DEVI_BUS_DOWN)
		result |= DI_BUS_DOWN;

	return (result);
}

ddi_node_state_t
di_node_state(di_node_t node)
{
	return (DI_NODE(node)->node_state);
}

uint_t
di_flags(di_node_t node)
{
	return (DI_NODE(node)->flags);
}

uint_t
di_retired(di_node_t node)
{
	return (di_flags(node) & DEVI_RETIRED);
}

ddi_devid_t
di_devid(di_node_t node)
{
	if (DI_NODE(node)->devid == 0)
		return (NULL);

	return ((ddi_devid_t)((caddr_t)node +
	    DI_NODE(node)->devid - DI_NODE(node)->self));
}

int
di_driver_major(di_node_t node)
{
	int major;

	major = DI_NODE(node)->drv_major;
	if (major < 0)
		return (-1);
	return (major);
}

char *
di_driver_name(di_node_t node)
{
	int major;
	caddr_t pa;
	struct di_devnm *devnm;

	major = DI_NODE(node)->drv_major;
	if (major < 0)
		return (NULL);

	pa = (caddr_t)node - DI_NODE(node)->self;
	devnm = DI_DEVNM(pa + DI_ALL(pa)->devnames);

	if (devnm[major].name)
		return (pa + devnm[major].name);
	else
		return (NULL);
}

uint_t
di_driver_ops(di_node_t node)
{
	int major;
	caddr_t pa;
	struct di_devnm *devnm;

	major = DI_NODE(node)->drv_major;
	if (major < 0)
		return (0);

	pa = (caddr_t)node - DI_NODE(node)->self;
	devnm = DI_DEVNM(pa + DI_ALL(pa)->devnames);

	return (devnm[major].ops);
}

/*
 * returns the length of the path, caller must free memory
 */
char *
di_devfs_path(di_node_t node)
{
	caddr_t pa;
	di_node_t parent;
	int depth = 0, len = 0;
	char *buf, *name[MAX_TREE_DEPTH], *addr[MAX_TREE_DEPTH];

	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (NULL);
	}

	/*
	 * trace back to root, note the node_name & address
	 */
	while ((parent = di_parent_node(node)) != DI_NODE_NIL) {
		name[depth] = di_node_name(node);
		len += strlen(name[depth]) + 1;		/* 1 for '/' */

		if ((addr[depth] = di_bus_addr(node)) != NULL)
			len += strlen(addr[depth]) + 1;	/* 1 for '@' */

		node = parent;
		depth++;
	}

	/*
	 * get the path to the root of snapshot
	 */
	pa = (caddr_t)node - DI_NODE(node)->self;
	name[depth] = DI_ALL(pa)->root_path;
	len += strlen(name[depth]) + 1;

	/*
	 * allocate buffer and assemble path
	 */
	if ((buf = malloc(len)) == NULL) {
		return (NULL);
	}

	(void) strcpy(buf, name[depth]);
	len = strlen(buf);
	if (buf[len - 1] == '/')
		len--;	/* delete trailing '/' */

	while (depth) {
		depth--;
		buf[len] = '/';
		(void) strcpy(buf + len + 1, name[depth]);
		len += strlen(name[depth]) + 1;
		if (addr[depth] && addr[depth][0] != '\0') {
			buf[len] = '@';
			(void) strcpy(buf + len + 1, addr[depth]);
			len += strlen(addr[depth]) + 1;
		}
	}

	return (buf);
}

char *
di_devfs_minor_path(di_minor_t minor)
{
	di_node_t	node;
	char		*full_path, *name, *devfspath;
	int		full_path_len;

	if (minor == DI_MINOR_NIL) {
		errno = EINVAL;
		return (NULL);
	}

	name = di_minor_name(minor);
	node = di_minor_devinfo(minor);
	devfspath = di_devfs_path(node);
	if (devfspath == NULL)
		return (NULL);

	/* make the full path to the device minor node */
	full_path_len = strlen(devfspath) + strlen(name) + 2;
	full_path = (char *)calloc(1, full_path_len);
	if (full_path != NULL)
		(void) snprintf(full_path, full_path_len, "%s:%s",
		    devfspath, name);

	di_devfs_path_free(devfspath);
	return (full_path);
}

/*
 * Produce a string representation of path to di_path_t (pathinfo node). This
 * string is identical to di_devfs_path had the device been enumerated under
 * the pHCI: it has a base path to pHCI, then uses node_name of client, and
 * device unit-address of pathinfo node.
 */
char *
di_path_devfs_path(di_path_t path)
{
	di_node_t	phci_node;
	char		*phci_path, *path_name, *path_addr;
	char		*full_path;
	int		full_path_len;

	if (path == DI_PATH_NIL) {
		errno = EINVAL;
		return (NULL);
	}

	/* get name@addr for path */
	path_name = di_path_node_name(path);
	path_addr = di_path_bus_addr(path);
	if ((path_name == NULL) || (path_addr == NULL))
		return (NULL);

	/* base path to pHCI devinfo node */
	phci_node = di_path_phci_node(path);
	if (phci_node == NULL)
		return (NULL);
	phci_path = di_devfs_path(phci_node);
	if (phci_path == NULL)
		return (NULL);

	/* make the full string representation of path */
	full_path_len = strlen(phci_path) + 1 + strlen(path_name) +
	    1 + strlen(path_addr) + 1;
	full_path = (char *)calloc(1, full_path_len);

	if (full_path != NULL)
		(void) snprintf(full_path, full_path_len, "%s/%s@%s",
		    phci_path, path_name, path_addr);
	di_devfs_path_free(phci_path);
	return (full_path);
}

char *
di_path_client_devfs_path(di_path_t path)
{
	return (di_devfs_path(di_path_client_node(path)));
}

void
di_devfs_path_free(char *buf)
{
	if (buf == NULL) {
		DPRINTF((DI_ERR, "di_devfs_path_free NULL arg!\n"));
		return;
	}

	free(buf);
}

/*
 * Return 1 if name is a IEEE-1275 generic name. If new generic
 * names are defined, they should be added to this table
 */
static int
is_generic(const char *name, int len)
{
	const char	**gp;

	/* from IEEE-1275 recommended practices section 3 */
	static const char *generic_names[] = {
	    "atm",
	    "disk",
	    "display",
	    "dma-controller",
	    "ethernet",
	    "fcs",
	    "fdc",
	    "fddi",
	    "fibre-channel",
	    "ide",
	    "interrupt-controller",
	    "isa",
	    "keyboard",
	    "memory",
	    "mouse",
	    "nvram",
	    "pc-card",
	    "pci",
	    "printer",
	    "rtc",
	    "sbus",
	    "scanner",
	    "scsi",
	    "serial",
	    "sound",
	    "ssa",
	    "tape",
	    "timer",
	    "token-ring",
	    "vme",
	    0
	};

	for (gp = generic_names; *gp; gp++) {
		if ((strncmp(*gp, name, len) == 0) &&
		    (strlen(*gp) == len))
			return (1);
	}
	return (0);
}

/*
 * Determine if two paths below /devices refer to the same device, ignoring
 * any generic .vs. non-generic 'name' issues in "[[/]name[@addr[:minor]]]*".
 * Return 1 if the paths match.
 */
int
di_devfs_path_match(const char *dp1, const char *dp2)
{
	const char	*p1, *p2;
	const char	*ec1, *ec2;
	const char	*at1, *at2;
	char		nc;
	int		g1, g2;

	/* progress through both strings */
	for (p1 = dp1, p2 = dp2; (*p1 == *p2) && *p1; p1++, p2++) {
		/* require match until the start of a component */
		if (*p1 != '/')
			continue;

		/* advance p1 and p2 to start of 'name' in component */
		nc = *(p1 + 1);
		if ((nc == '\0') || (nc == '/'))
			continue;		/* skip trash */
		p1++;
		p2++;

		/*
		 * Both p1 and p2 point to beginning of 'name' in component.
		 * Determine where current component ends: next '/' or '\0'.
		 */
		ec1 = strchr(p1, '/');
		if (ec1 == NULL)
			ec1 = p1 + strlen(p1);
		ec2 = strchr(p2, '/');
		if (ec2 == NULL)
			ec2 = p2 + strlen(p2);

		/* Determine where name ends based on whether '@' exists */
		at1 = strchr(p1, '@');
		at2 = strchr(p2, '@');
		if (at1 && (at1 < ec1))
			ec1 = at1;
		if (at2 && (at2 < ec2))
			ec2 = at2;

		/*
		 * At this point p[12] point to beginning of name and
		 * ec[12] point to character past the end of name. Determine
		 * if the names are generic.
		 */
		g1 = is_generic(p1, ec1 - p1);
		g2 = is_generic(p2, ec2 - p2);

		if (g1 != g2) {
			/*
			 * one generic and one non-generic
			 * skip past the names in the match.
			 */
			p1 = ec1;
			p2 = ec2;
		} else {
			if (*p1 != *p2)
				break;
		}
	}

	return ((*p1 == *p2) ? 1 : 0);
}

/* minor data access */
di_minor_t
di_minor_next(di_node_t node, di_minor_t minor)
{
	caddr_t pa;

	/*
	 * paranoid error checking
	 */
	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_MINOR_NIL);
	}

	/*
	 * minor is not NIL
	 */
	if (minor != DI_MINOR_NIL) {
		if (DI_MINOR(minor)->next != 0)
			return ((di_minor_t)((void *)((caddr_t)minor -
			    DI_MINOR(minor)->self + DI_MINOR(minor)->next)));
		else {
			errno = ENXIO;
			return (DI_MINOR_NIL);
		}
	}

	/*
	 * minor is NIL-->caller asks for first minor node
	 */
	if (DI_NODE(node)->minor_data != 0) {
		return (DI_MINOR((caddr_t)node - DI_NODE(node)->self +
		    DI_NODE(node)->minor_data));
	}

	/*
	 * no minor data-->check if snapshot includes minor data
	 *	in order to set the correct errno
	 */
	pa = (caddr_t)node - DI_NODE(node)->self;
	if (DINFOMINOR & DI_ALL(pa)->command)
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (DI_MINOR_NIL);
}

/* private interface for dealing with alias minor link generation */
di_node_t
di_minor_devinfo(di_minor_t minor)
{
	if (minor == DI_MINOR_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	return (DI_NODE((caddr_t)minor - DI_MINOR(minor)->self +
	    DI_MINOR(minor)->node));
}

ddi_minor_type
di_minor_type(di_minor_t minor)
{
	return (DI_MINOR(minor)->type);
}

char *
di_minor_name(di_minor_t minor)
{
	if (DI_MINOR(minor)->name == 0)
		return (NULL);

	return ((caddr_t)minor - DI_MINOR(minor)->self + DI_MINOR(minor)->name);
}

dev_t
di_minor_devt(di_minor_t minor)
{
	return (makedev(DI_MINOR(minor)->dev_major,
	    DI_MINOR(minor)->dev_minor));
}

int
di_minor_spectype(di_minor_t minor)
{
	return (DI_MINOR(minor)->spec_type);
}

char *
di_minor_nodetype(di_minor_t minor)
{
	if (DI_MINOR(minor)->node_type == 0)
		return (NULL);

	return ((caddr_t)minor -
	    DI_MINOR(minor)->self + DI_MINOR(minor)->node_type);
}

/*
 * Single public interface for accessing software properties
 */
di_prop_t
di_prop_next(di_node_t node, di_prop_t prop)
{
	int list = DI_PROP_DRV_LIST;

	/*
	 * paranoid check
	 */
	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_PROP_NIL);
	}

	/*
	 * Find which prop list we are at
	 */
	if (prop != DI_PROP_NIL)
		list = DI_PROP(prop)->prop_list;

	do {
		switch (list++) {
		case DI_PROP_DRV_LIST:
			prop = di_prop_drv_next(node, prop);
			break;
		case DI_PROP_SYS_LIST:
			prop = di_prop_sys_next(node, prop);
			break;
		case DI_PROP_GLB_LIST:
			prop = di_prop_global_next(node, prop);
			break;
		case DI_PROP_HW_LIST:
			prop = di_prop_hw_next(node, prop);
			break;
		default:	/* shouldn't happen */
			errno = EFAULT;
			return (DI_PROP_NIL);
		}
	} while ((prop == DI_PROP_NIL) && (list <= DI_PROP_HW_LIST));

	return (prop);
}

dev_t
di_prop_devt(di_prop_t prop)
{
	return (makedev(DI_PROP(prop)->dev_major, DI_PROP(prop)->dev_minor));
}

char *
di_prop_name(di_prop_t prop)
{
	if (DI_PROP(prop)->prop_name == 0)
		return (NULL);

	return ((caddr_t)prop - DI_PROP(prop)->self + DI_PROP(prop)->prop_name);
}

int
di_prop_type(di_prop_t prop)
{
	uint_t flags = DI_PROP(prop)->prop_flags;

	if (flags & DDI_PROP_UNDEF_IT)
		return (DI_PROP_TYPE_UNDEF_IT);

	if (DI_PROP(prop)->prop_len == 0)
		return (DI_PROP_TYPE_BOOLEAN);

	if ((flags & DDI_PROP_TYPE_MASK) == DDI_PROP_TYPE_ANY)
		return (DI_PROP_TYPE_UNKNOWN);

	if (flags & DDI_PROP_TYPE_INT)
		return (DI_PROP_TYPE_INT);

	if (flags & DDI_PROP_TYPE_INT64)
		return (DI_PROP_TYPE_INT64);

	if (flags & DDI_PROP_TYPE_STRING)
		return (DI_PROP_TYPE_STRING);

	if (flags & DDI_PROP_TYPE_BYTE)
		return (DI_PROP_TYPE_BYTE);

	/*
	 * Shouldn't get here. In case we do, return unknown type.
	 *
	 * XXX--When DDI_PROP_TYPE_COMPOSITE is implemented, we need
	 *	to add DI_PROP_TYPE_COMPOSITE.
	 */
	DPRINTF((DI_ERR, "Unimplemented property type: 0x%x\n", flags));

	return (DI_PROP_TYPE_UNKNOWN);
}

/*
 * Extract type-specific values of an property
 */
extern int di_prop_decode_common(void *prop_data, int len,
	int ddi_type, int prom);

int
di_prop_ints(di_prop_t prop, int **prop_data)
{
	if (DI_PROP(prop)->prop_len == 0)
		return (0);	/* boolean property */

	if ((DI_PROP(prop)->prop_data == 0) ||
	    (DI_PROP(prop)->prop_data == (di_off_t)-1)) {
		errno = EFAULT;
		*prop_data = NULL;
		return (-1);
	}

	*prop_data = (int *)((void *)((caddr_t)prop - DI_PROP(prop)->self
	    + DI_PROP(prop)->prop_data));

	return (di_prop_decode_common((void *)prop_data,
	    DI_PROP(prop)->prop_len, DI_PROP_TYPE_INT, 0));
}

int
di_prop_int64(di_prop_t prop, int64_t **prop_data)
{
	if (DI_PROP(prop)->prop_len == 0)
		return (0);	/* boolean property */

	if ((DI_PROP(prop)->prop_data == 0) ||
	    (DI_PROP(prop)->prop_data == (di_off_t)-1)) {
		errno = EFAULT;
		*prop_data = NULL;
		return (-1);
	}

	*prop_data = (int64_t *)((void *)((caddr_t)prop - DI_PROP(prop)->self
	    + DI_PROP(prop)->prop_data));

	return (di_prop_decode_common((void *)prop_data,
	    DI_PROP(prop)->prop_len, DI_PROP_TYPE_INT64, 0));
}

int
di_prop_strings(di_prop_t prop, char **prop_data)
{
	if (DI_PROP(prop)->prop_len == 0)
		return (0);	/* boolean property */

	if ((DI_PROP(prop)->prop_data == 0) ||
	    (DI_PROP(prop)->prop_data == (di_off_t)-1)) {
		errno = EFAULT;
		*prop_data = NULL;
		return (-1);
	}

	*prop_data = (char *)((caddr_t)prop - DI_PROP(prop)->self
	    + DI_PROP(prop)->prop_data);

	return (di_prop_decode_common((void *)prop_data,
	    DI_PROP(prop)->prop_len, DI_PROP_TYPE_STRING, 0));
}

int
di_prop_bytes(di_prop_t prop, uchar_t **prop_data)
{
	if (DI_PROP(prop)->prop_len == 0)
		return (0);	/* boolean property */

	if ((DI_PROP(prop)->prop_data == 0) ||
	    (DI_PROP(prop)->prop_data == (di_off_t)-1)) {
		errno = EFAULT;
		*prop_data = NULL;
		return (-1);
	}

	*prop_data = (uchar_t *)((caddr_t)prop - DI_PROP(prop)->self
	    + DI_PROP(prop)->prop_data);

	return (di_prop_decode_common((void *)prop_data,
	    DI_PROP(prop)->prop_len, DI_PROP_TYPE_BYTE, 0));
}

/*
 * returns 1 for match, 0 for no match
 */
static int
match_prop(di_prop_t prop, dev_t match_dev, const char *name, int type)
{
	int prop_type;

#ifdef DEBUG
	if (di_prop_name(prop) == NULL) {
		DPRINTF((DI_ERR, "libdevinfo: property has no name!\n"));
		return (0);
	}
#endif /* DEBUG */

	if (strcmp(name, di_prop_name(prop)) != 0)
		return (0);

	if ((match_dev != DDI_DEV_T_ANY) && (di_prop_devt(prop) != match_dev))
		return (0);

	/*
	 * XXX prop_type is different from DDI_*. See PSARC 1997/127.
	 */
	prop_type = di_prop_type(prop);
	if ((prop_type != DI_PROP_TYPE_UNKNOWN) && (prop_type != type) &&
	    (prop_type != DI_PROP_TYPE_BOOLEAN))
		return (0);

	return (1);
}

static di_prop_t
di_prop_search(dev_t match_dev, di_node_t node, const char *name,
    int type)
{
	di_prop_t prop = DI_PROP_NIL;

	/*
	 * The check on match_dev follows ddi_prop_lookup_common().
	 * Other checks are libdevinfo specific implementation.
	 */
	if ((node == DI_NODE_NIL) || (name == NULL) || (strlen(name) == 0) ||
	    (match_dev == DDI_DEV_T_NONE) || !DI_PROP_TYPE_VALID(type)) {
		errno = EINVAL;
		return (DI_PROP_NIL);
	}

	while ((prop = di_prop_next(node, prop)) != DI_PROP_NIL) {
		DPRINTF((DI_TRACE1, "match prop name %s, devt 0x%lx, type %d\n",
		    di_prop_name(prop), di_prop_devt(prop),
		    di_prop_type(prop)));
		if (match_prop(prop, match_dev, name, type))
			return (prop);
	}

	return (DI_PROP_NIL);
}

di_prop_t
di_prop_find(dev_t match_dev, di_node_t node, const char *name)
{
	di_prop_t prop = DI_PROP_NIL;

	if ((node == DI_NODE_NIL) || (name == NULL) || (strlen(name) == 0) ||
	    (match_dev == DDI_DEV_T_NONE)) {
		errno = EINVAL;
		return (DI_PROP_NIL);
	}

	while ((prop = di_prop_next(node, prop)) != DI_PROP_NIL) {
		DPRINTF((DI_TRACE1, "found prop name %s, devt 0x%lx, type %d\n",
		    di_prop_name(prop), di_prop_devt(prop),
		    di_prop_type(prop)));

		if (strcmp(name, di_prop_name(prop)) == 0 &&
		    (match_dev == DDI_DEV_T_ANY ||
		    di_prop_devt(prop) == match_dev))
			return (prop);
	}

	return (DI_PROP_NIL);
}

int
di_prop_lookup_ints(dev_t dev, di_node_t node, const char *prop_name,
	int **prop_data)
{
	di_prop_t prop;

	if ((prop = di_prop_search(dev, node, prop_name,
	    DI_PROP_TYPE_INT)) == DI_PROP_NIL)
		return (-1);

	return (di_prop_ints(prop, (void *)prop_data));
}

int
di_prop_lookup_int64(dev_t dev, di_node_t node, const char *prop_name,
	int64_t **prop_data)
{
	di_prop_t prop;

	if ((prop = di_prop_search(dev, node, prop_name,
	    DI_PROP_TYPE_INT64)) == DI_PROP_NIL)
		return (-1);

	return (di_prop_int64(prop, (void *)prop_data));
}

int
di_prop_lookup_strings(dev_t dev, di_node_t node, const char *prop_name,
    char **prop_data)
{
	di_prop_t prop;

	if ((prop = di_prop_search(dev, node, prop_name,
	    DI_PROP_TYPE_STRING)) == DI_PROP_NIL)
		return (-1);

	return (di_prop_strings(prop, (void *)prop_data));
}

int
di_prop_lookup_bytes(dev_t dev, di_node_t node, const char *prop_name,
	uchar_t **prop_data)
{
	di_prop_t prop;

	if ((prop = di_prop_search(dev, node, prop_name,
	    DI_PROP_TYPE_BYTE)) == DI_PROP_NIL)
		return (-1);

	return (di_prop_bytes(prop, (void *)prop_data));
}

/*
 * Consolidation private property access functions
 */
enum prop_type {
	PROP_TYPE_DRV,
	PROP_TYPE_SYS,
	PROP_TYPE_GLOB,
	PROP_TYPE_HW
};

static di_prop_t
di_prop_next_common(di_node_t node, di_prop_t prop, int prop_type)
{
	caddr_t pa;
	di_off_t prop_off = 0;

	if (prop != DI_PROP_NIL) {
		if (DI_PROP(prop)->next) {
			return (DI_PROP((caddr_t)prop -
			    DI_PROP(prop)->self + DI_PROP(prop)->next));
		} else {
			return (DI_PROP_NIL);
		}
	}


	/*
	 * prop is NIL, caller asks for first property
	 */
	pa = (caddr_t)node - DI_NODE(node)->self;
	switch (prop_type) {
	case PROP_TYPE_DRV:
		prop_off = DI_NODE(node)->drv_prop;
		break;
	case PROP_TYPE_SYS:
		prop_off = DI_NODE(node)->sys_prop;
		break;
	case PROP_TYPE_HW:
		prop_off = DI_NODE(node)->hw_prop;
		break;
	case PROP_TYPE_GLOB:
		prop_off = DI_NODE(node)->glob_prop;
		if (prop_off == -1) {
			/* no global property */
			prop_off = 0;
		} else if ((prop_off == 0) && (DI_NODE(node)->drv_major >= 0)) {
			/* refer to devnames array */
			struct di_devnm *devnm = DI_DEVNM(pa +
			    DI_ALL(pa)->devnames + (DI_NODE(node)->drv_major *
			    sizeof (struct di_devnm)));
			prop_off = devnm->global_prop;
		}
		break;
	}

	if (prop_off) {
		return (DI_PROP(pa + prop_off));
	}

	/*
	 * no prop found. Check the reason for not found
	 */
	if (DINFOPROP & DI_ALL(pa)->command)
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (DI_PROP_NIL);
}

di_prop_t
di_prop_drv_next(di_node_t node, di_prop_t prop)
{
	return (di_prop_next_common(node, prop, PROP_TYPE_DRV));
}

di_prop_t
di_prop_sys_next(di_node_t node, di_prop_t prop)
{
	return (di_prop_next_common(node, prop, PROP_TYPE_SYS));
}

di_prop_t
di_prop_global_next(di_node_t node, di_prop_t prop)
{
	return (di_prop_next_common(node, prop, PROP_TYPE_GLOB));
}

di_prop_t
di_prop_hw_next(di_node_t node, di_prop_t prop)
{
	return (di_prop_next_common(node, prop, PROP_TYPE_HW));
}

int
di_prop_rawdata(di_prop_t prop, uchar_t **prop_data)
{
#ifdef DEBUG
	if (prop == DI_PROP_NIL) {
		errno = EINVAL;
		return (-1);
	}
#endif /* DEBUG */

	if (DI_PROP(prop)->prop_len == 0) {
		*prop_data = NULL;
		return (0);
	}

	if ((DI_PROP(prop)->prop_data == 0) ||
	    (DI_PROP(prop)->prop_data == (di_off_t)-1)) {
		errno = EFAULT;
		*prop_data = NULL;
		return (-1);
	}

	/*
	 * No memory allocation.
	 */
	*prop_data = (uchar_t *)((caddr_t)prop - DI_PROP(prop)->self +
	    DI_PROP(prop)->prop_data);

	return (DI_PROP(prop)->prop_len);
}

/*
 * Consolidation private interfaces for accessing I/O multipathing data
 */
di_path_t
di_path_phci_next_path(di_node_t node, di_path_t path)
{
	caddr_t pa;

	/*
	 * path is not NIL
	 */
	if (path != DI_PATH_NIL) {
		if (DI_PATH(path)->path_p_link != 0)
			return (DI_PATH((void *)((caddr_t)path -
			    DI_PATH(path)->self + DI_PATH(path)->path_p_link)));
		else {
			errno = ENXIO;
			return (DI_PATH_NIL);
		}
	}

	/*
	 * Path is NIL; the caller is asking for the first path info node
	 */
	if (DI_NODE(node)->multipath_phci != 0) {
		DPRINTF((DI_INFO, "phci_next_path: returning %p\n",
		    ((caddr_t)node -
		    DI_NODE(node)->self + DI_NODE(node)->multipath_phci)));
		return (DI_PATH((caddr_t)node - DI_NODE(node)->self +
		    DI_NODE(node)->multipath_phci));
	}

	/*
	 * No pathing data; check if the snapshot includes path data in order
	 * to set errno properly.
	 */
	pa = (caddr_t)node - DI_NODE(node)->self;
	if (DINFOPATH & (DI_ALL(pa)->command))
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (DI_PATH_NIL);
}

di_path_t
di_path_client_next_path(di_node_t node, di_path_t path)
{
	caddr_t pa;

	/*
	 * path is not NIL
	 */
	if (path != DI_PATH_NIL) {
		if (DI_PATH(path)->path_c_link != 0)
			return (DI_PATH((caddr_t)path - DI_PATH(path)->self
			    + DI_PATH(path)->path_c_link));
		else {
			errno = ENXIO;
			return (DI_PATH_NIL);
		}
	}

	/*
	 * Path is NIL; the caller is asking for the first path info node
	 */
	if (DI_NODE(node)->multipath_client != 0) {
		DPRINTF((DI_INFO, "client_next_path: returning %p\n",
		    ((caddr_t)node -
		    DI_NODE(node)->self + DI_NODE(node)->multipath_client)));
		return (DI_PATH((caddr_t)node - DI_NODE(node)->self +
		    DI_NODE(node)->multipath_client));
	}

	/*
	 * No pathing data; check if the snapshot includes path data in order
	 * to set errno properly.
	 */
	pa = (caddr_t)node - DI_NODE(node)->self;
	if (DINFOPATH & (DI_ALL(pa)->command))
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (DI_PATH_NIL);
}

/*
 * XXX Remove the private di_path_(addr,next,next_phci,next_client) interfaces
 * below after NWS consolidation switches to using di_path_bus_addr,
 * di_path_phci_next_path, and di_path_client_next_path per CR6638521.
 */
char *
di_path_addr(di_path_t path, char *buf)
{
	caddr_t pa;		/* starting address of map */

	pa = (caddr_t)path - DI_PATH(path)->self;

	(void) strncpy(buf, (char *)(pa + DI_PATH(path)->path_addr),
	    MAXPATHLEN);
	return (buf);
}
di_path_t
di_path_next(di_node_t node, di_path_t path)
{
	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_PATH_NIL);
	}

	if (DI_NODE(node)->multipath_client) {
		return (di_path_client_next_path(node, path));
	} else if (DI_NODE(node)->multipath_phci) {
		return (di_path_phci_next_path(node, path));
	} else {
		/*
		 * The node had multipathing data but didn't appear to be a
		 * phci *or* a client; probably a programmer error.
		 */
		errno = EINVAL;
		return (DI_PATH_NIL);
	}
}
di_path_t
di_path_next_phci(di_node_t node, di_path_t path)
{
	return (di_path_client_next_path(node, path));
}
di_path_t
di_path_next_client(di_node_t node, di_path_t path)
{
	return (di_path_phci_next_path(node, path));
}




di_path_state_t
di_path_state(di_path_t path)
{
	return ((di_path_state_t)DI_PATH(path)->path_state);
}

uint_t
di_path_flags(di_path_t path)
{
	return (DI_PATH(path)->path_flags);
}

char *
di_path_node_name(di_path_t path)
{
	di_node_t	client_node;

	/* pathinfo gets node_name from client */
	if ((client_node = di_path_client_node(path)) == NULL)
		return (NULL);
	return (di_node_name(client_node));
}

char *
di_path_bus_addr(di_path_t path)
{
	caddr_t pa = (caddr_t)path - DI_PATH(path)->self;

	if (DI_PATH(path)->path_addr == 0)
		return (NULL);

	return ((char *)(pa + DI_PATH(path)->path_addr));
}

int
di_path_instance(di_path_t path)
{
	return (DI_PATH(path)->path_instance);
}

di_node_t
di_path_client_node(di_path_t path)
{
	caddr_t pa;		/* starting address of map */

	if (path == DI_PATH_NIL) {
		errno = EINVAL;
		return (DI_PATH_NIL);
	}

	DPRINTF((DI_TRACE, "Get client node for path %p\n", path));

	pa = (caddr_t)path - DI_PATH(path)->self;

	if (DI_PATH(path)->path_client) {
		return (DI_NODE(pa + DI_PATH(path)->path_client));
	}

	/*
	 * Deal with error condition:
	 *   If parent doesn't exist and node is not the root,
	 *   set errno to ENOTSUP. Otherwise, set errno to ENXIO.
	 */
	if ((DI_PATH(path)->path_snap_state & DI_PATH_SNAP_NOCLIENT) == 0)
		errno = ENOTSUP;
	else
		errno = ENXIO;

	return (DI_NODE_NIL);
}

di_node_t
di_path_phci_node(di_path_t path)
{
	caddr_t pa;		/* starting address of map */

	if (path == DI_PATH_NIL) {
		errno = EINVAL;
		return (DI_PATH_NIL);
	}

	DPRINTF((DI_TRACE, "Get phci node for path %p\n", path));

	pa = (caddr_t)path - DI_PATH(path)->self;

	if (DI_PATH(path)->path_phci) {
		return (DI_NODE(pa + DI_PATH(path)->path_phci));
	}

	/*
	 * Deal with error condition:
	 *   If parent doesn't exist and node is not the root,
	 *   set errno to ENOTSUP. Otherwise, set errno to ENXIO.
	 */
	if ((DI_PATH(path)->path_snap_state & DI_PATH_SNAP_NOPHCI) == 0)
		errno = ENOTSUP;
	else
		errno = ENXIO;

	return (DI_NODE_NIL);
}

di_path_prop_t
di_path_prop_next(di_path_t path, di_path_prop_t prop)
{
	caddr_t pa;

	if (path == DI_PATH_NIL) {
		errno = EINVAL;
		return (DI_PROP_NIL);
	}

	/*
	 * prop is not NIL
	 */
	if (prop != DI_PROP_NIL) {
		if (DI_PROP(prop)->next != 0)
			return (DI_PATHPROP((caddr_t)prop -
			    DI_PROP(prop)->self + DI_PROP(prop)->next));
		else {
			errno = ENXIO;
			return (DI_PROP_NIL);
		}
	}

	/*
	 * prop is NIL-->caller asks for first property
	 */
	pa = (caddr_t)path - DI_PATH(path)->self;
	if (DI_PATH(path)->path_prop != 0) {
		return (DI_PATHPROP(pa + DI_PATH(path)->path_prop));
	}

	/*
	 * no property data-->check if snapshot includes props
	 *	in order to set the correct errno
	 */
	if (DINFOPROP & (DI_ALL(pa)->command))
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (DI_PROP_NIL);
}

char *
di_path_prop_name(di_path_prop_t prop)
{
	caddr_t pa;		/* starting address of map */
	pa = (caddr_t)prop - DI_PATHPROP(prop)->self;
	return ((char *)(pa + DI_PATHPROP(prop)->prop_name));
}

int
di_path_prop_len(di_path_prop_t prop)
{
	return (DI_PATHPROP(prop)->prop_len);
}

int
di_path_prop_type(di_path_prop_t prop)
{
	switch (DI_PATHPROP(prop)->prop_type) {
		case DDI_PROP_TYPE_INT:
			return (DI_PROP_TYPE_INT);
		case DDI_PROP_TYPE_INT64:
			return (DI_PROP_TYPE_INT64);
		case DDI_PROP_TYPE_BYTE:
			return (DI_PROP_TYPE_BYTE);
		case DDI_PROP_TYPE_STRING:
			return (DI_PROP_TYPE_STRING);
	}
	return (DI_PROP_TYPE_UNKNOWN);
}

int
di_path_prop_bytes(di_path_prop_t prop, uchar_t **prop_data)
{
	if ((DI_PATHPROP(prop)->prop_data == 0) ||
	    (DI_PATHPROP(prop)->prop_data == (di_off_t)-1)) {
		errno = EFAULT;
		*prop_data = NULL;
		return (-1);
	}

	*prop_data = (uchar_t *)((caddr_t)prop - DI_PATHPROP(prop)->self
	    + DI_PATHPROP(prop)->prop_data);

	return (di_prop_decode_common((void *)prop_data,
	    DI_PATHPROP(prop)->prop_len, DI_PROP_TYPE_BYTE, 0));
}

int
di_path_prop_ints(di_path_prop_t prop, int **prop_data)
{
	if (DI_PATHPROP(prop)->prop_len == 0)
		return (0);

	if ((DI_PATHPROP(prop)->prop_data == 0) ||
	    (DI_PATHPROP(prop)->prop_data == (di_off_t)-1)) {
		errno = EFAULT;
		*prop_data = NULL;
		return (-1);
	}

	*prop_data = (int *)((void *)((caddr_t)prop - DI_PATHPROP(prop)->self
	    + DI_PATHPROP(prop)->prop_data));

	return (di_prop_decode_common((void *)prop_data,
	    DI_PATHPROP(prop)->prop_len, DI_PROP_TYPE_INT, 0));
}

int
di_path_prop_int64s(di_path_prop_t prop, int64_t **prop_data)
{
	if (DI_PATHPROP(prop)->prop_len == 0)
		return (0);

	if ((DI_PATHPROP(prop)->prop_data == 0) ||
	    (DI_PATHPROP(prop)->prop_data == (di_off_t)-1)) {
		errno = EFAULT;
		*prop_data = NULL;
		return (-1);
	}

	*prop_data = (int64_t *)((void *)((caddr_t)prop -
	    DI_PATHPROP(prop)->self + DI_PATHPROP(prop)->prop_data));

	return (di_prop_decode_common((void *)prop_data,
	    DI_PATHPROP(prop)->prop_len, DI_PROP_TYPE_INT64, 0));
}

int
di_path_prop_strings(di_path_prop_t prop, char **prop_data)
{
	if (DI_PATHPROP(prop)->prop_len == 0)
		return (0);

	if ((DI_PATHPROP(prop)->prop_data == 0) ||
	    (DI_PATHPROP(prop)->prop_data == (di_off_t)-1)) {
		errno = EFAULT;
		*prop_data = NULL;
		return (-1);
	}

	*prop_data = (char *)((caddr_t)prop - DI_PATHPROP(prop)->self
	    + DI_PATHPROP(prop)->prop_data);

	return (di_prop_decode_common((void *)prop_data,
	    DI_PATHPROP(prop)->prop_len, DI_PROP_TYPE_STRING, 0));
}

static di_path_prop_t
di_path_prop_search(di_path_t path, const char *name, int type)
{
	di_path_prop_t prop = DI_PROP_NIL;

	/*
	 * Sanity check arguments
	 */
	if ((path == DI_PATH_NIL) || (name == NULL) || (strlen(name) == 0) ||
	    !DI_PROP_TYPE_VALID(type)) {
		errno = EINVAL;
		return (DI_PROP_NIL);
	}

	while ((prop = di_path_prop_next(path, prop)) != DI_PROP_NIL) {
		int prop_type = di_path_prop_type(prop);

		DPRINTF((DI_TRACE1, "match path prop name %s, type %d\n",
		    di_path_prop_name(prop), prop_type));

		if (strcmp(name, di_path_prop_name(prop)) != 0)
			continue;

		if ((prop_type != DI_PROP_TYPE_UNKNOWN) && (prop_type != type))
			continue;

		return (prop);
	}

	return (DI_PROP_NIL);
}

int
di_path_prop_lookup_bytes(di_path_t path, const char *prop_name,
    uchar_t **prop_data)
{
	di_path_prop_t prop;

	if ((prop = di_path_prop_search(path, prop_name,
	    DI_PROP_TYPE_BYTE)) == DI_PROP_NIL)
		return (-1);

	return (di_path_prop_bytes(prop, prop_data));
}

int
di_path_prop_lookup_ints(di_path_t path, const char *prop_name,
    int **prop_data)
{
	di_path_prop_t prop;

	if ((prop = di_path_prop_search(path, prop_name,
	    DI_PROP_TYPE_INT)) == DI_PROP_NIL)
		return (-1);

	return (di_path_prop_ints(prop, prop_data));
}

int
di_path_prop_lookup_int64s(di_path_t path, const char *prop_name,
    int64_t **prop_data)
{
	di_path_prop_t prop;

	if ((prop = di_path_prop_search(path, prop_name,
	    DI_PROP_TYPE_INT64)) == DI_PROP_NIL)
		return (-1);

	return (di_path_prop_int64s(prop, prop_data));
}

int di_path_prop_lookup_strings(di_path_t path, const char *prop_name,
    char **prop_data)
{
	di_path_prop_t prop;

	if ((prop = di_path_prop_search(path, prop_name,
	    DI_PROP_TYPE_STRING)) == DI_PROP_NIL)
		return (-1);

	return (di_path_prop_strings(prop, prop_data));
}

/*
 * Consolidation private interfaces for traversing vhci nodes.
 */
di_node_t
di_vhci_first_node(di_node_t root)
{
	struct di_all *dap;
	caddr_t		pa;		/* starting address of map */

	DPRINTF((DI_INFO, "Get first vhci node\n"));

	if (root == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	pa = (caddr_t)root - DI_NODE(root)->self;
	dap = DI_ALL(pa);

	if (dap->top_vhci_devinfo == NULL) {
		errno = ENXIO;
		return (DI_NODE_NIL);
	}

	return (DI_NODE(pa + dap->top_vhci_devinfo));
}

di_node_t
di_vhci_next_node(di_node_t node)
{
	caddr_t		pa;		/* starting address of map */

	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	DPRINTF((DI_TRACE, "next vhci node on the snap shot:"
	    " current=%s\n", di_node_name(node)));

	if (DI_NODE(node)->next_vhci == NULL) {
		errno = ENXIO;
		return (DI_NODE_NIL);
	}

	pa = (caddr_t)node - DI_NODE(node)->self;

	return (DI_NODE(pa + DI_NODE(node)->next_vhci));
}

/*
 * Consolidation private interfaces for traversing phci nodes.
 */
di_node_t
di_phci_first_node(di_node_t vhci_node)
{
	caddr_t		pa;		/* starting address of map */

	DPRINTF((DI_INFO, "Get first phci node:\n"
	    " current=%s", di_node_name(vhci_node)));

	if (vhci_node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	pa = (caddr_t)vhci_node - DI_NODE(vhci_node)->self;

	if (DI_NODE(vhci_node)->top_phci == NULL) {
		errno = ENXIO;
		return (DI_NODE_NIL);
	}

	return (DI_NODE(pa + DI_NODE(vhci_node)->top_phci));
}

di_node_t
di_phci_next_node(di_node_t node)
{
	caddr_t		pa;		/* starting address of map */

	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	DPRINTF((DI_TRACE, "next phci node on the snap shot:"
	    " current=%s\n", di_node_name(node)));

	if (DI_NODE(node)->next_phci == NULL) {
		errno = ENXIO;
		return (DI_NODE_NIL);
	}

	pa = (caddr_t)node - DI_NODE(node)->self;

	return (DI_NODE(pa + DI_NODE(node)->next_phci));
}

/*
 * Consolidation private interfaces for private data
 */
void *
di_parent_private_data(di_node_t node)
{
	caddr_t pa;

	if (DI_NODE(node)->parent_data == 0) {
		errno = ENXIO;
		return (NULL);
	}

	if (DI_NODE(node)->parent_data == (di_off_t)-1) {
		/*
		 * Private data requested, but not obtained due to a memory
		 * error (e.g. wrong format specified)
		 */
		errno = EFAULT;
		return (NULL);
	}

	pa = (caddr_t)node - DI_NODE(node)->self;
	if (DI_NODE(node)->parent_data)
		return (pa + DI_NODE(node)->parent_data);

	if (DI_ALL(pa)->command & DINFOPRIVDATA)
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (NULL);
}

void *
di_driver_private_data(di_node_t node)
{
	caddr_t pa;

	if (DI_NODE(node)->driver_data == 0) {
		errno = ENXIO;
		return (NULL);
	}

	if (DI_NODE(node)->driver_data == (di_off_t)-1) {
		/*
		 * Private data requested, but not obtained due to a memory
		 * error (e.g. wrong format specified)
		 */
		errno = EFAULT;
		return (NULL);
	}

	pa = (caddr_t)node - DI_NODE(node)->self;
	if (DI_NODE(node)->driver_data)
		return (pa + DI_NODE(node)->driver_data);

	if (DI_ALL(pa)->command & DINFOPRIVDATA)
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (NULL);
}

/*
 * Hotplug information access
 */

typedef struct {
	void		*arg;
	const char	*type;
	uint_t		flag;
	int		(*hp_callback)(di_node_t, di_hp_t, void *);
} di_walk_hp_arg_t;

static int
di_walk_hp_callback(di_node_t node, void *argp)
{
	di_walk_hp_arg_t 	*arg = (di_walk_hp_arg_t *)argp;
	di_hp_t			hp;
	char			*type_str;

	for (hp = DI_HP_NIL; (hp = di_hp_next(node, hp)) != DI_HP_NIL; ) {

		/* Exclude non-matching types if a type filter is specified */
		if (arg->type != NULL) {
			type_str = di_hp_description(hp);
			if (type_str && (strcmp(arg->type, type_str) != 0))
				continue;
		}

		/* Exclude ports if DI_HP_PORT flag not specified */
		if (!(arg->flag & DI_HP_PORT) &&
		    (di_hp_type(hp) == DDI_HP_CN_TYPE_VIRTUAL_PORT))
			continue;

		/* Exclude connectors if DI_HP_CONNECTOR flag not specified */
		if (!(arg->flag & DI_HP_CONNECTOR) &&
		    !(di_hp_type(hp) == DDI_HP_CN_TYPE_VIRTUAL_PORT))
			continue;

		/* Perform callback */
		if (arg->hp_callback(node, hp, arg->arg) != DI_WALK_CONTINUE)
			return (DI_WALK_TERMINATE);
	}

	return (DI_WALK_CONTINUE);
}

int
di_walk_hp(di_node_t node, const char *type, uint_t flag, void *arg,
    int (*hp_callback)(di_node_t node, di_hp_t hp, void *arg))
{
	di_walk_hp_arg_t	walk_arg;
	caddr_t			pa;

#ifdef DEBUG
	char	*devfspath = di_devfs_path(node);
	DPRINTF((DI_INFO, "walking hotplug nodes under %s\n", devfspath));
	di_devfs_path_free(devfspath);
#endif
	/*
	 * paranoid error checking
	 */
	if ((node == DI_NODE_NIL) || (hp_callback == NULL)) {
		errno = EINVAL;
		return (-1);
	}

	/* check if hotplug data is included in snapshot */
	pa = (caddr_t)node - DI_NODE(node)->self;
	if (!(DI_ALL(pa)->command & DINFOHP)) {
		errno = ENOTSUP;
		return (-1);
	}

	walk_arg.arg = arg;
	walk_arg.type = type;
	walk_arg.flag = flag;
	walk_arg.hp_callback = hp_callback;
	return (di_walk_node(node, DI_WALK_CLDFIRST, &walk_arg,
	    di_walk_hp_callback));
}

di_hp_t
di_hp_next(di_node_t node, di_hp_t hp)
{
	caddr_t pa;

	/*
	 * paranoid error checking
	 */
	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_HP_NIL);
	}

	/*
	 * hotplug node is not NIL
	 */
	if (hp != DI_HP_NIL) {
		if (DI_HP(hp)->next != 0)
			return (DI_HP((caddr_t)hp - hp->self + hp->next));
		else {
			errno = ENXIO;
			return (DI_HP_NIL);
		}
	}

	/*
	 * hotplug node is NIL-->caller asks for first hotplug node
	 */
	if (DI_NODE(node)->hp_data != 0) {
		return (DI_HP((caddr_t)node - DI_NODE(node)->self +
		    DI_NODE(node)->hp_data));
	}

	/*
	 * no hotplug data-->check if snapshot includes hotplug data
	 *	in order to set the correct errno
	 */
	pa = (caddr_t)node - DI_NODE(node)->self;
	if (DINFOHP & DI_ALL(pa)->command)
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (DI_HP_NIL);
}

char *
di_hp_name(di_hp_t hp)
{
	caddr_t pa;

	/*
	 * paranoid error checking
	 */
	if (hp == DI_HP_NIL) {
		errno = EINVAL;
		return (NULL);
	}

	pa = (caddr_t)hp - DI_HP(hp)->self;

	if (DI_HP(hp)->hp_name == 0) {
		errno = ENXIO;
		return (NULL);
	}

	return ((char *)(pa + DI_HP(hp)->hp_name));
}

int
di_hp_connection(di_hp_t hp)
{
	/*
	 * paranoid error checking
	 */
	if (hp == DI_HP_NIL) {
		errno = EINVAL;
		return (-1);
	}

	if (DI_HP(hp)->hp_connection == -1)
		errno = ENOENT;

	return (DI_HP(hp)->hp_connection);
}

int
di_hp_depends_on(di_hp_t hp)
{
	/*
	 * paranoid error checking
	 */
	if (hp == DI_HP_NIL) {
		errno = EINVAL;
		return (-1);
	}

	if (DI_HP(hp)->hp_depends_on == -1)
		errno = ENOENT;

	return (DI_HP(hp)->hp_depends_on);
}

int
di_hp_state(di_hp_t hp)
{
	/*
	 * paranoid error checking
	 */
	if (hp == DI_HP_NIL) {
		errno = EINVAL;
		return (-1);
	}

	return (DI_HP(hp)->hp_state);
}

int
di_hp_type(di_hp_t hp)
{
	/*
	 * paranoid error checking
	 */
	if (hp == DI_HP_NIL) {
		errno = EINVAL;
		return (-1);
	}

	return (DI_HP(hp)->hp_type);
}

char *
di_hp_description(di_hp_t hp)
{
	caddr_t pa;

	/*
	 * paranoid error checking
	 */
	if (hp == DI_HP_NIL) {
		errno = EINVAL;
		return (NULL);
	}

	pa = (caddr_t)hp - DI_HP(hp)->self;

	if (DI_HP(hp)->hp_type_str == 0)
		return (NULL);

	return ((char *)(pa + DI_HP(hp)->hp_type_str));
}

di_node_t
di_hp_child(di_hp_t hp)
{
	caddr_t pa;		/* starting address of map */

	/*
	 * paranoid error checking
	 */
	if (hp == DI_HP_NIL) {
		errno = EINVAL;
		return (DI_NODE_NIL);
	}

	pa = (caddr_t)hp - DI_HP(hp)->self;

	if (DI_HP(hp)->hp_child > 0) {
		return (DI_NODE(pa + DI_HP(hp)->hp_child));
	}

	/*
	 * Deal with error condition:
	 *   Child doesn't exist, figure out if DINFOSUBTREE is set.
	 *   If it isn't, set errno to ENOTSUP.
	 */
	if (!(DINFOSUBTREE & DI_ALL(pa)->command))
		errno = ENOTSUP;
	else
		errno = ENXIO;

	return (DI_NODE_NIL);
}

time_t
di_hp_last_change(di_hp_t hp)
{
	/*
	 * paranoid error checking
	 */
	if (hp == DI_HP_NIL) {
		errno = EINVAL;
		return ((time_t)0);
	}

	return ((time_t)DI_HP(hp)->hp_last_change);
}

/*
 * PROM property access
 */

/*
 * openprom driver stuff:
 *	The maximum property length depends on the buffer size. We use
 *	OPROMMAXPARAM defined in <sys/openpromio.h>
 *
 *	MAXNAMESZ is max property name. obpdefs.h defines it as 32 based on 1275
 *	MAXVALSZ is maximum value size, which is whatever space left in buf
 */

#define	OBP_MAXBUF	OPROMMAXPARAM - sizeof (int)
#define	OBP_MAXPROPLEN	OBP_MAXBUF - OBP_MAXPROPNAME;

struct di_prom_prop {
	char *name;
	int len;
	uchar_t *data;
	struct di_prom_prop *next;	/* form a linked list */
};

struct di_prom_handle { /* handle to prom */
	mutex_t lock;	/* synchronize access to openprom fd */
	int	fd;	/* /dev/openprom file descriptor */
	struct di_prom_prop *list;	/* linked list of prop */
	union {
		char buf[OPROMMAXPARAM];
		struct openpromio opp;
	} oppbuf;
};

di_prom_handle_t
di_prom_init()
{
	struct di_prom_handle *p;

	if ((p = malloc(sizeof (struct di_prom_handle))) == NULL)
		return (DI_PROM_HANDLE_NIL);

	DPRINTF((DI_INFO, "di_prom_init: get prom handle 0x%p\n", p));

	(void) mutex_init(&p->lock, USYNC_THREAD, NULL);
	if ((p->fd = open("/dev/openprom", O_RDONLY)) < 0) {
		free(p);
		return (DI_PROM_HANDLE_NIL);
	}
	p->list = NULL;

	return ((di_prom_handle_t)p);
}

static void
di_prom_prop_free(struct di_prom_prop *list)
{
	struct di_prom_prop *tmp = list;

	while (tmp != NULL) {
		list = tmp->next;
		if (tmp->name != NULL) {
			free(tmp->name);
		}
		if (tmp->data != NULL) {
			free(tmp->data);
		}
		free(tmp);
		tmp = list;
	}
}

void
di_prom_fini(di_prom_handle_t ph)
{
	struct di_prom_handle *p = (struct di_prom_handle *)ph;

	DPRINTF((DI_INFO, "di_prom_fini: free prom handle 0x%p\n", p));

	(void) close(p->fd);
	(void) mutex_destroy(&p->lock);
	di_prom_prop_free(p->list);

	free(p);
}

/*
 * Internal library interface for locating the property
 * XXX: ph->lock must be held for the duration of call.
 */
static di_prom_prop_t
di_prom_prop_found(di_prom_handle_t ph, int nodeid,
	di_prom_prop_t prom_prop)
{
	struct di_prom_handle *p = (struct di_prom_handle *)ph;
	struct openpromio *opp = &p->oppbuf.opp;
	int *ip = (int *)((void *)opp->oprom_array);
	struct di_prom_prop *prop = (struct di_prom_prop *)prom_prop;

	DPRINTF((DI_TRACE1, "Looking for nodeid 0x%x\n", nodeid));

	/*
	 * Set "current" nodeid in the openprom driver
	 */
	opp->oprom_size = sizeof (int);
	*ip = nodeid;
	if (ioctl(p->fd, OPROMSETNODEID, opp) < 0) {
		DPRINTF((DI_ERR, "*** Nodeid not found 0x%x\n", nodeid));
		return (DI_PROM_PROP_NIL);
	}

	DPRINTF((DI_TRACE, "Found nodeid 0x%x\n", nodeid));

	bzero(opp, OBP_MAXBUF);
	opp->oprom_size = OBP_MAXPROPNAME;
	if (prom_prop != DI_PROM_PROP_NIL)
		(void) strcpy(opp->oprom_array, prop->name);

	if ((ioctl(p->fd, OPROMNXTPROP, opp) < 0) || (opp->oprom_size == 0))
		return (DI_PROM_PROP_NIL);

	/*
	 * Prom property found. Allocate struct for storing prop
	 *   (reuse variable prop)
	 */
	if ((prop = malloc(sizeof (struct di_prom_prop))) == NULL)
		return (DI_PROM_PROP_NIL);

	/*
	 * Get a copy of property name
	 */
	if ((prop->name = strdup(opp->oprom_array)) == NULL) {
		free(prop);
		return (DI_PROM_PROP_NIL);
	}

	/*
	 * get property value and length
	 */
	opp->oprom_size = OBP_MAXPROPLEN;

	if ((ioctl(p->fd, OPROMGETPROP, opp) < 0) ||
	    (opp->oprom_size == (uint_t)-1)) {
		free(prop->name);
		free(prop);
		return (DI_PROM_PROP_NIL);
	}

	/*
	 * make a copy of the property value
	 */
	prop->len = opp->oprom_size;

	if (prop->len == 0)
		prop->data = NULL;
	else if ((prop->data = malloc(prop->len)) == NULL) {
		free(prop->name);
		free(prop);
		return (DI_PROM_PROP_NIL);
	}

	bcopy(opp->oprom_array, prop->data, prop->len);

	/*
	 * Prepend prop to list in prom handle
	 */
	prop->next = p->list;
	p->list = prop;

	return ((di_prom_prop_t)prop);
}

di_prom_prop_t
di_prom_prop_next(di_prom_handle_t ph, di_node_t node, di_prom_prop_t prom_prop)
{
	struct di_prom_handle *p = (struct di_prom_handle *)ph;

	DPRINTF((DI_TRACE1, "Search next prop for node 0x%p with ph 0x%p\n",
	    node, p));

	/*
	 * paranoid check
	 */
	if ((ph == DI_PROM_HANDLE_NIL) || (node == DI_NODE_NIL)) {
		errno = EINVAL;
		return (DI_PROM_PROP_NIL);
	}

	if (di_nodeid(node) != DI_PROM_NODEID) {
		errno = ENXIO;
		return (DI_PROM_PROP_NIL);
	}

	/*
	 * synchronize access to prom file descriptor
	 */
	(void) mutex_lock(&p->lock);

	/*
	 * look for next property
	 */
	prom_prop = di_prom_prop_found(ph, DI_NODE(node)->nodeid, prom_prop);

	(void) mutex_unlock(&p->lock);

	return (prom_prop);
}

char *
di_prom_prop_name(di_prom_prop_t prom_prop)
{
	/*
	 * paranoid check
	 */
	if (prom_prop == DI_PROM_PROP_NIL) {
		errno = EINVAL;
		return (NULL);
	}

	return (((struct di_prom_prop *)prom_prop)->name);
}

int
di_prom_prop_data(di_prom_prop_t prom_prop, uchar_t **prom_prop_data)
{
	/*
	 * paranoid check
	 */
	if (prom_prop == DI_PROM_PROP_NIL) {
		errno = EINVAL;
		return (NULL);
	}

	*prom_prop_data = ((struct di_prom_prop *)prom_prop)->data;

	return (((struct di_prom_prop *)prom_prop)->len);
}

/*
 * Internal library interface for locating the property
 *    Returns length if found, -1 if prop doesn't exist.
 */
static struct di_prom_prop *
di_prom_prop_lookup_common(di_prom_handle_t ph, di_node_t node,
	const char *prom_prop_name)
{
	struct openpromio *opp;
	struct di_prom_prop *prop;
	struct di_prom_handle *p = (struct di_prom_handle *)ph;

	/*
	 * paranoid check
	 */
	if ((ph == DI_PROM_HANDLE_NIL) || (node == DI_NODE_NIL)) {
		errno = EINVAL;
		return (NULL);
	}

	if (di_nodeid(node) != DI_PROM_NODEID) {
		errno = ENXIO;
		return (NULL);
	}

	opp = &p->oppbuf.opp;

	(void) mutex_lock(&p->lock);

	opp->oprom_size = sizeof (int);
	opp->oprom_node = DI_NODE(node)->nodeid;
	if (ioctl(p->fd, OPROMSETNODEID, opp) < 0) {
		errno = ENXIO;
		DPRINTF((DI_ERR, "*** Nodeid not found 0x%x\n",
		    DI_NODE(node)->nodeid));
		(void) mutex_unlock(&p->lock);
		return (NULL);
	}

	/*
	 * get property length
	 */
	bzero(opp, OBP_MAXBUF);
	opp->oprom_size = OBP_MAXPROPLEN;
	(void) strcpy(opp->oprom_array, prom_prop_name);

	if ((ioctl(p->fd, OPROMGETPROPLEN, opp) < 0) ||
	    (opp->oprom_len == -1)) {
		/* no such property */
		(void) mutex_unlock(&p->lock);
		return (NULL);
	}

	/*
	 * Prom property found. Allocate struct for storing prop
	 */
	if ((prop = malloc(sizeof (struct di_prom_prop))) == NULL) {
		(void) mutex_unlock(&p->lock);
		return (NULL);
	}
	prop->name = NULL;	/* we don't need the name */
	prop->len = opp->oprom_len;

	if (prop->len == 0) {	/* boolean property */
		prop->data = NULL;
		prop->next = p->list;
		p->list = prop;
		(void) mutex_unlock(&p->lock);
		return (prop);
	}

	/*
	 * retrieve the property value
	 */
	bzero(opp, OBP_MAXBUF);
	opp->oprom_size = OBP_MAXPROPLEN;
	(void) strcpy(opp->oprom_array, prom_prop_name);

	if ((ioctl(p->fd, OPROMGETPROP, opp) < 0) ||
	    (opp->oprom_size == (uint_t)-1)) {
		/* error retrieving property value */
		(void) mutex_unlock(&p->lock);
		free(prop);
		return (NULL);
	}

	/*
	 * make a copy of the property value, stick in ph->list
	 */
	if ((prop->data = malloc(prop->len)) == NULL) {
		(void) mutex_unlock(&p->lock);
		free(prop);
		return (NULL);
	}

	bcopy(opp->oprom_array, prop->data, prop->len);

	prop->next = p->list;
	p->list = prop;
	(void) mutex_unlock(&p->lock);

	return (prop);
}

int
di_prom_prop_lookup_ints(di_prom_handle_t ph, di_node_t node,
	const char *prom_prop_name, int **prom_prop_data)
{
	int len;
	struct di_prom_prop *prop;

	prop = di_prom_prop_lookup_common(ph, node, prom_prop_name);

	if (prop == NULL) {
		*prom_prop_data = NULL;
		return (-1);
	}

	if (prop->len == 0) {	/* boolean property */
		*prom_prop_data = NULL;
		return (0);
	}

	len = di_prop_decode_common((void *)&prop->data, prop->len,
	    DI_PROP_TYPE_INT, 1);
	*prom_prop_data = (int *)((void *)prop->data);

	return (len);
}

int
di_prom_prop_lookup_strings(di_prom_handle_t ph, di_node_t node,
	const char *prom_prop_name, char **prom_prop_data)
{
	int len;
	struct di_prom_prop *prop;

	prop = di_prom_prop_lookup_common(ph, node, prom_prop_name);

	if (prop == NULL) {
		*prom_prop_data = NULL;
		return (-1);
	}

	if (prop->len == 0) {	/* boolean property */
		*prom_prop_data = NULL;
		return (0);
	}

	/*
	 * Fix an openprom bug (OBP string not NULL terminated).
	 * XXX This should really be fixed in promif.
	 */
	if (((char *)prop->data)[prop->len - 1] != '\0') {
		uchar_t *tmp;
		prop->len++;
		if ((tmp = realloc(prop->data, prop->len)) == NULL)
			return (-1);

		prop->data = tmp;
		((char *)prop->data)[prop->len - 1] = '\0';
		DPRINTF((DI_INFO, "OBP string not NULL terminated: "
		    "node=%s, prop=%s, val=%s\n",
		    di_node_name(node), prom_prop_name, prop->data));
	}

	len = di_prop_decode_common((void *)&prop->data, prop->len,
	    DI_PROP_TYPE_STRING, 1);
	*prom_prop_data = (char *)prop->data;

	return (len);
}

int
di_prom_prop_lookup_bytes(di_prom_handle_t ph, di_node_t node,
	const char *prom_prop_name, uchar_t **prom_prop_data)
{
	int len;
	struct di_prom_prop *prop;

	prop = di_prom_prop_lookup_common(ph, node, prom_prop_name);

	if (prop == NULL) {
		*prom_prop_data = NULL;
		return (-1);
	}

	if (prop->len == 0) {	/* boolean property */
		*prom_prop_data = NULL;
		return (0);
	}

	len = di_prop_decode_common((void *)&prop->data, prop->len,
	    DI_PROP_TYPE_BYTE, 1);
	*prom_prop_data = prop->data;

	return (len);
}

/*
 * returns an allocated array through <prop_data> only when its count > 0
 * and the number of entries (count) as the function return value;
 * use di_slot_names_free() to free the array
 */
int
di_prop_slot_names(di_prop_t prop, di_slot_name_t **prop_data)
{
	int rawlen, count;
	uchar_t *rawdata;
	char *nm = di_prop_name(prop);

	if (nm == NULL || strcmp(DI_PROP_SLOT_NAMES, nm) != 0)
		goto ERROUT;

	rawlen = di_prop_rawdata(prop, &rawdata);
	if (rawlen <= 0 || rawdata == NULL)
		goto ERROUT;

	count = di_slot_names_decode(rawdata, rawlen, prop_data);
	if (count < 0 || *prop_data == NULL)
		goto ERROUT;

	return (count);
	/*NOTREACHED*/
ERROUT:
	errno = EFAULT;
	*prop_data = NULL;
	return (-1);
}

int
di_prop_lookup_slot_names(dev_t dev, di_node_t node,
    di_slot_name_t **prop_data)
{
	di_prop_t prop;

	/*
	 * change this if and when DI_PROP_TYPE_COMPOSITE is implemented
	 * and slot-names is properly flagged as such
	 */
	if ((prop = di_prop_find(dev, node, DI_PROP_SLOT_NAMES)) ==
	    DI_PROP_NIL) {
		*prop_data = NULL;
		return (-1);
	}

	return (di_prop_slot_names(prop, (void *)prop_data));
}

/*
 * returns an allocated array through <prop_data> only when its count > 0
 * and the number of entries (count) as the function return value;
 * use di_slot_names_free() to free the array
 */
int
di_prom_prop_slot_names(di_prom_prop_t prom_prop, di_slot_name_t **prop_data)
{
	int rawlen, count;
	uchar_t *rawdata;

	rawlen = di_prom_prop_data(prom_prop, &rawdata);
	if (rawlen <= 0 || rawdata == NULL)
		goto ERROUT;

	count = di_slot_names_decode(rawdata, rawlen, prop_data);
	if (count < 0 || *prop_data == NULL)
		goto ERROUT;

	return (count);
	/*NOTREACHED*/
ERROUT:
	errno = EFAULT;
	*prop_data = NULL;
	return (-1);
}

int
di_prom_prop_lookup_slot_names(di_prom_handle_t ph, di_node_t node,
    di_slot_name_t **prop_data)
{
	struct di_prom_prop *prom_prop;

	prom_prop = di_prom_prop_lookup_common(ph, node, DI_PROP_SLOT_NAMES);
	if (prom_prop == NULL) {
		*prop_data = NULL;
		return (-1);
	}

	return (di_prom_prop_slot_names(prom_prop, prop_data));
}

di_lnode_t
di_link_to_lnode(di_link_t link, uint_t endpoint)
{
	struct di_all *di_all;

	if ((link == DI_LINK_NIL) ||
	    ((endpoint != DI_LINK_SRC) && (endpoint != DI_LINK_TGT))) {
		errno = EINVAL;
		return (DI_LNODE_NIL);
	}

	di_all = DI_ALL((caddr_t)link - DI_LINK(link)->self);

	if (endpoint == DI_LINK_SRC) {
		return (DI_LNODE((caddr_t)di_all + DI_LINK(link)->src_lnode));
	} else {
		return (DI_LNODE((caddr_t)di_all + DI_LINK(link)->tgt_lnode));
	}
	/* NOTREACHED */
}

char *
di_lnode_name(di_lnode_t lnode)
{
	return (di_driver_name(di_lnode_devinfo(lnode)));
}

di_node_t
di_lnode_devinfo(di_lnode_t lnode)
{
	struct di_all *di_all;

	di_all = DI_ALL((caddr_t)lnode - DI_LNODE(lnode)->self);
	return (DI_NODE((caddr_t)di_all + DI_LNODE(lnode)->node));
}

int
di_lnode_devt(di_lnode_t lnode, dev_t *devt)
{
	if ((lnode == DI_LNODE_NIL) || (devt == NULL)) {
		errno = EINVAL;
		return (-1);
	}
	if ((DI_LNODE(lnode)->dev_major == (major_t)-1) &&
	    (DI_LNODE(lnode)->dev_minor == (minor_t)-1))
		return (-1);

	*devt = makedev(DI_LNODE(lnode)->dev_major, DI_LNODE(lnode)->dev_minor);
	return (0);
}

int
di_link_spectype(di_link_t link)
{
	return (DI_LINK(link)->spec_type);
}

void
di_minor_private_set(di_minor_t minor, void *data)
{
	DI_MINOR(minor)->user_private_data = (uintptr_t)data;
}

void *
di_minor_private_get(di_minor_t minor)
{
	return ((void *)(uintptr_t)DI_MINOR(minor)->user_private_data);
}

void
di_node_private_set(di_node_t node, void *data)
{
	DI_NODE(node)->user_private_data = (uintptr_t)data;
}

void *
di_node_private_get(di_node_t node)
{
	return ((void *)(uintptr_t)DI_NODE(node)->user_private_data);
}

void
di_path_private_set(di_path_t path, void *data)
{
	DI_PATH(path)->user_private_data = (uintptr_t)data;
}

void *
di_path_private_get(di_path_t path)
{
	return ((void *)(uintptr_t)DI_PATH(path)->user_private_data);
}

void
di_lnode_private_set(di_lnode_t lnode, void *data)
{
	DI_LNODE(lnode)->user_private_data = (uintptr_t)data;
}

void *
di_lnode_private_get(di_lnode_t lnode)
{
	return ((void *)(uintptr_t)DI_LNODE(lnode)->user_private_data);
}

void
di_link_private_set(di_link_t link, void *data)
{
	DI_LINK(link)->user_private_data = (uintptr_t)data;
}

void *
di_link_private_get(di_link_t link)
{
	return ((void *)(uintptr_t)DI_LINK(link)->user_private_data);
}

di_lnode_t
di_lnode_next(di_node_t node, di_lnode_t lnode)
{
	struct di_all *di_all;

	/*
	 * paranoid error checking
	 */
	if (node == DI_NODE_NIL) {
		errno = EINVAL;
		return (DI_LNODE_NIL);
	}

	di_all = DI_ALL((caddr_t)node - DI_NODE(node)->self);

	if (lnode == DI_NODE_NIL) {
		if (DI_NODE(node)->lnodes != NULL)
			return (DI_LNODE((caddr_t)di_all +
			    DI_NODE(node)->lnodes));
	} else {
		if (DI_LNODE(lnode)->node_next != NULL)
			return (DI_LNODE((caddr_t)di_all +
			    DI_LNODE(lnode)->node_next));
	}

	if (DINFOLYR & DI_ALL(di_all)->command)
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (DI_LNODE_NIL);
}

di_link_t
di_link_next_by_node(di_node_t node, di_link_t link, uint_t endpoint)
{
	struct di_all *di_all;

	/*
	 * paranoid error checking
	 */
	if ((node == DI_NODE_NIL) ||
	    ((endpoint != DI_LINK_SRC) && (endpoint != DI_LINK_TGT))) {
		errno = EINVAL;
		return (DI_LINK_NIL);
	}

	di_all = DI_ALL((caddr_t)node - DI_NODE(node)->self);

	if (endpoint == DI_LINK_SRC) {
		if (link == DI_LINK_NIL) {
			if (DI_NODE(node)->src_links != NULL)
				return (DI_LINK((caddr_t)di_all +
				    DI_NODE(node)->src_links));
		} else {
			if (DI_LINK(link)->src_node_next != NULL)
				return (DI_LINK((caddr_t)di_all +
				    DI_LINK(link)->src_node_next));
		}
	} else {
		if (link == DI_LINK_NIL) {
			if (DI_NODE(node)->tgt_links != NULL)
				return (DI_LINK((caddr_t)di_all +
				    DI_NODE(node)->tgt_links));
		} else {
			if (DI_LINK(link)->tgt_node_next != NULL)
				return (DI_LINK((caddr_t)di_all +
				    DI_LINK(link)->tgt_node_next));
		}
	}

	if (DINFOLYR & DI_ALL(di_all)->command)
		errno = ENXIO;
	else
		errno = ENOTSUP;

	return (DI_LINK_NIL);
}

di_link_t
di_link_next_by_lnode(di_lnode_t lnode, di_link_t link, uint_t endpoint)
{
	struct di_all *di_all;

	/*
	 * paranoid error checking
	 */
	if ((lnode == DI_LNODE_NIL) ||
	    ((endpoint != DI_LINK_SRC) && (endpoint != DI_LINK_TGT))) {
		errno = EINVAL;
		return (DI_LINK_NIL);
	}

	di_all = DI_ALL((caddr_t)lnode - DI_LNODE(lnode)->self);

	if (endpoint == DI_LINK_SRC) {
		if (link == DI_LINK_NIL) {
			if (DI_LNODE(lnode)->link_out == NULL)
				return (DI_LINK_NIL);
			return (DI_LINK((caddr_t)di_all +
			    DI_LNODE(lnode)->link_out));
		} else {
			if (DI_LINK(link)->src_link_next == NULL)
				return (DI_LINK_NIL);
			return (DI_LINK((caddr_t)di_all +
			    DI_LINK(link)->src_link_next));
		}
	} else {
		if (link == DI_LINK_NIL) {
			if (DI_LNODE(lnode)->link_in == NULL)
				return (DI_LINK_NIL);
			return (DI_LINK((caddr_t)di_all +
			    DI_LNODE(lnode)->link_in));
		} else {
			if (DI_LINK(link)->tgt_link_next == NULL)
				return (DI_LINK_NIL);
			return (DI_LINK((caddr_t)di_all +
			    DI_LINK(link)->tgt_link_next));
		}
	}
	/* NOTREACHED */
}

/*
 * Internal library function:
 *   Invoke callback for each link data on the link list of first node
 *   on node_list headp, and place children of first node on the list.
 *
 *   This is similar to walk_one_node, except we only walk in child
 *   first mode.
 */
static void
walk_one_link(struct node_list **headp, uint_t ep,
    void *arg, int (*callback)(di_link_t link, void *arg))
{
	int		action = DI_WALK_CONTINUE;
	di_link_t	link = DI_LINK_NIL;
	di_node_t	node = (*headp)->node;

	while ((link = di_link_next_by_node(node, link, ep)) != DI_LINK_NIL) {
		action = callback(link, arg);
		if (action == DI_WALK_TERMINATE) {
			break;
		}
	}

	update_node_list(action, DI_WALK_LINKGEN, headp);
}

int
di_walk_link(di_node_t root, uint_t flag, uint_t endpoint, void *arg,
    int (*link_callback)(di_link_t link, void *arg))
{
	struct node_list  *head;	/* node_list for tree walk */

#ifdef DEBUG
	char *devfspath = di_devfs_path(root);
	DPRINTF((DI_INFO, "walking %s link data under %s\n",
	    (endpoint == DI_LINK_SRC) ? "src" : "tgt", devfspath));
	di_devfs_path_free(devfspath);
#endif

	/*
	 * paranoid error checking
	 */
	if ((root == DI_NODE_NIL) || (link_callback == NULL) || (flag != 0) ||
	    ((endpoint != DI_LINK_SRC) && (endpoint != DI_LINK_TGT))) {
		errno = EINVAL;
		return (-1);
	}

	if ((head = malloc(sizeof (struct node_list))) == NULL) {
		DPRINTF((DI_ERR, "malloc of node_list failed\n"));
		return (-1);
	}

	head->next = NULL;
	head->node = root;

	DPRINTF((DI_INFO, "Start link data walking from node %s\n",
	    di_node_name(root)));

	while (head != NULL)
		walk_one_link(&head, endpoint, arg, link_callback);

	return (0);
}

/*
 * Internal library function:
 *   Invoke callback for each link data on the link list of first node
 *   on node_list headp, and place children of first node on the list.
 *
 *   This is similar to walk_one_node, except we only walk in child
 *   first mode.
 */
static void
walk_one_lnode(struct node_list **headp, void *arg,
    int (*callback)(di_lnode_t lnode, void *arg))
{
	int		action = DI_WALK_CONTINUE;
	di_lnode_t	lnode = DI_LNODE_NIL;
	di_node_t	node = (*headp)->node;

	while ((lnode = di_lnode_next(node, lnode)) != DI_LNODE_NIL) {
		action = callback(lnode, arg);
		if (action == DI_WALK_TERMINATE) {
			break;
		}
	}

	update_node_list(action, DI_WALK_LINKGEN, headp);
}

int
di_walk_lnode(di_node_t root, uint_t flag, void *arg,
    int (*lnode_callback)(di_lnode_t lnode, void *arg))
{
	struct node_list  *head;	/* node_list for tree walk */

#ifdef DEBUG
	char *devfspath = di_devfs_path(root);
	DPRINTF((DI_INFO, "walking lnode data under %s\n", devfspath));
	di_devfs_path_free(devfspath);
#endif

	/*
	 * paranoid error checking
	 */
	if ((root == DI_NODE_NIL) || (lnode_callback == NULL) || (flag != 0)) {
		errno = EINVAL;
		return (-1);
	}

	if ((head = malloc(sizeof (struct node_list))) == NULL) {
		DPRINTF((DI_ERR, "malloc of node_list failed\n"));
		return (-1);
	}

	head->next = NULL;
	head->node = root;

	DPRINTF((DI_INFO, "Start lnode data walking from node %s\n",
	    di_node_name(root)));

	while (head != NULL)
		walk_one_lnode(&head, arg, lnode_callback);

	return (0);
}

static char *
alias_to_curr(di_node_t anynode, char *devfspath, di_node_t *nodep)
{
	caddr_t		pa;
	struct di_all	*all;
	struct di_alias *di_alias;
	di_node_t	node;
	char		*curr;
	char		*cp;
	char		*alias;
	di_off_t off;
	char buf[MAXPATHLEN];

	*nodep = NULL;

	if (anynode == DI_NODE_NIL || devfspath == NULL)
		return (NULL);

	pa = (caddr_t)anynode - DI_NODE(anynode)->self;
	all = DI_ALL(pa);

	di_alias = NULL;
	for (off = all->aliases; off > 0; off = di_alias->next) {
		di_alias = DI_ALIAS(pa + off);
		alias = di_alias->alias;
		if (strncmp(devfspath, alias, strlen(alias)) == 0) {
			cp = devfspath + strlen(alias);
			node = DI_NODE(pa + di_alias->curroff);
			assert(node != DI_NODE_NIL);
			if (*cp == '\0') {
				*nodep = node;
				return (NULL);
			} else if (*cp == '/') {
				curr = di_devfs_path(node);
				(void) snprintf(buf, sizeof (buf), "%s%s",
				    curr, cp);
				di_devfs_path_free(curr);
				curr = strdup(buf);
				return (curr);
			}
		}
	}

	return (NULL);
}

static di_node_t
di_lookup_node_impl(di_node_t root, char *devfspath)
{
	struct di_all *dap;
	di_node_t node;
	char *copy, *slash, *pname, *paddr;

	/*
	 * Path must be absolute and musn't have duplicate slashes
	 */
	if (*devfspath != '/' || strstr(devfspath, "//")) {
		DPRINTF((DI_ERR, "Invalid path: %s\n", devfspath));
		return (DI_NODE_NIL);
	}

	if (root == DI_NODE_NIL) {
		DPRINTF((DI_ERR, "root node is DI_NODE_NIL\n"));
		return (DI_NODE_NIL);
	}

	dap = DI_ALL((caddr_t)root - DI_NODE(root)->self);
	if (strcmp(dap->root_path, "/") != 0) {
		DPRINTF((DI_ERR, "snapshot root not / : %s\n", dap->root_path));
		return (DI_NODE_NIL);
	}

	if ((copy = strdup(devfspath)) == NULL) {
		DPRINTF((DI_ERR, "strdup failed on: %s\n", devfspath));
		return (DI_NODE_NIL);
	}

	for (slash = copy, node = root; slash; ) {

		/*
		 * Handle devfspath = "/" case as well as trailing '/'
		 */
		if (*(slash + 1) == '\0')
			break;

		/*
		 * More path-components exist. Deal with the next one
		 */
		pname = slash + 1;
		node = di_child_node(node);

		if (slash = strchr(pname, '/'))
			*slash = '\0';
		if (paddr = strchr(pname, '@'))
			*paddr++ = '\0';

		for (; node != DI_NODE_NIL; node = di_sibling_node(node)) {
			char *name, *baddr;

			name = di_node_name(node);
			baddr = di_bus_addr(node);

			if (strcmp(pname, name) != 0)
				continue;

			/*
			 * Mappings between a "path-address" and bus-addr
			 *
			 *	paddr		baddr
			 *	---------------------
			 *	NULL		NULL
			 *	NULL		""
			 *	""		N/A	(invalid paddr)
			 */
			if (paddr && baddr && strcmp(paddr, baddr) == 0)
				break;
			if (paddr == NULL && (baddr == NULL || *baddr == '\0'))
				break;
		}

		/*
		 * No nodes in the sibling list or there was no match
		 */
		if (node == DI_NODE_NIL) {
			DPRINTF((DI_ERR, "%s@%s: no node\n", pname, paddr));
			free(copy);
			return (DI_NODE_NIL);
		}
	}

	assert(node != DI_NODE_NIL);
	free(copy);
	return (node);
}

di_node_t
di_lookup_node(di_node_t root, char *devfspath)
{
	di_node_t	node;
	char		*curr;

	node = di_lookup_node_impl(root, devfspath);
	if (node != DI_NODE_NIL) {
		return (node);
	}

	/* node is already set to DI_NODE_NIL */
	curr = alias_to_curr(root, devfspath, &node);
	if (curr == NULL) {
		/* node may or may node be DI_NODE_NIL */
		return (node);
	}

	node = di_lookup_node_impl(root, curr);

	free(curr);

	return (node);
}

char *
di_alias2curr(di_node_t anynode, char *alias)
{
	di_node_t currnode = DI_NODE_NIL;
	char *curr;

	if (anynode == DI_NODE_NIL || alias == NULL)
		return (NULL);

	curr = alias_to_curr(anynode, alias, &currnode);
	if (curr == NULL && currnode != DI_NODE_NIL) {
		return (di_devfs_path(currnode));
	} else if (curr == NULL) {
		return (strdup(alias));
	}

	return (curr);
}

di_path_t
di_lookup_path(di_node_t root, char *devfspath)
{
	di_node_t	phci_node;
	di_path_t	path = DI_PATH_NIL;
	char		*copy, *lastslash;
	char		*pname, *paddr;
	char		*path_name, *path_addr;

	if ((copy = strdup(devfspath)) == NULL) {
		DPRINTF((DI_ERR, "strdup failed on: %s\n", devfspath));
		return (DI_NODE_NIL);
	}

	if ((lastslash = strrchr(copy, '/')) == NULL) {
		DPRINTF((DI_ERR, "failed to find component: %s\n", devfspath));
		goto out;
	}

	/* stop at pHCI and find the node for the phci */
	*lastslash = '\0';
	phci_node = di_lookup_node(root, copy);
	if (phci_node == NULL) {
		DPRINTF((DI_ERR, "failed to find component: %s\n", devfspath));
		goto out;
	}

	/* set up pname and paddr for last component */
	pname = lastslash + 1;
	if ((paddr = strchr(pname, '@')) == NULL) {
		DPRINTF((DI_ERR, "failed to find unit-addr: %s\n", devfspath));
		goto out;
	}
	*paddr++ = '\0';

	/* walk paths below phci looking for match */
	for (path = di_path_phci_next_path(phci_node, DI_PATH_NIL);
	    path != DI_PATH_NIL;
	    path = di_path_phci_next_path(phci_node, path)) {

		/* get name@addr of path */
		path_name = di_path_node_name(path);
		path_addr = di_path_bus_addr(path);
		if ((path_name == NULL) || (path_addr == NULL))
			continue;

		/* break on match */
		if ((strcmp(pname, path_name) == 0) &&
		    (strcmp(paddr, path_addr) == 0))
			break;
	}

out:	free(copy);
	return (path);
}

static char *
msglevel2str(di_debug_t msglevel)
{
	switch (msglevel) {
		case DI_ERR:
			return ("ERROR");
		case DI_INFO:
			return ("Info");
		case DI_TRACE:
			return ("Trace");
		case DI_TRACE1:
			return ("Trace1");
		case DI_TRACE2:
			return ("Trace2");
		default:
			return ("UNKNOWN");
	}
}

void
dprint(di_debug_t msglevel, const char *fmt, ...)
{
	va_list	ap;
	char	*estr;

	if (di_debug <= DI_QUIET)
		return;

	if (di_debug < msglevel)
		return;

	estr = msglevel2str(msglevel);

	assert(estr);

	va_start(ap, fmt);

	(void) fprintf(stderr, "libdevinfo[%lu]: %s: ",
	    (ulong_t)getpid(), estr);
	(void) vfprintf(stderr, fmt, ap);

	va_end(ap);
}

/* end of devinfo.c */