[mirror_zfs-debian.git] / lib / libzfs / libzfs_status.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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2012 by Delphix. All rights reserved.
 * Copyright (c) 2013 Steven Hartland. All rights reserved.
 */

/*
 * This file contains the functions which analyze the status of a pool.  This
 * include both the status of an active pool, as well as the status exported
 * pools.  Returns one of the ZPOOL_STATUS_* defines describing the status of
 * the pool.  This status is independent (to a certain degree) from the state of
 * the pool.  A pool's state describes only whether or not it is capable of
 * providing the necessary fault tolerance for data.  The status describes the
 * overall status of devices.  A pool that is online can still have a device
 * that is experiencing errors.
 *
 * Only a subset of the possible faults can be detected using 'zpool status',
 * and not all possible errors correspond to a FMA message ID.  The explanation
 * is left up to the caller, depending on whether it is a live pool or an
 * import.
 */

#include <libzfs.h>
#include <string.h>
#include <unistd.h>
#include "libzfs_impl.h"
#include "zfeature_common.h"

/*
 * Message ID table.  This must be kept in sync with the ZPOOL_STATUS_* defines
 * in libzfs.h.  Note that there are some status results which go past the end
 * of this table, and hence have no associated message ID.
 */
static char *zfs_msgid_table[] = {
	"ZFS-8000-14",
	"ZFS-8000-2Q",
	"ZFS-8000-3C",
	"ZFS-8000-4J",
	"ZFS-8000-5E",
	"ZFS-8000-6X",
	"ZFS-8000-72",
	"ZFS-8000-8A",
	"ZFS-8000-9P",
	"ZFS-8000-A5",
	"ZFS-8000-EY",
	"ZFS-8000-HC",
	"ZFS-8000-JQ",
	"ZFS-8000-K4",
	"ZFS-8000-ER",
};

#define	NMSGID	(sizeof (zfs_msgid_table) / sizeof (zfs_msgid_table[0]))

/* ARGSUSED */
static int
vdev_missing(uint64_t state, uint64_t aux, uint64_t errs)
{
	return (state == VDEV_STATE_CANT_OPEN &&
	    aux == VDEV_AUX_OPEN_FAILED);
}

/* ARGSUSED */
static int
vdev_faulted(uint64_t state, uint64_t aux, uint64_t errs)
{
	return (state == VDEV_STATE_FAULTED);
}

/* ARGSUSED */
static int
vdev_errors(uint64_t state, uint64_t aux, uint64_t errs)
{
	return (state == VDEV_STATE_DEGRADED || errs != 0);
}

/* ARGSUSED */
static int
vdev_broken(uint64_t state, uint64_t aux, uint64_t errs)
{
	return (state == VDEV_STATE_CANT_OPEN);
}

/* ARGSUSED */
static int
vdev_offlined(uint64_t state, uint64_t aux, uint64_t errs)
{
	return (state == VDEV_STATE_OFFLINE);
}

/* ARGSUSED */
static int
vdev_removed(uint64_t state, uint64_t aux, uint64_t errs)
{
	return (state == VDEV_STATE_REMOVED);
}

/*
 * Detect if any leaf devices that have seen errors or could not be opened.
 */
static boolean_t
find_vdev_problem(nvlist_t *vdev, int (*func)(uint64_t, uint64_t, uint64_t))
{
	nvlist_t **child;
	vdev_stat_t *vs;
	uint_t c, children;
	char *type;

	/*
	 * Ignore problems within a 'replacing' vdev, since we're presumably in
	 * the process of repairing any such errors, and don't want to call them
	 * out again.  We'll pick up the fact that a resilver is happening
	 * later.
	 */
	verify(nvlist_lookup_string(vdev, ZPOOL_CONFIG_TYPE, &type) == 0);
	if (strcmp(type, VDEV_TYPE_REPLACING) == 0)
		return (B_FALSE);

	if (nvlist_lookup_nvlist_array(vdev, ZPOOL_CONFIG_CHILDREN, &child,
	    &children) == 0) {
		for (c = 0; c < children; c++)
			if (find_vdev_problem(child[c], func))
				return (B_TRUE);
	} else {
		verify(nvlist_lookup_uint64_array(vdev, ZPOOL_CONFIG_VDEV_STATS,
		    (uint64_t **)&vs, &c) == 0);

		if (func(vs->vs_state, vs->vs_aux,
		    vs->vs_read_errors +
		    vs->vs_write_errors +
		    vs->vs_checksum_errors))
			return (B_TRUE);
	}

	/*
	 * Check any L2 cache devs
	 */
	if (nvlist_lookup_nvlist_array(vdev, ZPOOL_CONFIG_L2CACHE, &child,
	    &children) == 0) {
		for (c = 0; c < children; c++)
			if (find_vdev_problem(child[c], func))
				return (B_TRUE);
	}

	return (B_FALSE);
}

