[mirror_zfs.git] / lib / libzfs / libzfs_import.c

/*
 * 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 2015 Nexenta Systems, Inc. All rights reserved.
 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
 * Copyright 2015 RackTop Systems.
 * Copyright (c) 2016, Intel Corporation.
 */

#include <errno.h>
#include <libintl.h>
#include <libgen.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/vdev_impl.h>
#include <libzfs.h>
#include <libzfs_impl.h>
#include <libzutil.h>
#include <sys/arc_impl.h>

/*
 * Returns true if the named pool matches the given GUID.
 */
static int
pool_active(libzfs_handle_t *hdl, const char *name, uint64_t guid,
    boolean_t *isactive)
{
	zpool_handle_t *zhp;
	uint64_t theguid;

	if (zpool_open_silent(hdl, name, &zhp) != 0)
		return (-1);

	if (zhp == NULL) {
		*isactive = B_FALSE;
		return (0);
	}

	verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_POOL_GUID,
	    &theguid) == 0);

	zpool_close(zhp);

	*isactive = (theguid == guid);
	return (0);
}

static nvlist_t *
refresh_config(libzfs_handle_t *hdl, nvlist_t *config)
{
	nvlist_t *nvl;
	zfs_cmd_t zc = {"\0"};
	int err, dstbuf_size;

	if (zcmd_write_conf_nvlist(hdl, &zc, config) != 0)
		return (NULL);

	dstbuf_size = MAX(CONFIG_BUF_MINSIZE, zc.zc_nvlist_conf_size * 4);

	if (zcmd_alloc_dst_nvlist(hdl, &zc, dstbuf_size) != 0) {
		zcmd_free_nvlists(&zc);
		return (NULL);
	}

	while ((err = zfs_ioctl(hdl, ZFS_IOC_POOL_TRYIMPORT,
	    &zc)) != 0 && errno == ENOMEM) {
		if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
			zcmd_free_nvlists(&zc);
			return (NULL);
		}
	}

	if (err) {
		zcmd_free_nvlists(&zc);
		return (NULL);
	}

	if (zcmd_read_dst_nvlist(hdl, &zc, &nvl) != 0) {
		zcmd_free_nvlists(&zc);
		return (NULL);
	}

	zcmd_free_nvlists(&zc);
	return (nvl);
}

static nvlist_t *
refresh_config_libzfs(void *handle, nvlist_t *tryconfig)
{
	return (refresh_config((libzfs_handle_t *)handle, tryconfig));
}

static int
pool_active_libzfs(void *handle, const char *name, uint64_t guid,
    boolean_t *isactive)
{
	return (pool_active((libzfs_handle_t *)handle, name, guid, isactive));
}

const pool_config_ops_t libzfs_config_ops = {
	.pco_refresh_config = refresh_config_libzfs,
	.pco_pool_active = pool_active_libzfs,
};

/*
 * Return the offset of the given label.
 */
static uint64_t
label_offset(uint64_t size, int l)
{
	ASSERT(P2PHASE_TYPED(size, sizeof (vdev_label_t), uint64_t) == 0);
	return (l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ?
	    0 : size - VDEV_LABELS * sizeof (vdev_label_t)));
}

/*
 * Given a file descriptor, clear (zero) the label information.  This function
 * is used in the appliance stack as part of the ZFS sysevent module and
 * to implement the "zpool labelclear" command.
 */
