xref: /illumos-gate/usr/src/lib/libpool/common/pool_kernel.c (revision aab83bb8)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2012 Milan Jurik. All rights reserved.
 */

#include <assert.h>
#include <errno.h>
#include <exacct.h>
#include <fcntl.h>
#include <libnvpair.h>
#include <limits.h>
#include <poll.h>
#include <pool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <stropts.h>
#include <thread.h>
#include <time.h>
#include <unistd.h>

#include <libxml/tree.h>

#include <sys/mman.h>
#include <sys/pool.h>
#include <sys/pool_impl.h>
#include <sys/priocntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>

#include "dict.h"

#include "pool_internal.h"
#include "pool_impl.h"
#include "pool_kernel_impl.h"

/*
 * libpool kernel Manipulation Routines
 *
 * pool_kernel.c implements the kernel manipulation routines used by the
 * libpool kernel datastore. The functions are grouped into the following
 * logical areas
 *
 */

/*
 * Device snapshot transfer buffer size
 */
#define	KERNEL_SNAPSHOT_BUF_SZ	65535

/*
 * Kernel result set's initial size. 8 is probably large enough for
 * most queries. Queries requiring more space are accomodated using
 * realloc on a per result set basis.
 */
#define	KERNEL_RS_INITIAL_SZ	8

/*
 * Property manipulation macros
 */
#define	KERNEL_PROP_RDONLY	0x1

/*
 * Information required to evaluate qualifying elements for a query
 */
struct query_obj {
	const pool_conf_t *conf;
	const pool_elem_t *src;
	const char *src_attr;
	pool_elem_class_t classes;
	pool_value_t **props;
	pool_knl_result_set_t *rs;
};

/*
 * Identifies a pool element with a processor set id
 */
typedef struct pool_set_xref {
	pool_knl_pool_t	*psx_pool;
	uint_t		psx_pset_id;
	struct pool_set_xref *psx_next;
} pool_set_xref_t;

/*
 * Controls exacct snapshot load into libpool data structure
 */
typedef struct pool_snap_load {
	int *psl_changed;
	pool_set_xref_t *psl_xref;
	pool_elem_t *psl_system;
	pool_knl_resource_t *psl_pset;
} pool_snap_load_t;

/*
 * Information about an XML document which is being constructed
 */
struct knl_to_xml {
	xmlDocPtr ktx_doc;
	xmlNodePtr ktx_node;
};

/*
 * Undo structure processing. The following structures are all used to
 * allow changes to the libpool snapshot and kernel following an
 * unsuccessful commit.
 */
typedef struct pool_create_undo {
	pool_create_t pcu_ioctl;
	pool_elem_t *pcu_elem;
} pool_create_undo_t;

typedef struct pool_destroy_undo {
	pool_destroy_t pdu_ioctl;
	pool_elem_t *pdu_elem;
} pool_destroy_undo_t;

typedef struct pool_assoc_undo {
	pool_assoc_t pau_ioctl;
	pool_elem_t *pau_assoc;
	pool_elem_t *pau_oldres;
	pool_elem_t *pau_newres;
} pool_assoc_undo_t;

typedef struct pool_dissoc_undo {
	pool_dissoc_t pdu_ioctl;
	pool_elem_t *pdu_dissoc;
	pool_elem_t *pdu_oldres;
	pool_elem_t *pdu_newres;
} pool_dissoc_undo_t;

typedef struct pool_xtransfer_undo {
	pool_xtransfer_t pxu_ioctl;
	pool_elem_t *pxu_src;
	pool_elem_t *pxu_tgt;
	pool_component_t **pxu_rl;
} pool_xtransfer_undo_t;

typedef struct pool_propput_undo {
	pool_propput_t ppu_ioctl;
	pool_elem_t *ppu_elem;
	nvlist_t *ppu_alist;
	nvlist_t *ppu_blist;
	uchar_t ppu_doioctl;
} pool_propput_undo_t;

typedef struct pool_proprm_undo {
	pool_proprm_t pru_ioctl;
	pool_elem_t *pru_elem;
	pool_value_t pru_oldval;
} pool_proprm_undo_t;

extern const char *dtd_location;

extern const char *element_class_tags[];
extern const char pool_info_location[];

/*
 * These functions are defined in pool_xml.c and represent the minimum
 * XML support required to allow a pool kernel configuration to be
 * exported as an XML document.
 */
extern int pool_xml_set_attr(xmlNodePtr, xmlChar *, const pool_value_t *);
extern int pool_xml_set_prop(xmlNodePtr, xmlChar *, const pool_value_t *);
extern void xml_init(void);
extern xmlNodePtr node_create(xmlNodePtr, const xmlChar *);
extern void pool_error_func(void *, const char *, ...);
/*
 * Utilities
 */
static int load_group(pool_conf_t *, pool_knl_elem_t *, ea_object_t *,
    pool_snap_load_t *);
static void pool_knl_elem_free(pool_knl_elem_t *, int);
static int pool_knl_put_xml_property(pool_elem_t *, xmlNodePtr, const char *,
    const pool_value_t *);
static int pool_knl_snap_load_push(pool_snap_load_t *, pool_knl_pool_t *);
static int pool_knl_snap_load_update(pool_snap_load_t *, int, uint_t);
static int pool_knl_snap_load_remove(pool_snap_load_t *, int, uint_t);
static nvpair_t *pool_knl_find_nvpair(nvlist_t *, const char *);
static int pool_knl_nvlist_add_value(nvlist_t *, const char *,
    const pool_value_t *);
static int pool_knl_recover(pool_conf_t *);
static uint64_t hash_id(const pool_elem_t *);
static int blocking_open(const char *, int);

/*
 * Connections
 */
static void pool_knl_connection_free(pool_knl_connection_t *);

/*
 * Configuration
 */
static int pool_knl_close(pool_conf_t *);
static int pool_knl_validate(const pool_conf_t *, pool_valid_level_t);
static int pool_knl_commit(pool_conf_t *);
static int pool_knl_export(const pool_conf_t *, const char *,
    pool_export_format_t);
static int pool_knl_rollback(pool_conf_t *);
static pool_result_set_t *pool_knl_exec_query(const pool_conf_t *,
    const pool_elem_t *, const char *, pool_elem_class_t, pool_value_t **);
static int pool_knl_remove(pool_conf_t *);
static char *pool_knl_get_binding(pool_conf_t *, pid_t);
static int pool_knl_set_binding(pool_conf_t *, const char *, idtype_t, id_t);
static char *pool_knl_get_resource_binding(pool_conf_t *,
    pool_resource_elem_class_t, pid_t);
static int pool_knl_res_transfer(pool_resource_t *, pool_resource_t *,
    uint64_t);
static int pool_knl_res_xtransfer(pool_resource_t *, pool_resource_t *,
    pool_component_t **);

/*
 * Result Sets
 */
static pool_knl_result_set_t *pool_knl_result_set_alloc(const pool_conf_t *);
static int pool_knl_result_set_append(pool_knl_result_set_t *,
    pool_knl_elem_t *);
static int pool_knl_result_set_realloc(pool_knl_result_set_t *);
static void pool_knl_result_set_free(pool_knl_result_set_t *);
static pool_elem_t *pool_knl_rs_next(pool_result_set_t *);
static pool_elem_t *pool_knl_rs_prev(pool_result_set_t *);
static pool_elem_t *pool_knl_rs_first(pool_result_set_t *);
static pool_elem_t *pool_knl_rs_last(pool_result_set_t *);
static int pool_knl_rs_set_index(pool_result_set_t *, int);
static int pool_knl_rs_get_index(pool_result_set_t *);
static int pool_knl_rs_count(pool_result_set_t *);
static int pool_knl_rs_close(pool_result_set_t *);

/*
 * Element (and sub-type)
 */
static pool_knl_elem_t *pool_knl_elem_wrap(pool_conf_t *, pool_elem_class_t,
    pool_resource_elem_class_t, pool_component_elem_class_t);
static pool_elem_t *pool_knl_elem_create(pool_conf_t *, pool_elem_class_t,
    pool_resource_elem_class_t, pool_component_elem_class_t);
static int pool_knl_elem_remove(pool_elem_t *);
static int pool_knl_set_container(pool_elem_t *, pool_elem_t *);
static pool_elem_t *pool_knl_get_container(const pool_elem_t *);
/*
 * Pool element specific
 */
static int pool_knl_pool_associate(pool_t *, const pool_resource_t *);
static int pool_knl_pool_dissociate(pool_t *, const pool_resource_t *);

/*
 * Resource elements specific
 */
static int pool_knl_resource_is_system(const pool_resource_t *);
static int pool_knl_resource_can_associate(const pool_resource_t *);

/* Properties */
static pool_value_class_t pool_knl_get_property(const pool_elem_t *,
    const char *, pool_value_t *);
static pool_value_class_t pool_knl_get_dynamic_property(const pool_elem_t *,
    const char *, pool_value_t *);
static int pool_knl_put_property(pool_elem_t *, const char *,
    const pool_value_t *);
static int pool_knl_rm_property(pool_elem_t *, const char *);
static pool_value_t **pool_knl_get_properties(const pool_elem_t *, uint_t *);

/*
 * Logging
 */
static int log_item_commit(log_item_t *);
static int log_item_undo(log_item_t *);
static int log_item_release(log_item_t *);

/*
 * Utilities
 */

/*
 * load_group() updates the library configuration with the kernel
 * snapshot supplied in ep. The function is designed to be called
 * recursively. This function depends implicitly on the ordering of
 * the data provided in ep. Changes to the ordering of data in ep must
 * be matched by changes to this function.
 */