/*
 * Active pool health status.
 *
 * To determine the status for a pool, we make several passes over the config,
 * picking the most egregious error we find.  In order of importance, we do the
 * following:
 *
 *	- Check for a complete and valid configuration
 *	- Look for any faulted or missing devices in a non-replicated config
 *	- Check for any data errors
 *	- Check for any faulted or missing devices in a replicated config
 *	- Look for any devices showing errors
 *	- Check for any resilvering devices
 *
 * There can obviously be multiple errors within a single pool, so this routine
 * only picks the most damaging of all the current errors to report.
 */
static zpool_status_t
check_status(nvlist_t *config, boolean_t isimport, zpool_errata_t *erratap)
{
	nvlist_t *nvroot;
	vdev_stat_t *vs;
	pool_scan_stat_t *ps = NULL;
	uint_t vsc, psc;
	uint64_t nerr;
	uint64_t version;
	uint64_t stateval;
	uint64_t suspended;
	uint64_t hostid = 0;
	uint64_t errata = 0;
	unsigned long system_hostid = get_system_hostid();

	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
	    &version) == 0);
	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	    &nvroot) == 0);
	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
	    (uint64_t **)&vs, &vsc) == 0);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	    &stateval) == 0);

	/*
	 * Currently resilvering a vdev
	 */
	(void) nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_SCAN_STATS,
	    (uint64_t **)&ps, &psc);
	if (ps && ps->pss_func == POOL_SCAN_RESILVER &&
	    ps->pss_state == DSS_SCANNING)
		return (ZPOOL_STATUS_RESILVERING);

	/*
	 * Pool last accessed by another system.
	 */
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID, &hostid);
	if (hostid != 0 && (unsigned long)hostid != system_hostid &&
	    stateval == POOL_STATE_ACTIVE)
		return (ZPOOL_STATUS_HOSTID_MISMATCH);

	/*
	 * Newer on-disk version.
	 */
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	    vs->vs_aux == VDEV_AUX_VERSION_NEWER)
		return (ZPOOL_STATUS_VERSION_NEWER);

	/*
	 * Unsupported feature(s).
	 */
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	    vs->vs_aux == VDEV_AUX_UNSUP_FEAT) {
		nvlist_t *nvinfo;

		verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO,
		    &nvinfo) == 0);
		if (nvlist_exists(nvinfo, ZPOOL_CONFIG_CAN_RDONLY))
			return (ZPOOL_STATUS_UNSUP_FEAT_WRITE);
		return (ZPOOL_STATUS_UNSUP_FEAT_READ);
	}

	/*
	 * Check that the config is complete.
	 */
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	    vs->vs_aux == VDEV_AUX_BAD_GUID_SUM)
		return (ZPOOL_STATUS_BAD_GUID_SUM);

	/*
	 * Check whether the pool has suspended due to failed I/O.
	 */
	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_SUSPENDED,
	    &suspended) == 0) {
		if (suspended == ZIO_FAILURE_MODE_CONTINUE)
			return (ZPOOL_STATUS_IO_FAILURE_CONTINUE);
		return (ZPOOL_STATUS_IO_FAILURE_WAIT);
	}

	/*
	 * Could not read a log.
	 */
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	    vs->vs_aux == VDEV_AUX_BAD_LOG) {
		return (ZPOOL_STATUS_BAD_LOG);
	}

	/*
	 * Bad devices in non-replicated config.
	 */
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	    find_vdev_problem(nvroot, vdev_faulted))
		return (ZPOOL_STATUS_FAULTED_DEV_NR);

	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	    find_vdev_problem(nvroot, vdev_missing))
		return (ZPOOL_STATUS_MISSING_DEV_NR);

	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	    find_vdev_problem(nvroot, vdev_broken))
		return (ZPOOL_STATUS_CORRUPT_LABEL_NR);

	/*
	 * Corrupted pool metadata
	 */
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	    vs->vs_aux == VDEV_AUX_CORRUPT_DATA)
		return (ZPOOL_STATUS_CORRUPT_POOL);

	/*
	 * Persistent data errors.
	 */
	if (!isimport) {
		if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT,
		    &nerr) == 0 && nerr != 0)
			return (ZPOOL_STATUS_CORRUPT_DATA);
	}

	/*
	 * Missing devices in a replicated config.
	 */
	if (find_vdev_problem(nvroot, vdev_faulted))
		return (ZPOOL_STATUS_FAULTED_DEV_R);
	if (find_vdev_problem(nvroot, vdev_missing))
		return (ZPOOL_STATUS_MISSING_DEV_R);
	if (find_vdev_problem(nvroot, vdev_broken))
		return (ZPOOL_STATUS_CORRUPT_LABEL_R);

	/*
	 * Devices with errors
	 */
	if (!isimport && find_vdev_problem(nvroot, vdev_errors))
		return (ZPOOL_STATUS_FAILING_DEV);

	/*
	 * Offlined devices
	 */
	if (find_vdev_problem(nvroot, vdev_offlined))
		return (ZPOOL_STATUS_OFFLINE_DEV);

	/*
	 * Removed device
	 */
	if (find_vdev_problem(nvroot, vdev_removed))
		return (ZPOOL_STATUS_REMOVED_DEV);

	/*
	 * Outdated, but usable, version
	 */
	if (SPA_VERSION_IS_SUPPORTED(version) && version != SPA_VERSION)
		return (ZPOOL_STATUS_VERSION_OLDER);

	/*
	 * Usable pool with disabled features
	 */
	if (version >= SPA_VERSION_FEATURES) {
		int i;
		nvlist_t *feat;

		if (isimport) {
			feat = fnvlist_lookup_nvlist(config,
			    ZPOOL_CONFIG_LOAD_INFO);
			feat = fnvlist_lookup_nvlist(feat,
			    ZPOOL_CONFIG_ENABLED_FEAT);
		} else {
			feat = fnvlist_lookup_nvlist(config,
			    ZPOOL_CONFIG_FEATURE_STATS);
		}

		for (i = 0; i < SPA_FEATURES; i++) {
			zfeature_info_t *fi = &spa_feature_table[i];
			if (!nvlist_exists(feat, fi->fi_guid))
				return (ZPOOL_STATUS_FEAT_DISABLED);
		}
	}

	/*
	 * Informational errata available.
	 */
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRATA, &errata);
	if (errata) {
		*erratap = errata;
		return (ZPOOL_STATUS_ERRATA);
	}

	return (ZPOOL_STATUS_OK);
}