int
zpool_clear_label(int fd)
{
	struct stat64 statbuf;
	int l;
	vdev_label_t *label;
	l2arc_dev_hdr_phys_t *l2dhdr;
	uint64_t size;
	int labels_cleared = 0, header_cleared = 0;
	boolean_t clear_l2arc_header = B_FALSE;

	if (fstat64_blk(fd, &statbuf) == -1)
		return (0);

	size = P2ALIGN_TYPED(statbuf.st_size, sizeof (vdev_label_t), uint64_t);

	if ((label = calloc(1, sizeof (vdev_label_t))) == NULL)
		return (-1);

	if ((l2dhdr = calloc(1, sizeof (l2arc_dev_hdr_phys_t))) == NULL) {
		free(label);
		return (-1);
	}

	for (l = 0; l < VDEV_LABELS; l++) {
		uint64_t state, guid, l2cache;
		nvlist_t *config;

		if (pread64(fd, label, sizeof (vdev_label_t),
		    label_offset(size, l)) != sizeof (vdev_label_t)) {
			continue;
		}

		if (nvlist_unpack(label->vl_vdev_phys.vp_nvlist,
		    sizeof (label->vl_vdev_phys.vp_nvlist), &config, 0) != 0) {
			continue;
		}

		/* Skip labels which do not have a valid guid. */
		if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID,
		    &guid) != 0 || guid == 0) {
			nvlist_free(config);
			continue;
		}

		/* Skip labels which are not in a known valid state. */
		if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
		    &state) != 0 || state > POOL_STATE_L2CACHE) {
			nvlist_free(config);
			continue;
		}

		/* If the device is a cache device clear the header. */
		if (!clear_l2arc_header) {
			if (nvlist_lookup_uint64(config,
			    ZPOOL_CONFIG_POOL_STATE, &l2cache) == 0 &&
			    l2cache == POOL_STATE_L2CACHE) {
				clear_l2arc_header = B_TRUE;
			}
		}

		nvlist_free(config);

		/*
		 * A valid label was found, overwrite this label's nvlist
		 * and uberblocks with zeros on disk.  This is done to prevent
		 * system utilities, like blkid, from incorrectly detecting a
		 * partial label.  The leading pad space is left untouched.
		 */
		memset(label, 0, sizeof (vdev_label_t));
		size_t label_size = sizeof (vdev_label_t) - (2 * VDEV_PAD_SIZE);

		if (pwrite64(fd, label, label_size, label_offset(size, l) +
		    (2 * VDEV_PAD_SIZE)) == label_size) {
			labels_cleared++;
		}
	}

	/* Clear the L2ARC header. */
	if (clear_l2arc_header) {
		memset(l2dhdr, 0, sizeof (l2arc_dev_hdr_phys_t));
		if (pwrite64(fd, l2dhdr, sizeof (l2arc_dev_hdr_phys_t),
		    VDEV_LABEL_START_SIZE) == sizeof (l2arc_dev_hdr_phys_t)) {
			header_cleared++;
		}
	}

	free(label);
	free(l2dhdr);

	if (labels_cleared == 0)
		return (-1);

	return (0);
}

static boolean_t
find_guid(nvlist_t *nv, uint64_t guid)
{
	uint64_t tmp;
	nvlist_t **child;
	uint_t c, children;

	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &tmp) == 0);
	if (tmp == guid)
		return (B_TRUE);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	    &child, &children) == 0) {
		for (c = 0; c < children; c++)
			if (find_guid(child[c], guid))
				return (B_TRUE);
	}

	return (B_FALSE);
}

typedef struct aux_cbdata {
	const char	*cb_type;
	uint64_t	cb_guid;
	zpool_handle_t	*cb_zhp;
} aux_cbdata_t;

static int
find_aux(zpool_handle_t *zhp, void *data)
{
	aux_cbdata_t *cbp = data;
	nvlist_t **list;
	uint_t i, count;
	uint64_t guid;
	nvlist_t *nvroot;

	verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE,
	    &nvroot) == 0);

	if (nvlist_lookup_nvlist_array(nvroot, cbp->cb_type,
	    &list, &count) == 0) {
		for (i = 0; i < count; i++) {
			verify(nvlist_lookup_uint64(list[i],
			    ZPOOL_CONFIG_GUID, &guid) == 0);
			if (guid == cbp->cb_guid) {
				cbp->cb_zhp = zhp;
				return (1);
			}
		}
	}

	zpool_close(zhp);
	return (0);
}

