/*

 * 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 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * The pool configuration repository is stored in /etc/zfs/zpool.cache as a

 * single packed nvlist.  While it would be nice to just read in this

 * file from userland, this wouldn't work from a local zone.  So we have to have

 * a zpool ioctl to return the complete configuration for all pools.  In the

 * global zone, this will be identical to reading the file and unpacking it in

 * userland.

 */

#include <errno.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stddef.h>

#include <string.h>

#include <unistd.h>

#include <libintl.h>

#include <libuutil.h>

#include "libzfs_impl.h"

typedef struct config_node {

	char		*cn_name;

	nvlist_t	*cn_config;

	uu_avl_node_t	cn_avl;

} config_node_t;

/* ARGSUSED */

static int

config_node_compare(const void *a, const void *b, void *unused)

{

	int ret;

	const config_node_t *ca = (config_node_t *)a;

	const config_node_t *cb = (config_node_t *)b;

	ret = strcmp(ca->cn_name, cb->cn_name);

	if (ret < 0)

		return (-1);

	else if (ret > 0)

		return (1);

	else

		return (0);

}

/*

 * Loads the pool namespace, or re-loads it if the cache has changed.

 */

{

	nvlist_t *config;

	config_node_t *cn;

	nvpair_t *elem;

	zfs_cmd_t zc = { 0 };

	uu_avl_walk_t *walk;

		/*

		 * This is the first time we've accessed the configuration

		 * cache.  Initialize the AVL tree and then fall through to the

		 * common code.

		 */

		    sizeof (config_node_t),

		    offsetof(config_node_t, cn_avl),

		    config_node_compare, UU_DEFAULT)) == NULL)

	}

	/*

	 * Issue the ZFS_IOC_POOL_CONFIGS ioctl.

	 * This can fail for one of two reasons:

	 *

	 * 	EEXIST		The generation counts match, nothing to do.

	 * 	ENOMEM		The zc_config_dst buffer isn't large enough to

	 * 			hold the config; zc_config_dst_size will have

	 *			been modified to tell us how much to allocate.

	 */

	zc.zc_config_dst_size = 1024;

	for (;;) {

			switch (errno) {

			case EEXIST:

				/*

				 * The namespace hasn't changed.

				 */

				free((void *)(uintptr_t)zc.zc_config_dst);

			case ENOMEM:

				free((void *)(uintptr_t)zc.zc_config_dst);

				break;

			default:

			}

		} else {

			break;

		}

	}

	free((void *)(uintptr_t)zc.zc_config_dst);

	/*

	 * Clear out any existing configuration information.

	 */

	while ((cn = uu_avl_walk_next(walk)) != NULL) {

		nvlist_free(cn->cn_config);

		free(cn->cn_name);

		free(cn);

	}

	elem = NULL;

	while ((elem = nvlist_next_nvpair(config, elem)) != NULL) {

		nvlist_t *child;

		uu_avl_index_t where;

		verify(nvpair_value_nvlist(elem, &child) == 0);

	}

	nvlist_free(config);

}

/*

 * Retrive the configuration for the given pool.  The configuration is a nvlist

 * describing the vdevs, as well as the statistics associated with each one.

 */

nvlist_t *

zpool_get_config(zpool_handle_t *zhp, nvlist_t **oldconfig)

{

	if (oldconfig)

		*oldconfig = zhp->zpool_old_config;

	return (zhp->zpool_config);

}

/*

 * Refresh the vdev statistics associated with the given pool.  This is used in

 * iostat to show configuration changes and determine the delta from the last

 * time the function was called.  This function can fail, in case the pool has

 * been destroyed.

 */

int

zpool_refresh_stats(zpool_handle_t *zhp)

{

	zfs_cmd_t zc = { 0 };

	int error;

	nvlist_t *config;

	(void) strcpy(zc.zc_name, zhp->zpool_name);

	if (zhp->zpool_config_size == 0)

		zhp->zpool_config_size = 1 << 16;

	zc.zc_config_dst_size = zhp->zpool_config_size;

	for (;;) {

			/*

			 * The real error is returned in the zc_cookie field.

			 */

			break;

		}

		if (errno == ENOMEM) {

			free((void *)(uintptr_t)zc.zc_config_dst);

		} else {

			free((void *)(uintptr_t)zc.zc_config_dst);

		}

	}

	zhp->zpool_config_size = zc.zc_config_dst_size;

	free((void *)(uintptr_t)zc.zc_config_dst);

	if (zhp->zpool_config != NULL) {

		uint64_t oldtxg, newtxg;

		verify(nvlist_lookup_uint64(zhp->zpool_config,

		    ZPOOL_CONFIG_POOL_TXG, &oldtxg) == 0);

		verify(nvlist_lookup_uint64(config,

		    ZPOOL_CONFIG_POOL_TXG, &newtxg) == 0);

		if (zhp->zpool_old_config != NULL)

			nvlist_free(zhp->zpool_old_config);

		if (oldtxg != newtxg) {

			nvlist_free(zhp->zpool_config);

			zhp->zpool_old_config = NULL;

		} else {

			zhp->zpool_old_config = zhp->zpool_config;

		}

	}

	zhp->zpool_config = config;

}

/*

 * Iterate over all pools in the system.

 */

int

{

	config_node_t *cn;

	zpool_handle_t *zhp;

	int ret;

			continue;

		if ((ret = func(zhp, data)) != 0)

			return (ret);

	}

	return (0);

}

/*

 * Iterate over root datasets, calling the given function for each.  The zfs

 * handle passed each time must be explicitly closed by the callback.

 */

int

{

	config_node_t *cn;

	zfs_handle_t *zhp;

	int ret;

			continue;

		if ((ret = func(zhp, data)) != 0)

			return (ret);

	}

	return (0);

}