zpool_status_t
zpool_get_status(zpool_handle_t *zhp, char **msgid, zpool_errata_t *errata)
{
	zpool_status_t ret = check_status(zhp->zpool_config, B_FALSE, errata);

	if (ret >= NMSGID)
		*msgid = NULL;
	else
		*msgid = zfs_msgid_table[ret];

	return (ret);
}

zpool_status_t
zpool_import_status(nvlist_t *config, char **msgid, zpool_errata_t *errata)
{
	zpool_status_t ret = check_status(config, B_TRUE, errata);

	if (ret >= NMSGID)
		*msgid = NULL;
	else
		*msgid = zfs_msgid_table[ret];

	return (ret);
}

static void
dump_ddt_stat(const ddt_stat_t *dds, int h)
{
	char refcnt[6];
	char blocks[6], lsize[6], psize[6], dsize[6];
	char ref_blocks[6], ref_lsize[6], ref_psize[6], ref_dsize[6];

	if (dds == NULL || dds->dds_blocks == 0)
		return;

	if (h == -1)
		(void) strcpy(refcnt, "Total");
	else
		zfs_nicenum(1ULL << h, refcnt, sizeof (refcnt));

	zfs_nicenum(dds->dds_blocks, blocks, sizeof (blocks));
	zfs_nicenum(dds->dds_lsize, lsize, sizeof (lsize));
	zfs_nicenum(dds->dds_psize, psize, sizeof (psize));
	zfs_nicenum(dds->dds_dsize, dsize, sizeof (dsize));
	zfs_nicenum(dds->dds_ref_blocks, ref_blocks, sizeof (ref_blocks));
	zfs_nicenum(dds->dds_ref_lsize, ref_lsize, sizeof (ref_lsize));
	zfs_nicenum(dds->dds_ref_psize, ref_psize, sizeof (ref_psize));
	zfs_nicenum(dds->dds_ref_dsize, ref_dsize, sizeof (ref_dsize));

	(void) printf("%6s   %6s   %5s   %5s   %5s   %6s   %5s   %5s   %5s\n",
	    refcnt,
	    blocks, lsize, psize, dsize,
	    ref_blocks, ref_lsize, ref_psize, ref_dsize);
}