int
load_group(pool_conf_t *conf, pool_knl_elem_t *elem, ea_object_t *ep,
    pool_snap_load_t *psl)
{
	ea_object_t *eo;
	pool_knl_elem_t *old_elem;
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
	int ret = PO_SUCCESS;

	if ((ep->eo_catalog & EXD_DATA_MASK) == EXD_GROUP_SYSTEM) {
		if ((elem = pool_knl_elem_wrap(conf, PEC_SYSTEM, PREC_INVALID,
		    PCEC_INVALID)) == NULL)
			return (PO_FAIL);
		if (nvlist_alloc(&elem->pke_properties, NV_UNIQUE_NAME_TYPE,
		    0) != 0) {
			pool_knl_elem_free(elem, PO_FALSE);
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		/*
		 * Check to see if we already have an element
		 * for this data. If we have, free the newly
		 * created elem and continue with the old one
		 */
		if ((old_elem = dict_get(prov->pkc_elements, elem)) != NULL) {
			nvlist_free(old_elem->pke_properties);
			old_elem->pke_properties = elem->pke_properties;
			pool_knl_elem_free(elem, PO_FALSE);
			elem = old_elem;
		} else {
			if (dict_put(prov->pkc_elements, elem, elem) != NULL) {
				pool_knl_elem_free(elem, PO_TRUE);
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
		}
		psl->psl_system = (pool_elem_t *)elem;
	}

	for (eo = ep->eo_group.eg_objs; eo != NULL; eo = eo->eo_next) {
		int data;
		pool_knl_elem_t *prop_elem = NULL;

		data = (eo->eo_catalog & EXD_DATA_MASK);

		switch (data) {
		case EXD_SYSTEM_TSTAMP:
		case EXD_POOL_TSTAMP:
		case EXD_PSET_TSTAMP:
		case EXD_CPU_TSTAMP:
			if (eo->eo_item.ei_uint64 > prov->pkc_lotime) {
				if (eo->eo_item.ei_uint64 > prov->pkc_ltime)
					prov->pkc_ltime = eo->eo_item.ei_uint64;
				if (psl->psl_changed) {
					switch (data) {
					case EXD_SYSTEM_TSTAMP:
						*psl->psl_changed |= POU_SYSTEM;
						break;
					case EXD_POOL_TSTAMP:
						*psl->psl_changed |= POU_POOL;
						break;
					case EXD_PSET_TSTAMP:
						*psl->psl_changed |= POU_PSET;
						break;
					case EXD_CPU_TSTAMP:
						*psl->psl_changed |= POU_CPU;
						break;
					}
				}
			}
			break;
		case EXD_SYSTEM_PROP:
		case EXD_POOL_PROP:
		case EXD_PSET_PROP:
		case EXD_CPU_PROP:
			if (data == EXD_PSET_PROP) {
				prop_elem = elem;
				elem = (pool_knl_elem_t *)psl->psl_pset;
			}
			nvlist_free(elem->pke_properties);
			if (nvlist_unpack(eo->eo_item.ei_raw,
			    eo->eo_item.ei_size, &elem->pke_properties, 0) !=
			    0) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			elem->pke_ltime = prov->pkc_ltime;
			if (data == EXD_PSET_PROP) {
				elem = prop_elem;
			}
			break;
		case EXD_POOL_POOLID:
			if (nvlist_alloc(&elem->pke_properties,
			    NV_UNIQUE_NAME_TYPE, 0) != 0) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			if (nvlist_add_int64(elem->pke_properties,
			    "pool.sys_id",
			    (int64_t)eo->eo_item.ei_uint32) != 0) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			if ((old_elem = dict_get(prov->pkc_elements, elem)) !=
			    NULL) {
				nvlist_free(old_elem->pke_properties);
				old_elem->pke_properties = elem->pke_properties;
				pool_knl_elem_free(elem, PO_FALSE);
				elem = old_elem;
			} else {
				if (dict_put(prov->pkc_elements, elem, elem) !=
				    NULL) {
					pool_knl_elem_free(elem, PO_TRUE);
					pool_seterror(POE_SYSTEM);
					return (PO_FAIL);
				}
			}
			if (pool_knl_snap_load_push(psl,
			    (pool_knl_pool_t *)elem) != PO_SUCCESS) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			((pool_knl_pool_t *)elem)->pkp_assoc[PREC_PSET] = NULL;
			break;
		case EXD_POOL_PSETID:
			if (pool_knl_snap_load_update(psl, EXD_POOL_PSETID,
			    eo->eo_item.ei_uint32) != PO_SUCCESS) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			break;
		case EXD_PSET_PSETID:
			if (nvlist_alloc(&elem->pke_properties,
			    NV_UNIQUE_NAME_TYPE, 0) != 0) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			if (nvlist_add_int64(elem->pke_properties,
			    "pset.sys_id",
			    (int64_t)eo->eo_item.ei_uint32) != 0) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			if ((old_elem = dict_get(prov->pkc_elements, elem)) !=
			    NULL) {
				nvlist_free(old_elem->pke_properties);
				old_elem->pke_properties = elem->pke_properties;
				pool_knl_elem_free(elem, PO_FALSE);
				elem = old_elem;
			} else {
				if (dict_put(prov->pkc_elements, elem, elem) !=
				    NULL) {
					pool_knl_elem_free(elem, PO_TRUE);
					pool_seterror(POE_SYSTEM);
					return (PO_FAIL);
				}
			}
			psl->psl_pset = (pool_knl_resource_t *)elem;
			if (pool_knl_snap_load_remove(psl, data,
			    eo->eo_item.ei_uint32) != PO_SUCCESS) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			break;
		case EXD_CPU_CPUID:
			if (nvlist_alloc(&elem->pke_properties,
			    NV_UNIQUE_NAME_TYPE, 0) != 0) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			if (nvlist_add_int64(elem->pke_properties,
			    "cpu.sys_id",
			    (int64_t)eo->eo_item.ei_uint32) != 0) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			if ((old_elem = dict_get(prov->pkc_elements, elem)) !=
			    NULL) {
				nvlist_free(old_elem->pke_properties);
				old_elem->pke_properties = elem->pke_properties;
				old_elem->pke_parent = elem->pke_parent;
				pool_knl_elem_free(elem, PO_FALSE);
				elem = old_elem;
			} else {
				if (dict_put(prov->pkc_elements, elem, elem) !=
				    NULL) {
					pool_knl_elem_free(elem, PO_TRUE);
					pool_seterror(POE_SYSTEM);
					return (PO_FAIL);
				}
			}
			break;
		case EXD_GROUP_POOL:
			if ((elem = pool_knl_elem_wrap(conf, PEC_POOL,
			    PREC_INVALID, PCEC_INVALID)) == NULL)
				return (PO_FAIL);
			if (pool_set_container(psl->psl_system,
			    (pool_elem_t *)elem) != PO_SUCCESS) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			break;
		case EXD_GROUP_PSET:
			if ((elem = pool_knl_elem_wrap(conf, PEC_RES_COMP,
			    PREC_PSET, PCEC_INVALID)) == NULL)
				return (PO_FAIL);
			if (pool_set_container(psl->psl_system,
			    (pool_elem_t *)elem) != PO_SUCCESS) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			break;
		case EXD_GROUP_CPU:
			if ((elem = pool_knl_elem_wrap(conf, PEC_COMP,
			    PREC_INVALID, PCEC_CPU)) == NULL)
				return (PO_FAIL);
			if (pool_set_container((pool_elem_t *)psl->psl_pset,
			    (pool_elem_t *)elem) != PO_SUCCESS) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			break;
		default:
			break;
		}


		if (eo->eo_type == EO_GROUP) {
			if ((ret = load_group(conf, elem, eo, psl)) == PO_FAIL)
				break;
		}
	}
	return (ret);
}

/*
 * Push a snapshot entry onto the list of pools in the snapshot.
 */
int
pool_knl_snap_load_push(pool_snap_load_t *psl, pool_knl_pool_t *pkp)
{
	pool_set_xref_t *psx;

	if ((psx = malloc(sizeof (pool_set_xref_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	(void) memset(psx, 0, sizeof (pool_set_xref_t));
	psx->psx_pool = pkp;
	/*
	 * Push onto the list of pools
	 */
	psx->psx_next = psl->psl_xref;
	psl->psl_xref = psx;

	return (PO_SUCCESS);
}

/*
 * Update the current cross-reference for the supplied type of
 * resource.
 */
int
pool_knl_snap_load_update(pool_snap_load_t *psl, int type, uint_t id)
{
	switch (type) {
	case EXD_POOL_PSETID:
		psl->psl_xref->psx_pset_id = id;
		break;
	default:
		return (PO_FAIL);
	}

	return (PO_SUCCESS);
}

/*
 * Remove a resource entry with the supplied type and id from the
 * snapshot list when it is no longer required.
 */
int
pool_knl_snap_load_remove(pool_snap_load_t *psl, int type, uint_t id)
{
	pool_set_xref_t *current, *prev, *next;

	for (prev = NULL, current = psl->psl_xref; current != NULL;
	    current = next) {
		switch (type) {
		case EXD_PSET_PSETID:
			if (current->psx_pset_id == id)
				current->psx_pool->pkp_assoc[PREC_PSET] =
				    psl->psl_pset;
			break;
		default:
			return (PO_FAIL);
		}
		next = current->psx_next;
		if (current->psx_pool->pkp_assoc[PREC_PSET] != NULL) {
			if (prev != NULL) {
				prev->psx_next = current->psx_next;
			} else {
				psl->psl_xref = current->psx_next;
			}
			free(current);
		} else
			prev = current;
	}

	return (PO_SUCCESS);
}

/*
 * Return the nvpair with the supplied name from the supplied list.
 *
 * NULL is returned if the name cannot be found in the list.
 */
nvpair_t *
pool_knl_find_nvpair(nvlist_t *l, const char *name)
{
	nvpair_t *pair;

	for (pair = nvlist_next_nvpair(l, NULL); pair != NULL;
	    pair = nvlist_next_nvpair(l, pair)) {
		if (strcmp(nvpair_name(pair), name) == 0)
			break;
	}
	return (pair);
}

/*
 * Close the configuration. There are a few steps to closing a configuration:
 * - Close the pseudo device
 * - Free the data provider
 * Returns PO_SUCCESS/PO_FAIL
 */
int
pool_knl_close(pool_conf_t *conf)
{
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;

	if (close(prov->pkc_fd) < 0) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	/*
	 * Rollback any pending changes before freeing the prov. This
	 * ensures there are no memory leaks from pending transactions.
	 * However, don't rollback when we've done a temporary pool since the
	 * pool/resources haven't really been committed in this case.
	 * They will all be freed in pool_knl_connection_free and we don't
	 * want to double free them.
	 */
	if (!(conf->pc_prov->pc_oflags & PO_TEMP))
		(void) pool_knl_rollback(conf);
	pool_knl_connection_free(prov);
	return (PO_SUCCESS);
}

/*
 * Remove elements in this map (previously identified as "dead") from
 * the configuration map (prov->pkc_elements).
 */

/* ARGSUSED1 */
static void
remove_dead_elems(const void *key, void **value, void *cl)
{
	pool_knl_elem_t *pke = (pool_knl_elem_t *)key;
	pool_conf_t *conf = TO_CONF(TO_ELEM(pke));
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;

	assert(dict_remove(prov->pkc_elements, pke) != NULL);
#ifdef DEBUG
	dprintf("remove_dead_elems:\n");
	pool_elem_dprintf(TO_ELEM(pke));
#endif	/* DEBUG */
	pool_knl_elem_free(pke, PO_TRUE);
}

/*
 * Find elements which were not updated the last time that
 * load_group() was called. Add those elements into a separate map
 * (passed in cl) which will be later used to remove these elements
 * from the configuration map.
 */
/* ARGSUSED1 */
static void
find_dead_elems(const void *key, void **value, void *cl)
{
	pool_knl_elem_t *pke = (pool_knl_elem_t *)key;
	pool_conf_t *conf = TO_CONF(TO_ELEM(pke));
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
	dict_hdl_t *dead_map = (dict_hdl_t *)cl;

	if (pke->pke_ltime < prov->pkc_ltime)
		(void) dict_put(dead_map, pke, pke);
}

/*
 * Update the snapshot held by the library. This function acts as the
 * controller for the snapshot update procedure. Then snapshot is
 * actually updated in multiple phases by the load_group() function
 * (which updates existing elements and creates new elements as
 * required) and then by find_dead_elems and remove_dead_elems
 * (respectively responsible for identifying elements which are to be
 * removed and then removing them).
 *
 * Returns PO_SUCCESS
 */
int
pool_knl_update(pool_conf_t *conf, int *changed)
{
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
	pool_query_t query = {0};
	ea_object_t *ep;
	dict_hdl_t *dead_map;
	pool_snap_load_t psl = { NULL };

	/*
	 * Ensure the library snapshot is consistent, if there are any
	 * outstanding transactions return failure.
	 */
	if (log_size(prov->pkc_log) != 0) {
		pool_seterror(POE_INVALID_CONF);
		return (PO_FAIL);
	}
	/*
	 * Query the kernel for a snapshot of the configuration state. Use
	 * load_group to allocate the user-land representation of the
	 * data returned in the snapshot.
	 */
	/* LINTED E_CONSTANT_CONDITION */
	while (1) {
		if (ioctl(prov->pkc_fd, POOL_QUERY, &query) < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		if ((query.pq_io_buf = calloc(1,
		    (query.pq_io_bufsize < KERNEL_SNAPSHOT_BUF_SZ) ?
		    query.pq_io_bufsize * 2 : query.pq_io_bufsize)) == NULL) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		if (ioctl(prov->pkc_fd, POOL_QUERY, &query) < 0) {
			free(query.pq_io_buf);
			if (errno != ENOMEM) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
			query.pq_io_bufsize = 0;
			query.pq_io_buf = NULL;
		} else
			break;
	}
	if (ea_unpack_object(&ep, EUP_NOALLOC, query.pq_io_buf,
	    query.pq_io_bufsize) != EO_GROUP) {
		free(query.pq_io_buf);
		pool_seterror(POE_DATASTORE);
		return (PO_FAIL);
	}
	/*
	 * Update the library snapshot
	 */
	psl.psl_changed = changed;
	prov->pkc_lotime = prov->pkc_ltime;
	if (load_group(conf, NULL, ep, &psl) != PO_SUCCESS) {
		free(query.pq_io_buf);
		ea_free_object(ep, EUP_NOALLOC);
		return (PO_FAIL);
	}

	free(query.pq_io_buf);
	ea_free_object(ep, EUP_NOALLOC);
	/*
	 * Now search the dictionary for items that must be removed because
	 * they were neither created nor updated.
	 */
	if ((dead_map = dict_new((int (*)(const void *, const void *))
	    pool_elem_compare, (uint64_t (*)(const void *))hash_id)) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	dict_map(prov->pkc_elements, find_dead_elems, dead_map);

	if (dict_length(dead_map) > 0) {
		dict_map(dead_map, remove_dead_elems, NULL);
	}
	dict_free(&dead_map);

	return (PO_SUCCESS);
}

/*
 * Rely on the kernel to always keep a kernel configuration valid.
 * Returns PO_SUCCESS
 */
/* ARGSUSED */
int
pool_knl_validate(const pool_conf_t *conf, pool_valid_level_t level)
{
	return ((conf->pc_state == POF_INVALID) ? PO_FAIL : PO_SUCCESS);
}

/*
 * Process all the outstanding transactions in the log. If the processing
 * fails, then attempt to rollback and "undo" the changes.
 */
int
pool_knl_commit(pool_conf_t *conf)
{
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
	int lock = 1;

	/*
	 * Lock the kernel state for the commit
	 */
	if (ioctl(prov->pkc_fd, POOL_COMMIT, lock) < 0) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	lock = 0;
	/*
	 * If the state is LS_FAIL, then try to recover before
	 * performing the commit.
	 */
	if (prov->pkc_log->l_state == LS_FAIL) {
		if (pool_knl_recover(conf) == PO_FAIL) {
			/*
			 * Unlock the kernel state for the
			 * commit. Assert that this * can't fail,
			 * since if it ever does fail the library is
			 * unusable.
			 */
			assert(ioctl(prov->pkc_fd, POOL_COMMIT, lock) >= 0);
		}
	}
	/*
	 * Commit the log
	 */
	if (log_walk(prov->pkc_log, log_item_commit) != PO_SUCCESS) {
		(void) pool_knl_recover(conf);
		/*
		 * Unlock the kernel state for the commit. Assert that
		 * this can't fail, since if it ever does fail the
		 * library is unusable.
		 */
		assert(ioctl(prov->pkc_fd, POOL_COMMIT, lock) >= 0);
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	/*
	 * Unlock the kernel state for the commit. Assert that this
	 * can't fail, since if it ever does fail the library is
	 * unusable.
	 */
	assert(ioctl(prov->pkc_fd, POOL_COMMIT, lock) >= 0);
	/*
	 * Release the log resources
	 */
	(void) log_walk(prov->pkc_log, log_item_release);
	log_empty(prov->pkc_log);
	return (PO_SUCCESS);
}

/*
 * prop_build_cb() is designed to be called from
 * pool_walk_properties(). The property value is used to put an XML
 * property on the supplied ktx_node. This is an essential part of the
 * mechanism used to export a kernel configuration in libpool XML
 * form.
 */
/* ARGSUSED */
static int
prop_build_cb(pool_conf_t *UNUSED, pool_elem_t *pe, const char *name,
    pool_value_t *pval, void *user)
{
	struct knl_to_xml *info = (struct knl_to_xml *)user;

	return (pool_knl_put_xml_property((pool_elem_t *)pe, info->ktx_node,
	    name, pval));
}

/*
 * Duplicate some of the functionality from pool_xml_put_property()
 * (see pool_xml.c) to allow a kernel configuration to add XML nodes
 * to an XML tree which represents the kernel configuration. This is
 * an essential part of the mechanism used to export a kernel
 * configuration in libpool XML form.
 */
int
pool_knl_put_xml_property(pool_elem_t *pe, xmlNodePtr node, const char *name,
    const pool_value_t *val)
{

	/*
	 * "type" is a special attribute which is not visible ever outside of
	 * libpool. Use the specific type accessor function.
	 */
	if (strcmp(name, c_type) == 0) {
		return (pool_xml_set_attr(node, BAD_CAST name,
		    val));
	}
	if (is_ns_property(pe, name) != NULL) {	/* in ns */
		if (pool_xml_set_attr(node,
		    BAD_CAST property_name_minus_ns(pe, name), val) == PO_FAIL)
			return (pool_xml_set_prop(node, BAD_CAST name,
			    val));
	} else
		return (pool_xml_set_prop(node, BAD_CAST name, val));
	return (PO_SUCCESS);
}

/*
 * Export the kernel configuration as an XML file. The configuration
 * is used to build an XML document in memory. This document is then
 * saved to the supplied location.
 */
int
pool_knl_export(const pool_conf_t *conf, const char *location,
    pool_export_format_t fmt)
{
	xmlNodePtr node_comment;
	xmlNodePtr system;
	int ret;
	pool_t **ps;
	pool_resource_t **rs;
	uint_t nelem;
	int i;
	struct knl_to_xml info;
	char_buf_t *cb = NULL;
	xmlValidCtxtPtr cvp;

	xml_init();


	switch (fmt) {
	case POX_NATIVE:
		info.ktx_doc = xmlNewDoc(BAD_CAST "1.0");
		(void) xmlCreateIntSubset(info.ktx_doc, BAD_CAST "system",
		    BAD_CAST "-//Sun Microsystems Inc//DTD Resource "
		    "Management All//EN",
		    BAD_CAST dtd_location);

		if ((cvp = xmlNewValidCtxt()) == NULL) {
			xmlFreeDoc(info.ktx_doc);
			pool_seterror(POE_DATASTORE);
			return (PO_FAIL);
		}
		/*
		 * Call xmlValidateDocument() to force the parsing of
		 * the DTD. Ignore errors and warning messages as we
		 * know the document isn't valid.
		 */
		(void) xmlValidateDocument(cvp, info.ktx_doc);
		xmlFreeValidCtxt(cvp);
		if ((info.ktx_node = node_create(NULL, BAD_CAST "system")) ==
		    NULL) {
			xmlFreeDoc(info.ktx_doc);
			pool_seterror(POE_DATASTORE);
			return (PO_FAIL);
		}

		system = info.ktx_node;
		info.ktx_doc->_private = (void *)conf;

		(void) xmlDocSetRootElement(info.ktx_doc, info.ktx_node);
		(void) xmlSetProp(info.ktx_node, BAD_CAST c_ref_id,
		    BAD_CAST "dummy");
		if ((node_comment = xmlNewDocComment(info.ktx_doc,
		    BAD_CAST "\nConfiguration for pools facility. Do NOT"
		    " edit this file by hand - use poolcfg(1)"
		    " or libpool(3POOL) instead.\n")) == NULL) {
			xmlFreeDoc(info.ktx_doc);
			pool_seterror(POE_DATASTORE);
			return (PO_FAIL);
		}
		if (xmlAddPrevSibling(info.ktx_node, node_comment) == NULL) {
			xmlFree(node_comment);
			xmlFreeDoc(info.ktx_doc);
			pool_seterror(POE_DATASTORE);
			return (PO_FAIL);
		}
		if (pool_walk_any_properties((pool_conf_t *)conf,
		    pool_conf_to_elem(conf), &info, prop_build_cb, 1) ==
		    PO_FAIL) {
			xmlFreeDoc(info.ktx_doc);
			return (PO_FAIL);
		}
		if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL) {
			xmlFreeDoc(info.ktx_doc);
			return (PO_FAIL);
		}
		/*
		 * Now add pool details
		 */
		if ((ps = pool_query_pools(conf, &nelem, NULL)) != NULL) {
			for (i = 0; i < nelem; i++) {
				pool_elem_t *elem = TO_ELEM(ps[i]);
				uint_t nreselem;
				const char *sep = "";
				int j;

				if (elem_is_tmp(elem))
					continue;

				if ((info.ktx_node = node_create(system,
				    BAD_CAST element_class_tags
				    [pool_elem_class(elem)])) == NULL) {
					free(ps);
					free_char_buf(cb);
					xmlFreeDoc(info.ktx_doc);
					pool_seterror(POE_DATASTORE);
					return (PO_FAIL);
				}
				if (pool_walk_any_properties(
				    (pool_conf_t *)conf,
				    elem, &info, prop_build_cb, 1) == PO_FAIL) {
					free(ps);
					free_char_buf(cb);
					xmlFreeDoc(info.ktx_doc);
					return (PO_FAIL);
				}
				/*
				 * TODO: pset specific res manipulation
				 */
				if ((rs = pool_query_pool_resources(conf, ps[i],
				    &nreselem, NULL)) == NULL) {
					free(ps);
					free_char_buf(cb);
					xmlFreeDoc(info.ktx_doc);
					pool_seterror(POE_INVALID_CONF);
					return (PO_FAIL);
				}
				if (set_char_buf(cb, "") == PO_FAIL) {
					free(rs);
					free(ps);
					free_char_buf(cb);
					xmlFreeDoc(info.ktx_doc);
					return (PO_FAIL);
				}
				for (j = 0; j < nreselem; j++) {
					pool_elem_t *reselem = TO_ELEM(rs[j]);
					if (append_char_buf(cb, "%s%s_%d", sep,
					    pool_elem_class_string(reselem),
					    (int)elem_get_sysid(reselem)) ==
					    PO_FAIL) {
						free(rs);
						free(ps);
						free_char_buf(cb);
						xmlFreeDoc(info.ktx_doc);
						return (PO_FAIL);
					}
					sep = " ";
				}
				free(rs);
				(void) xmlSetProp(info.ktx_node, BAD_CAST "res",
				    BAD_CAST cb->cb_buf);
				if (set_char_buf(cb, "%s_%d",
				    pool_elem_class_string(elem),
				    (int)elem_get_sysid(elem)) == PO_FAIL) {
					free(ps);
					free_char_buf(cb);
					xmlFreeDoc(info.ktx_doc);
					return (PO_FAIL);
				}
				(void) xmlSetProp(info.ktx_node,
				    BAD_CAST c_ref_id,
				    BAD_CAST  cb->cb_buf);
			}
			free(ps);
		}
		/*
		 * Now add resource details (including components)
		 */
		if ((rs = pool_query_resources(conf, &nelem, NULL)) != NULL) {
			for (i = 0; i < nelem; i++) {
				pool_elem_t *elem = TO_ELEM(rs[i]);
				pool_component_t **cs = NULL;
				uint_t ncompelem;
				int j;

				if (elem_is_tmp(elem))
					continue;

				if ((info.ktx_node = node_create(system,
				    BAD_CAST element_class_tags
				    [pool_elem_class(elem)])) == NULL) {
					free(rs);
					free_char_buf(cb);
					xmlFreeDoc(info.ktx_doc);
					pool_seterror(POE_DATASTORE);
					return (PO_FAIL);
				}
				if (pool_walk_any_properties(
				    (pool_conf_t *)conf,
				    elem, &info, prop_build_cb, 1) == PO_FAIL) {
					free(rs);
					free_char_buf(cb);
					xmlFreeDoc(info.ktx_doc);
					return (PO_FAIL);
				}
				if (set_char_buf(cb, "%s_%d",
				    pool_elem_class_string(elem),
				    (int)elem_get_sysid(elem)) == PO_FAIL) {
					free(rs);
					free_char_buf(cb);
					xmlFreeDoc(info.ktx_doc);
					return (PO_FAIL);
				}
				(void) xmlSetProp(info.ktx_node,
				    BAD_CAST c_ref_id,
				    BAD_CAST  cb->cb_buf);
				if ((cs = pool_query_resource_components(conf,
				    rs[i], &ncompelem, NULL)) != NULL) {
					xmlNodePtr resource = info.ktx_node;

					for (j = 0; j < ncompelem; j++) {
						pool_elem_t *compelem =
						    TO_ELEM(cs[j]);
						if ((info.ktx_node =
						    node_create(resource,
						    BAD_CAST element_class_tags
						    [pool_elem_class(
						    compelem)])) == NULL) {
							pool_seterror(
							    POE_DATASTORE);
							free(rs);
							free(cs);
							free_char_buf(cb);
							xmlFreeDoc(info.
							    ktx_doc);
							return (PO_FAIL);
						}
						if (pool_walk_any_properties(
						    (pool_conf_t *)conf,
						    compelem, &info,
						    prop_build_cb, 1) ==
						    PO_FAIL) {
							free(rs);
							free(cs);
							free_char_buf(cb);
							xmlFreeDoc(info.
							    ktx_doc);
							return (PO_FAIL);
						}
						if (set_char_buf(cb, "%s_%d",
						    pool_elem_class_string(
						    compelem),
						    (int)elem_get_sysid(
						    compelem)) == PO_FAIL) {
							free(rs);
							free(cs);
							free_char_buf(cb);
							xmlFreeDoc(info.
							    ktx_doc);
							return (PO_FAIL);
						}
						(void) xmlSetProp(info.ktx_node,
						    BAD_CAST c_ref_id,
						    BAD_CAST  cb->cb_buf);
					}
					free(cs);
				}
			}
			free(rs);
		}
		free_char_buf(cb);
		/*
		 * Set up the message handlers prior to calling
		 * xmlValidateDocument()
		 */
		if ((cvp = xmlNewValidCtxt()) == NULL) {
			xmlFreeDoc(info.ktx_doc);
			pool_seterror(POE_DATASTORE);
			return (PO_FAIL);
		}
		cvp->error    = pool_error_func;
		cvp->warning  = pool_error_func;
		if (xmlValidateDocument(cvp, info.ktx_doc) == 0) {
			xmlFreeValidCtxt(cvp);
			xmlFreeDoc(info.ktx_doc);
			pool_seterror(POE_INVALID_CONF);
			return (PO_FAIL);
		}
		xmlFreeValidCtxt(cvp);
		ret = xmlSaveFormatFile(location, info.ktx_doc, 1);
		xmlFreeDoc(info.ktx_doc);
		if (ret == -1) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		return (PO_SUCCESS);
	default:
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	}
}

/*
 * Rollback the changes to the kernel
 */
int
pool_knl_recover(pool_conf_t *conf)
{
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;

	prov->pkc_log->l_state = LS_RECOVER;
	if (log_reverse_walk(prov->pkc_log, log_item_undo) != PO_SUCCESS) {
		dprintf("Library configuration consistency error\n");
		prov->pkc_log->l_state = LS_FAIL;
		pool_seterror(POE_INVALID_CONF);
		return (PO_FAIL);
	}
	prov->pkc_log->l_state = LS_DO;
	return (PO_SUCCESS);
}

/*
 * Rollback the changes to the configuration
 */
int
pool_knl_rollback(pool_conf_t *conf)
{
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;

	prov->pkc_log->l_state = LS_UNDO;
	if (log_reverse_walk(prov->pkc_log, log_item_undo) != PO_SUCCESS) {
		dprintf("Kernel configuration consistency error\n");
		(void) log_walk(prov->pkc_log, log_item_release);
		log_empty(prov->pkc_log);
		prov->pkc_log->l_state = LS_FAIL;
		pool_seterror(POE_INVALID_CONF);
		return (PO_FAIL);
	}
	(void) log_walk(prov->pkc_log, log_item_release);
	log_empty(prov->pkc_log);
	prov->pkc_log->l_state = LS_DO;
	return (PO_SUCCESS);
}

/*
 * Callback used to build the result set for a query. Each invocation will
 * supply a candidate element for inclusion. The element is filtered by:
 * - class
 * - properties
 * If the element "matches" the target, then it is added to the result
 * set, otherwise it is ignored.
 */
/* ARGSUSED1 */
static void
build_result_set(const void *key, void **value, void *cl)
{
	struct query_obj *qo = (struct query_obj *)cl;
	pool_knl_elem_t *pke = (pool_knl_elem_t *)key;

	/*
	 * Check to see if it's the right class of element
	 */
	if (qo->classes & (1 << pool_elem_class((pool_elem_t *)key))) {
		int i;
		/*
		 * Now check to see if the src element is correct. If no src
		 * element is supplied, ignore this check
		 */
		if (qo->src) {
			pool_knl_elem_t *parent;

			for (parent = pke; parent != NULL;
			    parent = parent->pke_parent) {
				if (parent == (pool_knl_elem_t *)qo->src)
					break;
			}
			if (parent == NULL)
				return;
		}
		/*
		 * Now check for property matches (if there are any specified)
		 */
		if (qo->props) {
			int matched = PO_TRUE;
			for (i = 0; qo->props[i] != NULL; i++) {
				pool_value_t val = POOL_VALUE_INITIALIZER;

				if (pool_get_property(TO_CONF(TO_ELEM(pke)),
				    (pool_elem_t *)pke,
				    pool_value_get_name(qo->props[i]), &val) ==
				    POC_INVAL) {
					matched = PO_FALSE;
					break;
				} else {
					if (pool_value_equal(qo->props[i],
					    &val) != PO_TRUE) {
						matched = PO_FALSE;
						break;
					}
				}
			}
			if (matched == PO_TRUE)
				(void) pool_knl_result_set_append(qo->rs,
				    (pool_knl_elem_t *)key);
		} else {
			(void) pool_knl_result_set_append(qo->rs,
			    (pool_knl_elem_t *)key);
		}
	}
}

/*
 * Execute the supplied query and return a result set which contains
 * all qualifying elements.
 */
pool_result_set_t *
pool_knl_exec_query(const pool_conf_t *conf, const pool_elem_t *src,
    const char *src_attr, pool_elem_class_t classes, pool_value_t **props)
{
	pool_knl_result_set_t *rs;
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
	struct query_obj qo;
	int matched = PO_TRUE;

	/*
	 * Have a buffer at this point, that we can use
	 */
	if ((rs = pool_knl_result_set_alloc(conf)) == NULL) {
		return (NULL);
	}
	qo.conf = conf;
	qo.src = src;
	qo.src_attr = src_attr;
	qo.classes = classes;
	qo.props = props;
	qo.rs = rs;
	if (src_attr != NULL) {
		pool_knl_pool_t *pkp = (pool_knl_pool_t *)src;

		/*
		 * Note: This logic is resource specific and must be
		 * extended for additional resource types.
		 */
		/*
		 * Check for property matches (if there are any specified)
		 */
		if (props) {
			int i;

			for (i = 0; props[i] != NULL; i++) {
				pool_value_t val = POOL_VALUE_INITIALIZER;

				if (pool_get_property(conf,
				    (pool_elem_t *)pkp->pkp_assoc[PREC_PSET],
				    pool_value_get_name(props[i]), &val) ==
				    POC_INVAL) {
					matched = PO_FALSE;
					break;
				} else {
					if (pool_value_equal(props[i],
					    &val) != PO_TRUE) {
						matched = PO_FALSE;
						break;
					}
				}
			}
		}

		if (matched == PO_TRUE)
			(void) pool_knl_result_set_append(rs,
			    (pool_knl_elem_t *)pkp->pkp_assoc[PREC_PSET]);
	} else
		dict_map(prov->pkc_elements, build_result_set, &qo);

	if (rs->pkr_count == 0)
		pool_seterror(POE_INVALID_SEARCH);
	return ((pool_result_set_t *)rs);
}

/*
 * Callback function intended to be used from pool_walk_pools(). If
 * the supplied pool is not the default pool attempt to destroy it.
 */
/*ARGSUSED*/
static int
destroy_pool_cb(pool_conf_t *conf, pool_t *pool, void *unused)
{
	if (elem_is_default(TO_ELEM(pool)) != PO_TRUE)
		return (pool_destroy(conf, pool));
	/*
	 * Return PO_SUCCESS even though we don't delete the default
	 * pool so that the walk continues
	 */
	return (PO_SUCCESS);
}

/*
 * Remove the configuration details. This means remove all elements
 * apart from the system elements.
 */
int
pool_knl_remove(pool_conf_t *conf)
{
	uint_t i, nelem;
	pool_resource_t **resources;

	conf->pc_state = POF_DESTROY;
	if ((resources = pool_query_resources(conf, &nelem, NULL)) != NULL) {
		for (i = 0; i < nelem; i++) {
			if (resource_is_system(resources[i]) == PO_FALSE)
				if (pool_resource_destroy(conf, resources[i]) !=
				    PO_SUCCESS) {
					pool_seterror(POE_INVALID_CONF);
					return (PO_FAIL);
				}
		}
		free(resources);
	}
	(void) pool_walk_pools(conf, conf, destroy_pool_cb);
	if (pool_conf_commit(conf, PO_FALSE) != PO_SUCCESS)
		return (PO_FAIL);

	if (pool_conf_close(conf) != PO_SUCCESS)
		return (PO_FAIL);

	return (PO_SUCCESS);
}

/*
 * Determine the name of the pool to which the supplied pid is
 * bound. If it cannot be determined return NULL.
 */
char *
pool_knl_get_binding(pool_conf_t *conf, pid_t pid)
{
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
	const char *sval;
	char *name = NULL;
	pool_bindq_t bindq;
	pool_value_t *props[] = { NULL, NULL };
	uint_t nelem = 0;
	pool_t **pools;
	pool_value_t val = POOL_VALUE_INITIALIZER;

	props[0] = &val;

	bindq.pb_o_id_type = P_PID;
	bindq.pb_o_id = pid;
	if (ioctl(prov->pkc_fd, POOL_BINDQ, &bindq) < 0) {
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}

	if (pool_value_set_name(props[0], "pool.sys_id") != PO_SUCCESS) {
		return (NULL);
	}
	pool_value_set_int64(props[0], bindq.pb_i_id);
	if ((pools = pool_query_pools(conf, &nelem, props)) == NULL) {
		pool_seterror(POE_BADPARAM);
		return (NULL);
	}

	if (nelem != 1) {
		free(pools);
		pool_seterror(POE_INVALID_CONF);
		return (NULL);
	}
	if (pool_get_ns_property(TO_ELEM(pools[0]), c_name, props[0])
	    == POC_INVAL) {
		free(pools);
		return (NULL);
	}
	if (pool_value_get_string(props[0], &sval) != PO_SUCCESS) {
		free(pools);
		return (NULL);
	}
	if ((name = strdup(sval)) == NULL) {
		free(pools);
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}
	return (name);
}

/*
 * Bind idtype id to the pool name.
 */
int
pool_knl_set_binding(pool_conf_t *conf, const char *pool_name, idtype_t idtype,
    id_t id)
{
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
	pool_bind_t bind;
	pool_t *pool;
	int ret;

	if ((pool = pool_get_pool(conf, pool_name)) == NULL)
		return (PO_FAIL);

	bind.pb_o_id_type = idtype;
	bind.pb_o_id = id;
	bind.pb_o_pool_id = elem_get_sysid(TO_ELEM(pool));

	while ((ret = ioctl(prov->pkc_fd, POOL_BIND, &bind)) < 0 &&
	    errno == EAGAIN)
		;
	if (ret < 0) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	return (PO_SUCCESS);
}

/*
 * pool_knl_get_resource_binding() returns the binding for a pid to
 * the supplied type of resource. If a binding cannot be determined,
 * NULL is returned.
 */
char *
pool_knl_get_resource_binding(pool_conf_t *conf,
    pool_resource_elem_class_t type, pid_t pid)
{
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
	const char *sval;
	char *name = NULL;
	pool_bindq_t bindq;
	pool_value_t *props[] = { NULL, NULL };
	uint_t nelem = 0;
	pool_t **pools;
	pool_resource_t **resources;
	pool_value_t val = POOL_VALUE_INITIALIZER;

	props[0] = &val;
	bindq.pb_o_id_type = P_PID;
	bindq.pb_o_id = pid;
	if (ioctl(prov->pkc_fd, POOL_BINDQ, &bindq) < 0) {
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}

	if (pool_value_set_name(props[0], "pool.sys_id") != PO_SUCCESS) {
		return (NULL);
	}
	pool_value_set_int64(props[0], bindq.pb_i_id);
	if ((pools = pool_query_pools(conf, &nelem, props)) == NULL) {
		pool_seterror(POE_BADPARAM);
		return (NULL);
	}

	if (nelem != 1) {
		free(pools);
		pool_seterror(POE_INVALID_CONF);
		return (NULL);
	}

	if (pool_value_set_string(props[0], pool_resource_type_string(type)) !=
	    PO_SUCCESS ||
	    pool_value_set_name(props[0], c_type) != PO_SUCCESS) {
		free(pools);
		return (NULL);
	}

	if ((resources = pool_query_pool_resources(conf, pools[0], &nelem,
	    NULL)) == NULL) {
		free(pools);
		pool_seterror(POE_INVALID_CONF);
		return (NULL);
	}
	free(pools);
	if (nelem != 1) {
		free(resources);
		pool_seterror(POE_INVALID_CONF);
		return (NULL);
	}
	if (pool_get_ns_property(TO_ELEM(resources[0]), c_name, props[0]) ==
	    POC_INVAL) {
		free(resources);
		return (NULL);
	}
	free(resources);
	if (pool_value_get_string(props[0], &sval) != PO_SUCCESS) {
		return (NULL);
	}
	if ((name = strdup(sval)) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}
	return (name);
}

/*
 * Allocate the required library data structure and initialise it.
 */
pool_knl_elem_t *
pool_knl_elem_wrap(pool_conf_t *conf, pool_elem_class_t class,
    pool_resource_elem_class_t res_class,
    pool_component_elem_class_t comp_class)
{
	pool_knl_elem_t *elem;
	pool_elem_t *pe;

	switch (class) {
	case PEC_SYSTEM:
		if ((elem = malloc(sizeof (pool_knl_system_t))) == NULL) {
			pool_seterror(POE_SYSTEM);
			return (NULL);
		}
		(void) memset(elem, 0, sizeof (pool_knl_system_t));
		break;
	case PEC_POOL:
		if ((elem = malloc(sizeof (pool_knl_pool_t))) == NULL) {
			pool_seterror(POE_SYSTEM);
			return (NULL);
		}
		(void) memset(elem, 0, sizeof (pool_knl_pool_t));
		break;
	case PEC_RES_COMP:
	case PEC_RES_AGG:
		if ((elem = malloc(sizeof (pool_knl_resource_t))) == NULL) {
			pool_seterror(POE_SYSTEM);
			return (NULL);
		}
		(void) memset(elem, 0, sizeof (pool_knl_resource_t));
		break;
	case PEC_COMP:
		if ((elem = malloc(sizeof (pool_knl_component_t))) == NULL) {
			pool_seterror(POE_SYSTEM);
			return (NULL);
		}
		(void) memset(elem, 0, sizeof (pool_knl_component_t));
		break;
	default:
		pool_seterror(POE_BADPARAM);
		return (NULL);
	}
	pe = TO_ELEM(elem);
	pe->pe_conf = conf;
	pe->pe_class = class;
	pe->pe_resource_class = res_class;
	pe->pe_component_class = comp_class;
	/* Set up the function pointers for element manipulation */
	pe->pe_get_prop = pool_knl_get_property;
	pe->pe_put_prop = pool_knl_put_property;
	pe->pe_rm_prop = pool_knl_rm_property;
	pe->pe_get_props = pool_knl_get_properties;
	pe->pe_remove = pool_knl_elem_remove;
	pe->pe_get_container = pool_knl_get_container;
	pe->pe_set_container = pool_knl_set_container;
	/*
	 * Specific initialisation for different types of element
	 */
	if (class == PEC_POOL) {
		pool_knl_pool_t *pp = (pool_knl_pool_t *)elem;
		pp->pp_associate = pool_knl_pool_associate;
		pp->pp_dissociate = pool_knl_pool_dissociate;
		pp->pkp_assoc[PREC_PSET] = (pool_knl_resource_t *)
		    resource_by_sysid(conf, PS_NONE, "pset");
	}
	if (class == PEC_RES_COMP || class == PEC_RES_AGG) {
		pool_knl_resource_t *pr = (pool_knl_resource_t *)elem;
		pr->pr_is_system = pool_knl_resource_is_system;
		pr->pr_can_associate = pool_knl_resource_can_associate;
	}
#if DEBUG
	if (dict_put(((pool_knl_connection_t *)conf->pc_prov)->pkc_leaks,
	    elem, elem) != NULL)
		assert(!"leak map put failed");
	dprintf("allocated %p\n", elem);
#endif	/* DEBUG */
	return (elem);
}

/*
 * Allocate a new pool_knl_elem_t in the supplied configuration of the
 * specified class.
 * Returns element pointer/NULL
 */
pool_elem_t *
pool_knl_elem_create(pool_conf_t *conf, pool_elem_class_t class,
    pool_resource_elem_class_t res_class,
    pool_component_elem_class_t comp_class)
{
	pool_knl_elem_t *elem;
	pool_create_undo_t *create;
	pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
	static int id = -3;
	char_buf_t *cb;

	if ((elem = pool_knl_elem_wrap(conf, class, res_class, comp_class)) ==
	    NULL)
		return (NULL);

	/*
	 * Allocate an nvlist to hold properties
	 */
	if (nvlist_alloc(&elem->pke_properties, NV_UNIQUE_NAME_TYPE, 0) != 0) {
		pool_knl_elem_free(elem, PO_FALSE);
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}
	/*
	 * Allocate a temporary ID and name until the element is
	 * created for real
	 */
	if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL) {
		pool_knl_elem_free(elem, PO_TRUE);
		return (NULL);
	}
	if (set_char_buf(cb, "%s.sys_id",
	    pool_elem_class_string((pool_elem_t *)elem)) != PO_SUCCESS) {
		pool_knl_elem_free(elem, PO_TRUE);
		free_char_buf(cb);
		return (NULL);
	}
	(void) nvlist_add_int64(elem->pke_properties, cb->cb_buf, id--);
	if (set_char_buf(cb, "%s.name",
	    pool_elem_class_string((pool_elem_t *)elem)) != PO_SUCCESS) {
		pool_knl_elem_free(elem, PO_TRUE);
		free_char_buf(cb);
		return (NULL);
	}
	(void) nvlist_add_string(elem->pke_properties, cb->cb_buf, "");
	/*
	 * If it's a resource class, it will need an initial size
	 */
	if (class == PEC_RES_COMP || class == PEC_RES_AGG) {
		if (set_char_buf(cb, "%s.size",
		    pool_elem_class_string((pool_elem_t *)elem)) !=
		    PO_SUCCESS) {
			pool_knl_elem_free(elem, PO_TRUE);
			free_char_buf(cb);
			return (NULL);
		}
		(void) nvlist_add_uint64(elem->pke_properties, cb->cb_buf, 0);
	}
	free_char_buf(cb);

	/*
	 * Register the newly created element
	 */
	if (dict_put(prov->pkc_elements, elem, elem) != NULL) {
		pool_knl_elem_free(elem, PO_TRUE);
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}

	if (prov->pkc_log->l_state != LS_DO)
		return ((pool_elem_t *)elem);

	/*
	 * The remaining logic is setting up the arguments for the
	 * POOL_CREATE ioctl and appending the details into the log.
	 */
	if ((create = malloc(sizeof (pool_create_undo_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}
	create->pcu_ioctl.pc_o_type = class;
	switch (class) {
	case PEC_SYSTEM:
		pool_seterror(POE_BADPARAM);
		free(create);
		return (NULL);
	case PEC_POOL: /* NO-OP */
		break;
	case PEC_RES_COMP:
	case PEC_RES_AGG:
		create->pcu_ioctl.pc_o_sub_type = res_class;
		break;
	case PEC_COMP:
		create->pcu_ioctl.pc_o_sub_type = comp_class;
		break;
	default:
		pool_seterror(POE_BADPARAM);
		free(create);
		return (NULL);
	}

	create->pcu_elem = (pool_elem_t *)elem;

	if (log_append(prov->pkc_log, POOL_CREATE, (void *)create) !=
	    PO_SUCCESS) {
		free(create);
		return (NULL);
	}
	return ((pool_elem_t *)elem);
}

/*
 * Remove the details of the element from our userland copy and destroy
 * the element (if appropriate) in the kernel.
 */
int
pool_knl_elem_remove(pool_elem_t *pe)
{
	pool_knl_connection_t *prov;
	pool_destroy_undo_t *destroy;

	prov = (pool_knl_connection_t *)(TO_CONF(pe))->pc_prov;

	if (dict_remove(prov->pkc_elements, pe) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	if (prov->pkc_log->l_state != LS_DO) {
		return (PO_SUCCESS);
	}

	/*
	 * The remaining logic is setting up the arguments for the
	 * POOL_DESTROY ioctl and appending the details into the log.
	 */
	if ((destroy = malloc(sizeof (pool_destroy_undo_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	destroy->pdu_ioctl.pd_o_type = pool_elem_class(pe);

	if (destroy->pdu_ioctl.pd_o_type == PEC_RES_COMP ||
	    destroy->pdu_ioctl.pd_o_type == PEC_RES_AGG)
		destroy->pdu_ioctl.pd_o_sub_type = pool_resource_elem_class(pe);

	if (destroy->pdu_ioctl.pd_o_type == PEC_COMP)
		destroy->pdu_ioctl.pd_o_sub_type =
		    pool_component_elem_class(pe);

	destroy->pdu_elem = pe;

	if (log_append(prov->pkc_log, POOL_DESTROY, (void *)destroy) !=
	    PO_SUCCESS) {
		free(destroy);
		return (PO_FAIL);
	}
	return (PO_SUCCESS);
}

/*
 * Set the parent of the supplied child to the supplied parent
 */
int
pool_knl_set_container(pool_elem_t *pp, pool_elem_t *pc)
{
	pool_knl_elem_t *pkp = (pool_knl_elem_t *)pp;
	pool_knl_elem_t *pkc = (pool_knl_elem_t *)pc;

	pkc->pke_parent = pkp;
	return (PO_SUCCESS);
}

/*
 * TODO: Needed for msets and ssets.
 */
/* ARGSUSED */
int
pool_knl_res_transfer(pool_resource_t *src, pool_resource_t *tgt,
    uint64_t size) {
	return (PO_FAIL);
}

/*
 * Transfer resource components from one resource set to another.
 */
int
pool_knl_res_xtransfer(pool_resource_t *src, pool_resource_t *tgt,
    pool_component_t **rl) {
	pool_elem_t *src_e = TO_ELEM(src);
	pool_elem_t *tgt_e = TO_ELEM(tgt);
	pool_xtransfer_undo_t *xtransfer;
	size_t size;
	pool_knl_connection_t *prov =
	    (pool_knl_connection_t *)TO_CONF(src_e)->pc_prov;

	if (prov->pkc_log->l_state != LS_DO) {
		/*
		 * Walk the Result Set and move the resource components
		 */
		for (size = 0; rl[size] != NULL; size++) {
			if (pool_set_container(TO_ELEM(tgt),
			    TO_ELEM(rl[size])) == PO_FAIL) {
				return (PO_FAIL);
			}
		}
		return (PO_SUCCESS);
	}

	/*
	 * The remaining logic is setting up the arguments for the
	 * POOL_XTRANSFER ioctl and appending the details into the log.
	 */
	if ((xtransfer = malloc(sizeof (pool_xtransfer_undo_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}

	if (pool_elem_class(src_e) == PEC_RES_COMP) {
		xtransfer->pxu_ioctl.px_o_id_type =
		    pool_resource_elem_class(src_e);
	} else {
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	}


	for (xtransfer->pxu_ioctl.px_o_complist_size = 0;
	    rl[xtransfer->pxu_ioctl.px_o_complist_size] != NULL;
	    xtransfer->pxu_ioctl.px_o_complist_size++)
		/* calculate the size using the terminating NULL */;
	if ((xtransfer->pxu_ioctl.px_o_comp_list =
		calloc(xtransfer->pxu_ioctl.px_o_complist_size,
		sizeof (id_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	if ((xtransfer->pxu_rl = calloc(
	    xtransfer->pxu_ioctl.px_o_complist_size + 1,
	    sizeof (pool_component_t *))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	(void) memcpy(xtransfer->pxu_rl, rl,
	    xtransfer->pxu_ioctl.px_o_complist_size *
	    sizeof (pool_component_t *));
	xtransfer->pxu_src = src_e;
	xtransfer->pxu_tgt = tgt_e;

	if (log_append(prov->pkc_log, POOL_XTRANSFER, (void *)xtransfer) !=
	    PO_SUCCESS) {
		free(xtransfer);
		return (PO_FAIL);
	}
	for (size = 0; rl[size] != NULL; size++) {
		if (pool_set_container(TO_ELEM(tgt), TO_ELEM(rl[size])) ==
		    PO_FAIL) {
			return (PO_FAIL);
		}
	}
	return (PO_SUCCESS);
}

/*
 * Return the parent of an element.
 */
pool_elem_t *
pool_knl_get_container(const pool_elem_t *pe)
{
	pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;

	return ((pool_elem_t *)pke->pke_parent);
}

/*
 * Note: This function is resource specific, needs extending for other
 * resource types
 */
int
pool_knl_resource_is_system(const pool_resource_t *pr)
{
	switch (pool_resource_elem_class(TO_ELEM(pr))) {
	case PREC_PSET:
		return (PSID_IS_SYSSET(
		    elem_get_sysid(TO_ELEM(pr))));
	default:
		return (PO_FALSE);
	}
}

/*
 * Note: This function is resource specific, needs extending for other
 * resource types
 */
int
pool_knl_resource_can_associate(const pool_resource_t *pr)
{
	switch (pool_resource_elem_class(TO_ELEM(pr))) {
	case PREC_PSET:
		return (PO_TRUE);
	default:
		return (PO_FALSE);
	}
}

/*
 * pool_knl_pool_associate() associates the supplied resource to the
 * supplied pool.
 *
 * Returns: PO_SUCCESS/PO_FAIL
 */
int
pool_knl_pool_associate(pool_t *pool, const pool_resource_t *resource)
{
	pool_knl_connection_t *prov;
	pool_knl_pool_t *pkp = (pool_knl_pool_t *)pool;
	pool_resource_elem_class_t res_class =
	    pool_resource_elem_class(TO_ELEM(resource));
	pool_assoc_undo_t *assoc;
	pool_knl_resource_t *orig_res = pkp->pkp_assoc[res_class];

	/*
	 * Are we allowed to associate with this target?
	 */
	if (pool_knl_resource_can_associate(resource) == PO_FALSE) {
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	}
	prov = (pool_knl_connection_t *)(TO_CONF(TO_ELEM(pool)))->pc_prov;

	if (prov->pkc_log->l_state != LS_DO) {
		pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)resource;
		return (PO_SUCCESS);
	}

	/*
	 * The remaining logic is setting up the arguments for the
	 * POOL_ASSOC ioctl and appending the details into the log.
	 */
	if ((assoc = malloc(sizeof (pool_assoc_undo_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	assoc->pau_assoc = TO_ELEM(pool);
	assoc->pau_oldres = (pool_elem_t *)orig_res;
	assoc->pau_newres = TO_ELEM(resource);

	assoc->pau_ioctl.pa_o_id_type = res_class;

	if (log_append(prov->pkc_log, POOL_ASSOC, (void *)assoc) !=
	    PO_SUCCESS) {
		free(assoc);
		pkp->pkp_assoc[res_class] = orig_res;
		return (PO_FAIL);
	}
	pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)resource;
	return (PO_SUCCESS);
}

/*
 * pool_knl_pool_dissociate() dissociates the supplied resource from
 * the supplied pool.
 *
 * Returns: PO_SUCCESS/PO_FAIL
 */
int
pool_knl_pool_dissociate(pool_t *pool, const pool_resource_t *resource)
{
	pool_knl_connection_t *prov;
	pool_dissoc_undo_t *dissoc;
	pool_knl_pool_t *pkp = (pool_knl_pool_t *)pool;
	pool_resource_t *default_res = (pool_resource_t *)get_default_resource(
	    resource);
	pool_resource_elem_class_t res_class =
	    pool_resource_elem_class(TO_ELEM(resource));

	prov = (pool_knl_connection_t *)(TO_CONF(TO_ELEM(pool)))->pc_prov;

	if (prov->pkc_log->l_state != LS_DO) {
		pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)default_res;
		return (PO_SUCCESS);
	}
	/*
	 * The remaining logic is setting up the arguments for the
	 * POOL_DISSOC ioctl and appending the details into the log.
	 */
	if ((dissoc = malloc(sizeof (pool_dissoc_undo_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	dissoc->pdu_dissoc = TO_ELEM(pool);
	dissoc->pdu_oldres = TO_ELEM(resource);
	dissoc->pdu_newres = TO_ELEM(default_res);

	dissoc->pdu_ioctl.pd_o_id_type = res_class;

	if (log_append(prov->pkc_log, POOL_DISSOC, (void *)dissoc) !=
	    PO_SUCCESS) {
		free(dissoc);
		pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)resource;
		return (PO_FAIL);
	}

	/*
	 * Update our local copy
	 */
	pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)default_res;
	return (PO_SUCCESS);
}

/*
 * Allocate a data provider for the supplied configuration and optionally
 * discover resources.
 * The data provider is the cross over point from the "abstract" configuration
 * functions into the data representation specific manipulation routines.
 * This function sets up all the required pointers to create a kernel aware
 * data provider.
 * Returns PO_SUCCESS/PO_FAIL
 */
int
pool_knl_connection_alloc(pool_conf_t *conf, int oflags)
{
	pool_knl_connection_t *prov;

	if ((prov = malloc(sizeof (pool_knl_connection_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	(void) memset(prov, 0, sizeof (pool_knl_connection_t));
	/*
	 * Initialise data members
	 */
	prov->pc_name = strdup("kernel");
	prov->pc_store_type = KERNEL_DATA_STORE;
	prov->pc_oflags = oflags;
	/*
	 * Initialise function pointers
	 */
	prov->pc_close = pool_knl_close;
	prov->pc_validate = pool_knl_validate;
	prov->pc_commit = pool_knl_commit;
	prov->pc_export = pool_knl_export;
	prov->pc_rollback = pool_knl_rollback;
	prov->pc_exec_query = pool_knl_exec_query;
	prov->pc_elem_create = pool_knl_elem_create;
	prov->pc_remove = pool_knl_remove;
	prov->pc_res_xfer = pool_knl_res_transfer;
	prov->pc_res_xxfer = pool_knl_res_xtransfer;
	prov->pc_get_binding = pool_knl_get_binding;
	prov->pc_set_binding = pool_knl_set_binding;
	prov->pc_get_resource_binding = pool_knl_get_resource_binding;
	/*
	 * Associate the provider to it's configuration
	 */
	conf->pc_prov = (pool_connection_t *)prov;
	/*
	 * End of common initialisation
	 */
	/*
	 * Attempt to open the pseudo device, if the configuration is opened
	 * readonly then try to open an info device, otherwise try to open
	 * the writeable device.
	 */
	if (oflags & PO_RDWR) {
		if ((prov->pkc_fd = blocking_open(pool_dynamic_location(),
		    O_RDWR)) < 0) {
			free(prov);
			conf->pc_prov = NULL;
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
	} else {
		if ((prov->pkc_fd = open(pool_info_location, O_RDWR)) < 0) {
			free(prov);
			conf->pc_prov = NULL;
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
	}
	/*
	 * Allocate the element dictionary
	 */
	if ((prov->pkc_elements = dict_new((int (*)(const void *, const void *))
	    pool_elem_compare, (uint64_t (*)(const void *))hash_id)) == NULL) {
		(void) close(prov->pkc_fd);
		free(prov);
		conf->pc_prov = NULL;
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
#if DEBUG
	if ((prov->pkc_leaks = dict_new(NULL, NULL)) == NULL) {
		dict_free(&prov->pkc_elements);
		(void) close(prov->pkc_fd);
		free(prov);
		conf->pc_prov = NULL;
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
#endif	/* DEBUG */
	/*
	 * Allocate the transaction log
	 */
	if ((prov->pkc_log = log_alloc(conf)) == NULL) {
#if DEBUG
		dict_free(&prov->pkc_leaks);
#endif	/* DEBUG */
		dict_free(&prov->pkc_elements);
		(void) close(prov->pkc_fd);
		free(prov);
		conf->pc_prov = NULL;
		return (PO_FAIL);
	}
	/*
	 * At this point the configuration provider has been initialized,
	 * mark the configuration as valid so that the various routines
	 * which rely on a valid configuration will work correctly.
	 */
	conf->pc_state = POF_VALID;
	/*
	 * Update the library snapshot from the kernel
	 */
	if (pool_knl_update(conf, NULL) != PO_SUCCESS) {
#if DEBUG
		dict_free(&prov->pkc_leaks);
#endif	/* DEBUG */
		dict_free(&prov->pkc_elements);
		(void) close(prov->pkc_fd);
		free(prov);
		conf->pc_prov = NULL;
		conf->pc_state = POF_INVALID;
		return (PO_FAIL);
	}
	return (PO_SUCCESS);
}

#if DEBUG
static void
pool_knl_elem_printf_cb(const void *key, void **value, void *cl)
{
	pool_knl_elem_t *pke = (pool_knl_elem_t *)key;
	dict_hdl_t *map = (dict_hdl_t *)cl;

	dprintf("leak elem:%p\n", pke);
	if (pke->pke_properties != NULL) {
		nvlist_print(stdout, pke->pke_properties);
	} else
		dprintf("no properties\n");
	assert(dict_get(map, pke) == NULL);
}
#endif	/* DEBUG */
/*
 * pool_knl_elem_free() releases the resources associated with the
 * supplied element.
 */
static void
pool_knl_elem_free(pool_knl_elem_t *pke, int freeprop)
{
#if DEBUG
	pool_conf_t *conf = TO_CONF(TO_ELEM(pke));
	if (dict_remove(((pool_knl_connection_t *)conf->pc_prov)->pkc_leaks,
	    pke) == NULL)
		dprintf("%p, wasn't in the leak map\n", pke);
	if (freeprop == PO_TRUE) {
		pool_elem_dprintf(TO_ELEM(pke));
	}
	dprintf("released %p\n", pke);
#endif	/* DEBUG */
	if (freeprop == PO_TRUE) {
		nvlist_free(pke->pke_properties);
	}
	free(pke);
}

/*
 * pool_knl_elem_free_cb() is designed to be used with
 * dict_map(). When a connection is freed, this function is used to
 * free all element resources.
 */
/* ARGSUSED1 */
static void
pool_knl_elem_free_cb(const void *key, void **value, void *cl)
{
	pool_knl_elem_t *pke = (pool_knl_elem_t *)key;

#ifdef DEBUG
	dprintf("pool_knl_elem_free_cb:\n");
	dprintf("about to release %p ", pke);
	pool_elem_dprintf(TO_ELEM(pke));
#endif	/* DEBUG */
	pool_knl_elem_free(pke, PO_TRUE);
}

/*
 * Free the resources for a kernel data provider.
 */
void
pool_knl_connection_free(pool_knl_connection_t *prov)
{
	if (prov->pkc_log != NULL) {
		(void) log_walk(prov->pkc_log, log_item_release);
		log_free(prov->pkc_log);
	}
	if (prov->pkc_elements != NULL) {
		dict_map(prov->pkc_elements, pool_knl_elem_free_cb, NULL);
#if DEBUG
		dprintf("dict length is %llu\n", dict_length(prov->pkc_leaks));
		dict_map(prov->pkc_leaks, pool_knl_elem_printf_cb,
		    prov->pkc_elements);
		assert(dict_length(prov->pkc_leaks) == 0);
		dict_free(&prov->pkc_leaks);
#endif	/* DEBUG */
		dict_free(&prov->pkc_elements);
	}
	free((void *)prov->pc_name);
	free(prov);
}

/*
 * Return the specified property value.
 *
 * POC_INVAL is returned if an error is detected and the error code is updated
 * to indicate the cause of the error.
 */
pool_value_class_t
pool_knl_get_property(const pool_elem_t *pe, const char *name,
    pool_value_t *val)
{
	pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;
	nvpair_t *pair;
	const pool_prop_t *prop;

	if ((prop = provider_get_prop(pe, name)) != NULL)
		if (prop_is_stored(prop) == PO_FALSE)
			return (pool_knl_get_dynamic_property(pe, name, val));

	if ((pair = pool_knl_find_nvpair(pke->pke_properties, name)) == NULL) {
		pool_seterror(POE_BADPARAM);
		return (POC_INVAL);
	}

	if (pool_value_from_nvpair(val, pair) == PO_FAIL) {
		return (POC_INVAL);
	}

	return (pool_value_get_type(val));
}

/*
 * Return the specified property value.
 *
 * If a property is designated as dynamic, then this function will
 * always try to return the latest value of the property from the
 * kernel.
 *
 * POC_INVAL is returned if an error is detected and the error code is updated
 * to indicate the cause of the error.
 */
pool_value_class_t
pool_knl_get_dynamic_property(const pool_elem_t *pe, const char *name,
    pool_value_t *val)
{
	pool_knl_connection_t *prov;
	pool_propget_t propget = { 0 };
	nvlist_t *proplist;
	nvpair_t *pair;

	propget.pp_o_id_type = pool_elem_class(pe);
	if (pool_elem_class(pe) == PEC_RES_COMP ||
	    pool_elem_class(pe) == PEC_RES_AGG)
		propget.pp_o_id_subtype = pool_resource_elem_class(pe);
	if (pool_elem_class(pe) == PEC_COMP)
		propget.pp_o_id_subtype =
		    (pool_resource_elem_class_t)pool_component_elem_class(pe);

	propget.pp_o_id = elem_get_sysid(pe);
	propget.pp_o_prop_name_size = strlen(name);
	propget.pp_o_prop_name = (char *)name;
	propget.pp_i_bufsize = KERNEL_SNAPSHOT_BUF_SZ;
	propget.pp_i_buf = malloc(KERNEL_SNAPSHOT_BUF_SZ);
	bzero(propget.pp_i_buf, KERNEL_SNAPSHOT_BUF_SZ);

	prov = (pool_knl_connection_t *)(TO_CONF(pe))->pc_prov;
	if (ioctl(prov->pkc_fd, POOL_PROPGET, &propget) < 0) {
		free(propget.pp_i_buf);
		pool_seterror(POE_SYSTEM);
		return (POC_INVAL);
	}
	if (nvlist_unpack(propget.pp_i_buf, propget.pp_i_bufsize,
	    &proplist, 0) != 0) {
		free(propget.pp_i_buf);
		pool_seterror(POE_SYSTEM);
		return (POC_INVAL);
	}
	free(propget.pp_i_buf);

	if ((pair = nvlist_next_nvpair(proplist, NULL)) == NULL) {
		nvlist_free(proplist);
		pool_seterror(POE_SYSTEM);
		return (POC_INVAL);
	}

	if (pool_value_from_nvpair(val, pair) == PO_FAIL) {
		nvlist_free(proplist);
		return (POC_INVAL);
	}
	nvlist_free(proplist);
	return (pool_value_get_type(val));
}

/*
 * Update the specified property value.
 *
 * PO_FAIL is returned if an error is detected and the error code is updated
 * to indicate the cause of the error.
 */
int
pool_knl_put_property(pool_elem_t *pe, const char *name,
    const pool_value_t *val)
{
	pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;
	pool_knl_connection_t *prov =
	    (pool_knl_connection_t *)(TO_CONF(pe))->pc_prov;
	nvpair_t *bp, *ap;
	pool_propput_undo_t *propput;
	nvlist_t *bl = NULL;
	const pool_prop_t *prop;

	if ((bp = pool_knl_find_nvpair(pke->pke_properties, name)) != NULL) {
		if (nvlist_alloc(&bl, NV_UNIQUE_NAME_TYPE, 0) != 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		if (nvlist_add_nvpair(bl, bp) != 0) {
			nvlist_free(bl);
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
	}
	if (pool_knl_nvlist_add_value(pke->pke_properties, name, val) !=
	    PO_SUCCESS)
		return (PO_FAIL);

	if (prov->pkc_log->l_state != LS_DO) {
		nvlist_free(bl);
		return (PO_SUCCESS);
	}
	/*
	 * The remaining logic is setting up the arguments for the
	 * POOL_PROPPUT ioctl and appending the details into the log.
	 */
	if ((propput = malloc(sizeof (pool_propput_undo_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	(void) memset(propput, 0, sizeof (pool_propput_undo_t));
	propput->ppu_blist = bl;

	ap = pool_knl_find_nvpair(pke->pke_properties, name);

	if (nvlist_alloc(&propput->ppu_alist, NV_UNIQUE_NAME_TYPE, 0) != 0) {
		nvlist_free(propput->ppu_blist);
		free(propput);
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	if (nvlist_add_nvpair(propput->ppu_alist, ap) != 0) {
		nvlist_free(propput->ppu_blist);
		nvlist_free(propput->ppu_alist);
		free(propput);
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}

	if (nvlist_pack(propput->ppu_alist,
	    (char **)&propput->ppu_ioctl.pp_o_buf,
	    &propput->ppu_ioctl.pp_o_bufsize, NV_ENCODE_NATIVE, 0) != 0) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	nvlist_free(propput->ppu_alist);
	propput->ppu_ioctl.pp_o_id_type = pool_elem_class(pe);
	if (pool_elem_class(pe) == PEC_RES_COMP ||
	    pool_elem_class(pe) == PEC_RES_AGG)
		propput->ppu_ioctl.pp_o_id_sub_type =
		    pool_resource_elem_class(pe);
	if (pool_elem_class(pe) == PEC_COMP)
		propput->ppu_ioctl.pp_o_id_sub_type =
		    (pool_resource_elem_class_t)pool_component_elem_class(pe);

	propput->ppu_elem = pe;
	if ((prop = provider_get_prop(propput->ppu_elem, name)) != NULL) {
		if (prop_is_readonly(prop) == PO_TRUE)
			propput->ppu_doioctl |= KERNEL_PROP_RDONLY;
	}

	if (log_append(prov->pkc_log, POOL_PROPPUT, (void *)propput) !=
	    PO_SUCCESS) {
		nvlist_free(propput->ppu_blist);
		free(propput);
		return (PO_FAIL);
	}
	return (PO_SUCCESS);
}

/*
 * Remove the specified property value.
 *
 * PO_FAIL is returned if an error is detected and the error code is
 * updated to indicate the cause of the error.
 */
int
pool_knl_rm_property(pool_elem_t *pe, const char *name)
{
	pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;
	pool_knl_connection_t *prov =
	    (pool_knl_connection_t *)(TO_CONF(pe))->pc_prov;
	pool_proprm_undo_t *proprm;

	if (pool_knl_find_nvpair(pke->pke_properties, name) == NULL) {
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	}

	if ((proprm = malloc(sizeof (pool_proprm_undo_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	(void) memset(proprm, 0, sizeof (pool_proprm_undo_t));
	proprm->pru_oldval.pv_class = POC_INVAL;
	(void) pool_get_property(TO_CONF(pe), pe, name, &proprm->pru_oldval);

	if (prov->pkc_log->l_state != LS_DO) {
		free(proprm);
		(void) nvlist_remove_all(pke->pke_properties, (char *)name);
		return (PO_SUCCESS);
	}
	/*
	 * The remaining logic is setting up the arguments for the
	 * POOL_PROPRM ioctl and appending the details into the log.
	 */

	proprm->pru_ioctl.pp_o_id_type = pool_elem_class(pe);
	if (pool_elem_class(pe) == PEC_RES_COMP ||
	    pool_elem_class(pe) == PEC_RES_AGG)
		proprm->pru_ioctl.pp_o_id_sub_type =
		    pool_resource_elem_class(pe);

	if (pool_elem_class(pe) == PEC_COMP)
		proprm->pru_ioctl.pp_o_id_sub_type =
		    (pool_resource_elem_class_t)pool_component_elem_class(pe);

	proprm->pru_ioctl.pp_o_prop_name_size = strlen(name);
	proprm->pru_ioctl.pp_o_prop_name =
	    (char *)pool_value_get_name(&proprm->pru_oldval);
	proprm->pru_elem = pe;

	if (log_append(prov->pkc_log, POOL_PROPRM, (void *)proprm) !=
	    PO_SUCCESS) {
		free(proprm);
		return (PO_FAIL);
	}

	(void) nvlist_remove_all(pke->pke_properties, (char *)name);
	return (PO_SUCCESS);
}

/*
 * Return a NULL terminated array of pool_value_t which represents all
 * of the properties stored for an element
 *
 * Return NULL on failure. It is the caller's responsibility to free
 * the returned array of values.
 */
pool_value_t **
pool_knl_get_properties(const pool_elem_t *pe, uint_t *nprops)
{
	nvpair_t *pair;
	pool_value_t **result;
	pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;
	int i = 0;

	*nprops = 0;

	for (pair = nvlist_next_nvpair(pke->pke_properties, NULL); pair != NULL;
	    pair = nvlist_next_nvpair(pke->pke_properties, pair))
		(*nprops)++;
	if ((result = calloc(*nprops + 1, sizeof (pool_value_t *))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}
	for (pair = nvlist_next_nvpair(pke->pke_properties, NULL); pair != NULL;
	    pair = nvlist_next_nvpair(pke->pke_properties, pair), i++) {
		result[i] = pool_value_alloc();
		if (pool_value_from_nvpair(result[i], pair) == PO_FAIL) {
			while (i-- >= 0)
				pool_value_free(result[i]);
			free(result);
			return (NULL);
		}
	}
	return (result);
}

/*
 * Append an entry to a result set. Reallocate the array used to store
 * results if it's full.
 * Returns PO_SUCCESS/PO_FAIL
 */
int
pool_knl_result_set_append(pool_knl_result_set_t *rs, pool_knl_elem_t *pke)
{
	if (rs->pkr_count == rs->pkr_size)
		if (pool_knl_result_set_realloc(rs) != PO_SUCCESS)
			return (PO_FAIL);

	rs->pkr_list[rs->pkr_count++] = pke;

	return (PO_SUCCESS);
}

/*
 * Resize the array used to store results. A simple doubling strategy
 * is used.
 * Returns PO_SUCCESS/PO_FAIL
 */
int
pool_knl_result_set_realloc(pool_knl_result_set_t *rs)
{
	pool_knl_elem_t **old_list = rs->pkr_list;
	int new_size = rs->pkr_size * 2;

	if ((rs->pkr_list = realloc(rs->pkr_list,
	    new_size * sizeof (pool_knl_elem_t *))) == NULL) {
		rs->pkr_list = old_list;
		pool_seterror(POE_SYSTEM);
		return (PO_FAIL);
	}
	rs->pkr_size = new_size;

	return (PO_SUCCESS);
}

/*
 * Allocate a result set. The Result Set stores the result of a query.
 * Returns pool_knl_result_set_t pointer/NULL
 */
pool_knl_result_set_t *
pool_knl_result_set_alloc(const pool_conf_t *conf)
{
	pool_knl_result_set_t *rs;

	if ((rs = malloc(sizeof (pool_knl_result_set_t))) == NULL) {
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}
	(void) memset(rs, 0, sizeof (pool_knl_result_set_t));
	rs->pkr_size = KERNEL_RS_INITIAL_SZ;
	if (pool_knl_result_set_realloc(rs) == PO_FAIL) {
		free(rs);
		pool_seterror(POE_SYSTEM);
		return (NULL);
	}
	rs->prs_conf = conf;
	rs->prs_index = -1;
	rs->prs_active = PO_TRUE;
	/* Fix up the result set accessor functions to the knl specfic ones */
	rs->prs_next = pool_knl_rs_next;
	rs->prs_prev = pool_knl_rs_prev;
	rs->prs_first = pool_knl_rs_first;
	rs->prs_last = pool_knl_rs_last;
	rs->prs_get_index = pool_knl_rs_get_index;
	rs->prs_set_index = pool_knl_rs_set_index;
	rs->prs_close = pool_knl_rs_close;
	rs->prs_count = pool_knl_rs_count;
	return (rs);
}

/*
 * Free a result set. Ensure that the resources are all released at
 * this point.
 */
void
pool_knl_result_set_free(pool_knl_result_set_t *rs)
{
	free(rs->pkr_list);
	free(rs);
}
/*
 * Return the next element in a result set.
 * Returns pool_elem_t pointer/NULL
 */
pool_elem_t *
pool_knl_rs_next(pool_result_set_t *set)
{
	pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;

	if (kset->prs_index == kset->pkr_count - 1)
		return (NULL);
	return ((pool_elem_t *)kset->pkr_list[++kset->prs_index]);
}

/*
 * Return the previous element in a result set.
 * Returns pool_elem_t pointer/NULL
 */
pool_elem_t *
pool_knl_rs_prev(pool_result_set_t *set)
{
	pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;

	if (kset->prs_index < 0)
		return (NULL);
	return ((pool_elem_t *)kset->pkr_list[kset->prs_index--]);
}

/*
 * Sets the current index in a result set.
 * Returns PO_SUCCESS/PO_FAIL
 */
int
pool_knl_rs_set_index(pool_result_set_t *set, int index)
{
	pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;

	if (index < 0 || index >= kset->pkr_count) {
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	}
	kset->prs_index = index;
	return (PO_SUCCESS);
}

/*
 * Return the current index in a result set.
 * Returns current index
 */
int
pool_knl_rs_get_index(pool_result_set_t *set)
{
	pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;

	return (kset->prs_index);
}

/*
 * Return the first element in a result set.
 * Returns pool_elem_t pointer/NULL
 */
pool_elem_t *
pool_knl_rs_first(pool_result_set_t *set)
{
	pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;

	return ((pool_elem_t *)kset->pkr_list[0]);
}

/*
 * Return the last element in a result set.
 * Returns pool_elem_t pointer/NULL
 */
pool_elem_t *
pool_knl_rs_last(pool_result_set_t *set)
{
	pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;

	return ((pool_elem_t *)kset->pkr_list[kset->pkr_count - 1]);
}

/*
 * Return the number of results in a result set.
 * Returns result count
 */
int
pool_knl_rs_count(pool_result_set_t *set)
{
	pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;

	return (kset->pkr_count);
}


/*
 * Close a result set. Free the resources
 * Returns PO_SUCCESS/PO_FAIL
 */
int
pool_knl_rs_close(pool_result_set_t *set)
{
	pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;

	pool_knl_result_set_free(kset);
	return (PO_SUCCESS);
}

/*
 * Commit an individual transaction log item(). This processing is
 * essential to the pool_conf_commit() logic. When pool_conf_commit()
 * is invoked, the pending transaction log for the configuration is
 * walked and all pending changes to the kernel are invoked. If a
 * change succeeds it is marked in the log as successful and
 * processing continues, if it fails then failure is returned and the
 * log will be "rolled back" to undo changes to the library snapshot
 * and the kernel.
 */
int
log_item_commit(log_item_t *li)
{
	pool_knl_connection_t *prov =
	    (pool_knl_connection_t *)li->li_log->l_conf->pc_prov;
	pool_create_undo_t *create;
	pool_destroy_undo_t *destroy;
	pool_assoc_undo_t *assoc;
	pool_dissoc_undo_t *dissoc;
	pool_propput_undo_t *propput;
	pool_proprm_undo_t *proprm;
	pool_xtransfer_undo_t *xtransfer;
	char_buf_t *cb;
	size_t size;
	pool_elem_t *pair;
	pool_value_t val = POOL_VALUE_INITIALIZER;
	int ret;

	switch (li->li_op) {
	case POOL_CREATE:
		create = (pool_create_undo_t *)li->li_details;
		if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL)
			return (PO_FAIL);
		if (set_char_buf(cb, "%s.sys_id",
		    pool_elem_class_string(create->pcu_elem)) != PO_SUCCESS) {
			free_char_buf(cb);
			return (PO_FAIL);
		}
#ifdef DEBUG
		dprintf("log_item_commit: POOL_CREATE, remove from dict\n");
		pool_elem_dprintf(create->pcu_elem);
#endif	/* DEBUG */
		/*
		 * May not need to remove the element if it was
		 * already destroyed before commit. Just cast the
		 * return to void.
		 */
		(void) dict_remove(prov->pkc_elements,
		    (pool_knl_elem_t *)create->pcu_elem);

		if (ioctl(prov->pkc_fd, POOL_CREATE, &create->pcu_ioctl) < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		/*
		 * Now that we have created our element in the kernel,
		 * it has a valid allocated system id. Remove the
		 * element from the element dictionary, using the
		 * current key, and then re-insert under the new key.
		 */
#ifdef DEBUG
		pool_elem_dprintf(create->pcu_elem);
#endif	/* DEBUG */
		assert(nvlist_add_int64(
		    ((pool_knl_elem_t *)create->pcu_elem)->pke_properties,
		    cb->cb_buf, create->pcu_ioctl.pc_i_id) == 0);
		free_char_buf(cb);
		assert(dict_put(prov->pkc_elements, create->pcu_elem,
		    create->pcu_elem) == NULL);
		/*
		 * If the element has a pair in the static
		 * configuration, update it with the sys_id
		 */
		if ((pair = pool_get_pair(create->pcu_elem)) != NULL) {
			pool_value_set_int64(&val, create->pcu_ioctl.pc_i_id);
			assert(pool_put_any_ns_property(pair, c_sys_prop, &val)
			    == PO_SUCCESS);
		}
		li->li_state = LS_UNDO;
		break;
	case POOL_DESTROY:
		destroy = (pool_destroy_undo_t *)li->li_details;

		destroy->pdu_ioctl.pd_o_id = elem_get_sysid(destroy->pdu_elem);

		/*
		 * It may be that this element was created in the last
		 * transaction. In which case POOL_CREATE, above, will
		 * have re-inserted the element in the dictionary. Try
		 * to remove it just in case this has occurred.
		 */
		(void) dict_remove(prov->pkc_elements,
		    (pool_knl_elem_t *)destroy->pdu_elem);
		while ((ret = ioctl(prov->pkc_fd, POOL_DESTROY,
		    &destroy->pdu_ioctl)) < 0 && errno == EAGAIN)
			;
		if (ret < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
#ifdef DEBUG
		dprintf("log_item_commit: POOL_DESTROY\n");
		pool_elem_dprintf(destroy->pdu_elem);
#endif	/* DEBUG */
		li->li_state = LS_UNDO;
		break;
	case POOL_ASSOC:
		assoc = (pool_assoc_undo_t *)li->li_details;

		assoc->pau_ioctl.pa_o_pool_id =
		    elem_get_sysid(assoc->pau_assoc);
		assoc->pau_ioctl.pa_o_res_id =
		    elem_get_sysid(assoc->pau_newres);
		while ((ret = ioctl(prov->pkc_fd, POOL_ASSOC,
		    &assoc->pau_ioctl)) < 0 && errno == EAGAIN)
			;
		if (ret < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		li->li_state = LS_UNDO;
		break;
	case POOL_DISSOC:
		dissoc = (pool_dissoc_undo_t *)li->li_details;

		dissoc->pdu_ioctl.pd_o_pool_id =
		    elem_get_sysid(dissoc->pdu_dissoc);

		while ((ret = ioctl(prov->pkc_fd, POOL_DISSOC,
		    &dissoc->pdu_ioctl)) < 0 && errno == EAGAIN)
			;
		if (ret < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		li->li_state = LS_UNDO;
		break;
	case POOL_TRANSFER:
		li->li_state = LS_UNDO;
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	case POOL_XTRANSFER:
		xtransfer = (pool_xtransfer_undo_t *)li->li_details;

		xtransfer->pxu_ioctl.px_o_src_id =
		    elem_get_sysid(xtransfer->pxu_src);
		xtransfer->pxu_ioctl.px_o_tgt_id =
		    elem_get_sysid(xtransfer->pxu_tgt);
		for (size = 0; xtransfer->pxu_rl[size] != NULL; size ++) {
			xtransfer->pxu_ioctl.px_o_comp_list[size] =
			    elem_get_sysid(TO_ELEM(xtransfer->pxu_rl[size]));
#ifdef DEBUG
			dprintf("log_item_commit: POOL_XTRANSFER\n");
			pool_elem_dprintf(TO_ELEM(xtransfer->pxu_rl[size]));
#endif	/* DEBUG */
		}

		/*
		 * Don't actually transfer resources if the configuration
		 * is in POF_DESTROY state. This is to prevent problems
		 * relating to transferring off-line CPUs. Instead rely
		 * on the POOL_DESTROY ioctl to transfer the CPUS.
		 */
		if (li->li_log->l_conf->pc_state != POF_DESTROY &&
		    ioctl(prov->pkc_fd, POOL_XTRANSFER,
		    &xtransfer->pxu_ioctl) < 0) {
#ifdef DEBUG
			dprintf("log_item_commit: POOL_XTRANSFER, ioctl "
			    "failed\n");
#endif	/* DEBUG */
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		li->li_state = LS_UNDO;
		break;
	case POOL_PROPPUT:
		propput = (pool_propput_undo_t *)li->li_details;

		if (pool_elem_class(propput->ppu_elem) != PEC_SYSTEM) {
			propput->ppu_ioctl.pp_o_id =
			    elem_get_sysid(propput->ppu_elem);
		}
		/*
		 * Some properties, e.g. pset.size, are read-only in the
		 * kernel and attempting to change them will fail and cause
		 * problems. Although this property is read-only through the
		 * public interface, the library needs to modify it's value.
		 */
		if ((propput->ppu_doioctl & KERNEL_PROP_RDONLY) == 0) {
			if (ioctl(prov->pkc_fd, POOL_PROPPUT,
			    &propput->ppu_ioctl) < 0) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
		}
		li->li_state = LS_UNDO;
		break;
	case POOL_PROPRM:
		proprm = (pool_proprm_undo_t *)li->li_details;

		if (pool_elem_class(proprm->pru_elem) != PEC_SYSTEM) {
			proprm->pru_ioctl.pp_o_id =
			    elem_get_sysid(proprm->pru_elem);
		}
		if (ioctl(prov->pkc_fd, POOL_PROPRM, &proprm->pru_ioctl) < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		li->li_state = LS_UNDO;
		break;
	default:
		return (PO_FAIL);
	}
	return (PO_SUCCESS);
}

/*
 * Undo an individual transaction log item(). This processing is
 * essential to the pool_conf_commit() and pool_conf_rollback()
 * logic. Changes to the libpool snapshot and the kernel are carried
 * out separately. The library snapshot is updated synchronously,
 * however the kernel update is delayed until the user calls
 * pool_conf_commit().
 *
 * When undoing transactions, library changes will be undone unless
 * this invocation is as a result of a commit failure, in which case
 * the log state will be LS_RECOVER. Kernel changes will only be
 * undone if they are marked as having been done, in which case the
 * log item state will be LS_UNDO.
 */
int
log_item_undo(log_item_t *li)
{
	pool_knl_connection_t *prov =
	    (pool_knl_connection_t *)li->li_log->l_conf->pc_prov;
	pool_create_undo_t *create;
	pool_destroy_undo_t *destroy;
	pool_assoc_undo_t *assoc;
	pool_dissoc_undo_t *dissoc;
	pool_propput_undo_t *propput;
	pool_proprm_undo_t *proprm;
	pool_xtransfer_undo_t *xtransfer;
	char_buf_t *cb;
	size_t size;
	pool_destroy_t u_destroy;
	pool_create_t u_create;
	pool_assoc_t u_assoc;
	pool_xtransfer_t u_xtransfer;
	pool_propput_t u_propput;
	pool_proprm_t u_proprm;
	pool_conf_t *conf = li->li_log->l_conf;
	nvpair_t *pair;
	nvlist_t *tmplist;
	int ret;

	if (li->li_log->l_state != LS_RECOVER) {
	switch (li->li_op) {
	case POOL_CREATE:
		create = (pool_create_undo_t *)li->li_details;

		(void) dict_remove(prov->pkc_elements, create->pcu_elem);
#ifdef DEBUG
		dprintf("log_item_undo: POOL_CREATE\n");
		assert(create->pcu_elem != NULL);
		dprintf("log_item_undo: POOL_CREATE %p\n", create->pcu_elem);
		pool_elem_dprintf(create->pcu_elem);
#endif	/* DEBUG */
		pool_knl_elem_free((pool_knl_elem_t *)create->pcu_elem,
		    PO_TRUE);
		break;
	case POOL_DESTROY:
		destroy = (pool_destroy_undo_t *)li->li_details;

		assert(dict_put(prov->pkc_elements, destroy->pdu_elem,
		    destroy->pdu_elem) == NULL);
		break;
	case POOL_ASSOC:
		assoc = (pool_assoc_undo_t *)li->li_details;

		if (assoc->pau_oldres != NULL)
			((pool_knl_pool_t *)assoc->pau_assoc)->pkp_assoc
			    [pool_resource_elem_class(assoc->pau_oldres)] =
			    (pool_knl_resource_t *)assoc->pau_oldres;
		break;
	case POOL_DISSOC:
		dissoc = (pool_dissoc_undo_t *)li->li_details;

		if (dissoc->pdu_oldres != NULL)
			((pool_knl_pool_t *)dissoc->pdu_dissoc)->pkp_assoc
			    [pool_resource_elem_class(dissoc->pdu_oldres)] =
			    (pool_knl_resource_t *)dissoc->pdu_oldres;
		break;
	case POOL_TRANSFER:
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	case POOL_XTRANSFER:
		xtransfer = (pool_xtransfer_undo_t *)li->li_details;

		for (size = 0; xtransfer->pxu_rl[size] != NULL; size++) {
			pool_value_t val = POOL_VALUE_INITIALIZER;
			uint64_t src_size;
			uint64_t tgt_size;

			if (pool_set_container(xtransfer->pxu_src,
			    TO_ELEM(xtransfer->pxu_rl[size])) == PO_FAIL) {
				return (PO_FAIL);
			}
			/*
			 * Maintain the library view of the size
			 */
			if (resource_get_size(pool_elem_res(xtransfer->pxu_src),
			    &src_size) != PO_SUCCESS ||
			    resource_get_size(pool_elem_res(xtransfer->pxu_tgt),
			    &tgt_size) != PO_SUCCESS) {
				pool_seterror(POE_BADPARAM);
				return (PO_FAIL);
			}
			src_size++;
			tgt_size--;
			pool_value_set_uint64(&val, src_size);
			(void) pool_put_any_ns_property(xtransfer->pxu_src,
			    c_size_prop, &val);
			pool_value_set_uint64(&val, tgt_size);
			(void) pool_put_any_ns_property(xtransfer->pxu_tgt,
			    c_size_prop, &val);
		}
		break;
	case POOL_PROPPUT:
		propput = (pool_propput_undo_t *)li->li_details;

		if ((propput->ppu_doioctl & KERNEL_PROP_RDONLY) == 0) {
			if (propput->ppu_blist != NULL) {
				if (nvlist_merge(
				    ((pool_knl_elem_t *)propput->ppu_elem)->
				    pke_properties, propput->ppu_blist, 0)
				    != 0) {
					pool_seterror(POE_SYSTEM);
					return (PO_FAIL);
				}
			} else {
				if (nvlist_unpack(propput->ppu_ioctl.pp_o_buf,
				    propput->ppu_ioctl.pp_o_bufsize,
				    &propput->ppu_alist, 0) != 0) {
					pool_seterror(POE_SYSTEM);
					return (PO_FAIL);
				}
				pair = nvlist_next_nvpair(propput->ppu_alist,
				    NULL);
				(void) nvlist_remove_all(((pool_knl_elem_t *)
				    propput->ppu_elem)->pke_properties,
				    nvpair_name(pair));
				nvlist_free(propput->ppu_alist);
			}
		}
		break;
	case POOL_PROPRM:
		proprm = (pool_proprm_undo_t *)li->li_details;

		if (pool_value_get_type(&proprm->pru_oldval) != POC_INVAL) {
			if (pool_put_property(conf, proprm->pru_elem,
			    proprm->pru_ioctl.pp_o_prop_name,
			    &proprm->pru_oldval) != PO_SUCCESS) {
				return (PO_FAIL);
			}
		}
		break;
	default:
		return (PO_FAIL);
	}
	}
	/*
	 * Only try to undo the state of the kernel if we modified it.
	 */
	if (li->li_state == LS_DO) {
		return (PO_SUCCESS);
	}

	switch (li->li_op) {
	case POOL_CREATE:
		create = (pool_create_undo_t *)li->li_details;

		u_destroy.pd_o_type = create->pcu_ioctl.pc_o_type;
		u_destroy.pd_o_sub_type = create->pcu_ioctl.pc_o_sub_type;
		u_destroy.pd_o_id = create->pcu_ioctl.pc_i_id;

		while ((ret = ioctl(prov->pkc_fd, POOL_DESTROY,
		    &u_destroy)) < 0 && errno == EAGAIN)
			;
		if (ret < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		li->li_state = LS_DO;
		break;
	case POOL_DESTROY:
		destroy = (pool_destroy_undo_t *)li->li_details;

		u_create.pc_o_type = destroy->pdu_ioctl.pd_o_type;
		u_create.pc_o_sub_type = destroy->pdu_ioctl.pd_o_sub_type;

		if (ioctl(prov->pkc_fd, POOL_CREATE, &u_create) < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}

		if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL) {
			return (PO_FAIL);
		}
		if (set_char_buf(cb, "%s.sys_id",
		    pool_elem_class_string(destroy->pdu_elem)) != PO_SUCCESS) {
			free_char_buf(cb);
			return (PO_FAIL);
		}
		(void) nvlist_add_int64(
		    ((pool_knl_elem_t *)destroy->pdu_elem)->pke_properties,
		    cb->cb_buf, u_create.pc_i_id);
		free_char_buf(cb);
		if (dict_put(prov->pkc_elements, destroy->pdu_elem,
		    destroy->pdu_elem) != NULL) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		/*
		 * Now we need to reset all the properties and
		 * associations in the kernel for this newly created
		 * replacement.
		 */
		u_propput.pp_o_id_type = destroy->pdu_ioctl.pd_o_type;
		u_propput.pp_o_id_sub_type = destroy->pdu_ioctl.pd_o_sub_type;
		u_propput.pp_o_id = u_create.pc_i_id;
		u_propput.pp_o_buf = NULL;
		/*
		 * Remove the read-only properties before attempting
		 * to restore the state of the newly created property
		 */
		(void) nvlist_dup(((pool_knl_elem_t *)destroy->pdu_elem)->
		    pke_properties, &tmplist, 0);
		for (pair = nvlist_next_nvpair(tmplist, NULL); pair != NULL;
		    pair = nvlist_next_nvpair(tmplist, pair)) {
			const pool_prop_t *prop;
			char *name = nvpair_name(pair);
			if ((prop = provider_get_prop(destroy->pdu_elem,
			    name)) != NULL)
				if (prop_is_readonly(prop) == PO_TRUE)
					(void) nvlist_remove_all(tmplist, name);
		}
		if (nvlist_pack(tmplist, (char **)&u_propput.pp_o_buf,
		    &u_propput.pp_o_bufsize, NV_ENCODE_NATIVE, 0) != 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		nvlist_free(tmplist);
		if (ioctl(prov->pkc_fd, POOL_PROPPUT, &u_propput) < 0) {
			free(u_propput.pp_o_buf);
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		free(u_propput.pp_o_buf);
		/*
		 * Now reset the associations for all the resource
		 * types if the thing which we are recreating is a
		 * pool
		 *
		 * TODO: This is resource specific and must be
		 * extended for additional resource types.
		 */
		if (destroy->pdu_ioctl.pd_o_type == PEC_POOL) {
			u_assoc.pa_o_pool_id = u_create.pc_i_id;
			u_assoc.pa_o_res_id =
			    elem_get_sysid(
			    TO_ELEM(((pool_knl_pool_t *)destroy->pdu_elem)->
			    pkp_assoc[PREC_PSET]));
			u_assoc.pa_o_id_type = PREC_PSET;

			if (ioctl(prov->pkc_fd, POOL_ASSOC, &u_assoc) < 0) {
				pool_seterror(POE_SYSTEM);
				return (PO_FAIL);
			}
		}
		li->li_state = LS_DO;
		break;
	case POOL_ASSOC:
		assoc = (pool_assoc_undo_t *)li->li_details;

		u_assoc.pa_o_pool_id = elem_get_sysid(assoc->pau_assoc);
		u_assoc.pa_o_res_id = elem_get_sysid(assoc->pau_oldres);
		u_assoc.pa_o_id_type = assoc->pau_ioctl.pa_o_id_type;

		while ((ret = ioctl(prov->pkc_fd, POOL_ASSOC, &u_assoc)) < 0 &&
		    errno == EAGAIN)
			;
		if (ret < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		li->li_state = LS_DO;
		break;
	case POOL_DISSOC:
		dissoc = (pool_dissoc_undo_t *)li->li_details;

		u_assoc.pa_o_pool_id = elem_get_sysid(dissoc->pdu_dissoc);
		u_assoc.pa_o_res_id = elem_get_sysid(dissoc->pdu_oldres);
		u_assoc.pa_o_id_type = dissoc->pdu_ioctl.pd_o_id_type;

		while ((ret = ioctl(prov->pkc_fd, POOL_ASSOC, &u_assoc)) < 0 &&
		    errno == EAGAIN)
			;
		if (ret < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		li->li_state = LS_DO;
		break;
	case POOL_TRANSFER:
		li->li_state = LS_DO;
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	case POOL_XTRANSFER:
		xtransfer = (pool_xtransfer_undo_t *)li->li_details;

		(void) memcpy(&u_xtransfer, &xtransfer->pxu_ioctl,
		    sizeof (pool_xtransfer_t));
		u_xtransfer.px_o_src_id = elem_get_sysid(xtransfer->pxu_tgt);
		u_xtransfer.px_o_tgt_id = elem_get_sysid(xtransfer->pxu_src);

		if (ioctl(prov->pkc_fd, POOL_XTRANSFER, &u_xtransfer) < 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		li->li_state = LS_DO;
		break;
	case POOL_PROPPUT:
		propput = (pool_propput_undo_t *)li->li_details;

		if ((propput->ppu_doioctl & KERNEL_PROP_RDONLY) == 0) {
			if (propput->ppu_blist) {
				(void) memcpy(&u_propput, &propput->ppu_ioctl,
				    sizeof (pool_propput_t));
				u_propput.pp_o_id =
				    elem_get_sysid(propput->ppu_elem);
				u_propput.pp_o_buf = NULL;
				if (nvlist_pack(propput->ppu_blist,
				    (char **)&u_propput.pp_o_buf,
				    &u_propput.pp_o_bufsize,
				    NV_ENCODE_NATIVE, 0) != 0) {
					pool_seterror(POE_SYSTEM);
					return (PO_FAIL);
				}
				if (ioctl(prov->pkc_fd, POOL_PROPPUT,
				    &u_propput) < 0) {
					free(u_propput.pp_o_buf);
					pool_seterror(POE_SYSTEM);
					return (PO_FAIL);
				}
				free(u_propput.pp_o_buf);
			} else {
				if (nvlist_unpack(propput->
				    ppu_ioctl.pp_o_buf,
				    propput->ppu_ioctl.pp_o_bufsize,
				    &propput->ppu_alist, 0) != 0) {
					pool_seterror(POE_SYSTEM);
					return (PO_FAIL);
				}
				u_proprm.pp_o_id_type =
				    propput->ppu_ioctl.pp_o_id_type;
				u_proprm.pp_o_id_sub_type =
				    propput->ppu_ioctl.pp_o_id_sub_type;
				u_proprm.pp_o_id =
				    elem_get_sysid(propput->ppu_elem);
				pair = nvlist_next_nvpair(propput->ppu_alist,
				    NULL);
				u_proprm.pp_o_prop_name = nvpair_name(pair);
				u_proprm.pp_o_prop_name_size =
				    strlen(u_proprm.pp_o_prop_name);

				if (provider_get_prop(propput->ppu_elem,
				    u_proprm.pp_o_prop_name) == NULL) {
					if (ioctl(prov->pkc_fd, POOL_PROPRM,
					    &u_proprm) < 0) {
						nvlist_free(propput->ppu_alist);
						pool_seterror(POE_SYSTEM);
						return (PO_FAIL);
					}
				}
				nvlist_free(propput->ppu_alist);
			}
		}
		li->li_state = LS_DO;
		break;
	case POOL_PROPRM:
		proprm = (pool_proprm_undo_t *)li->li_details;

		u_propput.pp_o_id_type = proprm->pru_ioctl.pp_o_id_type;
		u_propput.pp_o_id_sub_type =
		    proprm->pru_ioctl.pp_o_id_sub_type;
		u_propput.pp_o_id = elem_get_sysid(proprm->pru_elem);
		u_propput.pp_o_buf = NULL;
		/*
		 * Only try to remove the appropriate property
		 */
		if (nvlist_alloc(&tmplist, NV_UNIQUE_NAME_TYPE, 0) !=
		    0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		if (pool_knl_nvlist_add_value(tmplist,
		    pool_value_get_name(&proprm->pru_oldval),
		    &proprm->pru_oldval) != PO_SUCCESS)
			return (PO_FAIL);

		if (nvlist_pack(tmplist,
		    (char **)&u_propput.pp_o_buf, &u_propput.pp_o_bufsize,
		    NV_ENCODE_NATIVE, 0) != 0) {
			nvlist_free(tmplist);
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		nvlist_free(tmplist);
		if (ioctl(prov->pkc_fd, POOL_PROPPUT, &u_propput) < 0) {
			free(u_propput.pp_o_buf);
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		free(u_propput.pp_o_buf);
		li->li_state = LS_DO;
		break;
	default:
		return (PO_FAIL);
	}
		return (PO_SUCCESS);
}

/*
 * A log item stores state about the transaction it represents. This
 * function releases the resources associated with the transaction and
 * used to store the transaction state.
 */
int
log_item_release(log_item_t *li)
{
	pool_create_undo_t *create;
	pool_destroy_undo_t *destroy;
	pool_assoc_undo_t *assoc;
	pool_dissoc_undo_t *dissoc;
	pool_propput_undo_t *propput;
	pool_proprm_undo_t *proprm;
	pool_xtransfer_undo_t *xtransfer;

	switch (li->li_op) {
	case POOL_CREATE:
		create = (pool_create_undo_t *)li->li_details;

		free(create);
		break;
	case POOL_DESTROY:
		destroy = (pool_destroy_undo_t *)li->li_details;

#ifdef DEBUG
		dprintf("log_item_release: POOL_DESTROY\n");
#endif	/* DEBUG */

		if (li->li_state == LS_UNDO) {
#ifdef DEBUG
			pool_elem_dprintf(destroy->pdu_elem);
#endif	/* DEBUG */
			pool_knl_elem_free((pool_knl_elem_t *)destroy->
			    pdu_elem, PO_TRUE);
		}
		free(destroy);
		break;
	case POOL_ASSOC:
		assoc = (pool_assoc_undo_t *)li->li_details;

		free(assoc);
		break;
	case POOL_DISSOC:
		dissoc = (pool_dissoc_undo_t *)li->li_details;

		free(dissoc);
		break;
	case POOL_TRANSFER:
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	case POOL_XTRANSFER:
		xtransfer = (pool_xtransfer_undo_t *)li->li_details;

		free(xtransfer->pxu_rl);
		free(xtransfer->pxu_ioctl.px_o_comp_list);
		free(xtransfer);
		break;
	case POOL_PROPPUT:
		propput = (pool_propput_undo_t *)li->li_details;

		nvlist_free(propput->ppu_blist);
		free(propput->ppu_ioctl.pp_o_buf);
		free(propput);
		break;
	case POOL_PROPRM:
		proprm = (pool_proprm_undo_t *)li->li_details;

		free(proprm);
		break;
	default:
		return (PO_FAIL);
	}
	return (PO_SUCCESS);
}

/*
 * pool_knl_nvlist_add_value() adds a pool_value_t to an nvlist.
 */
int
pool_knl_nvlist_add_value(nvlist_t *list, const char *name,
    const pool_value_t *pv)
{
	uint64_t uval;
	int64_t ival;
	double dval;
	uchar_t dval_b[sizeof (double)];
	uchar_t bval;
	const char *sval;
	pool_value_class_t type;
	char *nv_name;

	if ((type = pool_value_get_type(pv)) == POC_INVAL) {
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	}
	nv_name = (char *)name;

	switch (type) {
	case POC_UINT:
		if (pool_value_get_uint64(pv, &uval) == POC_INVAL) {
			return (PO_FAIL);
		}
		if (nvlist_add_uint64(list, nv_name, uval) != 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		break;
	case POC_INT:
		if (pool_value_get_int64(pv, &ival) == POC_INVAL) {
			return (PO_FAIL);
		}
		if (nvlist_add_int64(list, nv_name, ival) != 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		break;
	case POC_DOUBLE:
		if (pool_value_get_double(pv, &dval) == POC_INVAL) {
			return (PO_FAIL);
		}
		/*
		 * Since there is no support for doubles in the
		 * kernel, store the double value in a byte array.
		 */
		(void) memcpy(dval_b, &dval, sizeof (double));
		if (nvlist_add_byte_array(list, nv_name, dval_b,
		    sizeof (double)) != 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		break;
	case POC_BOOL:
		if (pool_value_get_bool(pv, &bval) == POC_INVAL) {
			return (PO_FAIL);
		}
		if (nvlist_add_byte(list, nv_name, bval) != 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		break;
	case POC_STRING:
		if (pool_value_get_string(pv, &sval) == POC_INVAL) {
			return (PO_FAIL);
		}
		if (nvlist_add_string(list, nv_name, (char *)sval) != 0) {
			pool_seterror(POE_SYSTEM);
			return (PO_FAIL);
		}
		break;
	default:
		pool_seterror(POE_BADPARAM);
		return (PO_FAIL);
	}
	return (PO_SUCCESS);
}

/*
 * hash_id() hashes all elements in a pool configuration using the
 * "sys_id" property. Not all elements have a "sys_id" property,
 * however elem_get_sysid() caters for this by always returning a
 * constant value for those elements. This isn't anticipated to lead
 * to a performance degradation in the hash, since those elements
 * which are likely to be most prevalent in a configuration do have
 * "sys_id" as a property.
 */
uint64_t
hash_id(const pool_elem_t *pe)
{
	id_t id;

	id = elem_get_sysid(pe);
	return (hash_buf(&id, sizeof (id)));
}

/*
 *  blocking_open() guarantees access to the pool device, if open()
 * is failing with EBUSY.
 */
int
blocking_open(const char *path, int oflag)
{
	int fd;

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

	return (fd);
}