/*
 * Determines if the pool is in use.  If so, it returns true and the state of
 * the pool as well as the name of the pool.  Name string is allocated and
 * must be freed by the caller.
 */
int
zpool_in_use(libzfs_handle_t *hdl, int fd, pool_state_t *state, char **namestr,
    boolean_t *inuse)
{
	nvlist_t *config;
	char *name;
	boolean_t ret;
	uint64_t guid, vdev_guid;
	zpool_handle_t *zhp;
	nvlist_t *pool_config;
	uint64_t stateval, isspare;
	aux_cbdata_t cb = { 0 };
	boolean_t isactive;

	*inuse = B_FALSE;

	if (zpool_read_label(fd, &config, NULL) != 0) {
		(void) no_memory(hdl);
		return (-1);
	}

	if (config == NULL)
		return (0);

	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	    &stateval) == 0);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID,
	    &vdev_guid) == 0);

	if (stateval != POOL_STATE_SPARE && stateval != POOL_STATE_L2CACHE) {
		verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
		    &name) == 0);
		verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
		    &guid) == 0);
	}

	switch (stateval) {
	case POOL_STATE_EXPORTED:
		/*
		 * A pool with an exported state may in fact be imported
		 * read-only, so check the in-core state to see if it's
		 * active and imported read-only.  If it is, set
		 * its state to active.
		 */
		if (pool_active(hdl, name, guid, &isactive) == 0 && isactive &&
		    (zhp = zpool_open_canfail(hdl, name)) != NULL) {
			if (zpool_get_prop_int(zhp, ZPOOL_PROP_READONLY, NULL))
				stateval = POOL_STATE_ACTIVE;

			/*
			 * All we needed the zpool handle for is the
			 * readonly prop check.
			 */
			zpool_close(zhp);
		}

		ret = B_TRUE;
		break;

	case POOL_STATE_ACTIVE:
		/*
		 * For an active pool, we have to determine if it's really part
		 * of a currently active pool (in which case the pool will exist
		 * and the guid will be the same), or whether it's part of an
		 * active pool that was disconnected without being explicitly
		 * exported.
		 */
		if (pool_active(hdl, name, guid, &isactive) != 0) {
			nvlist_free(config);
			return (-1);
		}

		if (isactive) {
			/*
			 * Because the device may have been removed while
			 * offlined, we only report it as active if the vdev is
			 * still present in the config.  Otherwise, pretend like
			 * it's not in use.
			 */
			if ((zhp = zpool_open_canfail(hdl, name)) != NULL &&
			    (pool_config = zpool_get_config(zhp, NULL))
			    != NULL) {
				nvlist_t *nvroot;

				verify(nvlist_lookup_nvlist(pool_config,
				    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
				ret = find_guid(nvroot, vdev_guid);
			} else {
				ret = B_FALSE;
			}

			/*
			 * If this is an active spare within another pool, we
			 * treat it like an unused hot spare.  This allows the
			 * user to create a pool with a hot spare that currently
			 * in use within another pool.  Since we return B_TRUE,
			 * libdiskmgt will continue to prevent generic consumers
			 * from using the device.
			 */
			if (ret && nvlist_lookup_uint64(config,
			    ZPOOL_CONFIG_IS_SPARE, &isspare) == 0 && isspare)
				stateval = POOL_STATE_SPARE;

			if (zhp != NULL)
				zpool_close(zhp);
		} else {
			stateval = POOL_STATE_POTENTIALLY_ACTIVE;
			ret = B_TRUE;
		}
		break;

	case POOL_STATE_SPARE:
		/*
		 * For a hot spare, it can be either definitively in use, or
		 * potentially active.  To determine if it's in use, we iterate
		 * over all pools in the system and search for one with a spare
		 * with a matching guid.
		 *
		 * Due to the shared nature of spares, we don't actually report
		 * the potentially active case as in use.  This means the user
		 * can freely create pools on the hot spares of exported pools,
		 * but to do otherwise makes the resulting code complicated, and
		 * we end up having to deal with this case anyway.
		 */
		cb.cb_zhp = NULL;
		cb.cb_guid = vdev_guid;
		cb.cb_type = ZPOOL_CONFIG_SPARES;
		if (zpool_iter(hdl, find_aux, &cb) == 1) {
			name = (char *)zpool_get_name(cb.cb_zhp);
			ret = B_TRUE;
		} else {
			ret = B_FALSE;
		}
		break;

	case POOL_STATE_L2CACHE:

		/*
		 * Check if any pool is currently using this l2cache device.
		 */
		cb.cb_zhp = NULL;
		cb.cb_guid = vdev_guid;
		cb.cb_type = ZPOOL_CONFIG_L2CACHE;
		if (zpool_iter(hdl, find_aux, &cb) == 1) {
			name = (char *)zpool_get_name(cb.cb_zhp);
			ret = B_TRUE;
		} else {
			ret = B_FALSE;
		}
		break;

	default:
		ret = B_FALSE;
	}


	if (ret) {
		if ((*namestr = zfs_strdup(hdl, name)) == NULL) {
			if (cb.cb_zhp)
				zpool_close(cb.cb_zhp);
			nvlist_free(config);
			return (-1);
		}
		*state = (pool_state_t)stateval;
	}

	if (cb.cb_zhp)
		zpool_close(cb.cb_zhp);

	nvlist_free(config);
	*inuse = ret;
	return (0);
}
Commit	Line	Data
34dc7c2f BB	1	/*
	2	* CDDL HEADER START
	3	*
	4	* The contents of this file are subject to the terms of the
	5	* Common Development and Distribution License (the "License").
	6	* You may not use this file except in compliance with the License.
	7	*
	8	* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
	9	* or http://www.opensolaris.org/os/licensing.
	10	* See the License for the specific language governing permissions
	11	* and limitations under the License.
	12	*
	13	* When distributing Covered Code, include this CDDL HEADER in each
	14	* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
	15	* If applicable, add the following below this CDDL HEADER, with the
	16	* fields enclosed by brackets "[]" replaced with your own identifying
	17	* information: Portions Copyright [yyyy] [name of copyright owner]
	18	*
	19	* CDDL HEADER END
	20	*/
	21	/*
0fdd8d64	22	* Copyright 2015 Nexenta Systems, Inc. All rights reserved.
572e2857	23	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
99f505a4	24	* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
ee42b3d6	25	* Copyright 2015 RackTop Systems.
39fc0cb5	26	* Copyright (c) 2016, Intel Corporation.
34dc7c2f BB	27	*/
34dc7c2f BB	28
34dc7c2f BB	29	#include <errno.h>
34dc7c2f BB	30	#include <libintl.h>
522db292	31	#include <libgen.h>
428870ff	32	#include <stddef.h>
34dc7c2f BB	33	#include <stdlib.h>
	34	#include <string.h>
	35	#include <sys/stat.h>
	36	#include <unistd.h>
34dc7c2f	37	#include <sys/vdev_impl.h>
1bbd8770	38	#include <libzfs.h>
e89f1295 DB	39	#include <libzfs_impl.h>
e89f1295 DB	40	#include <libzutil.h>
77f6826b	41	#include <sys/arc_impl.h>
34dc7c2f BB	42
	43	/*
	44	* Returns true if the named pool matches the given GUID.
	45	*/
	46	static int
	47	pool_active(libzfs_handle_t hdl, const char name, uint64_t guid,
	48	boolean_t *isactive)
	49	{
	50	zpool_handle_t *zhp;
	51	uint64_t theguid;
	52
	53	if (zpool_open_silent(hdl, name, &zhp) != 0)
	54	return (-1);
	55
	56	if (zhp == NULL) {
	57	*isactive = B_FALSE;
	58	return (0);
	59	}
	60
	61	verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_POOL_GUID,
	62	&theguid) == 0);
	63
	64	zpool_close(zhp);
	65
	66	*isactive = (theguid == guid);
	67	return (0);
	68	}
	69
	70	static nvlist_t *
	71	refresh_config(libzfs_handle_t hdl, nvlist_t config)
	72	{
	73	nvlist_t *nvl;
13fe0198	74	zfs_cmd_t zc = {"\0"};
28b40c8a	75	int err, dstbuf_size;
34dc7c2f BB	76
	77	if (zcmd_write_conf_nvlist(hdl, &zc, config) != 0)
	78	return (NULL);
	79
28b40c8a GM	80	dstbuf_size = MAX(CONFIG_BUF_MINSIZE, zc.zc_nvlist_conf_size * 4);
	81
	82	if (zcmd_alloc_dst_nvlist(hdl, &zc, dstbuf_size) != 0) {
34dc7c2f BB	83	zcmd_free_nvlists(&zc);
	84	return (NULL);
	85	}
	86
b834b58a	87	while ((err = zfs_ioctl(hdl, ZFS_IOC_POOL_TRYIMPORT,
34dc7c2f BB	88	&zc)) != 0 && errno == ENOMEM) {
	89	if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
	90	zcmd_free_nvlists(&zc);
	91	return (NULL);
	92	}
	93	}
	94
	95	if (err) {
34dc7c2f BB	96	zcmd_free_nvlists(&zc);
	97	return (NULL);
	98	}
	99
	100	if (zcmd_read_dst_nvlist(hdl, &zc, &nvl) != 0) {
	101	zcmd_free_nvlists(&zc);
	102	return (NULL);
	103	}
	104
	105	zcmd_free_nvlists(&zc);
	106	return (nvl);
	107	}
	108