/*
 * Print the DDT histogram and the column totals.
 */
void
zpool_dump_ddt(const ddt_stat_t *dds_total, const ddt_histogram_t *ddh)
{
	int h;

	(void) printf("\n");

	(void) printf("bucket   "
	    "           allocated             "
	    "          referenced          \n");
	(void) printf("______   "
	    "______________________________   "
	    "______________________________\n");

	(void) printf("%6s   %6s   %5s   %5s   %5s   %6s   %5s   %5s   %5s\n",
	    "refcnt",
	    "blocks", "LSIZE", "PSIZE", "DSIZE",
	    "blocks", "LSIZE", "PSIZE", "DSIZE");

	(void) printf("%6s   %6s   %5s   %5s   %5s   %6s   %5s   %5s   %5s\n",
	    "------",
	    "------", "-----", "-----", "-----",
	    "------", "-----", "-----", "-----");

	for (h = 0; h < 64; h++)
		dump_ddt_stat(&ddh->ddh_stat[h], h);

	dump_ddt_stat(dds_total, -1);

	(void) printf("\n");
}
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	*/
9ae529ec	21
34dc7c2f	22	/*
428870ff	23	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
9ae529ec	24	* Copyright (c) 2012 by Delphix. All rights reserved.
a08ee875	25	* Copyright (c) 2013 Steven Hartland. All rights reserved.
34dc7c2f BB	26	*/
34dc7c2f BB	27
34dc7c2f BB	28	/*
	29	* This file contains the functions which analyze the status of a pool. This
	30	* include both the status of an active pool, as well as the status exported
	31	* pools. Returns one of the ZPOOL_STATUS_* defines describing the status of
	32	* the pool. This status is independent (to a certain degree) from the state of
	33	* the pool. A pool's state describes only whether or not it is capable of
	34	* providing the necessary fault tolerance for data. The status describes the
	35	* overall status of devices. A pool that is online can still have a device
	36	* that is experiencing errors.
	37	*
	38	* Only a subset of the possible faults can be detected using 'zpool status',
	39	* and not all possible errors correspond to a FMA message ID. The explanation
	40	* is left up to the caller, depending on whether it is a live pool or an
	41	* import.
	42	*/
	43
	44	#include <libzfs.h>
	45	#include <string.h>
	46	#include <unistd.h>
	47	#include "libzfs_impl.h"