e89f1295 DB	109	static nvlist_t *
e89f1295 DB	110	refresh_config_libzfs(void handle, nvlist_t tryconfig)
428870ff	111	{
e89f1295 DB	112	return (refresh_config((libzfs_handle_t *)handle, tryconfig));
e89f1295 DB	113	}
d6320ddb	114
e89f1295 DB	115	static int
	116	pool_active_libzfs(void handle, const char name, uint64_t guid,
	117	boolean_t *isactive)
	118	{
	119	return (pool_active((libzfs_handle_t *)handle, name, guid, isactive));
428870ff BB	120	}
428870ff BB	121
e89f1295 DB	122	const pool_config_ops_t libzfs_config_ops = {
	123	.pco_refresh_config = refresh_config_libzfs,
	124	.pco_pool_active = pool_active_libzfs,
	125	};
	126
34dc7c2f	127	/*
e89f1295	128	* Return the offset of the given label.
34dc7c2f BB	129	*/
	130	static uint64_t
	131	label_offset(uint64_t size, int l)
	132	{
	133	ASSERT(P2PHASE_TYPED(size, sizeof (vdev_label_t), uint64_t) == 0);
	134	return (l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ?
	135	0 : size - VDEV_LABELS * sizeof (vdev_label_t)));
	136	}
	137
51a3ae72 DK	138	/*
51a3ae72 DK	139	* Given a file descriptor, clear (zero) the label information. This function
131cc95c DK	140	* is used in the appliance stack as part of the ZFS sysevent module and
131cc95c DK	141	* to implement the "zpool labelclear" command.
51a3ae72 DK	142	*/
	143	int
	144	zpool_clear_label(int fd)
	145	{
	146	struct stat64 statbuf;
	147	int l;
	148	vdev_label_t *label;
77f6826b	149	l2arc_dev_hdr_phys_t *l2dhdr;
51a3ae72	150	uint64_t size;
77f6826b GA	151	int labels_cleared = 0, header_cleared = 0;
77f6826b GA	152	boolean_t clear_l2arc_header = B_FALSE;
51a3ae72 DK	153
	154	if (fstat64_blk(fd, &statbuf) == -1)
	155	return (0);
066da71e	156
51a3ae72 DK	157	size = P2ALIGN_TYPED(statbuf.st_size, sizeof (vdev_label_t), uint64_t);
51a3ae72 DK	158
8111eb4a	159	if ((label = calloc(1, sizeof (vdev_label_t))) == NULL)
51a3ae72 DK	160	return (-1);
51a3ae72 DK	161
77f6826b GA	162	if ((l2dhdr = calloc(1, sizeof (l2arc_dev_hdr_phys_t))) == NULL) {
	163	free(label);
	164	return (-1);
	165	}
	166
51a3ae72	167	for (l = 0; l < VDEV_LABELS; l++) {
77f6826b	168	uint64_t state, guid, l2cache;
066da71e BB	169	nvlist_t *config;
	170
	171	if (pread64(fd, label, sizeof (vdev_label_t),
4def05f8	172	label_offset(size, l)) != sizeof (vdev_label_t)) {
066da71e BB	173	continue;
	174	}
	175
	176	if (nvlist_unpack(label->vl_vdev_phys.vp_nvlist,
	177	sizeof (label->vl_vdev_phys.vp_nvlist), &config, 0) != 0) {
	178	continue;
	179	}
	180
	181	/* Skip labels which do not have a valid guid. */
	182	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID,
	183	&guid) != 0 \|\| guid == 0) {
	184	nvlist_free(config);
	185	continue;
	186	}
	187
	188	/* Skip labels which are not in a known valid state. */
	189	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	190	&state) != 0 \|\| state > POOL_STATE_L2CACHE) {
	191	nvlist_free(config);
	192	continue;
	193	}
	194