b9b24bb4	48	#include "zfeature_common.h"
34dc7c2f BB	49
	50	/*
	51	* Message ID table. This must be kept in sync with the ZPOOL_STATUS_* defines
	52	* in libzfs.h. Note that there are some status results which go past the end
	53	* of this table, and hence have no associated message ID.
	54	*/
	55	static char *zfs_msgid_table[] = {
	56	"ZFS-8000-14",
	57	"ZFS-8000-2Q",
	58	"ZFS-8000-3C",
	59	"ZFS-8000-4J",
	60	"ZFS-8000-5E",
	61	"ZFS-8000-6X",
	62	"ZFS-8000-72",
	63	"ZFS-8000-8A",
	64	"ZFS-8000-9P",
	65	"ZFS-8000-A5",
b128c09f BB	66	"ZFS-8000-EY",
	67	"ZFS-8000-HC",
	68	"ZFS-8000-JQ",
	69	"ZFS-8000-K4",
ea04106b	70	"ZFS-8000-ER",
34dc7c2f BB	71	};
	72
	73	#define NMSGID (sizeof (zfs_msgid_table) / sizeof (zfs_msgid_table[0]))
	74
	75	/* ARGSUSED */
	76	static int
	77	vdev_missing(uint64_t state, uint64_t aux, uint64_t errs)
	78	{
	79	return (state == VDEV_STATE_CANT_OPEN &&
	80	aux == VDEV_AUX_OPEN_FAILED);
	81	}
	82
	83	/* ARGSUSED */
	84	static int
	85	vdev_faulted(uint64_t state, uint64_t aux, uint64_t errs)
	86	{
	87	return (state == VDEV_STATE_FAULTED);
	88	}
	89
	90	/* ARGSUSED */
	91	static int
	92	vdev_errors(uint64_t state, uint64_t aux, uint64_t errs)
	93	{
	94	return (state == VDEV_STATE_DEGRADED \|\| errs != 0);
	95	}
	96
	97	/* ARGSUSED */
	98	static int
	99	vdev_broken(uint64_t state, uint64_t aux, uint64_t errs)
	100	{
	101	return (state == VDEV_STATE_CANT_OPEN);
	102	}
	103
	104	/* ARGSUSED */
	105	static int
	106	vdev_offlined(uint64_t state, uint64_t aux, uint64_t errs)
	107	{
	108	return (state == VDEV_STATE_OFFLINE);
	109	}
	110
45d1cae3 BB	111	/* ARGSUSED */
	112	static int
	113	vdev_removed(uint64_t state, uint64_t aux, uint64_t errs)
	114	{
	115	return (state == VDEV_STATE_REMOVED);
	116	}
	117
34dc7c2f BB	118	/*
	119	* Detect if any leaf devices that have seen errors or could not be opened.
	120	*/
	121	static boolean_t
	122	find_vdev_problem(nvlist_t vdev, int (func)(uint64_t, uint64_t, uint64_t))
	123	{
	124	nvlist_t **child;
	125	vdev_stat_t *vs;
	126	uint_t c, children;
	127	char *type;
	128
	129	/*
	130	* Ignore problems within a 'replacing' vdev, since we're presumably in
	131	* the process of repairing any such errors, and don't want to call them
	132	* out again. We'll pick up the fact that a resilver is happening
	133	* later.
	134	*/
	135	verify(nvlist_lookup_string(vdev, ZPOOL_CONFIG_TYPE, &type) == 0);
	136	if (strcmp(type, VDEV_TYPE_REPLACING) == 0)
	137	return (B_FALSE);
	138
	139	if (nvlist_lookup_nvlist_array(vdev, ZPOOL_CONFIG_CHILDREN, &child,
	140	&children) == 0) {
	141	for (c = 0; c < children; c++)
	142	if (find_vdev_problem(child[c], func))
	143	return (B_TRUE);
	144	} else {
428870ff	145	verify(nvlist_lookup_uint64_array(vdev, ZPOOL_CONFIG_VDEV_STATS,
34dc7c2f BB	146	(uint64_t **)&vs, &c) == 0);
	147
	148	if (func(vs->vs_state, vs->vs_aux,
	149	vs->vs_read_errors +
	150	vs->vs_write_errors +
	151	vs->vs_checksum_errors))
	152	return (B_TRUE);
	153	}
	154
a08ee875 LG	155	/*
	156	* Check any L2 cache devs
	157	*/
	158	if (nvlist_lookup_nvlist_array(vdev, ZPOOL_CONFIG_L2CACHE, &child,
	159	&children) == 0) {
	160	for (c = 0; c < children; c++)
	161	if (find_vdev_problem(child[c], func))
	162	return (B_TRUE);
	163	}
	164
34dc7c2f BB	165	return (B_FALSE);
	166	}
	167
	168	/*
	169	* Active pool health status.
	170	*
	171	* To determine the status for a pool, we make several passes over the config,
	172	* picking the most egregious error we find. In order of importance, we do the
	173	* following:
	174	*
	175	* - Check for a complete and valid configuration
	176	* - Look for any faulted or missing devices in a non-replicated config
	177	* - Check for any data errors
	178	* - Check for any faulted or missing devices in a replicated config
	179	* - Look for any devices showing errors
	180	* - Check for any resilvering devices
	181	*
	182	* There can obviously be multiple errors within a single pool, so this routine
	183	* only picks the most damaging of all the current errors to report.
	184	*/
	185	static zpool_status_t