77f6826b GA	195	/* If the device is a cache device clear the header. */
	196	if (!clear_l2arc_header) {
	197	if (nvlist_lookup_uint64(config,
	198	ZPOOL_CONFIG_POOL_STATE, &l2cache) == 0 &&
	199	l2cache == POOL_STATE_L2CACHE) {
	200	clear_l2arc_header = B_TRUE;
	201	}
	202	}
	203
066da71e BB	204	nvlist_free(config);
	205
	206	/*
	207	* A valid label was found, overwrite this label's nvlist
	208	* and uberblocks with zeros on disk. This is done to prevent
	209	* system utilities, like blkid, from incorrectly detecting a
	210	* partial label. The leading pad space is left untouched.
	211	*/
	212	memset(label, 0, sizeof (vdev_label_t));
	213	size_t label_size = sizeof (vdev_label_t) - (2 * VDEV_PAD_SIZE);
	214
	215	if (pwrite64(fd, label, label_size, label_offset(size, l) +
	216	(2 * VDEV_PAD_SIZE)) == label_size) {
	217	labels_cleared++;
4def05f8	218	}
51a3ae72 DK	219	}
51a3ae72 DK	220
77f6826b GA	221	/* Clear the L2ARC header. */
	222	if (clear_l2arc_header) {
	223	memset(l2dhdr, 0, sizeof (l2arc_dev_hdr_phys_t));
	224	if (pwrite64(fd, l2dhdr, sizeof (l2arc_dev_hdr_phys_t),
	225	VDEV_LABEL_START_SIZE) == sizeof (l2arc_dev_hdr_phys_t)) {
	226	header_cleared++;
	227	}
	228	}
	229
51a3ae72	230	free(label);
77f6826b	231	free(l2dhdr);
066da71e BB	232
	233	if (labels_cleared == 0)
	234	return (-1);
	235
51a3ae72 DK	236	return (0);
	237	}
	238
379ca9cf	239	static boolean_t
34dc7c2f BB	240	find_guid(nvlist_t *nv, uint64_t guid)
	241	{
	242	uint64_t tmp;
	243	nvlist_t **child;
	244	uint_t c, children;
	245
	246	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &tmp) == 0);
	247	if (tmp == guid)
	248	return (B_TRUE);
	249
	250	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	251	&child, &children) == 0) {
	252	for (c = 0; c < children; c++)
	253	if (find_guid(child[c], guid))
	254	return (B_TRUE);
	255	}
	256
	257	return (B_FALSE);
	258	}
	259
	260	typedef struct aux_cbdata {
	261	const char *cb_type;
	262	uint64_t cb_guid;
	263	zpool_handle_t *cb_zhp;
	264	} aux_cbdata_t;
	265
	266	static int
	267	find_aux(zpool_handle_t zhp, void data)
	268	{
	269	aux_cbdata_t *cbp = data;
	270	nvlist_t **list;
	271	uint_t i, count;
	272	uint64_t guid;
	273	nvlist_t *nvroot;
	274
	275	verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE,
	276	&nvroot) == 0);
	277
	278	if (nvlist_lookup_nvlist_array(nvroot, cbp->cb_type,
	279	&list, &count) == 0) {
	280	for (i = 0; i < count; i++) {
	281	verify(nvlist_lookup_uint64(list[i],
	282	ZPOOL_CONFIG_GUID, &guid) == 0);
	283	if (guid == cbp->cb_guid) {
	284	cbp->cb_zhp = zhp;
	285	return (1);
	286	}
	287	}
	288	}
	289
	290	zpool_close(zhp);
	291	return (0);
	292	}
	293
	294	/*
	295	* Determines if the pool is in use. If so, it returns true and the state of
c616dcf8	296	* the pool as well as the name of the pool. Name string is allocated and
34dc7c2f BB	297	* must be freed by the caller.
	298	*/
	299	int
	300	zpool_in_use(libzfs_handle_t hdl, int fd, pool_state_t state, char **namestr,
	301	boolean_t *inuse)
	302	{
	303	nvlist_t *config;
	304	char *name;
	305	boolean_t ret;
	306	uint64_t guid, vdev_guid;
	307	zpool_handle_t *zhp;
	308	nvlist_t *pool_config;
	309	uint64_t stateval, isspare;
	310	aux_cbdata_t cb = { 0 };
	311	boolean_t isactive;
	312
	313	*inuse = B_FALSE;
	314
7d90f569	315	if (zpool_read_label(fd, &config, NULL) != 0) {
34dc7c2f BB	316	(void) no_memory(hdl);
	317	return (-1);
	318	}
	319
	320	if (config == NULL)
	321	return (0);
	322
	323	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	324	&stateval) == 0);
	325	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID,
	326	&vdev_guid) == 0);
	327
	328	if (stateval != POOL_STATE_SPARE && stateval != POOL_STATE_L2CACHE) {
	329	verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
	330	&name) == 0);
	331	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	332	&guid) == 0);
	333	}
	334
	335	switch (stateval) {
	336	case POOL_STATE_EXPORTED:
572e2857 BB	337	/*
	338	* A pool with an exported state may in fact be imported
	339	* read-only, so check the in-core state to see if it's
	340	* active and imported read-only. If it is, set
	341	* its state to active.
	342	*/
	343	if (pool_active(hdl, name, guid, &isactive) == 0 && isactive &&
02f8fe42 JJS	344	(zhp = zpool_open_canfail(hdl, name)) != NULL) {
	345	if (zpool_get_prop_int(zhp, ZPOOL_PROP_READONLY, NULL))
	346	stateval = POOL_STATE_ACTIVE;
	347
	348	/*
	349	* All we needed the zpool handle for is the
	350	* readonly prop check.
	351	*/
	352	zpool_close(zhp);
	353	}
572e2857	354
34dc7c2f BB	355	ret = B_TRUE;
	356	break;
	357
	358	case POOL_STATE_ACTIVE:
	359	/*
	360	* For an active pool, we have to determine if it's really part
	361	* of a currently active pool (in which case the pool will exist
	362	* and the guid will be the same), or whether it's part of an
	363	* active pool that was disconnected without being explicitly
	364	* exported.
	365	*/
	366	if (pool_active(hdl, name, guid, &isactive) != 0) {
	367	nvlist_free(config);
	368	return (-1);
	369	}
	370
	371	if (isactive) {
	372	/*
	373	* Because the device may have been removed while
	374	* offlined, we only report it as active if the vdev is
	375	* still present in the config. Otherwise, pretend like
	376	* it's not in use.
	377	*/
	378	if ((zhp = zpool_open_canfail(hdl, name)) != NULL &&
	379	(pool_config = zpool_get_config(zhp, NULL))
	380	!= NULL) {
	381	nvlist_t *nvroot;
	382
	383	verify(nvlist_lookup_nvlist(pool_config,
	384	ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
	385	ret = find_guid(nvroot, vdev_guid);
	386	} else {
	387	ret = B_FALSE;
	388	}
	389
	390	/*
	391	* If this is an active spare within another pool, we
	392	* treat it like an unused hot spare. This allows the
	393	* user to create a pool with a hot spare that currently
	394	* in use within another pool. Since we return B_TRUE,
	395	* libdiskmgt will continue to prevent generic consumers
	396	* from using the device.
	397	*/
	398	if (ret && nvlist_lookup_uint64(config,
	399	ZPOOL_CONFIG_IS_SPARE, &isspare) == 0 && isspare)
	400	stateval = POOL_STATE_SPARE;
	401
	402	if (zhp != NULL)
	403	zpool_close(zhp);
	404	} else {
	405	stateval = POOL_STATE_POTENTIALLY_ACTIVE;
	406	ret = B_TRUE;
	407	}
	408	break;
	409
	410	case POOL_STATE_SPARE:
	411	/*
	412	* For a hot spare, it can be either definitively in use, or
	413	* potentially active. To determine if it's in use, we iterate
	414	* over all pools in the system and search for one with a spare
	415	* with a matching guid.
	416	*
	417	* Due to the shared nature of spares, we don't actually report
	418	* the potentially active case as in use. This means the user
419	* can freely create pools on the hot spares of exported pools,
420	* but to do otherwise makes the resulting code complicated, and
421	* we end up having to deal with this case anyway.
422	*/
423	cb.cb_zhp = NULL;
424	cb.cb_guid = vdev_guid;
425	cb.cb_type = ZPOOL_CONFIG_SPARES;
426	if (zpool_iter(hdl, find_aux, &cb) == 1) {
427	name = (char *)zpool_get_name(cb.cb_zhp);
0fdd8d64	428	ret = B_TRUE;
34dc7c2f	429	} else {
0fdd8d64	430	ret = B_FALSE;
34dc7c2f BB	431	}
	432	break;
	433
	434	case POOL_STATE_L2CACHE:
	435
	436	/*
	437	* Check if any pool is currently using this l2cache device.
	438	*/
	439	cb.cb_zhp = NULL;
	440	cb.cb_guid = vdev_guid;
	441	cb.cb_type = ZPOOL_CONFIG_L2CACHE;
	442	if (zpool_iter(hdl, find_aux, &cb) == 1) {
	443	name = (char *)zpool_get_name(cb.cb_zhp);
0fdd8d64	444	ret = B_TRUE;
34dc7c2f	445	} else {
0fdd8d64	446	ret = B_FALSE;
34dc7c2f BB	447	}
	448	break;
	449
	450	default:
	451	ret = B_FALSE;
	452	}
	453
	454
	455	if (ret) {
	456	if ((*namestr = zfs_strdup(hdl, name)) == NULL) {
	457	if (cb.cb_zhp)
	458	zpool_close(cb.cb_zhp);
	459	nvlist_free(config);
	460	return (-1);
	461	}
	462	*state = (pool_state_t)stateval;
	463	}
	464
	465	if (cb.cb_zhp)
	466	zpool_close(cb.cb_zhp);
	467
	468	nvlist_free(config);
	469	*inuse = ret;
	470	return (0);
	471	}