ea04106b	186	check_status(nvlist_t config, boolean_t isimport, zpool_errata_t erratap)
34dc7c2f BB	187	{
	188	nvlist_t *nvroot;
	189	vdev_stat_t *vs;
428870ff BB	190	pool_scan_stat_t *ps = NULL;
428870ff BB	191	uint_t vsc, psc;
34dc7c2f BB	192	uint64_t nerr;
	193	uint64_t version;
	194	uint64_t stateval;
b128c09f	195	uint64_t suspended;
34dc7c2f	196	uint64_t hostid = 0;
ea04106b AX	197	uint64_t errata = 0;
ea04106b AX	198	unsigned long system_hostid = get_system_hostid();
34dc7c2f BB	199
	200	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
	201	&version) == 0);
	202	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	203	&nvroot) == 0);
428870ff	204	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
34dc7c2f BB	205	(uint64_t **)&vs, &vsc) == 0);
	206	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	207	&stateval) == 0);
428870ff BB	208
	209	/*
	210	* Currently resilvering a vdev
	211	*/
	212	(void) nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_SCAN_STATS,
	213	(uint64_t **)&ps, &psc);
	214	if (ps && ps->pss_func == POOL_SCAN_RESILVER &&
	215	ps->pss_state == DSS_SCANNING)
	216	return (ZPOOL_STATUS_RESILVERING);
34dc7c2f BB	217
	218	/*
	219	* Pool last accessed by another system.
	220	*/
428870ff	221	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID, &hostid);
492b8e9e	222	if (hostid != 0 && (unsigned long)hostid != system_hostid &&
34dc7c2f BB	223	stateval == POOL_STATE_ACTIVE)
	224	return (ZPOOL_STATUS_HOSTID_MISMATCH);
	225
	226	/*
	227	* Newer on-disk version.
	228	*/
	229	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	230	vs->vs_aux == VDEV_AUX_VERSION_NEWER)
	231	return (ZPOOL_STATUS_VERSION_NEWER);
	232
9ae529ec CS	233	/*
	234	* Unsupported feature(s).
	235	*/
	236	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	237	vs->vs_aux == VDEV_AUX_UNSUP_FEAT) {
	238	nvlist_t *nvinfo;
	239
	240	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO,
	241	&nvinfo) == 0);
	242	if (nvlist_exists(nvinfo, ZPOOL_CONFIG_CAN_RDONLY))
	243	return (ZPOOL_STATUS_UNSUP_FEAT_WRITE);
	244	return (ZPOOL_STATUS_UNSUP_FEAT_READ);
	245	}
	246
34dc7c2f BB	247	/*
	248	* Check that the config is complete.
	249	*/
	250	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	251	vs->vs_aux == VDEV_AUX_BAD_GUID_SUM)
	252	return (ZPOOL_STATUS_BAD_GUID_SUM);
	253
b128c09f BB	254	/*
	255	* Check whether the pool has suspended due to failed I/O.
	256	*/
	257	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_SUSPENDED,
	258	&suspended) == 0) {
	259	if (suspended == ZIO_FAILURE_MODE_CONTINUE)
	260	return (ZPOOL_STATUS_IO_FAILURE_CONTINUE);
	261	return (ZPOOL_STATUS_IO_FAILURE_WAIT);
	262	}
	263
	264	/*
	265	* Could not read a log.
	266	*/
	267	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	268	vs->vs_aux == VDEV_AUX_BAD_LOG) {
	269	return (ZPOOL_STATUS_BAD_LOG);
	270	}
	271
34dc7c2f BB	272	/*
	273	* Bad devices in non-replicated config.
	274	*/
	275	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	276	find_vdev_problem(nvroot, vdev_faulted))
	277	return (ZPOOL_STATUS_FAULTED_DEV_NR);
	278
	279	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	280	find_vdev_problem(nvroot, vdev_missing))
	281	return (ZPOOL_STATUS_MISSING_DEV_NR);
	282
	283	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	284	find_vdev_problem(nvroot, vdev_broken))
	285	return (ZPOOL_STATUS_CORRUPT_LABEL_NR);
	286
	287	/*
	288	* Corrupted pool metadata
	289	*/
	290	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	291	vs->vs_aux == VDEV_AUX_CORRUPT_DATA)
	292	return (ZPOOL_STATUS_CORRUPT_POOL);
	293
	294	/*
	295	* Persistent data errors.
	296	*/
	297	if (!isimport) {
	298	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT,
	299	&nerr) == 0 && nerr != 0)
	300	return (ZPOOL_STATUS_CORRUPT_DATA);
	301	}
	302
	303	/*
	304	* Missing devices in a replicated config.
	305	*/
	306	if (find_vdev_problem(nvroot, vdev_faulted))
	307	return (ZPOOL_STATUS_FAULTED_DEV_R);
	308	if (find_vdev_problem(nvroot, vdev_missing))
	309	return (ZPOOL_STATUS_MISSING_DEV_R);
	310	if (find_vdev_problem(nvroot, vdev_broken))
	311	return (ZPOOL_STATUS_CORRUPT_LABEL_R);
	312
	313	/*
	314	* Devices with errors
	315	*/
	316	if (!isimport && find_vdev_problem(nvroot, vdev_errors))
	317	return (ZPOOL_STATUS_FAILING_DEV);
	318
	319	/*
	320	* Offlined devices
	321	*/
	322	if (find_vdev_problem(nvroot, vdev_offlined))
	323	return (ZPOOL_STATUS_OFFLINE_DEV);
	324
45d1cae3 BB	325	/*
	326	* Removed device
	327	*/
	328	if (find_vdev_problem(nvroot, vdev_removed))
	329	return (ZPOOL_STATUS_REMOVED_DEV);
	330
34dc7c2f BB	331	/*
	332	* Outdated, but usable, version
	333	*/
9ae529ec	334	if (SPA_VERSION_IS_SUPPORTED(version) && version != SPA_VERSION)
34dc7c2f BB	335	return (ZPOOL_STATUS_VERSION_OLDER);
34dc7c2f BB	336
b9b24bb4 CS	337	/*
	338	* Usable pool with disabled features
	339	*/
	340	if (version >= SPA_VERSION_FEATURES) {
	341	int i;
	342	nvlist_t *feat;
	343
	344	if (isimport) {
	345	feat = fnvlist_lookup_nvlist(config,
	346	ZPOOL_CONFIG_LOAD_INFO);
	347	feat = fnvlist_lookup_nvlist(feat,
	348	ZPOOL_CONFIG_ENABLED_FEAT);
	349	} else {
	350	feat = fnvlist_lookup_nvlist(config,
	351	ZPOOL_CONFIG_FEATURE_STATS);
	352	}
	353
	354	for (i = 0; i < SPA_FEATURES; i++) {
	355	zfeature_info_t *fi = &spa_feature_table[i];
	356	if (!nvlist_exists(feat, fi->fi_guid))
	357	return (ZPOOL_STATUS_FEAT_DISABLED);
	358	}
	359	}
	360
ea04106b AX	361	/*
	362	* Informational errata available.
	363	*/
	364	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRATA, &errata);
	365	if (errata) {
	366	*erratap = errata;
	367	return (ZPOOL_STATUS_ERRATA);
	368	}
	369
34dc7c2f BB	370	return (ZPOOL_STATUS_OK);
	371	}
	372
	373	zpool_status_t
ea04106b	374	zpool_get_status(zpool_handle_t zhp, char msgid, zpool_errata_t errata)
34dc7c2f	375	{
ea04106b	376	zpool_status_t ret = check_status(zhp->zpool_config, B_FALSE, errata);
34dc7c2f BB	377
	378	if (ret >= NMSGID)
	379	*msgid = NULL;
	380	else
	381	*msgid = zfs_msgid_table[ret];
	382
	383	return (ret);
	384	}
	385
	386	zpool_status_t
ea04106b	387	zpool_import_status(nvlist_t config, char msgid, zpool_errata_t errata)
34dc7c2f	388	{
ea04106b	389	zpool_status_t ret = check_status(config, B_TRUE, errata);
34dc7c2f BB	390
	391	if (ret >= NMSGID)
	392	*msgid = NULL;
	393	else
	394	*msgid = zfs_msgid_table[ret];
	395
	396	return (ret);
	397	}
428870ff BB	398
	399	static void
	400	dump_ddt_stat(const ddt_stat_t *dds, int h)
	401	{
	402	char refcnt[6];
	403	char blocks[6], lsize[6], psize[6], dsize[6];
	404	char ref_blocks[6], ref_lsize[6], ref_psize[6], ref_dsize[6];
	405
	406	if (dds == NULL \|\| dds->dds_blocks == 0)
	407	return;
	408
	409	if (h == -1)
	410	(void) strcpy(refcnt, "Total");
	411	else
	412	zfs_nicenum(1ULL << h, refcnt, sizeof (refcnt));
	413
	414	zfs_nicenum(dds->dds_blocks, blocks, sizeof (blocks));
	415	zfs_nicenum(dds->dds_lsize, lsize, sizeof (lsize));
	416	zfs_nicenum(dds->dds_psize, psize, sizeof (psize));
	417	zfs_nicenum(dds->dds_dsize, dsize, sizeof (dsize));
	418	zfs_nicenum(dds->dds_ref_blocks, ref_blocks, sizeof (ref_blocks));
	419	zfs_nicenum(dds->dds_ref_lsize, ref_lsize, sizeof (ref_lsize));
	420	zfs_nicenum(dds->dds_ref_psize, ref_psize, sizeof (ref_psize));
	421	zfs_nicenum(dds->dds_ref_dsize, ref_dsize, sizeof (ref_dsize));
	422
	423	(void) printf("%6s %6s %5s %5s %5s %6s %5s %5s %5s\n",
	424	refcnt,
	425	blocks, lsize, psize, dsize,
	426	ref_blocks, ref_lsize, ref_psize, ref_dsize);
	427	}
	428
	429	/*
	430	* Print the DDT histogram and the column totals.
	431	*/
	432	void
	433	zpool_dump_ddt(const ddt_stat_t dds_total, const ddt_histogram_t ddh)
	434	{
	435	int h;
	436
	437	(void) printf("\n");
	438
	439	(void) printf("bucket "
	440	" allocated "
	441	" referenced \n");
	442	(void) printf("______ "
	443	"______________________________ "
	444	"______________________________\n");
	445
	446	(void) printf("%6s %6s %5s %5s %5s %6s %5s %5s %5s\n",
	447	"refcnt",
	448	"blocks", "LSIZE", "PSIZE", "DSIZE",
	449	"blocks", "LSIZE", "PSIZE", "DSIZE");
	450
	451	(void) printf("%6s %6s %5s %5s %5s %6s %5s %5s %5s\n",
	452	"------",
	453	"------", "-----", "-----", "-----",
	454	"------", "-----", "-----", "-----");
	455
	456	for (h = 0; h < 64; h++)
	457	dump_ddt_stat(&ddh->ddh_stat[h], h);
	458
	459	dump_ddt_stat(dds_total, -1);
	460
	461	(void) printf("\n");
462	}